LCE_Breed_Quanti Class Reference

Implementation of the basic breeding and mating procedures, does not link to any trait. More...

#include <LCEquanti.h>

Inheritance diagram for LCE_Breed_Quanti:

Collaboration diagram for LCE_Breed_Quanti:

Public Member Functions
	LCE_Breed_Quanti ()
virtual	~LCE_Breed_Quanti ()
void	setVefromVa (Patch *patch, age_idx AGE)
void	setIndPhenotype (Patch *patch, sex_t SEX, age_idx AGE)
void	NonWrightFisherPopulation ()
void	WrightFisherPopulation ()
Implementations
virtual bool	setParameters ()
virtual void	execute ()
virtual LifeCycleEvent *	clone ()
virtual void	loadFileServices (FileServices *loader)
virtual void	loadStatServices (StatServices *loader)
virtual bool	resetParameterFromSource (std::string param, SimComponent *cmpt)
virtual age_t	removeAgeClass ()
virtual age_t	addAgeClass ()
virtual age_t	requiredAgeClass ()
Public Member Functions inherited from LCE_Breed_base
	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 ()
void	doAgingInWFpop ()
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 *	makeOffspring (Individual *newind, Individual *mother, Individual *father, unsigned int natalPatch)
	Overloads previous function when a new offspring is created "in-place", that is from existing pointer in a patch. 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...
bool	setMatingSystem ()
bool	setFecundity ()
bool	setSexRatio ()
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 ()
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 ()
Public Member Functions inherited from SimComponent
	SimComponent ()
virtual	~SimComponent ()
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...

Private Attributes
TProtoQuanti *	_QuantiProto
vector< double >	_h2
vector< double >(TTQuantiSH::*	_get_VA_func_ptr )(Patch *, const age_idx)
void(LCE_Breed_Quanti::*	_myPopModelFuncPtr )(void)

Additional Inherited Members
Protected Attributes inherited from LCE_Breed_base
TMatrix	_mean_fecundity
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...

Detailed Description

Implementation of the basic breeding and mating procedures, does not link to any trait.

Individuals mate according to the mating system chosen. The mated adults are not removed from the population. The offspring containers are filled with the new generation. Note that they are first emptied if still containing offspring individuals when starting the breeding process.

The population's age is set to ALL. The mating and realized fecundity counters of the reproducing males and females are updated.

See also

LCE_Breed_base

Constructor & Destructor Documentation

LCE_Breed_Quanti()

LCE_Breed_Quanti::LCE_Breed_Quanti ( )

inline

                       : LifeCycleEvent("breed_quanti","quant"), _QuantiProto(0),
  _get_VA_func_ptr(0), _myPopModelFuncPtr(0) { }

Referenced by clone().

Here is the caller graph for this function:

~LCE_Breed_Quanti()

virtual LCE_Breed_Quanti::~LCE_Breed_Quanti ( )

inlinevirtual

{ }

Member Function Documentation

addAgeClass()

virtual age_t LCE_Breed_Quanti::addAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return OFFSPRG;}

References OFFSPRG.

clone()

virtual LifeCycleEvent* LCE_Breed_Quanti::clone ( )

inlinevirtual

Implements LifeCycleEvent.

{return new LCE_Breed_Quanti();}

References LCE_Breed_Quanti().

execute()

void LCE_Breed_Quanti::execute ( )

virtual

Implements LifeCycleEvent.

{
#ifdef _DEBUG_
  message("LCE_Breed_Quanti::execute (Patch nb: %i offsprg nb: %i adlt nb: %i)\n"
          ,_popPtr->getPatchNbr(),_popPtr->size( OFFSPRG ),_popPtr->size( ADULTS ));
#endif
 
  if(_popPtr->size(OFFSPRG) != 0) {
    warning("offspring containers not empty at time of breeding, flushing.\n");
    _popPtr->flush(OFFSx);
  }
 
  //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();
 
  // proceed with mating and breeding
  (this->* _myPopModelFuncPtr)(); // calls either 'NonWrightFisherPopulation' or 'WrightFisherPopulation'
 
}

References LCE_Breed_base::_mean_fecundity, _myPopModelFuncPtr, LifeCycleEvent::_popPtr, ADULTS, Metapop::flush(), Metapop::getPatchNbr(), message(), TMatrix::ncols(), OFFSPRG, OFFSx, LCE_Breed_base::setFecundity(), Metapop::size(), and warning().

loadFileServices()

virtual void LCE_Breed_Quanti::loadFileServices ( FileServices *  loader )

inlinevirtual

Implements SimComponent.

{}

loadStatServices()

virtual void LCE_Breed_Quanti::loadStatServices ( StatServices *  loader )

inlinevirtual

Implements SimComponent.

{}

NonWrightFisherPopulation()

void LCE_Breed_Quanti::NonWrightFisherPopulation

(

)

{
  Patch* patch;
  Individual* mother;
  Individual* father;
  Individual* NewOffsprg;
  unsigned int nbBaby;
 
#ifdef _DEBUG_
  message("LCE_Breed_Quanti::execute::NonWrightFisherPopulation::mating system: %i; mean fecundity[0]: %f",
      getMatingSystem(), _mean_fecundity.get(0,0));
#endif
 
  _h2 = _QuantiProto->get_heritability(); //may have been reset during a run
 
  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
 
    }// for female
 
    // compute Va in each patch to set Ve to match the h2 required
    setVefromVa(patch,OFFSx);
 
    setIndPhenotype(patch, FEM, OFFSx);
    setIndPhenotype(patch, MAL, OFFSx);
 
  } //for patch
 
#ifdef _DEBUG_
  message("done, new offsprg nb: %i \n",_popPtr->size( OFFSPRG ));
#endif
}

References _h2, LCE_Breed_base::_mean_fecundity, LifeCycleEvent::_popPtr, _QuantiProto, Patch::add(), ADLTx, LCE_Breed_base::checkMatingCondition(), LCE_Breed_base::do_breed(), FEM, Patch::get(), TMatrix::get(), TProtoQuanti::get_heritability(), LCE_Breed_base::getFatherPtr(), LCE_Breed_base::getFecundity(), LCE_Breed_base::getMatingSystem(), Metapop::getPatch(), Metapop::getPatchNbr(), Individual::getSex(), LCE_Breed_base::makeOffspring(), MAL, message(), OFFSPRG, OFFSx, Individual::setFecundity(), setIndPhenotype(), setVefromVa(), Metapop::size(), and Patch::size().

Referenced by setParameters().

Here is the caller graph for this function:

removeAgeClass()

virtual age_t LCE_Breed_Quanti::removeAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return 0;}

requiredAgeClass()

virtual age_t LCE_Breed_Quanti::requiredAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return ADULTS;}

References ADULTS.

resetParameterFromSource()

virtual bool LCE_Breed_Quanti::resetParameterFromSource ( std::string  param, SimComponent *  cmpt  )

inlinevirtual

Implements SimComponent.

{return false;}

setIndPhenotype()

void LCE_Breed_Quanti::setIndPhenotype	(	Patch *	patch,
		sex_t	SEX,
		age_idx	AGE
	)

{
  for(unsigned int i = 0; i < patch->size(SEX, AGE); ++i)
  {
    patch->get(SEX, AGE, i)->setTraitValue(_LCELinkedTraitIndex);
  }
}

References LifeCycleEvent::_LCELinkedTraitIndex, Patch::get(), Individual::setTraitValue(), and Patch::size().

Referenced by NonWrightFisherPopulation(), and WrightFisherPopulation().

Here is the caller graph for this function:

setParameters()

bool LCE_Breed_Quanti::setParameters ( )

virtual

Reimplemented from LCE_Breed_base.

{
 
  _QuantiProto = dynamic_cast<TProtoQuanti*> ( _popPtr->getTraitPrototype("quant") );
 
  //check for allele model
  if(_QuantiProto->get_dominance_model() == 0)
    _get_VA_func_ptr = &TTQuantiSH::getVaNoDominance;
  else
    _get_VA_func_ptr = &TTQuantiSH::getVaWithDominance;
 
  if(!LCE_Breed_base::setParameters( )) return false;
 
  //by default, the population is not kept at constant size, ie not Wright-Fisher
  _myPopModelFuncPtr = &LCE_Breed_Quanti::NonWrightFisherPopulation;
 
  if(get_parameter("mating_isWrightFisher")->isSet())
    _myPopModelFuncPtr = &LCE_Breed_Quanti::WrightFisherPopulation;
 
  return true;
}

References _get_VA_func_ptr, _myPopModelFuncPtr, LifeCycleEvent::_popPtr, _QuantiProto, TProtoQuanti::get_dominance_model(), SimComponent::get_parameter(), IndFactory::getTraitPrototype(), TTQuantiSH::getVaNoDominance(), TTQuantiSH::getVaWithDominance(), Param::isSet(), NonWrightFisherPopulation(), LCE_Breed_base::setParameters(), and WrightFisherPopulation().

setVefromVa()

void LCE_Breed_Quanti::setVefromVa	(	Patch *	patch,
		age_idx	AGE
	)

{
  vector<double> Va;
 
  if(!(_popPtr->getCurrentGeneration()%_QuantiProto->get_h2_setTime())) // use setTime as periodicity
  {
 
    Va = (_QuantiProto->get_stater()->*_get_VA_func_ptr)(patch, AGE);  // compute Va
 
//    cout << "LCE_Breed_Quanti::setVefromVa:: Va/Ve = ";
 
    // we have to make sure that the phenotype will be calculated with Ve
    // this is not guaranteed if Ve was not in input
    _QuantiProto->set_trait_value_func_ptr(true);
 
    // set Ve to match h2 given computed value of Va
    for(unsigned int j = 0; j < _QuantiProto->get_num_traits(); ++j) {
 
//      cout << Va[j] <<"/"<< Va[j] * (1 - _h2[j])/_h2[j] <<" ";
 
      _QuantiProto->set_eVarianceSD( j, sqrt(Va[j] * (1 - _h2[j])/_h2[j]) );
    }
 
//    cout<<endl;
  }
 
}

References _get_VA_func_ptr, _h2, LifeCycleEvent::_popPtr, _QuantiProto, TProtoQuanti::get_h2_setTime(), TProtoQuanti::get_num_traits(), TProtoQuanti::get_stater(), Metapop::getCurrentGeneration(), TProtoQuanti::set_eVarianceSD(), and TProtoQuanti::set_trait_value_func_ptr().

Referenced by NonWrightFisherPopulation(), and WrightFisherPopulation().

Here is the caller graph for this function:

WrightFisherPopulation()

void LCE_Breed_Quanti::WrightFisherPopulation

(

)

{
  Patch* patch = 0;
  Individual* mother = 0;
  Individual* father = 0;
  Individual* NewOffsprg = 0;
  unsigned int indexOfMother = 0;
  unsigned int size = 0;
 
#ifdef _DEBUG_
  message("LCE_Breed::execute::WrightFisherPopulation::\n");
#endif
 
 
  _h2 = _QuantiProto->get_heritability(); //may have been reset during a run
 
  for(unsigned int i = 0; i < _popPtr->getPatchNbr(); i++) {
 
    patch = _popPtr->getPatch(i);
 
    if( !checkMatingCondition(patch) ) continue;
 
    size = patch->size(FEM, ADLTx);
 
    for(unsigned int s = 0; s < 2; ++s) {  //filling male and female offspring containers
      //-----------------------------------------------------------------------
      for(unsigned int c = 0; c < patch->get_K(sex_t(s)); ++c)
      {
        indexOfMother = RAND::Uniform(size);
 
        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->add(sex_t(s), OFFSx, NewOffsprg);
      }//END FOR ind
    } //END FOR sex
 
    // compute Va in each patch to set Ve to match the h2 required
     setVefromVa(patch, OFFSx);
 
     setIndPhenotype(patch, FEM, OFFSx);
     setIndPhenotype(patch, MAL, OFFSx);
 
  } //END FOR patch
 
#ifdef _DEBUG_
  message("LCE_Breed::execute::WrightFisherPopulation::new offsprg nb: %i \n",_popPtr->size( OFFSPRG ));
#endif
}

References _h2, LifeCycleEvent::_popPtr, _QuantiProto, Patch::add(), ADLTx, LCE_Breed_base::checkMatingCondition(), LCE_Breed_base::do_breed(), FEM, Patch::get(), TProtoQuanti::get_heritability(), Patch::get_K(), LCE_Breed_base::getFatherPtr(), Metapop::getPatch(), Metapop::getPatchNbr(), LCE_Breed_base::makeOffspring(), MAL, message(), OFFSPRG, OFFSx, setIndPhenotype(), Individual::setSex(), setVefromVa(), Metapop::size(), Patch::size(), and RAND::Uniform().

Referenced by setParameters().

Here is the caller graph for this function:

Member Data Documentation

_get_VA_func_ptr

vector<double>(TTQuantiSH::* LCE_Breed_Quanti::_get_VA_func_ptr) (Patch *, const age_idx)

private

Referenced by setParameters(), and setVefromVa().

_h2

vector<double> LCE_Breed_Quanti::_h2

private

Referenced by NonWrightFisherPopulation(), setVefromVa(), and WrightFisherPopulation().

_myPopModelFuncPtr

void(LCE_Breed_Quanti::* LCE_Breed_Quanti::_myPopModelFuncPtr) (void)

private

Referenced by execute(), and setParameters().

_QuantiProto

TProtoQuanti* LCE_Breed_Quanti::_QuantiProto

private

Referenced by NonWrightFisherPopulation(), setParameters(), setVefromVa(), and WrightFisherPopulation().

---

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

• LCEquanti.h
• LCEquanti.cc