LCE_Breed_base Class Reference

Base class for the breeding (and mating) life cycle events. More...

#include <LCEbreed.h>

Inheritance diagram for LCE_Breed_base:

Collaboration diagram for LCE_Breed_base:

Public Member Functions
	LCE_Breed_base ()
virtual	~LCE_Breed_base ()
virtual Individual *	getFatherPtr (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Calls the mating function according to the model chosen using the function pointer, used to get the father from the mother in a patch. More...
void	NonWrightFisherPopulation ()
void	WrightFisherPopulation ()
Individual *	breed (Individual *mother, Individual *father, unsigned int LocalPatch)
	Makes a new individual with the right parents. More...
Individual *	breed_cloning (Individual *mother, Individual *father, unsigned int LocalPatch)
	Makes a new individual by doing a deep copy of the mother (copies the mother's genes into the offspring). More...
Individual *	makeOffspring (Individual *ind)
	Last step of the breeding process, does inheritance and mutation of the parents' genes. More...
Individual *	do_breed (Individual *mother, Individual *father, unsigned int LocalPatch)
	Calls the breeding function unsing its pointer. More...
bool	checkMatingCondition (Patch *thePatch)
	Checks if any mating will take place in the patch passed as argument. More...
bool	checkNoSelfing (Patch *thePatch)
	Checks whether mating will take place in the current patch when mating is not selfing or cloning. More...
bool	checkPolygyny (Patch *thePatch)
	Checks whether mating will take place in the current patch when mating is polygynous. More...
bool	checkSelfing (Patch *thePatch)
	Checks whether mating will take place in the current patch when mating is selfing. More...
bool	checkCloning (Patch *thePatch)
	Checks whether mating will take place in the current patch when mating is cloning. More...
Implementations
virtual bool	setParameters ()
Parameter setters/updaters
bool	setMatingSystem ()
bool	setFecundity ()
bool	setSexRatio ()
Accessors
double	getMatingProportion ()
double	getMeanFecundity (unsigned int patch)
int	getMatingSystem ()
bool	doInheritance ()
double	getPoissonFecundity (double mean)
double	getFixedFecundity (double mean)
double	getGaussianFecundity (double mean)
double	getLogNormalFecundity (double mean)
double	getFecundity (unsigned int patch)
double	getFecundity (double mean)
sex_t	getOffsprgSex ()
sex_t	getOffsprgSexRandom ()
sex_t	getOffsprgSexFixed ()
sex_t	getOffsprgSexSelfing ()
sex_t	getOffsprgSexCloning ()
bool	isWrightFisher ()
Mating functions
Individual *	RandomMating (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male drawn randomly from a patch. More...
Individual *	fullPolyginy (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to the alpha male of the patch. More...
Individual *	fullPolyginy_manyMales (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to one of the first _mating_males males of the patch. More...
Individual *	partialPolyginy (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male from a patch chosen at random if _mating_proportion != 1, or the first male otherwise. More...
Individual *	partialPolyginy_manyMales (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male from a patch chosen at random if _mating_proportion != 1, or one of the _mating_males first males otherwise. More...
Individual *	fullMonoginy (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male with same index as mother (if available) from the focal patch. More...
Individual *	partialMonoginy (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male with same index as mother (if available) from the focal patch. More...
Individual *	fullSelfing (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns the mother pointer. More...
Individual *	partialSelfing (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns the mother pointer or a random female if _mating_proportion != 1. More...
Individual *	random_hermaphrodite (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a random female from the patch, will be the same mother with probability 1/N (Wright-Fisher model). More...
Public Member Functions inherited from LifeCycleEvent
	LifeCycleEvent (const char *name, const char *trait_link)
	Cstor. More...
virtual	~LifeCycleEvent ()
virtual void	init (Metapop *popPtr)
	Sets the pointer to the current Metapop and the trait link if applicable. More...
virtual bool	attach_trait (string trait)
virtual void	set_paramset (std::string name, bool required, SimComponent *owner)
virtual void	set_event_name (std::string &name)
	Set the name of the event (name of the ParamSet) and add the corresponding parameter to the set. More...
virtual void	set_event_name (const char *name)
virtual string &	get_event_name ()
	Accessor to the LCE's name. More...
virtual int	get_rank ()
	Accessor to the LCE rank in the life cycle. More...
virtual void	set_pop_ptr (Metapop *popPtr)
	Accessors for the population pointer. More...
virtual Metapop *	get_pop_ptr ()
virtual void	execute ()=0
	Execute the event on the pop. More...
virtual LifeCycleEvent *	clone ()=0
	Cloning interface. More...
virtual age_t	removeAgeClass ()=0
	Removes the returned age-class flag(s) from the current Metapop age-class flags. More...
virtual age_t	addAgeClass ()=0
	Adds the returned age-class flag(s) to the current Metapop age-class flags. More...
virtual age_t	requiredAgeClass ()=0
	Specifies what age-classes are required by the LCE to execute. More...
Public Member Functions inherited from SimComponent
	SimComponent ()
virtual	~SimComponent ()
virtual void	loadFileServices (FileServices *loader)=0
	Loads the component's FileHandler onto the FileServices. More...
virtual void	loadStatServices (StatServices *loader)=0
	Loads the component's StatHandler onto the StatServices. More...
virtual void	loadUpdaters (UpdaterServices *loader)
	Loads the parameters and component updater onto the updater manager. More...
virtual void	set_paramset (ParamSet *paramset)
	Sets the ParamSet member. More...
virtual void	set_paramsetFromCopy (const ParamSet &PSet)
	Reset the set of parameters from a another set. More...
virtual ParamSet *	get_paramset ()
	ParamSet accessor. More...
virtual void	add_parameter (Param *param)
	Interface to add a parameter to the set. More...
virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd)
	Interface to add a parameter to the set. More...
virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd, ParamUpdaterBase *updater)
	Interface to add a parameter and its updater to the set. More...
virtual Param *	get_parameter (std::string name)
	Param getter. More...
virtual double	get_parameter_value (std::string name)
	Param value getter. More...
virtual string	get_name ()
	Returnd the name of the ParamSet, i.e. More...
virtual bool	has_parameter (std::string name)
	Param getter. More...
virtual bool	resetParameterFromSource (std::string param, SimComponent *cmpt)=0

Protected Attributes
TMatrix	_mean_fecundity
Function pointers
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)
Protected Attributes inherited from LifeCycleEvent
std::string	_event_name
	The param name to be read in the init file. More...
Metapop *	_popPtr
	The ptr to the current Metapop. More...
std::string	_LCELinkedTraitType
	The name of the linked trait. More...
int	_LCELinkedTraitIndex
	The index in the individual's trait table of the linked trait. More...
Protected Attributes inherited from SimComponent
ParamSet *	_paramSet
	The parameters container. More...

Private Attributes
Parameters
int	_mating_system
unsigned int	_mating_males
unsigned int	_alpha_male
double	_mating_proportion
double	_sd_fecundity
bool	_do_inherit

Detailed Description

Base class for the breeding (and mating) life cycle events.

This class registers the whole set of basic mating parameters. Sets the function pointers for the mating system, fecundity and sex-ratio models, and breeding conditions checker (mostly checks for state of individual containers).

Constructor & Destructor Documentation

LCE_Breed_base()

LCE_Breed_base::LCE_Breed_base

(

)

: LifeCycleEvent("", ""),
_mating_system(0), _mating_proportion(1), _mean_fecundity(), _sd_fecundity(0),
_do_inherit(0), _mating_males(0), _alpha_male(0),
//_growthRates(0),
MatingFuncPtr(0),
DoBreedFuncPtr(0), PopModelFuncPtr(0),
FecundityFuncPtr(0), CheckMatingConditionFuncPtr(0), GetOffsprgSex(0)
 
{
  ParamUpdater<LCE_Breed_base> * updater = new ParamUpdater<LCE_Breed_base> (&LCE_Breed_base::setMatingSystem);
  
  add_parameter("mating_system",INT,true,true,1,6, updater);
  add_parameter("mating_proportion",DBL,false,true,0,1,updater);
  add_parameter("mating_males",INT,false,false,0,0, updater);
  add_parameter("mating_isWrightFisher", BOOL, false, false, 0, 0, updater);
 
//  add_parameter("growth_model", INT, false, true, 1, 7, updater);
//  add_parameter("growth_rate", DBL, false, false, 0, 0, updater);
  
  updater = new ParamUpdater< LCE_Breed_base > (&LCE_Breed_base::setFecundity);
  add_parameter("mean_fecundity",DBL,false,false,0,0, updater);
  add_parameter("fecundity_dist_stdev",DBL,false,false,0,0, updater);
  add_parameter("fecundity_distribution",STR,false,false,0,0, updater);
  
  updater = new ParamUpdater< LCE_Breed_base > (&LCE_Breed_base::setSexRatio);
  add_parameter("sex_ratio_mode",STR,false,false,0,0, updater);
}

References SimComponent::add_parameter(), BOOL, DBL, INT, setFecundity(), setMatingSystem(), setSexRatio(), and STR.

~LCE_Breed_base()

virtual LCE_Breed_base::~LCE_Breed_base ( )

inlinevirtual

{}

Member Function Documentation

breed()

Individual * LCE_Breed_base::breed	(	Individual *	mother,
		Individual *	father,
		unsigned int	LocalPatch
	)

Makes a new individual with the right parents.

Calls IndFactory::makeNewIndividual. The sex of the offspring is determined by a call to getOffsprgSex(). Recombination and mutation are done later, in the makeOffspring() procedure.

Parameters

mother	pointer to the mother
father	pointer to the father
LocalPatch	index of the natal patch

{
  return _popPtr->makeNewIndividual(mother, father, getOffsprgSex(), LocalPatch);
}

References LifeCycleEvent::_popPtr, getOffsprgSex(), and IndFactory::makeNewIndividual().

Referenced by setMatingSystem().

breed_cloning()

Individual * LCE_Breed_base::breed_cloning	(	Individual *	mother,
		Individual *	father,
		unsigned int	LocalPatch
	)

Makes a new individual by doing a deep copy of the mother (copies the mother's genes into the offspring).

Calls IndFactory::getNewIndividual() and then copy the mother into the new offspring.

Parameters

mother	pointer to the mother
father	pointer to the father (of no use here)
LocalPatch	index of the natal patch

{
  Individual *newind;
  
  if(mother == father) {
    newind = _popPtr->getNewIndividual();
    //cloning:
    (*newind) = (*mother); 
    
    newind->reset_counters();
    newind->setFather(NULL);
    newind->setFatherID(0);
    newind->setMother(mother);
    newind->setMotherID(mother->getID());
    newind->setIsSelfed(true);
    newind->setHome(LocalPatch);
    newind->setAge(0);
    _do_inherit = false;  
  } else {
    newind =  _popPtr->makeNewIndividual(mother, father, getOffsprgSex(), LocalPatch);
    _do_inherit = true;
  }
  
  return newind;
}

References _do_inherit, LifeCycleEvent::_popPtr, Individual::getID(), IndFactory::getNewIndividual(), getOffsprgSex(), IndFactory::makeNewIndividual(), Individual::reset_counters(), Individual::setAge(), Individual::setFather(), Individual::setFatherID(), Individual::setHome(), Individual::setIsSelfed(), Individual::setMother(), and Individual::setMotherID().

Referenced by LCE_Breed_Disperse::mate_cloning(), and setMatingSystem().

checkCloning()

bool LCE_Breed_base::checkCloning ( Patch *  thePatch )

inline

Checks whether mating will take place in the current patch when mating is cloning.

Only females must be present. Males containers are flushed if not empty.

Parameters

thePatch

the focal patch

  {    
    if(thePatch->size(MAL, ADLTx) != 0) thePatch->flush(MAL, ADLTx, this->_popPtr);
   
    return (thePatch->size(FEM, ADLTx) != 0);
  }

References LifeCycleEvent::_popPtr, ADLTx, FEM, Patch::flush(), MAL, and Patch::size().

Referenced by setMatingSystem().

checkMatingCondition()

bool LCE_Breed_base::checkMatingCondition ( Patch *  thePatch )

inline

Checks if any mating will take place in the patch passed as argument.

Is called prior to breeding in each patch. Calls the check function using its pointer.

Parameters

thePatch

the focal patch

  {
    return (this->* CheckMatingConditionFuncPtr) (thePatch);
  }

References CheckMatingConditionFuncPtr.

Referenced by LCE_BreedAssortativeMating::execute(), LCE_Breed_Selection::execute(), NonWrightFisherPopulation(), LCE_Breed_Quanti::NonWrightFisherPopulation(), WrightFisherPopulation(), and LCE_Breed_Quanti::WrightFisherPopulation().

checkNoSelfing()

bool LCE_Breed_base::checkNoSelfing ( Patch *  thePatch )

inline

Checks whether mating will take place in the current patch when mating is not selfing or cloning.

Males and females must be present in the patch for mating to occur.

Parameters

thePatch

the focal patch

  {
    return (thePatch->size(FEM, ADLTx) != 0 && thePatch->size(MAL, ADLTx) != 0);
  }

References ADLTx, FEM, MAL, and Patch::size().

Referenced by setMatingSystem().

checkPolygyny()

bool LCE_Breed_base::checkPolygyny ( Patch *  thePatch )

inline

Checks whether mating will take place in the current patch when mating is polygynous.

Males and females must be present in the patch for mating to occur.

Parameters

thePatch

the focal patch

  {
    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;
  }

References _alpha_male, ADLTx, FEM, MAL, Patch::size(), and RAND::Uniform().

Referenced by setMatingSystem().

checkSelfing()

bool LCE_Breed_base::checkSelfing ( Patch *  thePatch )

inline

Checks whether mating will take place in the current patch when mating is selfing.

Only females must be present.

Parameters

thePatch

the focal patch

  {
    if(thePatch->size(MAL, ADLTx) != 0) thePatch->flush(MAL, ADLTx, this->_popPtr);
    return (thePatch->size(FEM, ADLTx) != 0);
  }

References LifeCycleEvent::_popPtr, ADLTx, FEM, Patch::flush(), MAL, and Patch::size().

Referenced by setMatingSystem().

do_breed()

Individual* LCE_Breed_base::do_breed ( Individual *  mother, Individual *  father, unsigned int  LocalPatch  )

inline

Calls the breeding function unsing its pointer.

Used to distinguish cloning from other mating systems.

  {
    return (this->* DoBreedFuncPtr)(mother, father, LocalPatch);
  }

References DoBreedFuncPtr.

Referenced by LCE_Breed_Selection::do_breed_selection_FecFitness(), LCE_Breed_Selection::do_breed_selection_OffSurvival(), LCE_Breed_Selection::do_breed_selection_WrightFisher_1sex(), LCE_Breed_Selection::do_breed_selection_WrightFisher_2sex(), NonWrightFisherPopulation(), LCE_Breed_Quanti::NonWrightFisherPopulation(), WrightFisherPopulation(), and LCE_Breed_Quanti::WrightFisherPopulation().

doInheritance()

bool LCE_Breed_base::doInheritance ( )

inline

{return _do_inherit;}

References _do_inherit.

Referenced by makeOffspring(), and LCE_Breed_Selection::makeOffspringWithSelection().

fullMonoginy()

Individual* LCE_Breed_base::fullMonoginy ( Patch *  thePatch, Individual *  mother, unsigned int  motherIndex  )

inline

Returns a pointer to a male with same index as mother (if available) from the focal patch.

If the male is not available, one is drawn randomly from the patch.

Parameters

thePatch	the focal patch.
mother	the mother to mate with (unused here)
motherIndex	index of the mother in the patch adult female container

  {
    if(thePatch->size(MAL, ADLTx) < motherIndex+1)
      return RandomMating(thePatch, mother, motherIndex);
    else
      return thePatch->get(MAL, ADLTx, motherIndex);
  }

References ADLTx, Patch::get(), MAL, RandomMating(), and Patch::size().

Referenced by setMatingSystem().

fullPolyginy()

Individual* LCE_Breed_base::fullPolyginy ( Patch *  thePatch, Individual *  mother, unsigned int  motherIndex  )

inline

Returns a pointer to the alpha male of the patch.

The alpha male of a patch is set in the LCE_Breed_base::checkPolygyny function called before mating.

Parameters

thePatch	the focal patch.
mother	the mother to mate with (unused here).
motherIndex	index of the mother in the patch adult female container (unused here)

  { return thePatch->get(MAL, ADLTx, _alpha_male); }

References _alpha_male, ADLTx, Patch::get(), and MAL.

Referenced by partialPolyginy(), and setMatingSystem().

fullPolyginy_manyMales()

Individual* LCE_Breed_base::fullPolyginy_manyMales ( Patch *  thePatch, Individual *  mother, unsigned int  motherIndex  )

inline

Returns a pointer to one of the first _mating_males males of the patch.

Parameters

thePatch	the focal patch.
mother	the mother to mate with (unused here).
motherIndex	index of the mother in the patch adult female container (unused here)

  { 
    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 ) ); 
  }

References _mating_males, ADLTx, Patch::get(), MAL, Patch::size(), and RAND::Uniform().

Referenced by partialPolyginy_manyMales(), and setMatingSystem().

fullSelfing()

Individual* LCE_Breed_base::fullSelfing ( Patch *  thePatch, Individual *  mother, unsigned int  motherIndex  )

inline

Returns the mother pointer.

Parameters

thePatch	the focal patch.
mother	the mother to mate with (returned here)
motherIndex	index of the mother in the patch adult female container (unused here)

  {
      return mother;
  }

Referenced by setMatingSystem().

getFatherPtr()

virtual Individual* LCE_Breed_base::getFatherPtr ( Patch *  thePatch, Individual *  mother, unsigned int  motherIndex  )

inlinevirtual

Calls the mating function according to the model chosen using the function pointer, used to get the father from the mother in a patch.

Parameters

thePatch	pointer to the focal patch where mating is taking place
mother	pointer to the mother, returned when mating is done by self-fertilization or cloning
motherIndex	index of the mother in the current patch female container, used in the polyginy an monoginy mating systems

Returns

the pointer to the father following the mating scheme chosen

  { 
    return (this->*MatingFuncPtr)(thePatch, mother, motherIndex);
  }  

References MatingFuncPtr.

Referenced by LCE_Breed_Selection::do_breed_selection_FecFitness(), LCE_Breed_Selection::do_breed_selection_OffSurvival(), NonWrightFisherPopulation(), LCE_Breed_Quanti::NonWrightFisherPopulation(), LCE_Breed_Wolbachia::wolbachia_model_1(), LCE_Breed_Wolbachia::wolbachia_model_2(), WrightFisherPopulation(), and LCE_Breed_Quanti::WrightFisherPopulation().

getFecundity() [1/2]

double LCE_Breed_base::getFecundity ( double  mean )

inline

{return (this->* FecundityFuncPtr)(mean);}

References FecundityFuncPtr.

getFecundity() [2/2]

double LCE_Breed_base::getFecundity ( unsigned int  patch )

inline

{return (this->* FecundityFuncPtr)(_mean_fecundity.get(0, patch));}

References FecundityFuncPtr, and TMatrix::get().

Referenced by LCE_Breed_Selection::do_breed_selection_FecFitness(), LCE_Breed_Selection::do_breed_selection_OffSurvival(), NonWrightFisherPopulation(), LCE_Breed_Quanti::NonWrightFisherPopulation(), LCE_Breed_Wolbachia::wolbachia_model_1(), and LCE_Breed_Wolbachia::wolbachia_model_2().

getFixedFecundity()

double LCE_Breed_base::getFixedFecundity ( double  mean )

inline

{return (mean < 0) ? 0 : mean;}

Referenced by setFecundity().

getGaussianFecundity()

double LCE_Breed_base::getGaussianFecundity ( double  mean )

inline

                                                      {
    double fec; do{fec = mean + RAND::Gaussian(_sd_fecundity);}while(fec < 0);
    return fec;}

References _sd_fecundity, and RAND::Gaussian().

Referenced by setFecundity().

getLogNormalFecundity()

double LCE_Breed_base::getLogNormalFecundity ( double  mean )

inline

                                                       {
    double fec; do{fec = mean + RAND::LogNormal(mean, _sd_fecundity);}while(fec < 0);
    return fec;}

References _sd_fecundity, and RAND::LogNormal().

Referenced by setFecundity().

getMatingProportion()

double LCE_Breed_base::getMatingProportion ( )

inline

{return _mating_proportion;}

References _mating_proportion.

Referenced by LCE_Breed_Disperse::mate_selfing(), and LCE_Breed_Disperse::setParameters().

getMatingSystem()

int LCE_Breed_base::getMatingSystem ( )

inline

{return _mating_system;}

References _mating_system.

Referenced by LCE_Breed_Selection_Disperse::do_breed(), LCE_Breed_Disperse::do_breed_disperse_in_empty_patch(), LCE_Breed_Quanti::NonWrightFisherPopulation(), and LCE_Breed_Disperse::setParameters().

getMeanFecundity()

double LCE_Breed_base::getMeanFecundity ( unsigned int  patch )

inline

{return _mean_fecundity.get(0, patch);}

References _mean_fecundity, and TMatrix::get().

Referenced by LCE_Breed_Selection::do_breed_selection_FecFitness(), LCE_Breed_Disperse::fixedFecundityGrowth(), LCE_Breed_Selection::setParameters(), LCE_Breed_Wolbachia::setParameters(), LCE_Breed_Disperse::stochasticFecundityGrowth(), and LCE_Breed_Wolbachia::wolbachia_model_2().

getOffsprgSex()

sex_t LCE_Breed_base::getOffsprgSex ( )

inline

{return (this->* GetOffsprgSex) ();}

References GetOffsprgSex.

Referenced by breed(), and breed_cloning().

getOffsprgSexCloning()

sex_t LCE_Breed_base::getOffsprgSexCloning ( )

inline

{return FEM;}

References FEM.

Referenced by setSexRatio().

getOffsprgSexFixed()

sex_t LCE_Breed_base::getOffsprgSexFixed

(

)

{
  static bool sex = RAND::RandBool();
  sex ^= 1;
  return (sex_t)sex;
}

References RAND::RandBool().

Referenced by setSexRatio().

getOffsprgSexRandom()

sex_t LCE_Breed_base::getOffsprgSexRandom ( )

inline

{return (sex_t)RAND::RandBool();}

References RAND::RandBool().

Referenced by setSexRatio().

getOffsprgSexSelfing()

sex_t LCE_Breed_base::getOffsprgSexSelfing ( )

inline

{return FEM;}

References FEM.

Referenced by setSexRatio().

getPoissonFecundity()

double LCE_Breed_base::getPoissonFecundity ( double  mean )

inline

{return RAND::Poisson(mean);}

References RAND::Poisson().

Referenced by setFecundity().

isWrightFisher()

bool LCE_Breed_base::isWrightFisher ( )

inline

{return get_parameter("mating_isWrightFisher")->isSet();}

References SimComponent::get_parameter(), and Param::isSet().

Referenced by LCE_Breed::addAgeClass().

makeOffspring()

Individual * LCE_Breed_base::makeOffspring

(

Individual *

ind

)

Last step of the breeding process, does inheritance and mutation of the parents' genes.

Calls Individual::create(do_inherit, do_mutate) with do_inherit set following the local _do_inherit value. Updates the parent's fecundity counters. A breeding session looks like that:

Individual* newind;
Patch* natalPatch;
 
newind = makeOffspring( do_breed( mother, father = getFatherPtr(natalPatch, mother, motherIndex), LocalPatch = natalPatch->getID() ) )
 
natalPatch->add( newind->getSex(), OFFSx, newind );

Parameters

ind	the offspring, as returned by the do_breed function.

{
  unsigned int cat = ind->getPedigreeClass();
  
  ind->getMother()->DidHaveABaby(cat);
  if(cat!=4) ind->getFather()->DidHaveABaby(cat);
 
  return ind->create(doInheritance(), true);
}

References Individual::create(), Individual::DidHaveABaby(), doInheritance(), Individual::getFather(), Individual::getMother(), and Individual::getPedigreeClass().

Referenced by LCE_Breed_Disperse::do_breed_disperse_in_empty_patch(), LCE_Breed_Disperse::do_breed_disperse_in_patch(), LCE_Breed_Selection::do_breed_selection_FecFitness(), LCE_Breed_Selection::do_breed_selection_WrightFisher_1sex(), LCE_Breed_Selection::do_breed_selection_WrightFisher_2sex(), NonWrightFisherPopulation(), LCE_Breed_Quanti::NonWrightFisherPopulation(), WrightFisherPopulation(), and LCE_Breed_Quanti::WrightFisherPopulation().

NonWrightFisherPopulation()

void LCE_Breed_base::NonWrightFisherPopulation

(

)

{
  Patch* patch;
  Individual* mother;
  Individual* father;
  Individual* NewOffsprg;
  unsigned int nbBaby;
 
#ifdef _DEBUG_
  message("LCE_Breed::execute::NonWrightFisherPopulation::mating system: %i; mean fecundity[0]: %f",
      _mating_system, _mean_fecundity.get(0,0));
#endif
 
  //because mean fecundity can be patch-specific, we have to check whether the patch number changed
  if (_mean_fecundity.ncols() != _popPtr->getPatchNbr()) LCE_Breed_base::setFecundity();
 
  for(unsigned int i = 0; i < _popPtr->getPatchNbr(); i++) {
    
    patch = _popPtr->getPatch(i);
    
    if( !checkMatingCondition(patch) ) continue;
    
    for(unsigned int size = patch->size(FEM, ADLTx), indexOfMother = 0;
        indexOfMother < size;
        indexOfMother++)
    {
      mother = patch->get(FEM, ADLTx, indexOfMother);
      
      nbBaby = (unsigned int)mother->setFecundity( getFecundity(i) ) ; //allows for patch-specific fec
      //-----------------------------------------------------------------------
      while(nbBaby != 0) {
        
        father = this->getFatherPtr(patch, mother, indexOfMother);
        
        NewOffsprg = makeOffspring( do_breed(mother, father, i) );
        
        patch->add(NewOffsprg->getSex(), OFFSx, NewOffsprg);
        
        nbBaby--;
      }//_END__WHILE
      
    }
  }
 
#ifdef _DEBUG_
  message("done, new offsprg nb: %i \n",_popPtr->size( OFFSPRG ));
#endif
}

References _mating_system, _mean_fecundity, LifeCycleEvent::_popPtr, Patch::add(), ADLTx, checkMatingCondition(), do_breed(), FEM, Patch::get(), TMatrix::get(), getFatherPtr(), getFecundity(), Metapop::getPatch(), Metapop::getPatchNbr(), Individual::getSex(), makeOffspring(), message(), TMatrix::ncols(), OFFSPRG, OFFSx, setFecundity(), Individual::setFecundity(), Metapop::size(), and Patch::size().

Referenced by setMatingSystem().

partialMonoginy()

Individual* LCE_Breed_base::partialMonoginy ( Patch *  thePatch, Individual *  mother, unsigned int  motherIndex  )

inline

Returns a pointer to a male with same index as mother (if available) from the focal patch.

If the male is not available or _mating_proportion != 1, one is drawn randomly from the patch.

Parameters

thePatch	the focal patch.
mother	the mother to mate with (unused here)
motherIndex	index of the mother in the patch adult female container

  {
    if(RAND::Uniform() > _mating_proportion || thePatch->size(MAL, ADLTx) < motherIndex+1)
      return RandomMating(thePatch, mother, motherIndex);
    else
      return thePatch->get(MAL, ADLTx, motherIndex);
  }

References _mating_proportion, ADLTx, Patch::get(), MAL, RandomMating(), Patch::size(), and RAND::Uniform().

Referenced by setMatingSystem().

partialPolyginy()

Individual* LCE_Breed_base::partialPolyginy ( Patch *  thePatch, Individual *  mother, unsigned int  motherIndex  )

inline

Returns a pointer to a male from a patch chosen at random if _mating_proportion != 1, or the first male otherwise.

Parameters

thePatch	the focal patch.
mother	the mother to mate with (unused here).
motherIndex	index of the mother in the patch adult female container (unused here)

  {
    if(RAND::Uniform() > _mating_proportion)
      return RandomMating(thePatch, mother, 0);
    else
      return fullPolyginy(thePatch, 0, 0);
  }

References _mating_proportion, fullPolyginy(), RandomMating(), and RAND::Uniform().

Referenced by setMatingSystem().

partialPolyginy_manyMales()

Individual* LCE_Breed_base::partialPolyginy_manyMales ( Patch *  thePatch, Individual *  mother, unsigned int  motherIndex  )

inline

Returns a pointer to a male from a patch chosen at random if _mating_proportion != 1, or one of the _mating_males first males otherwise.

Parameters

thePatch	the focal patch.
mother	the mother to mate with (unused here).
motherIndex	index of the mother in the patch adult female container (unused here)

  {
    if(RAND::Uniform() > _mating_proportion)
      return RandomMating(thePatch, mother, 0);
    else
      return fullPolyginy_manyMales(thePatch, mother, 0);
  }

References _mating_proportion, fullPolyginy_manyMales(), RandomMating(), and RAND::Uniform().

Referenced by setMatingSystem().

partialSelfing()

Individual* LCE_Breed_base::partialSelfing ( Patch *  thePatch, Individual *  mother, unsigned int  motherIndex  )

inline

Returns the mother pointer or a random female if _mating_proportion != 1.

Parameters

thePatch	the focal patch.
mother	the mother to mate with (returned here)
motherIndex	index of the mother in the patch adult female container (unused here)

  {
    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;
  }

References _mating_proportion, ADLTx, FEM, Patch::get(), Patch::size(), and RAND::Uniform().

Referenced by setMatingSystem().

random_hermaphrodite()

Individual* LCE_Breed_base::random_hermaphrodite ( Patch *  thePatch, Individual *  mother, unsigned int  motherIndex  )

inline

Returns a random female from the patch, will be the same mother with probability 1/N (Wright-Fisher model).

Parameters

thePatch	the focal patch.
mother	the mother to mate with (unused here)
motherIndex	index of the mother in the patch adult female container (unused here)

  {
    return thePatch->get(FEM, ADLTx, RAND::Uniform(thePatch->size(FEM, ADLTx)) );
  }

References ADLTx, FEM, Patch::get(), Patch::size(), and RAND::Uniform().

Referenced by setMatingSystem().

RandomMating()

Individual* LCE_Breed_base::RandomMating ( Patch *  thePatch, Individual *  mother, unsigned int  motherIndex  )

inline

Returns a pointer to a male drawn randomly from a patch.

Parameters

thePatch	the focal patch.
mother	the mother to mate with (unused here)
motherIndex	index of the mother in the patch adult female container (unused here)

  { return thePatch->get(MAL, ADLTx, RAND::Uniform(thePatch->size(MAL, ADLTx)) ); }

References ADLTx, Patch::get(), MAL, Patch::size(), and RAND::Uniform().

Referenced by fullMonoginy(), LCE_BreedAssortativeMating::non_assortative_mating(), partialMonoginy(), partialPolyginy(), partialPolyginy_manyMales(), and setMatingSystem().

setFecundity()

bool LCE_Breed_base::setFecundity

(

)

{
  // FECUNDITY
 
  _mean_fecundity.reset();
  
  if (get_parameter("mean_fecundity")->isMatrix()) {
    
    get_parameter("mean_fecundity")->getMatrix(&_mean_fecundity);
    
    if(_mean_fecundity.nrows() != 1) {
      return error("\"mean_fecundity\" accepts a single number or a single array with patch-specific values.\n");
    }
    
    if(_mean_fecundity.ncols() > _popPtr->getPatchNbr()) {
      return error("\"mean_fecundity\" accepts an array of max num patches in length.\n");
    }
    else if (_mean_fecundity.ncols() < _popPtr->getPatchNbr())
    {
      // recycle values provided in input until PtachNbr values are reached
      unsigned int npat = _mean_fecundity.ncols();
      
      TMatrix tmp(_mean_fecundity);
      
      _mean_fecundity.reset(1, _popPtr->getPatchNbr());
      
      for (unsigned int i = 0; i < _popPtr->getPatchNbr(); i++) {
        _mean_fecundity.set(0, i, tmp.get(0 , i % npat));
      }
    }
  } else {
    //input parameter is not a matrix, copy value into the patch array:
 
    _mean_fecundity.reset(1, _popPtr->getPatchNbr(),get_parameter_value("mean_fecundity"));
  }
 
  
  if(get_parameter("fecundity_distribution")->isSet()) {
    
    string dist = get_parameter("fecundity_distribution")->getArg();
    
    if( dist == "fixed" || dist == "fix" )
    
      FecundityFuncPtr = &LCE_Breed_base::getFixedFecundity;
    
    else if( dist == "poisson" )
      
      FecundityFuncPtr = &LCE_Breed_base::getPoissonFecundity;
    
    else if( dist == "normal" || dist == "lognormal" ) {
 
      if(get_parameter("fecundity_dist_stdev")->isSet())
      {
        _sd_fecundity = get_parameter_value("fecundity_dist_stdev");
 
      } else {
 
          return error("parameter \"fecundity_dist_stdev\" is missing for \"normal\" fecundity distribution\n");
      }
 
      if(dist == "normal")
        FecundityFuncPtr = &LCE_Breed_base::getGaussianFecundity;
 
      if(dist == "lognormal")
        FecundityFuncPtr = &LCE_Breed_base::getLogNormalFecundity;
      
    } else {
        return error("unknown fecundity distribution parameter's argument!\n");
    }
  
  } else { //default distribution is Poisson:
    FecundityFuncPtr = &LCE_Breed_base::getPoissonFecundity;
  }
  return true;
}

References _mean_fecundity, LifeCycleEvent::_popPtr, _sd_fecundity, error(), FecundityFuncPtr, TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getArg(), getFixedFecundity(), getGaussianFecundity(), getLogNormalFecundity(), Param::getMatrix(), Metapop::getPatchNbr(), getPoissonFecundity(), TMatrix::ncols(), TMatrix::nrows(), TMatrix::reset(), and TMatrix::set().

Referenced by LCE_Breed_Quanti::execute(), LCE_Breed_base(), NonWrightFisherPopulation(), and setParameters().

setMatingSystem()

bool LCE_Breed_base::setMatingSystem

(

)

{
  _mating_system = (int)this->get_parameter_value("mating_system");
  
  if(get_parameter("mating_proportion")->isSet())
    _mating_proportion = this->get_parameter_value("mating_proportion");
  else
    _mating_proportion = 1;
  
  if(_paramSet->isSet("mating_males"))
    _mating_males = (int)_paramSet->getValue("mating_males");
  else
    _mating_males = 1;
  
  //set the mating functions ptr:
  CheckMatingConditionFuncPtr = &LCE_Breed_base::checkNoSelfing;
 
  DoBreedFuncPtr = &LCE_Breed_base::breed;
 
  _do_inherit = true; //is true unless the mating system is cloning
  
  //by default, the population is not kept at constant size, ie not Wright-Fisher
  PopModelFuncPtr = &LCE_Breed_base::NonWrightFisherPopulation;
 
  if(get_parameter("mating_isWrightFisher")->isSet()) {
 
    PopModelFuncPtr = &LCE_Breed_base::WrightFisherPopulation;
 
    // check if LCE aging is part of the life cycle and complain
    if( SIMenv::MainSim->get_LCE("aging")->get_parameter("aging")->isSet() )
      warning("the \"aging\" LCE is not compatible with \"mating_isWrightFisher\"\n\
>>>> \"aging\" will empty the population and may cause extinction!\n\
>>>> Remove \"aging\" form the life cycle if you want a Wright-Fisher population\n");
  }
 
  switch(_mating_system) {
    //random mating:
    case 1:
    {
      MatingFuncPtr = &LCE_Breed_base::RandomMating;
      break;
    }
    //polygyny:
    case 2:
    {
      if(_mating_proportion == 1)
        if(_mating_males == 1)
          MatingFuncPtr = &LCE_Breed_base::fullPolyginy;
        else
          MatingFuncPtr = &LCE_Breed_base::fullPolyginy_manyMales;
      else
        if(_mating_males == 1)
          MatingFuncPtr = &LCE_Breed_base::partialPolyginy;
        else
          MatingFuncPtr = &LCE_Breed_base::partialPolyginy_manyMales;
        
      CheckMatingConditionFuncPtr = &LCE_Breed_base::checkPolygyny;
      break;
    }
    //monogamy:
    case 3:
    {
      if(_mating_proportion == 1)
        MatingFuncPtr = &LCE_Breed_base::fullMonoginy;
      else 
        MatingFuncPtr = &LCE_Breed_base::partialMonoginy;
      
      break;
    }
    //selfing:
    case 4:
    {
      if(_mating_proportion == 1)
        MatingFuncPtr = &LCE_Breed_base::fullSelfing;
      else
        MatingFuncPtr = &LCE_Breed_base::partialSelfing;
      
      CheckMatingConditionFuncPtr = &LCE_Breed_base::checkSelfing;
 
      if(_popPtr->get_parameter("patch_capacity")->isSet()){
 
        fatal("\"mating_system 4\" should be better initialized together with \"patch_nbfem ...\" and \"patch_nbmal 0\". \n");
 
      }
 
      break;
    }
    //cloning
    case 5:
    {
      if(_mating_proportion == 1)
        MatingFuncPtr = &LCE_Breed_base::fullSelfing;
      else
        MatingFuncPtr = &LCE_Breed_base::partialSelfing;
 
      CheckMatingConditionFuncPtr = &LCE_Breed_base::checkCloning;
 
      DoBreedFuncPtr = &LCE_Breed_base::breed_cloning;
 
      if(_popPtr->get_parameter("patch_capacity")->isSet()){
 
        fatal("\"mating_system 5\" should be better initialized together with \"patch_nbfem ...\" and \"patch_nbmal 0\". \n");
 
      }
 
      break;
    }
    //random mating with hermaphrodites:
    case 6:
    {
      MatingFuncPtr = &LCE_Breed_base::random_hermaphrodite;
      CheckMatingConditionFuncPtr = &LCE_Breed_base::checkSelfing;
 
      if(_popPtr->get_parameter("patch_capacity")->isSet()){
 
        fatal("\"mating_system 6\" should be better initialized together with \"patch_nbfem ...\" and \"patch_nbmal 0\". \n");
 
      }
 
      break;
    }
      
  }
  
  return true;
}

References _do_inherit, _mating_males, _mating_proportion, _mating_system, SimComponent::_paramSet, LifeCycleEvent::_popPtr, breed(), breed_cloning(), checkCloning(), CheckMatingConditionFuncPtr, checkNoSelfing(), checkPolygyny(), checkSelfing(), DoBreedFuncPtr, fatal(), fullMonoginy(), fullPolyginy(), fullPolyginy_manyMales(), fullSelfing(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), ParamSet::getValue(), Param::isSet(), ParamSet::isSet(), SIMenv::MainSim, MatingFuncPtr, NonWrightFisherPopulation(), partialMonoginy(), partialPolyginy(), partialPolyginy_manyMales(), partialSelfing(), PopModelFuncPtr, random_hermaphrodite(), RandomMating(), warning(), and WrightFisherPopulation().

Referenced by LCE_Breed_base(), and setParameters().

setParameters()

bool LCE_Breed_base::setParameters ( )

virtual

Implements SimComponent.

Reimplemented in LCE_Breed_Wolbachia, LCE_Breed_Quanti, LCE_Breed_Selection_Disperse, LCE_Breed_Selection, LCE_Breed_Disperse, LCE_BreedAssortativeMating, and LCE_Breed.

{
  return ( setMatingSystem() && setFecundity() && setSexRatio() );
}

References setFecundity(), setMatingSystem(), and setSexRatio().

Referenced by LCE_Breed::setParameters(), LCE_BreedAssortativeMating::setParameters(), LCE_Breed_Disperse::setParameters(), LCE_Breed_Selection::setParameters(), LCE_Breed_Quanti::setParameters(), and LCE_Breed_Wolbachia::setParameters().

setSexRatio()

bool LCE_Breed_base::setSexRatio

(

)

{
  // SEX-RATIO
  
  // by default, the gender is set randomly (Bernoulli trial)
 
  GetOffsprgSex = &LCE_Breed_base::getOffsprgSexRandom;
 
  // this can be changed to a fixed 1:1 male:female ratio
  if(get_parameter("sex_ratio_mode")->isSet()) {
    
    if(get_parameter("sex_ratio_mode")->getArg() == "fixed") {
  
      GetOffsprgSex = &LCE_Breed_base::getOffsprgSexFixed;
    
    } else if(get_parameter("sex_ratio_mode")->getArg() != "random") {
    
      return error("\"sex_ratio_mode\" parameter argument must be either \"fixed\" or \"random\".");
      
    }
    
  }
 
  // gender-setting function differs for selfing and cloning species
  // in those two cases, only one sex is modeled; females
    
    switch(_mating_system) {
      case 4: GetOffsprgSex = &LCE_Breed_base::getOffsprgSexSelfing;
        break;
      case 5: GetOffsprgSex = &LCE_Breed_base::getOffsprgSexCloning;
        break;
      case 6: GetOffsprgSex = &LCE_Breed_base::getOffsprgSexSelfing;
        break;
    }
 
  return true;
}

References _mating_system, error(), SimComponent::get_parameter(), GetOffsprgSex, getOffsprgSexCloning(), getOffsprgSexFixed(), getOffsprgSexRandom(), and getOffsprgSexSelfing().

Referenced by LCE_Breed_base(), and setParameters().

WrightFisherPopulation()

void LCE_Breed_base::WrightFisherPopulation

(

)

{
  Patch* patch = 0;
  Individual* mother = 0;
  Individual* father = 0;
  Individual* NewOffsprg = 0;
  unsigned int indexOfMother = 0;
  unsigned int num_fem = 0, num_offsprg = 0;
 
#ifdef _DEBUG_
  message("LCE_Breed::execute::WrightFisherPopulation::");
#endif
 
  for(unsigned int i = 0; i < _popPtr->getPatchNbr(); i++) {
 
    patch = _popPtr->getPatch(i);
 
    if( !checkMatingCondition(patch) ) continue;
 
    num_fem = patch->size(FEM, ADLTx);
 
    for(unsigned int s = 0; s < 2; ++s) {  //filling male and female offspring containers
      //-----------------------------------------------------------------------
      num_offsprg = patch->get_K(sex_t(s));
 
      patch->resize(sex_t(s), OFFSx, num_offsprg);
 
      for(unsigned int c = 0; c < num_offsprg; ++c)
      {
        indexOfMother = RAND::Uniform(num_fem);
 
        mother = patch->get(FEM, ADLTx, indexOfMother );
 
        father = this->getFatherPtr(patch, mother, indexOfMother);
 
        NewOffsprg = makeOffspring( do_breed(mother, father, i) );
 
        NewOffsprg->setSex(sex_t(s));
 
        patch->set(sex_t(s), OFFSx, c, NewOffsprg);
      }//END FOR ind
    } //END FOR sex
 
    // we do the generation change here directly
     patch->flush(ADLTx, _popPtr);   //first move adults to recycling pool
     patch->move(FEM, OFFSx, ADLTx); //moves offspring to adult containers, resets offsprg size to 0
     patch->move(MAL, OFFSx, ADLTx);
  } //END FOR patch
 
#ifdef _DEBUG_
  message("done, new patch size: %i \n",_popPtr->size());
#endif
}

References LifeCycleEvent::_popPtr, ADLTx, checkMatingCondition(), do_breed(), FEM, Patch::flush(), Patch::get(), Patch::get_K(), getFatherPtr(), Metapop::getPatch(), Metapop::getPatchNbr(), makeOffspring(), MAL, message(), Patch::move(), OFFSx, Patch::resize(), Patch::set(), Individual::setSex(), Metapop::size(), Patch::size(), and RAND::Uniform().

Referenced by setMatingSystem().

Member Data Documentation

_alpha_male

unsigned int LCE_Breed_base::_alpha_male

private

Referenced by checkPolygyny(), and fullPolyginy().

_do_inherit

bool LCE_Breed_base::_do_inherit

private

Referenced by breed_cloning(), doInheritance(), and setMatingSystem().

_mating_males

unsigned int LCE_Breed_base::_mating_males

private

Referenced by fullPolyginy_manyMales(), and setMatingSystem().

_mating_proportion

double LCE_Breed_base::_mating_proportion

private

Referenced by getMatingProportion(), partialMonoginy(), partialPolyginy(), partialPolyginy_manyMales(), partialSelfing(), and setMatingSystem().

_mating_system

int LCE_Breed_base::_mating_system

private

Referenced by getMatingSystem(), NonWrightFisherPopulation(), setMatingSystem(), and setSexRatio().

_mean_fecundity

TMatrix LCE_Breed_base::_mean_fecundity

protected

Referenced by LCE_Breed_Quanti::execute(), getMeanFecundity(), NonWrightFisherPopulation(), LCE_Breed_Quanti::NonWrightFisherPopulation(), setFecundity(), and LCE_Breed_Disperse::setParameters().

_sd_fecundity

double LCE_Breed_base::_sd_fecundity

private

Referenced by getGaussianFecundity(), getLogNormalFecundity(), and setFecundity().

CheckMatingConditionFuncPtr

bool(LCE_Breed_base::* LCE_Breed_base::CheckMatingConditionFuncPtr) (Patch *thePatch)

protected

Referenced by checkMatingCondition(), and setMatingSystem().

DoBreedFuncPtr

Individual*(LCE_Breed_base::* LCE_Breed_base::DoBreedFuncPtr) (Individual *mother, Individual *father, unsigned int LocalPatch)

protected

Referenced by do_breed(), and setMatingSystem().

FecundityFuncPtr

double(LCE_Breed_base::* LCE_Breed_base::FecundityFuncPtr) (double mean)

protected

Referenced by getFecundity(), and setFecundity().

GetOffsprgSex

sex_t(LCE_Breed_base::* LCE_Breed_base::GetOffsprgSex) ()

protected

Referenced by getOffsprgSex(), and setSexRatio().

MatingFuncPtr

Individual*(LCE_Breed_base::* LCE_Breed_base::MatingFuncPtr) (Patch *, Individual *, unsigned int)

protected

Referenced by getFatherPtr(), setMatingSystem(), and LCE_BreedAssortativeMating::setParameters().

PopModelFuncPtr

void(LCE_Breed_base::* LCE_Breed_base::PopModelFuncPtr) (void)

protected

Referenced by LCE_Breed::execute(), and setMatingSystem().

---

The documentation for this class was generated from the following files:

• LCEbreed.h
• LCEbreed.cc