LCEcomposite.h

Go to the documentation of this file.

 
#ifndef LCE_COMPOSITE_H
#define LCE_COMPOSITE_H
 
#include <cmath>
#include "LCEbreed.h"
#include "LCEdisperse.h"
#include "LCEselection.h"
#include "lifecycleevent.h"
 
#ifdef HAS_GSL
 #include <gsl/gsl_rng.h>
 #include <gsl/gsl_randist.h>
#endif
//CLASS LCE_Breed_Disperse
//
class LCE_Breed_Disperse : public virtual LCE_Breed_base, public virtual LCE_Disperse_base
{
  void (LCE_Breed_Disperse::* _breed_disperse)();
 
 
  TMatrix _growthRates;
 
  // EXPONENTIAL GROWTH PARAMETERS:
  TMatrix _N_at_T0;
  unsigned int _T0_exp_growth;
 
protected: //so that the derived class can use these function pointers
 
  TMatrix _num_colonizers;
 
  sex_t _dispersing_sex;
 
  Individual*  (LCE_Breed_Disperse::* _make_offspring)(sex_t SEX, Patch* patch, unsigned int LocalPatch,
      gsl_ran_discrete_t* rate_fem, gsl_ran_discrete_t* rate_mal);
  unsigned int (LCE_Breed_Disperse::* _get_numFemOffspring)(Patch* patch);
  unsigned int (LCE_Breed_Disperse::* _get_numMalOffspring)(Patch* patch);
  unsigned int (LCE_Breed_Disperse::* _get_patchFecundity )(Patch* patch, sex_t SEX);
  
public:
  
  LCE_Breed_Disperse();
  
  virtual ~LCE_Breed_Disperse (){}
  
  void do_breed_disperse                ();
  void do_breed_disperse_propagule      ();
  void do_breed_disperse_in_patch       (sex_t SEX, Patch* patch, unsigned int ID, unsigned int num_offsprg);
  void do_breed_disperse_in_empty_patch (sex_t SEX, Patch* patch, unsigned int ID, unsigned int num_offsprg);
  
  
  unsigned int numFemOffspring              (Patch *patch)
  {
//    if (patch->size(FEM, ADLTx) == 0 && _dispersing_sex != FEM)//to avoid choosing a local female when there is none
//      return 0;
//    else
      return (this->*_get_patchFecundity)(patch, FEM);
  }
  
  unsigned int numFemOffspring_colonizers   (Patch *patch)
  {
    if(patch->isEmpty()) {
//      //check if only one sex sends gametes around, capturing the case of pollen dispersal
//      if(_dispersing_sex != FEM)
//        return 0;
//      else
 
      return _num_colonizers.get(1, patch->getID()); // Females on second row
 
    } else
      return (this->*_get_patchFecundity)(patch, FEM);
  }
 
  unsigned int numMalOffspring_notrandom     (Patch *patch)
  {
    return 0;
  }
  
  unsigned int numMalOffspring_random        (Patch *patch)
  { //return 0 if only males gametes migrate and there is no females in the patch
    //to avoid choosing a local female when there is none
    //(we assume it doesn't make sense to have only female gametes migrating)
//    if (patch->size(FEM, ADLTx) == 0 && _dispersing_sex != FEM)
//      return 0;
//    else
      return (this->*_get_patchFecundity)(patch, MAL);
  }
  
  unsigned int numMalOffspring_random_colonizers (Patch *patch)
  {
    if(patch->isEmpty()) {
//      //check if only one sex sends gametes around, capturing the case of pollen dispersal
//      if(_dispersing_sex != FEM)
//        return 0;
//      else
        return _num_colonizers.get(0, patch->getID()); // Males on first row
    } else
      return (this->*_get_patchFecundity)(patch, MAL);
  }
  
 
  unsigned int instantGrowth  (Patch* patch, sex_t SEX)
  {
    return patch->get_K(SEX);
  }
  unsigned int logisticGrowth (Patch* patch, sex_t SEX) 
  {
    double K = (double)patch->get_K(SEX);
    double r = _growthRates.get(0, patch->getID());
    double N = (double)patch->size(ADLTx);
    if( K <= N )
      return K;
    else
      return (unsigned int)ceil(N + r*N*((K-N)/K));
  }
  unsigned int stochasticLogisticGrowth (Patch* patch, sex_t SEX) 
  {
    return (unsigned int)RAND::Poisson((double)logisticGrowth(patch, SEX));
  }
  unsigned int conditionalLogisticGrowth (Patch* patch, sex_t SEX)
  {
    if (patch->size(SEX, ADLTx) < patch->get_K(SEX)/2) {
      return fixedFecundityGrowth(patch, SEX);
    } else {
      return logisticGrowth(patch, SEX);
    }
  }
  unsigned int conditionalStochasticLogisticGrowth (Patch* patch, sex_t SEX)
  {
    if (patch->size(SEX, ADLTx) < patch->get_K(SEX)/2) {
      return stochasticFecundityGrowth(patch, SEX);
    } else {
      return stochasticLogisticGrowth(patch, SEX);
    }
  }
  unsigned int fixedFecundityGrowth (Patch* patch, sex_t SEX)
  {
    return patch->size(SEX,ADULTS)*LCE_Breed_base::getMeanFecundity(patch->getID());
  }
  unsigned int stochasticFecundityGrowth (Patch* patch, sex_t SEX)
  {
    return RAND::Uniform(patch->size(SEX,ADULTS)*LCE_Breed_base::getMeanFecundity(patch->getID()));
  }
  unsigned int exponentialGrowth (Patch* patch, sex_t SEX);
  
  Individual* mate_random         (sex_t SEX, Patch *patch, unsigned int LocalPatch,
      gsl_ran_discrete_t* rate_fem, gsl_ran_discrete_t* rate_mal);
 
  Individual* mate_random_hermaphrodite (sex_t SEX, Patch *patch, unsigned int LocalPatch,
      gsl_ran_discrete_t* rate_fem, gsl_ran_discrete_t* rate_mal);
 
  Individual* mate_selfing        (sex_t SEX, Patch *patch, unsigned int LocalPatch,
      gsl_ran_discrete_t* rate_fem, gsl_ran_discrete_t* rate_mal);
 
  Individual* mate_full_selfing   (sex_t SEX, Patch *patch, unsigned int LocalPatch,
      gsl_ran_discrete_t* rate_fem, gsl_ran_discrete_t* rate_mal);
 
  Individual* mate_cloning        (sex_t SEX, Patch *patch, unsigned int LocalPatch,
      gsl_ran_discrete_t* rate_fem, gsl_ran_discrete_t* rate_mal);
 
  Individual* makeOffspring       (Individual* ind);
  
  Individual* get_parent          (sex_t SEX, sex_t DispSex, Patch* LocalPatch, unsigned int patchID,
      gsl_ran_discrete_t* rates);
  
//  virtual void init(Metapop* popPtr);  
  virtual bool setParameters ();
  virtual void execute ();
  virtual LifeCycleEvent* clone () {return new LCE_Breed_Disperse();}
  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 (isWrightFisher() ? NONE : OFFSPRG);}
  virtual age_t requiredAgeClass () {return ADULTS;}
  
};
 
// Class LCE_Breed_Selection
// 
class LCE_Breed_Selection : public virtual LCE_Breed_base, public virtual LCE_Selection_base
{
  
  void (LCE_Breed_Selection::* _breed_selection) (Patch* patch, unsigned int patchID, unsigned int *cntr);
  
  unsigned int _nb_trait;
  
  vector< unsigned int > _nonSelectedTraitIndices;
  
public:
    
  LCE_Breed_Selection ( ); // : LifeCycleEvent("breed_selection","") {}
  virtual ~LCE_Breed_Selection ( ) {}
  
  bool setNonSelectedTraitTable ();
 
  Individual* makeOffspringWithSelection (Individual* ind, unsigned int natalpatch);
 
  void do_breed_selection_FecFitness   (Patch* patch, unsigned int patchID, unsigned int *cntr);
  void do_breed_selection_OffSurvival  (Patch* patch, unsigned int patchID, unsigned int *cntr);
  void do_breed_selection_WrightFisher_2sex (Patch* patch, unsigned int patchID, unsigned int *cntr);
  void do_breed_selection_WrightFisher_1sex (Patch* patch, unsigned int patchID, unsigned int *cntr);
 
  void setReproScaledFitness_sum (sex_t SEX, valarray< double > &survival, unsigned int numReproFem, Patch* patch);
  gsl_ran_discrete_t* setReproScaledFitness_gsl (sex_t SEX, unsigned int numReproInd, Patch* patch);
 
//  virtual void init (Metapop* popPtr);
  virtual bool setParameters    ( );
  virtual void  execute         ( );
  virtual LifeCycleEvent* clone ( ){ return new LCE_Breed_Selection(); }
  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 (isWrightFisher() ? NONE : OFFSPRG);}
  virtual age_t requiredAgeClass( ) {return ADULTS;}
};
 
//CLASS LCE_Breed_Selection_Disperse
//
class LCE_Breed_Selection_Disperse : public virtual LCE_Breed_Disperse, public virtual LCE_Breed_Selection
{
//  int _max_try;
  
  void (LCE_Breed_Selection_Disperse::* _breed_selection_disperse)(int* counter);
  
public:
 
  LCE_Breed_Selection_Disperse();
  
  virtual ~LCE_Breed_Selection_Disperse() {}
  
  void breed_selection_disperse(int* counter);
  void breed_selection_disperse_propagule(int* counter);
  
  void do_breed (sex_t SEX, unsigned int size, int* counter, Patch* patch, unsigned int patchID);
    
//  virtual void init(Metapop* popPtr);  
  virtual bool setParameters ();
  virtual void execute ();
  virtual LifeCycleEvent* clone () {return new LCE_Breed_Selection_Disperse();}
  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 (isWrightFisher() ? NONE : OFFSPRG);}
  virtual age_t requiredAgeClass () {return ADULTS;}
};
#endif