ttwolbachia.h

Go to the documentation of this file.

 
#ifndef TTWOLBACHIA_H
#define TTWOLBACHIA_H
 
#include "ttrait.h"
#include "lifecycleevent.h"
#include "filehandler.h"
#include "stathandler.h"
#include "binarystoragebuffer.h"
#include "Uniform.h"
#include "LCEbreed.h"
 
class TTWolbachiaSH;
 
// ------------------------------------------------------------------------------
 
//                                TTWolbachia 
 
// ------------------------------------------------------------------------------
class TTWolbachia : public TTrait
{
private:
  double _transmit_rate;  
  bool _is_infected;
  
public:
        
    TTWolbachia () 
    : _transmit_rate(0), _is_infected(0) { }
  
  TTWolbachia (const TTWolbachia& T) 
    : _transmit_rate(T._transmit_rate), _is_infected(T._is_infected) { }
  
  
  virtual ~TTWolbachia                            () {}
  
  void set_transmit_rate              (double val) {_transmit_rate = val;}
  
  virtual void    init                              ()  {_is_infected = 0;}
  virtual void    init_sequence         ()  {_is_infected = 0;}
  virtual void    reset                             ()  {_is_infected = 0;}
  virtual void    inherit         (const TTrait* mother, const TTrait* father)
  {  _is_infected = *(bool*)mother->getValue();  }
  virtual void    mutate          ()
  {  _is_infected &= (RAND::Uniform() < _transmit_rate);  }  
  virtual void*   set_trait                       (void* value)
  {  _is_infected = *(bool*)value; return &_is_infected; }
  virtual void    set_sequence    (void** seq)  { }
  virtual void    set_value       ()  { }
  virtual void*   getValue                        () const {return (void*)&_is_infected;}
  virtual trait_t get_type                        () const {return WOLB;}
  virtual void**  get_sequence    () const {return NULL;}  
  virtual unsigned int    get_allele (int loc, int all) const {return _is_infected;}
  virtual double  get_allele_value(int loc, int all) const {return _is_infected;}
  virtual void    set_allele_value(unsigned int locus, unsigned int allele, double value)  {_is_infected=(bool)value;}  
  virtual void    show_up                           ()       {}
  virtual TTWolbachia*  clone             ()       {return new TTWolbachia(*this);}
  virtual TTWolbachia& operator=  (const TTrait& T);
  virtual bool    operator==      (const TTrait& T);
  virtual bool    operator!=      (const TTrait& T);
    
  virtual void    store_data      (BinaryStorageBuffer* saver)  
  { 
    unsigned char dummy = static_cast<unsigned char>(_is_infected);
    saver->store(&dummy, 1);
  }
  virtual bool    retrieve_data   (BinaryStorageBuffer* reader)
  {
    unsigned char dummy;
    reader->read(&dummy, 1);
    _is_infected = dummy;
    return true;
  }
  
};
 
// ------------------------------------------------------------------------------
 
//                                 TProtoWolbachia  
 
// ------------------------------------------------------------------------------
class TProtoWolbachia : public TraitPrototype {
public:
  TProtoWolbachia();
  TProtoWolbachia(const TProtoWolbachia&);
  ~TProtoWolbachia();
  
  virtual void init(){}
  virtual void reset(){}
  virtual bool setParameters()
  { _transmit_rate =  get_parameter_value("wolbachia_transmission_rate"); return true;}
  
  virtual TTWolbachia* hatch() 
  {
    TTWolbachia* new_trait = new TTWolbachia();
    new_trait->set_transmit_rate(_transmit_rate);
    return new_trait;
  }
  
  virtual TProtoWolbachia* clone() {return new TProtoWolbachia(*this);}
  
  virtual trait_t get_type ( ) const {return WOLB;}
  virtual   int             get_phenotype_dimension () {return 1;}
  virtual   int             get_allele_number () {return 2;}
  virtual   int             get_locus_number        () {return 1;}
  virtual   bool            is_mappable () {return false;}
  virtual   bool            is_mapped () {return false;}
  virtual   vector< unsigned int > get_locus_map_positions () {return vector<unsigned int>(1,0);}
 
  
  virtual void store_data (BinaryStorageBuffer* saver)     {/*we have nothing to save...*/}
  virtual bool retrieve_data (BinaryStorageBuffer* reader) {return true;}
  
  virtual void    loadFileServices ( FileServices* loader ) {}
  virtual void    loadStatServices ( StatServices* loader );
  virtual bool resetParameterFromSource (std::string param, SimComponent* cmpt) {return false;}
 
  
private:
  
    double _transmit_rate;
  TTWolbachiaSH* _stats;
};
 
// ------------------------------------------------------------------------------
 
//                                TTWolbachiaSH 
 
// ------------------------------------------------------------------------------
class TTWolbachiaSH : public TraitStatHandler<TProtoWolbachia, TTWolbachiaSH> {
  
  TProtoWolbachia* _trait;
  int _TTidx;
  double _Fmean, _Mmean, _var, _extrate;
public:
  
  TTWolbachiaSH (TProtoWolbachia* TT) 
  : TraitStatHandler<TProtoWolbachia, TTWolbachiaSH> (TT),
  _trait(TT), _TTidx(TT->get_index()), _Fmean(0), _Mmean(0), _var(0), _extrate(0) {}
  
  virtual ~TTWolbachiaSH ( ) { }
  
  virtual bool setStatRecorders (string& token);
  
  void   setInfectionStats                      ( );
  double getMeanInfection                       (unsigned int sex) {return ((bool)sex ? _Fmean : _Mmean);}
  double getMeanOffsprgInfection                (unsigned int sex);
  double getMeanFemaleInfection_perPatch        (unsigned int patch);
  double getMeanMaleInfection_perPatch          (unsigned int patch);
  double getMeanOffsprgFemaleInfection_perPatch (unsigned int patch);
  double getMeanOffsprgMaleInfection_perPatch   (unsigned int patch);
  double getIcompatibleMatingFreq                               ( );
  double getDemicInfectionVar                   ( ) {return _var;}
  double getDemicExtinctionRate                 ( ) {return _extrate;}
};
 
 
 
class TTWolbachiaFH;
 
 
class LCE_Breed_Wolbachia : public virtual LCE_Breed_base  {
  
  double _incomp_cost;
  double _fec_cost;
  double _infected_fec;
  TMatrix* _inoculum_size;
  unsigned int _inoculum_time;
  unsigned int _model;
  
  void (LCE_Breed_Wolbachia::* _breed_func_ptr) ();
  
  TTWolbachiaFH* _writer;
  
  void inoculate_wolbachia();
  double hasInfectedFemale ();
  
public:
        
        LCE_Breed_Wolbachia ( );
  
  virtual ~LCE_Breed_Wolbachia ( );
  
  void wolbachia_model_1 ();
  void wolbachia_model_2 ();
  
  virtual bool setParameters ();
  virtual void  execute ();
  
  virtual LifeCycleEvent* clone ( ) 
  { return new LCE_Breed_Wolbachia(); }
  
  
  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 OFFSPRG;}
  virtual age_t requiredAgeClass () {return ADULTS;}
};
 
// ------------------------------------------------------------------------------
 
//                               ****** TTWolbachiaFH ******
 
// ------------------------------------------------------------------------------
class TTWolbachiaFH: public EventFileHandler<LCE_Breed_Wolbachia> {
  
  map< unsigned int, unsigned int > _times;
  vector< double > _rate;
  
public:
        
  TTWolbachiaFH ( LCE_Breed_Wolbachia* TP )
  : EventFileHandler<LCE_Breed_Wolbachia> (TP, ".wolb")
  { }
  
  //TTWolbachiaFH ( ) { }
  virtual ~TTWolbachiaFH ( ) { }
  
  void record (unsigned int repl, unsigned int gen, double infection);
  
  virtual void FHwrite  ();
  
  virtual void FHread (string& filename) {}
  
};
 
#endif //TTWOLBACHIA_H