LCEbreed.h

Go to the documentation of this file.

 
#ifndef LCEBREED_H
#define LCEBREED_H
 
#include <functional>
#include "lifecycleevent.h"
#include "Uniform.h"
 
 
// Class LCE_Breed_base
// 
class LCE_Breed_base : public virtual LifeCycleEvent
{
  int _mating_system;
  unsigned int _mating_males;
  unsigned int _alpha_male;
  double _mating_proportion, _sd_fecundity;
  bool _do_inherit;
 
protected:
 
  Individual* (LCE_Breed_base::* MatingFuncPtr)   (Patch*, Individual*, unsigned int);
  Individual* (LCE_Breed_base::* DoBreedFuncPtr)  (Individual* mother, Individual* father, unsigned int LocalPatch);
  double (LCE_Breed_base::* FecundityFuncPtr)     (double mean);
  bool   (LCE_Breed_base::* CheckMatingConditionFuncPtr) (Patch* thePatch);
  sex_t  (LCE_Breed_base::* GetOffsprgSex)        ();
  void    (LCE_Breed_base::* PopModelFuncPtr) (void);
  
  TMatrix _mean_fecundity;
  
public:
 
  LCE_Breed_base ();
  
  virtual ~LCE_Breed_base ( ) {}
  
  virtual Individual* getFatherPtr (Patch* thePatch, Individual* mother, unsigned int motherIndex)
  { 
    return (this->*MatingFuncPtr)(thePatch, mother, motherIndex);
  }  
  virtual bool setParameters();
  
  bool setMatingSystem ();
  bool setFecundity ();
  bool setSexRatio ();
  double getMatingProportion ()                       {return _mating_proportion;}
  double getMeanFecundity    (unsigned int patch)     {return _mean_fecundity.get(0, patch);}
  int    getMatingSystem     ()                       {return _mating_system;}
  bool   doInheritance       ()                       {return _do_inherit;}
  double getPoissonFecundity (double mean)            {return RAND::Poisson(mean);}
  double getFixedFecundity   (double mean)            {return (mean < 0) ? 0 : mean;}
  double getGaussianFecundity(double mean)            {
    double fec; do{fec = mean + RAND::Gaussian(_sd_fecundity);}while(fec < 0);
    return fec;}
  double getLogNormalFecundity(double mean)            {
    double fec; do{fec = mean + RAND::LogNormal(mean, _sd_fecundity);}while(fec < 0);
    return fec;}
  double getFecundity        (unsigned int patch)     {return (this->* FecundityFuncPtr)(_mean_fecundity.get(0, patch));}
  double getFecundity        (double mean)            {return (this->* FecundityFuncPtr)(mean);}
  sex_t  getOffsprgSex       ()                       {return (this->* GetOffsprgSex) ();}
  sex_t  getOffsprgSexRandom ()                       {return (sex_t)RAND::RandBool();}
  sex_t  getOffsprgSexFixed  ();
  sex_t  getOffsprgSexSelfing()                       {return FEM;}
  sex_t  getOffsprgSexCloning()                       {return FEM;}
 
  bool   isWrightFisher      ()                       {return get_parameter("mating_isWrightFisher")->isSet();}
 
  void   NonWrightFisherPopulation ();
 
  void   WrightFisherPopulation    ();
 
  Individual* breed           (Individual* mother, Individual* father, unsigned int LocalPatch);
  
  Individual* breed_cloning   (Individual* mother, Individual* father, unsigned int LocalPatch);
  
  Individual* makeOffspring   (Individual* ind);
  
  Individual* do_breed        (Individual* mother, Individual* father, unsigned int LocalPatch)
  {
    return (this->* DoBreedFuncPtr)(mother, father, LocalPatch);
  }
  
  bool checkMatingCondition (Patch* thePatch)
  {
    return (this->* CheckMatingConditionFuncPtr) (thePatch);
  }
  bool checkNoSelfing (Patch* thePatch)
  {
    return (thePatch->size(FEM, ADLTx) != 0 && thePatch->size(MAL, ADLTx) != 0);
  }
  
  bool checkPolygyny (Patch* thePatch)
  {
    if(thePatch->size(FEM, ADLTx) == 0 || thePatch->size(MAL, ADLTx) == 0) return false;
    
//    if(thePatch->size(MAL, ADLTx) < _mating_males) _mating_males = thePatch->size(MAL, ADLTx);
    
    _alpha_male = (unsigned int)RAND::Uniform(thePatch->size(MAL, ADLTx));
    
    return true;
  }
  
  bool checkSelfing (Patch* thePatch)
  {
    if(thePatch->size(MAL, ADLTx) != 0) thePatch->flush(MAL, ADLTx, this->_popPtr);
    return (thePatch->size(FEM, ADLTx) != 0);
  }
  
  bool checkCloning (Patch* thePatch)
  {    
    if(thePatch->size(MAL, ADLTx) != 0) thePatch->flush(MAL, ADLTx, this->_popPtr);
   
    return (thePatch->size(FEM, ADLTx) != 0);
  }
  
  
 
  Individual* RandomMating   (Patch* thePatch, Individual* mother, unsigned int motherIndex)
  { return thePatch->get(MAL, ADLTx, RAND::Uniform(thePatch->size(MAL, ADLTx)) ); }
  
  Individual* fullPolyginy (Patch* thePatch, Individual* mother, unsigned int motherIndex)
  { return thePatch->get(MAL, ADLTx, _alpha_male); }
  
  Individual* fullPolyginy_manyMales (Patch* thePatch, Individual* mother, unsigned int motherIndex)
  { 
    if(thePatch->size(MAL,ADLTx) < _mating_males)
      return thePatch->get(MAL, ADLTx, RAND::Uniform( thePatch->size(MAL, ADLTx) ) );
    else
      return thePatch->get(MAL, ADLTx, RAND::Uniform( _mating_males ) ); 
  }
  
  Individual* partialPolyginy (Patch* thePatch, Individual* mother, unsigned int motherIndex)
  {
    if(RAND::Uniform() > _mating_proportion)
      return RandomMating(thePatch, mother, 0);
    else
      return fullPolyginy(thePatch, 0, 0);
  }
  
  Individual* partialPolyginy_manyMales  (Patch* thePatch, Individual* mother, unsigned int motherIndex)
  {
    if(RAND::Uniform() > _mating_proportion)
      return RandomMating(thePatch, mother, 0);
    else
      return fullPolyginy_manyMales(thePatch, mother, 0);
  }
  
  Individual* fullMonoginy (Patch* thePatch, Individual* mother, unsigned int motherIndex)
  {
    if(thePatch->size(MAL, ADLTx) < motherIndex+1)
      return RandomMating(thePatch, mother, motherIndex);
    else
      return thePatch->get(MAL, ADLTx, motherIndex);
  }
  
  Individual* partialMonoginy (Patch* thePatch, Individual* mother, unsigned int motherIndex)
  {
    if(RAND::Uniform() > _mating_proportion || thePatch->size(MAL, ADLTx) < motherIndex+1)
      return RandomMating(thePatch, mother, motherIndex);
    else
      return thePatch->get(MAL, ADLTx, motherIndex);
  }
  
  Individual* fullSelfing  (Patch* thePatch, Individual* mother, unsigned int motherIndex)
  {
      return mother;
  }
  
  Individual* partialSelfing  (Patch* thePatch, Individual* mother, unsigned int motherIndex)
  {
    unsigned int fem;
    if(RAND::Uniform() > _mating_proportion) {
      do {
        fem = RAND::Uniform(thePatch->size(FEM, ADLTx));
      } while(fem == motherIndex && thePatch->size(FEM, ADLTx) != 1);
      return thePatch->get(FEM, ADLTx, fem);
    }else
      return mother;
  }
  
  Individual* random_hermaphrodite  (Patch* thePatch, Individual* mother, unsigned int motherIndex)
  {
    return thePatch->get(FEM, ADLTx, RAND::Uniform(thePatch->size(FEM, ADLTx)) );
  }
    
};
 
// Class LCE_Breed
// 
class LCE_Breed : public virtual LCE_Breed_base
{
  
public:
    
  LCE_Breed ( ) : LifeCycleEvent("breed","") { }
  
  virtual ~LCE_Breed   ( ) { }
  
  virtual bool setParameters ();
  virtual void  execute (); 
  
  virtual LifeCycleEvent* clone ( ) {return new LCE_Breed();}
  
  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             ( );
  virtual age_t requiredAgeClass        ( ) {return ADULTS;}
};
 
// Class LCE_BreedAssortativeMating
//
class LCE_BreedAssortativeMating : public virtual LCE_Breed_base
{
  // the phenotypic difference indicative of a match. Is zero by default
  double _assortative_value;
 
  // assortative tolerance around the difference in phenotype:
  double _assortative_tolerance;
 
  double assortative_value_with_tolerance;
 
  // the functor used to test for a match, following option by the user
  std::function<bool(double,double)> _assortative_predicate;
 
  double _prop_non_assortative;
 
  Individual* (LCE_Breed_base::* MatingFuncPtr_base)   (Patch*, Individual*, unsigned int);
 
  Individual* (LCE_Breed_base::* AssortativeMatingFuncPtr)   (Patch*, Individual*, unsigned int);
 
 
public:
 
  LCE_BreedAssortativeMating ( );
 
  virtual ~LCE_BreedAssortativeMating   ( ) { }
 
 
  bool   testAssortativeMatingCouple (const double female_trait_value, const double male_trait_value);
  Individual* non_assortative_mating (Patch* patch, Individual* mother, unsigned int motherIndex);
  Individual* assortative_mating (deque<Individual*>& males, Individual* mother, unsigned int motherIndex);
 
  // to randomize males position when mating
  void ScrambleContainer (const int length, deque<Individual*>& array);
 
  // LAMPREY specific function:
  Individual* breed_lamprey(Individual* mother, Individual* father, unsigned int LocalPatch);
  void setPhenotypeAncestryBased(Individual* ind);
  void setPhenotypeMotherInherited(Individual* ind);
 
  virtual bool setParameters ();
  virtual void  execute ();
 
  virtual LifeCycleEvent* clone ( ) {return new LCE_BreedAssortativeMating();}
 
  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;}
};
 
#endif //LCEBREED_H