ttdispersal.h

Go to the documentation of this file.

 
#ifndef TTDISPERSALGENE_H
#define TTDISPERSALGENE_H
 
#include "ttrait.h"
#include "types.h"
#include "stathandler.h"
#include "metapop.h"
#include "binarystoragebuffer.h"
 
class TTDispersalSH;
class TProtoDispersal;
 
class TTDispersal : public TTrait
{
  double _mut_rate;
  double _mut_mean;
  double _init_rate_fem;
  double _init_rate_mal;
  
  TProtoDispersal* _myProto;
  
  sex_t   _gender;
//  trait_t _type;
  double _sequence[2];
  double _phenotype;
 
public:
  TTDispersal (sex_t sex);
  TTDispersal (const TTDispersal& TP)
    : _mut_rate(TP._mut_rate), _mut_mean(TP._mut_mean), _init_rate_fem(TP._init_rate_fem), 
    _init_rate_mal(TP._init_rate_mal), _myProto(TP._myProto), _gender(TP._gender), _phenotype(0) //, _type(TP._type)
  {}
  virtual ~TTDispersal () { }
  
  void set_mut_rate                    (double val)        {_mut_rate = val;}
  void set_mut_mean                    (double val)        {_mut_mean = val;}
  void set_init_rate_fem               (double val)        {_init_rate_fem = val;}
  void set_init_rate_mal               (double val)        {_init_rate_mal = val;}
  void set_gender                      (sex_t val)         {_gender = val;}
//  void set_type                        (trait_t val)       {_type = val;}
  void set_proto                       (TProtoDispersal* P){_myProto = P;}
  virtual void    init                 ( )                 { _sequence[0] = 0.0; _sequence[1] = 0.0; }
  virtual void    init_sequence        ( );
  virtual void    reset                ( )                 {init();}
  virtual void    inherit              (const TTrait* mother, const TTrait* father);
  virtual void    mutate               ( );
  virtual trait_t get_type             ( ) const           {return (_gender == FEM ? FDISP : MDISP);}
  virtual void    set_value            ( )                 {_phenotype = (_sequence[0] + _sequence[1])/2.0;}
  virtual void*   getValue             ( ) const           {return (void*)&_phenotype;}
  virtual void**  get_sequence         ( ) const           {return 0;}
  virtual unsigned int    get_allele (int loc, int all) const {return ( !(all<2) ? 0 : _sequence[all] );}
  virtual double  get_allele_value     (int loc, int all) const {return ( !(all<2) ? 0 : _sequence[all] );}
  virtual void    set_allele_value (unsigned int locus, unsigned int allele, double value)
    {assert(allele < 2); _sequence[allele] = value;}
  virtual void    set_sequence         (void** seq)        { }
  virtual void*   set_trait            (void* value)       {return value;}
  virtual void    show_up              ( );
  virtual TTDispersal*  clone          ( )                 {return new TTDispersal(*this);}
  virtual TTDispersal& operator= (const TTrait& TP);
  virtual bool operator== (const TTrait& TP);
  virtual bool operator!= (const TTrait& TP);
  
  //implements StorableComponent: 
  virtual void    store_data       (BinaryStorageBuffer* saver)  {saver->store(&_sequence, 2 * sizeof(double));}
  virtual bool    retrieve_data    (BinaryStorageBuffer* reader) {reader->read(&_sequence, 2 * sizeof(double));return true;}
};
// ------------------------------------------------------------------------------
 
//                                     TProtoDispersal 
 
// ------------------------------------------------------------------------------
class TProtoDispersal : public TraitPrototype {
 
public:
  TProtoDispersal(sex_t sex);
 
  TProtoDispersal(const TProtoDispersal& TP);
 
  virtual ~TProtoDispersal();
 
  virtual   void              init (){}
  virtual   void             reset (){}
  virtual   TTDispersal*     hatch ();
  virtual   TProtoDispersal* clone () {return new TProtoDispersal(*this);}
  virtual   trait_t       get_type () const {return (_gender == FEM ? FDISP : MDISP);}
  virtual   int             get_phenotype_dimension () {return 1;}
  virtual   int             get_allele_number () {return 3;} // 3 > 2 means it's not di-allelic
  virtual   int             get_locus_number        () {return 2;}
  virtual   bool            is_mappable () {return false;}
  virtual   bool            is_mapped () {return false;}
  virtual   vector< unsigned int > get_locus_map_positions () {return vector<unsigned int>(2,0);}
  virtual void    store_data       (BinaryStorageBuffer* saver)  {saver->store(&_gender, sizeof(sex_t));}
  virtual bool    retrieve_data    (BinaryStorageBuffer* reader) {reader->read(&_gender, sizeof(sex_t));return true;}
  virtual bool setParameters();
  virtual void loadFileServices ( FileServices* loader ) {}
  virtual void loadStatServices ( StatServices* loader );
  virtual bool resetParameterFromSource (std::string param, SimComponent* cmpt) {return false;}
 
  bool setNonRandom ();
  bool setRandom    ();
  
  bool get_init_mode () {return _init_random;}
  TMatrix* get_init_dist_params () {return &_init_dist_param;}
  string get_init_dist () {return _init_dist;}
  
private:
  double _mut_rate;
  double _mut_mean;
  double _init_rate_fem;
  double _init_rate_mal;
  
  string _init_dist;
  TMatrix _init_dist_param;
  bool _init_random;
  
  sex_t   _gender;
//  trait_t _type;
  TTDispersalSH* _stats;
};
 
// ------------------------------------------------------------------------------
 
//                                      TTDispersalSH
 
// ------------------------------------------------------------------------------
class TTDispersalSH: public StatHandler<TTDispersalSH> {
  
  TProtoDispersal* _trait;
  
  double _meanFemDisp, _meanMalDisp, _meanOffFemDisp, _meanOffMalDisp;
  
  int _fdispIdx, _mdispIdx;
    
public:
  
  TTDispersalSH (TProtoDispersal* TT) 
  : _trait(TT),_meanFemDisp(0), _meanMalDisp(0), _meanOffFemDisp(0), _meanOffMalDisp(0), _fdispIdx(-1), _mdispIdx(-1) { }
  
  virtual ~TTDispersalSH ( ) { }
  virtual void init ( ) 
  { 
    StatHandlerBase::init(); 
    _fdispIdx = _pop->getTraitIndex(FDISP); 
    _mdispIdx = _pop->getTraitIndex(MDISP);
  }
 
  virtual bool setStatRecorders (std::string& token);
  
  void addDispPerPatch (sex_t SEX, age_t AGE);
  
  double getmeanOFD                        ()            {return _meanOffFemDisp;}
  double getmeanOMD                        ()            {return _meanOffMalDisp;}
  double getmeanFD                         ()            {return _meanFemDisp;}
  double getmeanMD                         ()            {return _meanMalDisp;}
  double getMeanDispRate                   ();
  double getOffsprgMeanDispRate            ();
  double getMeanDispRate                   (sex_t sex);
  double getOffsprgMeanDispRate            (sex_t sex);
  double getMeanFemDispRate                ();
  double getMeanMalDispRate                ();
  double getMeanDispRateInPatch            (sex_t SEX, age_idx age, unsigned int traitidx, unsigned int i);
 
  double getPatchDisp_OF                   (unsigned int patch)
  {
    return getMeanDispRateInPatch(FEM, OFFSx, _fdispIdx, patch);
  }
 
  double getPatchDisp_OM                   (unsigned int patch)
  {
    return getMeanDispRateInPatch(MAL, OFFSx, _mdispIdx, patch);
  }
 
  double getPatchDisp_AF                   (unsigned int patch)
  {
    return getMeanDispRateInPatch(FEM, ADLTx, _fdispIdx, patch);
  }
  
  double getPatchDisp_AM                   (unsigned int patch)
  {
    return getMeanDispRateInPatch(MAL, ADLTx, _mdispIdx, patch);
  }
};
#endif //TTDISPERSALGENE_H