LCEmisc.h

Go to the documentation of this file.

 
#ifndef LCEMISC_H
#define LCEMISC_H
 
#include <iostream>
#include <string>
#include <map>
#include "types.h"
#include "lifecycleevent.h"
#include "fileservices.h"
#include "statservices.h"
#include "filehandler.h"
#include "stathandler.h"
#include "Uniform.h"
 
// LCE_Regulation
//
class LCE_Regulation: public LifeCycleEvent
{  
public:
 
  LCE_Regulation( ) : LifeCycleEvent("regulation","") {}
 
  virtual ~LCE_Regulation( ) { }
 
  void regulatePatch (Patch* patch, age_idx age, sex_t sex);
 
  //implementations:
  virtual bool setParameters () {return true;}
  virtual void execute ();
  virtual LCE_Regulation* clone ( ) {return new LCE_Regulation();}
  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 NONE;}
  virtual age_t addAgeClass ( ) {return NONE;}
  virtual age_t requiredAgeClass () {return NONE;}
};
 
// LCE_Aging
//
class LCE_Aging: public LifeCycleEvent
{
public:
 
  LCE_Aging( ) : LifeCycleEvent("aging","") {}
 
  virtual ~LCE_Aging( ) { }
 
  //implementations:
  virtual bool setParameters () {return true;}
  virtual void execute ();
  virtual LCE_Aging* clone ( ) {return new LCE_Aging();}
  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 OFFSPRG;}
  virtual age_t addAgeClass ( ) {return ADULTS;}
  virtual age_t requiredAgeClass () {return OFFSPRG;}
};
 
// LCE_Patch_Extinction
//
class LCE_Patch_Extinction: public LifeCycleEvent
{
  TMatrix* _Xtion_rate;
  TMatrix* _harvest_size;
  TMatrix* _harvest_proportion;
  string _harvest_distribution;
  bool _harvest_size_varies, _by_size, _by_proportion;
  double _harvest_dist_stdev;
  double _harvest_dist_shape;
  double _extinction_threshold;
 
  unsigned int (LCE_Patch_Extinction:: *_rand_size_fct) (double);
 
  unsigned int rand_uniform   (double max) {return RAND::Uniform((unsigned int)max);}
  unsigned int rand_poisson   (double mean){return (unsigned int)RAND::Poisson(mean);}
  unsigned int rand_gaussian  (double mean){return (unsigned int)abs(mean + RAND::Gaussian(_harvest_dist_stdev));}
  unsigned int rand_exp       (double mean){return (unsigned int)(-1.0 * mean * log(1.0-RAND::Uniform()));}
  unsigned int rand_lognormal (double mean){return (unsigned int)RAND::LogNormal(mean, _harvest_dist_stdev);}
 
public:
 
  LCE_Patch_Extinction( ) ;
  virtual ~LCE_Patch_Extinction( ) 
  {
    if(_Xtion_rate) delete _Xtion_rate;
    if(_harvest_size) delete _harvest_size; 
    if(_harvest_proportion) delete _harvest_proportion;
  }
 
  bool set_matrix_param (TMatrix* mat, string name);
  void do_flush (Patch *patch);
  void do_remove (age_idx AGE, Patch *patch);
  unsigned int get_harvest_size (age_idx AGE, Patch *patch);
 
  //LifeCycleEvent interface:
  virtual bool setParameters ();
  virtual void execute ();
  virtual LifeCycleEvent* clone ( ) {return new LCE_Patch_Extinction();}
 
  //SimComponent interface:
  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;}
};
 
class FHPedigreeReader;
 
//CROSSING    
//
class LCE_Cross : public LifeCycleEvent
{
  unsigned int _nSire, _nDam;
  unsigned int _nOffspring;
  unsigned int _atGeneration;
  bool _doAmongPop, _doWithinPop, _doReplace;
 
  FHPedigreeReader* _reader;
  string _pedigree_file;
  map<unsigned long, Individual* > _pedigree_pop;
 
public:
 
  LCE_Cross( );
  virtual ~LCE_Cross( ) { }
 
  void sampleAmongPop(Patch* patch, deque<Individual*>& males, unsigned int nsire);
  void sampleWithinPop(Patch* patch, deque<Individual*>& males, deque<Individual*>& females, unsigned int nsire);
  void generatePedigree ();
  bool create_individual_ancestors(Individual* ind);
 
  //LifeCycleEvent interface:
  virtual bool setParameters ();
  virtual void execute ();
  virtual LifeCycleEvent* clone ( ) {return new LCE_Cross();}
 
  //SimComponent interface:
  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;}
 
};
 
//CROSSING FILE READER
//
class FHPedigreeReader : public EventFileHandler<LCE_Cross> {
public:
  FHPedigreeReader(LCE_Cross* event); // : EventFileHandler< LCE_Cross > (event, ".ped");
  virtual ~FHPedigreeReader(){}
 
  virtual void FHwrite () {}
  virtual void FHread (string& filename);
 
  vector< unsigned long * >& getPedigree() {return _pedigree;}
 
private:
  vector< unsigned long * > _pedigree;
};
 
 
//RESIZE POP    
//
class LCE_Resize : public LifeCycleEvent
{
  list< int >::const_iterator _genITER;
  int _atGeneration;
  list< int > _generations;
  bool _do_flush, _do_fill, _do_regulate;
  TMatrix _patch2keep;
  age_t _setAge;
  Patch* _patchBackup;
public:
 
  LCE_Resize( );
  virtual ~LCE_Resize( ) { if(_patchBackup) delete _patchBackup;}
 
  void buildNewPatchArrayNoBackup();
  void buildNewPatchArrayWithBackup();
  void removeDesignatedPatch(bool do_backup);
  void updatePatchCapacities();
  void fillPop ( void (LCE_Resize:: *fillFuncPtr) (unsigned int p, age_idx age));
  void fillPatchNoBackup(unsigned int p, age_idx age);
  void fillPatchWithBackup(unsigned int p, age_idx age);
  void regulate( void (LCE_Resize::* regFuncPtr) (Patch *patch, age_idx age));
  void regulateAgeClassWithBackup(Patch *patch, age_idx age);
  void regulateAgeClassNoBackup(Patch *patch, age_idx age);
 
  //LifeCycleEvent interface:
  virtual bool setParameters ();
  bool         updateParameters ();
  virtual void execute ();
  virtual LifeCycleEvent* clone ( ) {return new LCE_Resize();}
 
  //SimComponent interface:
  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 //LCEMISC_H