ttbdmi.h

Go to the documentation of this file.

 
#ifndef _TTDBMI_H_
#define _TTDBMI_H_
 
#include "ttrait.h"
#include "types.h"
#include "stathandler.h"
#include "filehandler.h"
#include "lifecycleevent.h"
#include "metapop.h"
#include "bitstring.h"
#include "tmatrix.h"
#include "Uniform.h"
 
class TTBDMI_SH;
class TTBDMI_FH;
class TT_BDMI;
// ------------------------------------------------------------------------------
 
//   TProtoBDMI
 
// ------------------------------------------------------------------------------
class TProtoBDMI : public TTProtoWithMap {
  
  trait_t _type;
  
  bool _isHaploid;
  unsigned int _num_locus;
  unsigned int _npair;
  double _mut_rate;
  double _genomic_mut_rate;
  double _recomb_rate;
  double* _init_freq;
  bool    _isInitSet;
  static unsigned int _diploGenotTableCoding3x3[3][3];
  static unsigned int _diploGenotTableCoding4x4[4][4];
  
  void   (TT_BDMI::* _inherit_func_ptr)  (const TTrait*, const TTrait*);
  void   (TProtoBDMI::* _gamete_recomb_func_ptr)  (sex_t SEX, bitstring& seq, const bitstring* parent);
  void   (TT_BDMI::* _mutation_func_ptr) (void);
  double (TT_BDMI::* _viability_func_ptr) (void);
 
  TMatrix _genoTable;
  TTBDMI_SH* _stater;
  TTBDMI_FH* _writer;
 
  friend class TT_BDMI;
  
public:
  
  TProtoBDMI();
  TProtoBDMI(const TProtoBDMI& TP);
  virtual ~TProtoBDMI();
  
  int                       get_num_locus     ( )  {return _num_locus;}
  double                    get_mut_rate     ( )  {return _mut_rate;}
  bool                      isHaploid        ( )  {return _isHaploid;}
  void                      set_init_freq    (double* val, unsigned int size);
  double                    get_init_freq    (unsigned int i) {return _init_freq[i];}
  bool                      isInitSet        ( )  {return _isInitSet;}
 
  double                    getGenoFitnessHaplo (unsigned int row, unsigned int pos){
    assert(pos < 4);
    return _genoTable.get(row, pos);
  }
 
  double                    getGenoFitnessDiplo (unsigned int row, unsigned int posA, unsigned int posB)
  {
    return _genoTable.get(row, _diploGenotTableCoding4x4[posA][posB] );
  }
 
  double                    getGenoFitnessDiplo (unsigned int row, unsigned int pos)
  {
    assert(pos < 16);
    return _genoTable.get(row, pos);
  }
 
  void                      setGenoFitnessValue(unsigned int row, unsigned int geno, double value)
  { _genoTable.set(row, geno, value); }
 
  void                      showGenoTable (unsigned int nrows);
  
  void                      gamete_recombination  (sex_t SEX, bitstring& seq, const bitstring* parent);
  void                      inherit_free     (sex_t SEX, bitstring& seq, const bitstring* parent);
  void                      inherit_low      (sex_t SEX, bitstring& seq, const bitstring* parent);
  
  virtual   void            init     () {setParameters();}
  virtual   TTrait*         hatch    ();
  virtual   TraitPrototype* clone    () {return new TProtoBDMI(*this);}
  virtual   trait_t         get_type () const {return _type;}
  
  //implements StorageComponent
  virtual   void            store_data    (BinaryStorageBuffer* saver)
  {
    saver->store(&_num_locus, sizeof(int));
    saver->store(&_isHaploid, sizeof(bool));
  }
  virtual   bool            retrieve_data (BinaryStorageBuffer* reader);
  //implements SimComponent
  virtual   bool            setParameters ( );
  virtual   void            loadFileServices ( FileServices* loader );
  virtual   void            loadStatServices ( StatServices* loader );
  virtual   bool            resetParameterFromSource (std::string param, SimComponent* cmpt) {return false;}
  
};
// ------------------------------------------------------------------------------
 
//  TT_BDMI
 
// ------------------------------------------------------------------------------
class TT_BDMI : public TTrait {
 
  TProtoBDMI* _myProto;
  
  bitstring _sequence[2];
  
  double _phenotype;
  
  
  
  
  static unsigned int _haploGenotCoding[2][2];
  static unsigned int _diploGenotCoding[2][2];
 
public:
  //cstor & dstor
  TT_BDMI()
  : _myProto(0), _phenotype(0) {}
  
  TT_BDMI(const TT_BDMI& T)
  : _myProto(T._myProto), _phenotype(0){}
  
  virtual ~TT_BDMI() { }
  
  
  void            set_proto                     (TProtoBDMI* proto)    {_myProto = proto;}
  
  void            set_sequence                  (bitstring** seq);
  
  //inheritance routines:
  void            inherit_haplo                 (const TTrait* mother, const TTrait* father);
  void            inherit_diplo                 (const TTrait* mother, const TTrait* father);
  
  //mutation routines:
  void            mutate_haplo                  ( );
  void            mutate_diplo                  ( );
  
  double          viability_haplo               ( );
  double          viability_diplo               ( );
  
  unsigned int    get_num_mut_haplo             (unsigned int loc) {return _sequence[0][loc];}
  unsigned int    get_num_mut_diplo             (unsigned int loc) {return _sequence[0][loc] + _sequence[1][loc];}
  
  const bitstring&     get_bit_sequence         (bool chromosome) const {return _sequence[chromosome];}
  const bitstring*     get_genome_sequence      () const {return &_sequence[0];}
  
  virtual   void            init                ();
  virtual   void            init_sequence       ();
  virtual   void            reset               ();
  virtual   void            inherit             (const TTrait* mother, const TTrait* father);
  virtual   void            mutate              ();
  virtual   void*           set_trait           (void* value) {return NULL;}
  virtual   void            set_sequence        (void** seq) {}
  virtual   void            set_value           ();
  virtual   void*           getValue            () const {return (void*)&_phenotype;}
  virtual   trait_t         get_type            () const {return _myProto->get_type();}
  virtual   void**          get_sequence        () const {
    error("calling TT_BDMI::get_sequence()\n");
    return (void**)NULL;
  }
  virtual   double          get_allele_value    (int loc, int all) const;
  virtual   void            set_allele_value    (unsigned int locus, unsigned int allele, double value);
  virtual   void            show_up             ();
 
  virtual   TT_BDMI*         clone              () {return new TT_BDMI(*this);}
  virtual   TT_BDMI&         operator=          (const TTrait&);
  virtual   bool             operator==         (const TTrait&);
  virtual   bool             operator!=         (const TTrait&);
 
  //implements StorableComponent:
  virtual void    store_data     (BinaryStorageBuffer* saver);
  virtual bool    retrieve_data  (BinaryStorageBuffer* reader);
  
};
 
// ------------------------------------------------------------------------------
 
//  TTBDMI_FH
 
// ------------------------------------------------------------------------------
class TTBDMI_FH : public TraitFileHandler< TProtoBDMI > {
  
public:
  
  TTBDMI_FH(TProtoBDMI* TP) : TraitFileHandler< TProtoBDMI > (TP,".dmi") {}
  virtual ~TTBDMI_FH ( ) { }
  
  void write_haplo (Patch* patch, sex_t SEX, age_idx AGE, ofstream& FH);
  void write_diplo (Patch* patch, sex_t SEX, age_idx AGE, ofstream& FH);
  
  virtual void FHwrite  ();
  virtual void FHread (string& filename) {}
  
};
 
// ------------------------------------------------------------------------------
 
//  TTBDMI_SH
 
// ------------------------------------------------------------------------------
class TTBDMI_SH : public TraitStatHandler< TProtoBDMI, TTBDMI_SH > {
 
  double _freq, _freqIcomp;
  double *_patchFreq, *_patchIcmp;
  
public:
  TTBDMI_SH(TProtoBDMI* TP) : TraitStatHandler< TProtoBDMI, TTBDMI_SH > (TP),
  _freq(0), _freqIcomp(0), _patchFreq(0), _patchIcmp(0) {}
  
  virtual ~TTBDMI_SH(){if(_patchFreq)delete[]_patchFreq;if(_patchIcmp)delete[]_patchIcmp;}
  
  virtual bool setStatRecorders (std::string& token);
  
  void addStats          (age_t AGE);
  void setAdultStats     () ;
  void setOffsprgStats   ();
  void setStats          (age_idx agex, void(TTBDMI_SH::* cntFunc)(Patch*,sex_t,age_idx,double**,double**));
  void countAllele_haplo (Patch *patch, sex_t SEX, age_idx AGE, double **frqTab, double **icpTab);
  void countAllele_diplo (Patch *patch, sex_t SEX, age_idx AGE, double **frqTab, double **icpTab);
  double getFreq         () {return _freq;}
  double getFreqIcmp     () {return _freqIcomp;}
  double getPatchFreq    (unsigned int i) {return _patchFreq[i];}
  double getPatchIcmp    (unsigned int i) {return _patchIcmp[i];}
  
};
 
// ------------------------------------------------------------------------------
 
//  LCE_Init_BDMI
 
// ------------------------------------------------------------------------------
class LCE_Init_BDMI : public LifeCycleEvent {
  
  TMatrix _init_freq;
  unsigned int _nLocus;
  
public:
  
  LCE_Init_BDMI ( );
  
  virtual ~LCE_Init_BDMI ( ) { }
  
  bool setSpatialPattern(TMatrix& freq_mat, unsigned int patchNbr);
  bool setPatchFreq(TMatrix& freq_mat,TMatrix& pat_mat, unsigned int patchNbr);
  void init_value(sex_t SEX, age_idx age, unsigned int size, unsigned int deme);
  
  //LifeCycleEvent implementation:
  virtual void execute ();
  
  virtual LifeCycleEvent* clone ( ) {return new LCE_Init_BDMI();}
  
  virtual bool setParameters ();
  
  //SimComponent implementation:
  virtual void loadFileServices ( FileServices* loader ) {}
  virtual void loadStatServices ( StatServices* loader ) {}
  virtual bool resetParameterFromSource (std::string param, SimComponent* cmpt) {return false;}
  virtual age_t removeAgeClass ( ) {return 0;}
  virtual age_t addAgeClass ( ) {return 0;}
  virtual age_t requiredAgeClass () {return 0;}
};
 
#endif