LCE_Breed_Selection Class Reference

Composite LCE implementing breeding and viability selection on a given trait type. More...

#include <LCEcomposite.h>

Inheritance diagram for LCE_Breed_Selection:

Collaboration diagram for LCE_Breed_Selection:

Public Member Functions
	LCE_Breed_Selection ()
virtual	~LCE_Breed_Selection ()
bool	setNonSelectedTraitTable ()
	Builds the vector of traits not under selection. More...
Individual *	makeOffspringWithSelection (Individual *ind, unsigned int natalpatch)
	Performs viability selection and breeding at the same time. More...
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)
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 ()
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...
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 ()
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...
Public Member Functions inherited from LCE_Selection_base
	LCE_Selection_base ()
virtual	~LCE_Selection_base ()
bool	setSelectionMatrix ()
bool	setLocalOptima ()
bool	set_sel_model ()
bool	set_fit_model ()
bool	set_local_optima ()
bool	set_param_rate_of_change ()
void	set_std_rate_of_change ()
void	addPhenotypicSD (unsigned int deme, double *stDev)
void	changeLocalOptima ()
void	resetCounters ()
	Resets the fitness counters. More...
void	setMeans (unsigned int tot_ind)
	Computes the average fitness of each pedigree class. More...
double	getMeanFitness (age_idx age)
	Computes the mean fitness of the whole population for a given age class. More...
double	getMeanPatchFitness (age_idx age, unsigned int p)
	Computes the mean fitness in a given patch for a given age class. More...
double	getMaxFitness (age_idx age)
	Computes the maximum fitness value of the whole population for a given age class. More...
double	getMaxPatchFitness (age_idx age, unsigned int p)
	Computes the maximum fitness value in a given patch for a given age class. More...
double	setMeanFitness (age_idx age)
	Sets the _mean_fitness variable to the value of the mean population fitness. More...
double	getFitness (Individual *ind, unsigned int patch)
	Calls the fitness function according to the fitness model. More...
double	getFitnessFixedEffect (Individual *offsprg, unsigned int patch, unsigned int trait)
	Returns the fitness of an individual in the fixed selection model. More...
double	getFitnessDirect (Individual *offsprg, unsigned int patch, unsigned int trait)
	Returns the fitness of an individual following the direct selection model. More...
double	getFitnessUnivariateQuadratic (Individual *ind, unsigned int patch, unsigned int trait)
	Quadratic fitness surface, approximates the Gaussian model for weak selection and/or small deviation from the optimum. More...
double	getFitnessMultivariateGaussian (Individual *offsprg, unsigned int patch, unsigned int trait)
	Returns the fitness of an individual following the Gaussian selection model with one trait under selection. More...
double	getFitnessUnivariateGaussian (Individual *offsprg, unsigned int patch, unsigned int trait)
	Returns the fitness of an individual following the Gaussian selection model with several traits under selection. More...
double	getFitnessMultivariateGaussian_VE (Individual *offsprg, unsigned int patch, unsigned int trait)
	Returns the fitness of an individual following the Gaussian selection model with one trait under selection and environmental variance. More...
double	getFitnessUnivariateGaussian_VE (Individual *offsprg, unsigned int patch, unsigned int trait)
	Returns the fitness of an individual following the Gaussian selection model with several traits under selection and environmental variance. More...
double	getFitnessAbsolute (Individual *ind, unsigned int patch)
	Returns the raw fitness of the individual, without adjustment (absolute fitness). More...
double	getFitnessRelative (Individual *ind, unsigned int patch)
	Returns the relative fitness of the individual, adjusted by a scaling factor. More...
void	setScalingFactorLocal (age_idx age, unsigned int p)
	Sets the fitness scaling factor equal to the inverse of the mean local patch fitness. More...
void	setScalingFactorGlobal (age_idx age, unsigned int p)
	Sets the fitness scaling factor equal to the inverse of the mean population fitness. More...
void	setScalingFactorMaxLocal (age_idx age, unsigned int p)
	Sets the fitness scaling factor equal to the inverse of the maximum local patch fitness value. More...
void	setScalingFactorMaxGlobal (age_idx age, unsigned int p)
	Sets the fitness scaling factor equal to the inverse of the maximum population fitness value. More...
void	setScalingFactorAbsolute (age_idx age, unsigned int p)
	Resets the fitness scaling factor equal to one. More...
void	doViabilitySelection (sex_t SEX, age_idx AGE, Patch *patch, unsigned int p)
	Selectively removes individuals in the population depending on their fitness. More...

Private Attributes
void(LCE_Breed_Selection::*	_breed_selection )(Patch *patch, unsigned int patchID, unsigned int *cntr)
unsigned int	_nb_trait
vector< unsigned int >	_nonSelectedTraitIndices

Additional Inherited Members
Protected Attributes inherited from LCE_Breed_base
void(LCE_Breed_base::*	PopModelFuncPtr )(void)
TMatrix	_mean_fecundity
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...
Protected Attributes inherited from LCE_Selection_base
double	_letheq
double	_base_fitness
double	_mean_fitness
double	_max_fitness
double	_scaling_factor
bool	_is_local
bool	_is_absolute
double	_fitness [5]
	Fitness counters, one for each pedigree class. More...
double	_survival [5]
double	_ind_cntr [5]
vector< string >	_Traits
	The list of trait types under selection. More...
vector< unsigned int >	_TraitIndices
	The indices of the traits under selection. More...
vector< string >	_SelectionModels
	The selection models associated with each trait under selection. More...
LCE_SelectionSH *	_stater
LCE_SelectionFH *	_writer
int	_selectTraitDimension
	Number of quantitative traits under selection. More...
vector< double >	_selection_variance
	Patch-specific selection variance. More...
double	_eVariance
	Evironmental variance. More...
vector< double(LCE_Selection_base::*)(Individual *, unsigned int, unsigned int) >	_getRawFitness
	A vector containing pointers to fitness function related to each trait under selection. More...
double(LCE_Selection_base::*	_getFitness )(Individual *, unsigned int)
	Pointer to the function returning the individual fitness. More...
void(LCE_Selection_base::*	_setScalingFactor )(age_idx, unsigned int)
	Pointer to the function used to set the fitness scaling factor when fitness is relative. More...
void(LCE_Selection_base::*	_setNewLocalOptima )(void)
	Pointer to the function used to change the local phenotypic optima or its rate of change. More...

Detailed Description

Composite LCE implementing breeding and viability selection on a given trait type.

Inherits from LCE_Breed_base and LCE_Selection_base.

Constructor & Destructor Documentation

LCE_Breed_Selection()

LCE_Breed_Selection::LCE_Breed_Selection

(

)

                                           : LifeCycleEvent("breed_selection",""), 
_breed_selection(0), _nb_trait(0)
{
  add_parameter("breed_selection_fecundity_fitness", BOOL, false, false, 0, 0, 0);
//  get_parameter("mean_fecundity")->setIsRequired(true); //not set here or inherited by breed_selection_disperse
}

References SimComponent::add_parameter(), and BOOL.

Referenced by clone().

Here is the caller graph for this function:

~LCE_Breed_Selection()

virtual LCE_Breed_Selection::~LCE_Breed_Selection ( )

inlinevirtual

{}

Member Function Documentation

addAgeClass()

virtual age_t LCE_Breed_Selection::addAgeClass ( )

inlinevirtual

Reimplemented from LCE_Selection_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{return OFFSPRG;}

References OFFSPRG.

clone()

virtual LifeCycleEvent * LCE_Breed_Selection::clone ( )

inlinevirtual

Reimplemented from LCE_Selection_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{ return new LCE_Breed_Selection(); }

References LCE_Breed_Selection().

do_breed_selection_FecFitness()

void LCE_Breed_Selection::do_breed_selection_FecFitness	(	Patch *	patch,
		unsigned int	patchID,
		unsigned int *	cntr
	)

{
  unsigned int nbBaby;
  //double mean_fec;
  Individual* FatherPtr;
  Individual* MotherPtr;
  Individual* NewOffsprg;
  unsigned int cat;
 
  for(unsigned int size = patch->size(FEM, ADLTx), indexOfMother = 0;
      indexOfMother < size;
      indexOfMother++) {
    
    (this->*_setScalingFactor)(ADLTx, patchID); //from within LCE_selection_base
    
    MotherPtr = patch->get(FEM, ADLTx, indexOfMother);
        
    nbBaby = (unsigned int)MotherPtr->setFecundity( getFecundity(getMeanFecundity(patchID)*
                                                                 getFitness(MotherPtr, patchID)) );
        
    (*cntr) += nbBaby;
    //-----------------------------------------------------------------------
    while(nbBaby != 0) {
      
      
      FatherPtr = this->getFatherPtr(patch, MotherPtr, indexOfMother);
      
      NewOffsprg = LCE_Breed_base::makeOffspring( LCE_Breed_base::do_breed(MotherPtr, FatherPtr, patchID) );
      
      patch->add(NewOffsprg->getSex(), OFFSx, NewOffsprg);
      
      nbBaby--;
      
      cat = NewOffsprg->getPedigreeClass();
      
      _fitness[cat] += getFitness(NewOffsprg, patchID);
      _ind_cntr[cat]++;
      _survival[cat]++;
      
    }//_END__WHILE;
  }//end_for indexOfMother
  
}

References LCE_Selection_base::_fitness, LCE_Selection_base::_ind_cntr, LCE_Selection_base::_setScalingFactor, LCE_Selection_base::_survival, Patch::add(), ADLTx, LCE_Breed_base::do_breed(), FEM, Patch::get(), LCE_Breed_base::getFatherPtr(), LCE_Breed_base::getFecundity(), LCE_Selection_base::getFitness(), LCE_Breed_base::getMeanFecundity(), Individual::getPedigreeClass(), Individual::getSex(), LCE_Breed_base::makeOffspring(), OFFSx, Individual::setFecundity(), and Patch::size().

Referenced by setParameters().

Here is the caller graph for this function:

do_breed_selection_OffSurvival()

void LCE_Breed_Selection::do_breed_selection_OffSurvival	(	Patch *	patch,
		unsigned int	patchID,
		unsigned int *	cntr
	)

{
  unsigned int nbBaby;
  //double mean_fec;
  Individual* FatherPtr;
  Individual* MotherPtr;
  Individual* NewOffsprg;
  
  for(unsigned int size = patch->size(FEM, ADLTx), indexOfMother = 0;
      indexOfMother < size;
      indexOfMother++) {
    
    MotherPtr = patch->get(FEM, ADLTx, indexOfMother);
    
    nbBaby = (unsigned int)MotherPtr->setFecundity( getFecundity(patchID) );
    
    (*cntr) += nbBaby;
    //-----------------------------------------------------------------------
    while(nbBaby != 0) {
      
      FatherPtr = this->getFatherPtr(patch, MotherPtr, indexOfMother);
      
      NewOffsprg = makeOffspringWithSelection( LCE_Breed_base::do_breed(MotherPtr, FatherPtr, patchID), patchID );
      
      if(NewOffsprg != NULL)
        patch->add(NewOffsprg->getSex(), OFFSx, NewOffsprg);
      
      nbBaby--;
      
    }//_END__WHILE;
  }//end_for indexOfMother
  
}

References Patch::add(), ADLTx, LCE_Breed_base::do_breed(), FEM, Patch::get(), LCE_Breed_base::getFatherPtr(), LCE_Breed_base::getFecundity(), Individual::getSex(), makeOffspringWithSelection(), OFFSx, Individual::setFecundity(), and Patch::size().

Referenced by setParameters().

Here is the caller graph for this function:

do_breed_selection_WrightFisher_1sex()

void LCE_Breed_Selection::do_breed_selection_WrightFisher_1sex	(	Patch *	patch,
		unsigned int	patchID,
		unsigned int *	cntr
	)

{
  //WF pop with hermaphrodites
  Individual* FatherPtr = 0;
  Individual* MotherPtr = 0;
  Individual* NewOffsprg = 0;
  unsigned int size_parent = patch->size(FEM, ADLTx);
  unsigned int *offspring_count[2] = {NULL, NULL};
  unsigned int size_offspring;
 
  // FEMALE fitness
  valarray< double > fitness_fem(0.0, size_parent);
  setReproScaledFitness_sum(FEM, fitness_fem, size_parent, patch); //normalized probabilities = relative fitness
 
    //filling female offspring container only
    //-----------------------------------------------------------------------
    size_offspring = patch->get_K(FEM);
 
    //stores the index of mother for each offspring
    offspring_count[FEM] = new unsigned int [ size_offspring ];
 
    //stores the index of "father" for each offspring
    offspring_count[MAL] = new unsigned int [ size_offspring ];
 
    //randomly draw each mother and each father proportionally to their fitness:
 
    RAND::MultinomialOnNormalizedValarray_scrambleOut(size_parent, size_offspring, fitness_fem,
        offspring_count[FEM]);
    // second draw for second gamete
    RAND::MultinomialOnNormalizedValarray_scrambleOut(size_parent, size_offspring, fitness_fem,
        offspring_count[MAL]);
 
    //make offspring by paring mothers and fathers
 
    for(unsigned int i = 0; i < size_offspring; ++i)
    {
      MotherPtr = patch->get(FEM, ADLTx, offspring_count[FEM][i] );
 
      FatherPtr = patch->get(FEM, ADLTx, offspring_count[MAL][i] ); //this is a female too!
 
      NewOffsprg = makeOffspring( do_breed(MotherPtr, FatherPtr, patchID) );
 
      NewOffsprg->setSex(FEM);
 
      patch->add(FEM, OFFSx, NewOffsprg);
    }//END FOR ind
 
  if(offspring_count[FEM])
    delete [] offspring_count[FEM];
 
  if(offspring_count[MAL])
    delete [] offspring_count[MAL];
}

References Patch::add(), ADLTx, LCE_Breed_base::do_breed(), FEM, Patch::get(), Patch::get_K(), LCE_Breed_base::makeOffspring(), MAL, RAND::MultinomialOnNormalizedValarray_scrambleOut(), OFFSx, setReproScaledFitness_sum(), Individual::setSex(), and Patch::size().

Referenced by setParameters().

Here is the caller graph for this function:

do_breed_selection_WrightFisher_2sex()

void LCE_Breed_Selection::do_breed_selection_WrightFisher_2sex	(	Patch *	patch,
		unsigned int	patchID,
		unsigned int *	cntr
	)

{
  //double mean_fec;
  Individual* FatherPtr = 0;
  Individual* MotherPtr = 0;
  Individual* NewOffsprg = 0;
  unsigned int size_parent[2] = {patch->size(MAL, ADLTx), patch->size(FEM, ADLTx)};//[MAL=0,FEM=1]
  unsigned int *offspring_count[2] = {NULL, NULL};
  unsigned int size_offspring;
 
  // FEMALE fitness;  FEM = 1
  valarray< double > fitness_fem(0.0, size_parent[FEM]);
  setReproScaledFitness_sum(FEM, fitness_fem, size_parent[FEM], patch); //normalized probabilities = relative fitness
 
  // MALES fitness;   Mal = 0
  valarray< double > fitness_mal(0.0, size_parent[MAL]);
  setReproScaledFitness_sum(MAL, fitness_mal, size_parent[MAL], patch);
 
 
  for(unsigned int s = 0; s < 2; ++s) {
    //filling male and female offspring containers
    //-----------------------------------------------------------------------
    size_offspring = patch->get_K(sex_t(s));
 
    if(offspring_count[FEM]) delete [] offspring_count[FEM];
 
    if(offspring_count[MAL]) delete [] offspring_count[MAL];
 
    //stores the index of mother for each offspring
    offspring_count[FEM] = new unsigned int [ size_offspring ];
 
    //stores the index of father for each offspring
    offspring_count[MAL] = new unsigned int [ size_offspring ];
 
    //randomly draw each mother and each father proportionally to their fitness:
 
    RAND::MultinomialOnNormalizedValarray_scrambleOut(size_parent[FEM], size_offspring, fitness_fem,
        offspring_count[FEM]);
 
    RAND::MultinomialOnNormalizedValarray_scrambleOut(size_parent[MAL], size_offspring, fitness_mal,
        offspring_count[MAL]);
 
    //make offspring by paring mothers and fathers
 
    for(unsigned int i = 0; i < size_offspring; ++i)
    {
      MotherPtr = patch->get(FEM, ADLTx, offspring_count[FEM][i] );
 
      FatherPtr = patch->get(MAL, ADLTx, offspring_count[MAL][i] );
 
      NewOffsprg = makeOffspring( do_breed(MotherPtr, FatherPtr, patchID) );
 
      NewOffsprg->setSex(sex_t(s));
 
      patch->add(sex_t(s), OFFSx, NewOffsprg);
    }//END FOR ind
  } //END FOR sex
 
  if(offspring_count[FEM])
    delete [] offspring_count[FEM];
 
  if(offspring_count[MAL])
    delete [] offspring_count[MAL];
}

References Patch::add(), ADLTx, LCE_Breed_base::do_breed(), FEM, Patch::get(), Patch::get_K(), LCE_Breed_base::makeOffspring(), MAL, RAND::MultinomialOnNormalizedValarray_scrambleOut(), OFFSx, setReproScaledFitness_sum(), Individual::setSex(), and Patch::size().

Referenced by setParameters().

Here is the caller graph for this function:

execute()

void LCE_Breed_Selection::execute ( )

virtual

Reimplemented from LCE_Selection_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{
  Patch* current_patch;
  unsigned int ind_count;
  
  if(_popPtr->size(OFFSPRG) != 0) {
    warning("offspring containers not empty at time of breeding, flushing.\n");
    _popPtr->flush(OFFSx);
  }
  
#ifdef _DEBUG_
  message("LCE_Breed_Selection::execute\n");
#endif
  
  _scaling_factor = 1;
  _mean_fitness = 0;
  ind_count = 0;
  
  LCE_Selection_base::resetCounters();
  
  for(unsigned int home = 0; home < _popPtr->getPatchNbr(); home++) {
    
    current_patch = _popPtr->getPatch(home);
    
    if( !checkMatingCondition(current_patch) ) continue;
    
    (this->* _breed_selection) (current_patch, home, &ind_count);
    
  }//end_for home
  
  LCE_Selection_base::setMeans(ind_count);
  
#ifdef _DEBUG_
  message("   (offsprg nb: %i adults nb: %i, mean fitness: %f)\n",_popPtr->size(OFFSPRG),
          _popPtr->size(ADULTS), _mean_fitness);
#endif
  
}

References _breed_selection, LCE_Selection_base::_mean_fitness, LifeCycleEvent::_popPtr, LCE_Selection_base::_scaling_factor, ADULTS, LCE_Breed_base::checkMatingCondition(), Metapop::flush(), Metapop::getPatch(), Metapop::getPatchNbr(), message(), OFFSPRG, OFFSx, LCE_Selection_base::resetCounters(), LCE_Selection_base::setMeans(), Metapop::size(), and warning().

loadFileServices()

virtual void LCE_Breed_Selection::loadFileServices ( FileServices *  loader )

inlinevirtual

Reimplemented from LCE_Selection_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{}

loadStatServices()

void LCE_Breed_Selection::loadStatServices ( StatServices *  loader )

virtual

Reimplemented from LCE_Selection_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{
  LCE_Selection_base::loadStatServices(loader);
}

References LCE_Selection_base::loadStatServices().

makeOffspringWithSelection()

Individual * LCE_Breed_Selection::makeOffspringWithSelection	(	Individual *	ind,
		unsigned int	natalpatch
	)

Performs viability selection and breeding at the same time.

The selected trait is first inherited (with recombination and mutations) and survival checked before the remaining traits are inherited. This helps save some computing time. The function returns a null pointer in case of selective death.

Parameters

ind	the newborn, its new traits have not been computed yet
natalpatch	the index of the natal patch of the offfspring where selectin takes palce

{
  if(!ind->getMother() || !ind->getFather())
    fatal("found NULL parent ptr in offspring (LCE_Breed_Selection::makeOffspringWithSelection)\n");
 
  //do inheritance of the traits under selection:
  for(unsigned int i = 0; i < _TraitIndices.size(); ++i)
    ind->createTrait(_TraitIndices[i], LCE_Breed_base::doInheritance(), true);
  
  //check if the individual survives
  register double fitness = getFitness(ind, natalpatch);
  register unsigned int cat = ind->getPedigreeClass();
  
  _fitness[cat] += fitness;
  _ind_cntr[cat]++;
  
  if( RAND::Uniform() > fitness ) {
    //this one dies
    _popPtr->recycle(ind);
    
    ind->getMother()->addMating(cat);
    if(cat!=4) ind->getFather()->addMating(cat);
    
    return NULL;
    
  } else {
    //it survived, we'll return it
    
    //update counters
    _survival[cat]++;
    
    ind->getMother()->DidHaveABaby(cat);
    if(cat!=4) ind->getFather()->DidHaveABaby(cat);
  }
  
  //compute inheritance and mutation of the traits not under selection:
  for(unsigned int i = 0; i < _nonSelectedTraitIndices.size(); i++)
      ind->createTrait(_nonSelectedTraitIndices[i], LCE_Breed_base::doInheritance(), true);
  
  return ind;
}

References LCE_Selection_base::_fitness, LCE_Selection_base::_ind_cntr, _nonSelectedTraitIndices, LifeCycleEvent::_popPtr, LCE_Selection_base::_survival, LCE_Selection_base::_TraitIndices, Individual::addMating(), Individual::createTrait(), Individual::DidHaveABaby(), LCE_Breed_base::doInheritance(), fatal(), Individual::getFather(), LCE_Selection_base::getFitness(), Individual::getMother(), Individual::getPedigreeClass(), IndFactory::recycle(), and RAND::Uniform().

Referenced by LCE_Breed_Selection_Disperse::do_breed(), and do_breed_selection_OffSurvival().

Here is the caller graph for this function:

removeAgeClass()

virtual age_t LCE_Breed_Selection::removeAgeClass ( )

inlinevirtual

Reimplemented from LCE_Selection_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{return NONE;}

References NONE.

requiredAgeClass()

virtual age_t LCE_Breed_Selection::requiredAgeClass ( )

inlinevirtual

Reimplemented from LCE_Selection_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{return ADULTS;}

References ADULTS.

resetParameterFromSource()

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

inlinevirtual

Reimplemented from LCE_Selection_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{return false;}

setNonSelectedTraitTable()

bool LCE_Breed_Selection::setNonSelectedTraitTable

(

)

Builds the vector of traits not under selection.

Used in LCE_Breed_Selection_Disperse as well.

                                                   {
 
  _nb_trait = _popPtr->getIndividualProtoype()->getTraitNumber();
 
  _nonSelectedTraitIndices.clear();
 
#ifdef _DEBUG_
  cout << "@@@@ " << _nb_trait - _TraitIndices.size()<< " trait(s) not under selection\n";
#endif
 
  if (_nb_trait > _TraitIndices.size()) { //means we have some traits not under selection
 
    for (unsigned int i = 0; i < _nb_trait; ++i) {
      //check which trait is not under selection and add its index into the vector
      if (find(_TraitIndices.begin(), _TraitIndices.end(), i) == _TraitIndices.end()) {
        _nonSelectedTraitIndices.push_back(i);
      }
    }
 
    if(_nonSelectedTraitIndices.size() != _nb_trait - _TraitIndices.size())
      return error("LCE_Breed_Selection::setParameters:: trait not under selection was not found at initialization\n");
 
  }
 
  return true;
}

References _nb_trait, _nonSelectedTraitIndices, LifeCycleEvent::_popPtr, LCE_Selection_base::_TraitIndices, error(), IndFactory::getIndividualProtoype(), and Individual::getTraitNumber().

Referenced by setParameters(), and LCE_Breed_Selection_Disperse::setParameters().

Here is the caller graph for this function:

setParameters()

bool LCE_Breed_Selection::setParameters ( )

virtual

Reimplemented from LCE_Breed_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{
  if( !LCE_Breed_base::setParameters( ) ||  !LCE_Selection_base::setParameters( ) )
    return false;
  
  unsigned int mating_system = get_parameter_value("mating_system");
 
  if(get_parameter("mating_isWrightFisher")->isSet()) {
 
    if(mating_system == 1)
 
      _breed_selection = &LCE_Breed_Selection::do_breed_selection_WrightFisher_2sex;
 
    else if (mating_system == 6)
    
      _breed_selection = &LCE_Breed_Selection::do_breed_selection_WrightFisher_1sex;
 
    else {
      return error("the Wright-Fisher population model with selection (breed_selection) can only be set with\
 a random mating system: models 1 (2 sex random mating) or 6 (1 sex random mating)\n");
    }
    
  } else {
 
    // check mating system and mating options:
    if(getMeanFecundity(0) <= 0)
      return error("\"mean_fecundity\" is not set!\n");
 
    if(get_parameter("breed_selection_fecundity_fitness")->isSet()){
 
      _breed_selection = &LCE_Breed_Selection::do_breed_selection_FecFitness ;
 
    } else {
      _breed_selection = &LCE_Breed_Selection::do_breed_selection_OffSurvival ;
    }
  }
 
  return setNonSelectedTraitTable();
}

References _breed_selection, do_breed_selection_FecFitness(), do_breed_selection_OffSurvival(), do_breed_selection_WrightFisher_1sex(), do_breed_selection_WrightFisher_2sex(), error(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), LCE_Breed_base::getMeanFecundity(), setNonSelectedTraitTable(), LCE_Breed_base::setParameters(), and LCE_Selection_base::setParameters().

setReproScaledFitness_sum()

void LCE_Breed_Selection::setReproScaledFitness_sum	(	sex_t	SEX,
		valarray< double > &	survival,
		unsigned int	numReproFem,
		Patch *	patch
	)

{
  _scaling_factor = 1; //we want the raw fitness before re-scaling
  for(unsigned int i = 0; i < numReproFem; ++i) {
    survival[i] = getFitness(patch->get(SEX, ADLTx, i), patch->getID());
  }
 
  double sum = survival.sum();
 
  survival /= sum;
 
}

References LCE_Selection_base::_scaling_factor, ADLTx, Patch::get(), LCE_Selection_base::getFitness(), and Patch::getID().

Referenced by do_breed_selection_WrightFisher_1sex(), and do_breed_selection_WrightFisher_2sex().

Here is the caller graph for this function:

Member Data Documentation

_breed_selection

void(LCE_Breed_Selection::* LCE_Breed_Selection::_breed_selection) (Patch *patch, unsigned int patchID, unsigned int *cntr)

private

Referenced by execute(), and setParameters().

_nb_trait

unsigned int LCE_Breed_Selection::_nb_trait

private

Referenced by setNonSelectedTraitTable().

_nonSelectedTraitIndices

vector< unsigned int > LCE_Breed_Selection::_nonSelectedTraitIndices

private

Referenced by makeOffspringWithSelection(), and setNonSelectedTraitTable().

---

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

• LCEcomposite.h
• LCEcomposite.cc