Composite LCE performing breeding, migration and viability selection all in one. More...

#include <LCEcomposite.h>

Inheritance diagram for LCE_Breed_Selection_Disperse:

Collaboration diagram for LCE_Breed_Selection_Disperse:

Public Member Functions
	LCE_Breed_Selection_Disperse ()

virtual	~LCE_Breed_Selection_Disperse ()

void	breed_selection_disperse (int *counter)

void	breed_selection_disperse_propagule (int *counter)

void	do_breed (sex_t SEX, unsigned int size, int counter, Patch patch, unsigned int patchID)

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_Disperse
	LCE_Breed_Disperse ()

virtual	~LCE_Breed_Disperse ()

void	do_breed_disperse ()

void	do_breed_disperse_propagule ()

void	do_breed_disperse_in_patch (sex_t SEX, Patch *patch, unsigned int ID, unsigned int num_offsprg)

void	do_breed_disperse_in_empty_patch (sex_t SEX, Patch *patch, unsigned int ID, unsigned int num_offsprg)

unsigned int	numFemOffspring (Patch *patch)

unsigned int	numFemOffspring_colonizers (Patch *patch)
	The number of females produced in case a max number of colonizers was specified. More...

unsigned int	numMalOffspring_notrandom (Patch *patch)
	The number of males produced is always zero when the mating system is not random mating. More...

unsigned int	numMalOffspring_random (Patch *patch)

unsigned int	numMalOffspring_random_colonizers (Patch *patch)

unsigned int	instantGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced corresponds to the carrying capacity of the patch. More...

unsigned int	logisticGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced is given by the logistic growth function. More...

unsigned int	stochasticLogisticGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced is drawn from a Poisson with mean equal to the logistic growth predicate. More...

unsigned int	conditionalLogisticGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced depends on the adult density. More...

unsigned int	conditionalStochasticLogisticGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced depends on the adult density, similar to 'conditionalLogisticGrowth' except that this time, the fecundities are drawn from Poisson distributions. More...

unsigned int	fixedFecundityGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced is equal to the current number of breeders multiplied by the mean fecundity of the focal patch. More...

unsigned int	stochasticFecundityGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced is a random number drawn from a Poisson distribution with mean equal to the current number of breeders multiplied by the mean fecundity of the focal patch. More...

unsigned int	exponentialGrowth (Patch *patch, sex_t SEX)
	Exponential growth using current patch size as basis to calculate future sizes, set once the function is first called. More...

Individual *	mate_random (sex_t SEX, Patch patch, unsigned int LocalPatch, gsl_ran_discrete_t rate_fem, gsl_ran_discrete_t *rate_mal)

Individual *	mate_random_hermaphrodite (sex_t SEX, Patch patch, unsigned int LocalPatch, gsl_ran_discrete_t rate_fem, gsl_ran_discrete_t *rate_mal)

Individual *	mate_selfing (sex_t SEX, Patch patch, unsigned int LocalPatch, gsl_ran_discrete_t rate_fem, gsl_ran_discrete_t *rate_mal)

Individual *	mate_full_selfing (sex_t SEX, Patch patch, unsigned int LocalPatch, gsl_ran_discrete_t rate_fem, gsl_ran_discrete_t *rate_mal)

Individual *	mate_cloning (sex_t SEX, Patch patch, unsigned int LocalPatch, gsl_ran_discrete_t rate_fem, gsl_ran_discrete_t *rate_mal)

Individual *	makeOffspring (Individual *ind)

Individual *	get_parent (sex_t SEX, sex_t DispSex, Patch LocalPatch, unsigned int patchID, gsl_ran_discrete_t rates)

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...

Public Member Functions inherited from LCE_Disperse_base
	LCE_Disperse_base ()

virtual	~LCE_Disperse_base ()
	Deallocates the disp matrix. More...

bool	setBaseParameters (string prefix)

void	setParamPrefix (string pref)

void	addParameters (string prefix, ParamUpdaterBase *updater)

void	setIndentityDispMatrix (TMatrix *mat)

unsigned int	getMigrationPatchForward (sex_t SEX, unsigned int LocalPatch)

unsigned int	getMigrationPatchBackward (sex_t SEX, unsigned int LocalPatch)

unsigned int	getMigrationIndex (vector< double > &rates)

unsigned int	getMigrationIndexGSLdiscrete (gsl_ran_discrete_t *rates)

void	setPropaguleTargets ()

void	swapPostDisp ()

void	reset_counters ()

void	set_isForward (bool val)

bool	checkForwardDispersalMatrix (TMatrix *mat)

bool	checkBackwardDispersalMatrix (TMatrix *mat)

void	allocateDispMatrix (sex_t sex, unsigned int dim)

bool	updateDispMatrix ()

bool	setDispMatrix ()

bool	setReducedMatricesBySex (sex_t SEX, Param &connectivity, Param &rate)

bool	setReducedDispMatrix ()
	The reduced dispersal matrix contains the indices of the patches to which each patch is connected. More...

bool	setIsland_MigrantPool_Matrix ()

bool	setIsland_PropagulePool_Matrix ()

bool	setSteppingStone1DMatrix ()

bool	setLatticeMatrix ()
	Sets the dispersal matrices for the Lattice dispersal model. More...

bool	setBasicLatticeMatrix (int rows, int cols, double phi_mal, double phi_fem, double disp_mal, double disp_fem)

bool	setLatticeTorrusMatrix (int rows, int cols, double disp_mal, double disp_fem, TMatrix *grid)

bool	setLatticeAbsorbingMatrix ()

bool	setLatticeReflectingMatrix (int rows, int cols, TMatrix *grid)

bool	isForward ()

bool	isByNumber ()

unsigned int	getDispersalModel ()

double	getPropaguleProb ()

unsigned int	getPropaguleTarget (unsigned int home)

vector< double >	getConnectedPatches (sex_t SEX, unsigned int local_patch)

vector< double >	getConnectedRates (sex_t SEX, unsigned int local_patch)

double	getReducedDispersalRate (sex_t SEX, unsigned int row, unsigned int col)

unsigned int	getReducedDispersalPatchID (sex_t SEX, unsigned int row, unsigned int col)

Public Member Functions inherited from LCE_Breed_Selection
	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)

gsl_ran_discrete_t *	setReproScaledFitness_gsl (sex_t SEX, unsigned int numReproInd, Patch *patch)

Public Member Functions inherited from LCE_Selection_base
	LCE_Selection_base ()

virtual	~LCE_Selection_base ()

bool	setSelectionMatrix ()

bool	setSelectTraitMapping (unsigned int num_quanti_traits)

bool	setSelectionOffset (double default_val, double min_val)

bool	setLocalOptima ()

const TMatrix &	getLocalOptima () const

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...

void	updateFitnessCounters (double fitness, unsigned int ped_class, bool survived)
	Updates the fitness and survival mean counters. 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	getFitnessUnivariateLinear (Individual *offsprg, unsigned int patch, unsigned int trait)
	Returns the fitness of an individual following a Linear selection model with a single trait under selection. More...

double	getFitnessUnivariateDisruptive (Individual *offsprg, unsigned int patch, unsigned int trait)
	Returns the fitness of an individual following a Disruptive (inverted Gaussian) selection model with one trait under selection. More...

double	getFitnessMultivariateDisruptive (Individual *offsprg, unsigned int patch, unsigned int trait)
	Returns the fitness of an individual following a Disruptive (inverted Gaussian) selection model with several traits under selection. More...

double	getFitnessTruncation (Individual *offsprg, unsigned int patch, unsigned int trait)
	Returns the fitness of an individual following a Truncation selection model. 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	setScalingFactorForLinearSelection (age_idx age, unsigned int p)
	Sets the fitness scaling factor as the mean trait value in the patch to compute the fitness value in the linear selection model. 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...

void	checkChangeLocalOptima ()
	Check is rate of change in local optima has been set and must be applied. More...

Private Attributes
void(LCE_Breed_Selection_Disperse::*	_breed_selection_disperse )(int *counter)

Additional Inherited Members
Protected Attributes inherited from LCE_Breed_Disperse
int	_num_colonizers
	Maximum size of a patch after colonisation. More...

sex_t	_dispersing_sex
	Which part of the population is dispersing its gametes. More...

Individual (LCE_Breed_Disperse::	_make_offspring )(sex_t SEX, Patch patch, unsigned int LocalPatch, gsl_ran_discrete_t rate_fem, gsl_ran_discrete_t *rate_mal)

unsigned int(LCE_Breed_Disperse::*	_get_numFemOffspring )(Patch *patch)

unsigned int(LCE_Breed_Disperse::*	_get_numMalOffspring )(Patch *patch)

unsigned int(LCE_Breed_Disperse::*	_get_patchFecundity )(Patch *patch, sex_t SEX)

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...

Protected Attributes inherited from LCE_Disperse_base
unsigned int	_npatch
	Number of patches in the population. More...

vector< vector< double > >	_reducedDispMat [2]
	Matrix containing the indexes of the patches connected to each patch. More...

vector< vector< double > >	_reducedDispMatProba [2]
	Matrix containing the probability to migrate to/from the connected patches. More...

Protected Attributes inherited from LCE_Selection_base
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< unsigned int >	_selectTraitMapping
	Mapping from selection dimension index to quanti trait index (0-based). 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 performing breeding, migration and viability selection all in one.

Migration rates are backward rates and population sizes are constant. Inherits from LCE_Breed_Disperse and LCE_Breed_Selection (and thus from LCE_Breed_base, LCE_Selection_base, and LCE_Disperse_base as well). Fitness is always absolute here.

Constructor & Destructor Documentation

◆ LCE_Breed_Selection_Disperse()

LCE_Breed_Selection_Disperse::LCE_Breed_Selection_Disperse ( )

 :  LifeCycleEvent("breed_selection_disperse",""), _breed_selection_disperse(0)
 {
   add_parameter("breed_selection_disperse_fitness_threshold", DBL, false, true, 0, 1, 
                 new ParamUpdater<LCE_Breed_Selection_Disperse> (&LCE_Breed_Selection_Disperse::setParameters) );
 }

References SimComponent::add_parameter(), DBL, and setParameters().

Referenced by clone().

◆ ~LCE_Breed_Selection_Disperse()

virtual LCE_Breed_Selection_Disperse::~LCE_Breed_Selection_Disperse ( )

inlinevirtual

303 {}

Member Function Documentation

◆ addAgeClass()

virtual age_t LCE_Breed_Selection_Disperse::addAgeClass ( )

inlinevirtual

Reimplemented from LCE_Breed_Disperse.

320 {return (isWrightFisher() ? NONE : OFFSPRG);}

LCE_Breed_base::isWrightFisher

bool isWrightFisher()

Definition: LCEbreed.h:120

NONE

#define NONE

No age flag.

Definition: types.h:48

OFFSPRG

#define OFFSPRG

Offspring age class flag.

Definition: types.h:50

References LCE_Breed_base::isWrightFisher(), NONE, and OFFSPRG.

◆ breed_selection_disperse()

void LCE_Breed_Selection_Disperse::breed_selection_disperse ( int * counter )

 {
   Patch* patch;
   unsigned int nfem, nmal;
   
   //-----------------------------------------------------------------------------
   // mean fitness may be too close or == zero because selection is too strong or mean phenotype is too far from optimum
   // this is a problem in starting populations
   if( _popPtr->getCurrentGeneration() == 1 && getMeanFitness(ADLTx) < 1e-08 && _popPtr->size(ADLTx) != 0) {
     warning("The mean adult fitness in the initial generation is too close to zero, the simulation may hang indefinitely!");
     warning("The breed_selection_disperse LCE will stall with zero fitness among reproducers.\n\
              Please check the parameter values of your trait(s) under selection:\n\
              e.g. check the initial trait and allelic values or initial allele \n\
                   frequencies, and the selection parameters.\n");
     abort();
   }
   //-----------------------------------------------------------------------------
  
   for(unsigned int i = 0; i < _popPtr->getPatchNbr(); i++) {
     
     patch = _popPtr->getPatch(i);
     
     if(patch->size(OFFSx) != 0) patch->flush(OFFSx, _popPtr);
  
     // compute per-patch scaling factor (needed by linear selection to set mean trait values)
     (this->*_setScalingFactor)(ADLTx, i);
  
     _mean_fitness = getMeanPatchFitness(ADLTx, i);
  
     // catch the case of zero fitness in a population with one patch during a run
     if( _mean_fitness == 0 && _popPtr->size(ADLTx) != 0 && _popPtr->getPatchNbr() == 1) {
       warning("The mean adult fitness in patch %i is zero! The simulation may hang indefinitely", i+1);
       warning("The breed_selection_disperse LCE will stall with zero\n\
                   fitness among reproducers. Please check the parameter values\n\
                   of your trait(s) under selection:\n\
                   e.g. check the change in local optimum, allele frequencies,\n\
                   or selection parameters.\n");
       abort();
     }
  
     //@TODO breed_selection_disperse fix override of fitness scaling_factor set for linear selection
     if(_mean_fitness != 0) {
  
       if(_mean_fitness < _base_fitness) {
         warning("breed_selection_disperse::mean fitness is below the minimum fitness threshold set to %f, I'm resetting the fitness scaling factor to %f",
             _base_fitness, _base_fitness/_mean_fitness);
         _scaling_factor = _base_fitness/_mean_fitness;
  
       } else
         _scaling_factor = 1;
     }
  
     // determine how many male and female offspring we need to produce
     nfem = (this->* _get_numFemOffspring)(patch);
     nmal = (this->* _get_numMalOffspring)(patch);
     
     // perform breeding
     do_breed(FEM, nfem, counter, patch, i);
     do_breed(MAL, nmal, counter, patch, i);
     
   } 
 }

References LCE_Selection_base::_base_fitness, LCE_Breed_Disperse::_get_numFemOffspring, LCE_Breed_Disperse::_get_numMalOffspring, LCE_Selection_base::_mean_fitness, LifeCycleEvent::_popPtr, LCE_Selection_base::_scaling_factor, LCE_Selection_base::_setScalingFactor, abort(), ADLTx, do_breed(), FEM, Patch::flush(), Metapop::getCurrentGeneration(), LCE_Selection_base::getMeanFitness(), LCE_Selection_base::getMeanPatchFitness(), Metapop::getPatch(), Metapop::getPatchNbr(), MAL, OFFSx, Metapop::size(), Patch::size(), and warning().

Referenced by breed_selection_disperse_propagule(), and setParameters().

◆ breed_selection_disperse_propagule()

void LCE_Breed_Selection_Disperse::breed_selection_disperse_propagule ( int * counter )

 {
   this->setIsland_PropagulePool_Matrix();
   breed_selection_disperse(counter);
 }

References breed_selection_disperse(), and LCE_Disperse_base::setIsland_PropagulePool_Matrix().

Referenced by setParameters().

◆ clone()

virtual LifeCycleEvent* LCE_Breed_Selection_Disperse::clone ( )

inlinevirtual

Reimplemented from LCE_Breed_Disperse.

315 {return new LCE_Breed_Selection_Disperse();}

LCE_Breed_Selection_Disperse::LCE_Breed_Selection_Disperse

LCE_Breed_Selection_Disperse()

Definition: LCEcomposite.cc:592

References LCE_Breed_Selection_Disperse().

◆ do_breed()

void LCE_Breed_Selection_Disperse::do_breed	(	sex_t	SEX,
		unsigned int	size,
		int *	counter,
		Patch *	patch,
		unsigned int	patchID
	)

females

males

 {
 //    int viab_count;
   Individual *new_ind;
  
 //  cout<<"---- LCE_Breed_Selection_Disperse::do_breed ----\n";
 //
 //   cout<<"         ---- patch "<<patchID<<" ----\n";
 //
 //   if(patch->size(SEX, ADLTx) == 0)
 //     cout<<"         @@@@@ EXTINCTION PATCH @@@@@\n";
  
   vector<double> disp_rate_connected_fem = LCE_Disperse_base::getConnectedRates(FEM, patchID);
   vector<double> disp_rate_connected_mal = LCE_Disperse_base::getConnectedRates(MAL, patchID);
  
   double disp_table_fem[disp_rate_connected_fem.size()];
   double disp_table_mal[disp_rate_connected_mal.size()];
  
   // check that the connected patches are not empty
   unsigned int csize, c_size_fem = 0;
   vector< double > connected_patches = LCE_Disperse_base::getConnectedPatches(FEM, patchID);
  
   // set p(mother is local) = 0 if local patch is empty of females
 //  if(patch->size(FEM, ADLTx) == 0) {
 //    disp_rate_connected_fem[0] = 0;
 //  }
  
 //   cout<<"\t - female dispersal:\n";
  
   for(unsigned int i = 0; i < disp_rate_connected_fem.size(); ++i){
  
     csize = _popPtr->size(FEM, ADLTx, (unsigned int)connected_patches[i]);
  
     if(csize)
       disp_table_fem[i] = disp_rate_connected_fem[i];
     else
       disp_table_fem[i] = 0;
  
 //    cout<<"\t > "<<(unsigned int)connected_patches[i]<<": "
 //        <<csize<<" adlt female ("<<disp_table_fem[i]<<")"<<endl;
  
     c_size_fem += csize;
   }
  
   // no reproduction can happen if local and all connected patches are empty
   if( c_size_fem == 0 ) return;
  
   unsigned int c_size_mal = 0;
  
   // use the dispersal matrices for the dispersing sex
   connected_patches = LCE_Disperse_base::getConnectedPatches(_dispersing_sex, patchID);
  
   // the sex patch size to check depends on the mating system; male for random mating, fem otherwise
   sex_t sex2check = (this->getMatingSystem() == 1 ? MAL : FEM);
  
 //  cout<<"\t - male dispersal:\n";
  
   for(unsigned int i = 0; i < disp_rate_connected_mal.size(); ++i){
     csize = _popPtr->size(sex2check, ADLTx, (unsigned int)connected_patches[i]);
  
     if(csize)
       disp_table_mal[i] = disp_rate_connected_mal[i];
     else
       disp_table_mal[i] = 0;
  
 //    cout<<"\t > "<<(unsigned int)connected_patches[i]<<": "
 //        <<csize<<" adlt "<<(sex2check == MAL? "male" :"female")
 //        <<" ("<<disp_table_mal[i]<<")"<<endl;
  
     c_size_mal += csize;
   }
  
   // same about males,
   // or females in connected patches following the male dispersal matrix in case of hermaphroditism and differentiated dispersal
   if( c_size_mal == 0 ) return;
  
 //  cout<<"\t - size of connected patch; fem = "<<c_size_fem<<", mal = "<<c_size_mal<<endl;
  
   gsl_ran_discrete_t* gsltable_fem = gsl_ran_discrete_preproc(disp_rate_connected_fem.size(), disp_table_fem);
   gsl_ran_discrete_t* gsltable_mal = gsl_ran_discrete_preproc(disp_rate_connected_mal.size(), disp_table_mal);
  
 //  cout<<"\t  generating "<<size<<" offspring\n ";
  
   for(unsigned int j = 0, viab_count; j < size; j++) {
         viab_count = (*counter);
     do{
  
       // 1. choose the parents and create the offspring object (by recycling)
       new_ind = (this->*_make_offspring)(SEX, patch, patchID, gsltable_fem, gsltable_mal);
  
       if(new_ind) {
       // 2. compute inheritance of the traits and survival of the offspring
         new_ind = makeOffspringWithSelection(new_ind , patchID);
         (*counter)++;
       }
  
       viab_count++;
  
       if( viab_count - (*counter) > 100) {
         warning("it took more than %i trials to get a fit offspring.",viab_count - (*counter));
       }
  
     } while (new_ind == NULL);
     
     patch->add(SEX, OFFSx, new_ind);
     if(patch->size(ADLTx) == 0) patch->nbKolonisers++;
   }
  
 //  cout << "done\n";
  
   gsl_ran_discrete_free(gsltable_fem);
   gsl_ran_discrete_free(gsltable_mal);
 }

References LCE_Breed_Disperse::_dispersing_sex, LCE_Breed_Disperse::_make_offspring, LifeCycleEvent::_popPtr, Patch::add(), ADLTx, FEM, LCE_Disperse_base::getConnectedPatches(), LCE_Disperse_base::getConnectedRates(), LCE_Breed_base::getMatingSystem(), LCE_Breed_Selection::makeOffspringWithSelection(), MAL, Patch::nbKolonisers, OFFSx, Metapop::size(), Patch::size(), and warning().

Referenced by breed_selection_disperse().

◆ execute()

void LCE_Breed_Selection_Disperse::execute ( )

virtual

Reimplemented from LCE_Breed_Disperse.

 {
   int ind_count = 0;
   
 #ifdef _DEBUG_
   message("LCE_Breed_Selection_Disperse::execute (mean fitness(adlt): %f, fit scale: %f, offsprg nb: %i, adlt nb: %i, "
           ,getMeanFitness(ADLTx), _scaling_factor, _popPtr->size( OFFSPRG ), _popPtr->size( ADULTS ));
   fflush(stdout);
 #endif
   
   //  _scaling_factor = (_mean_fitness >= _base_fitness ? 1 : _base_fitness/_mean_fitness);
   
   if(_npatch != _popPtr->getPatchNbr()) {
     _npatch = _popPtr->getPatchNbr();
     if(!updateDispMatrix()) fatal("LCE_Breed_Selection_Disperse::execute: bailing out\n");
   }
   
   LCE_Selection_base::resetCounters();  
   LCE_Disperse_base::reset_counters();
  
   // check if change in local optima for quantitative traits
   LCE_Selection_base::checkChangeLocalOptima();
   
   (this->*_breed_selection_disperse)(&ind_count);
   
   LCE_Selection_base::setMeans(ind_count);
  
   // swap parents and offspring in WF populations
   if(LCE_Breed_base::isWrightFisher()) LCE_Breed_base::doAgingInWFpop();
   
 #ifdef _DEBUG_
   unsigned int a = 0, b = 0, c = 0;
   for(unsigned int i = 0; i < _popPtr->getPatchNbr(); i++){
     a += _popPtr->getPatch(i)->nbEmigrant;
     b += _popPtr->getPatch(i)->nbImigrant;
     c += _popPtr->getPatch(i)->nbPhilopat;
   }
   message("immigrate: %f, emigrants: %i, imigrants: %i, mean fitness(offsprg): %f)\n",(double)b/(b+c), a, b, _mean_fitness);
 #endif
 }  

References _breed_selection_disperse, LCE_Selection_base::_mean_fitness, LCE_Disperse_base::_npatch, LifeCycleEvent::_popPtr, LCE_Selection_base::_scaling_factor, ADLTx, ADULTS, LCE_Selection_base::checkChangeLocalOptima(), LCE_Breed_base::doAgingInWFpop(), fatal(), LCE_Selection_base::getMeanFitness(), Metapop::getPatch(), Metapop::getPatchNbr(), LCE_Breed_base::isWrightFisher(), message(), Patch::nbEmigrant, Patch::nbImigrant, Patch::nbPhilopat, OFFSPRG, LCE_Disperse_base::reset_counters(), LCE_Selection_base::resetCounters(), LCE_Selection_base::setMeans(), Metapop::size(), and LCE_Disperse_base::updateDispMatrix().

◆ loadFileServices()

virtual void LCE_Breed_Selection_Disperse::loadFileServices ( FileServices * loader )

inlinevirtual

Reimplemented from LCE_Breed_Disperse.

316 {}

◆ loadStatServices()

void LCE_Breed_Selection_Disperse::loadStatServices ( StatServices * loader )

virtual

Reimplemented from LCE_Breed_Disperse.

 {
   LCE_Selection_base::loadStatServices(loader);
 }

References LCE_Selection_base::loadStatServices().

◆ removeAgeClass()

virtual age_t LCE_Breed_Selection_Disperse::removeAgeClass ( )

inlinevirtual

Reimplemented from LCE_Breed_Disperse.

319 {return NONE;}

References NONE.

◆ requiredAgeClass()

virtual age_t LCE_Breed_Selection_Disperse::requiredAgeClass ( )

inlinevirtual

Reimplemented from LCE_Breed_Disperse.

321 {return ADULTS;}

References ADULTS.

◆ resetParameterFromSource()

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

inlinevirtual

Reimplemented from LCE_Breed_Disperse.

318 {return false;}

◆ setParameters()

bool LCE_Breed_Selection_Disperse::setParameters ( )

virtual

Reimplemented from LCE_Breed_Disperse.

 {
  
   if(!LCE_Breed_Disperse::setParameters()) return false;
   if(!LCE_Selection_base::setParameters()) return false;
   if(!LCE_Breed_Selection::setNonSelectedTraitTable()) return false;
   
   if(get_parameter("breed_selection_disperse_fitness_threshold")->isSet())
     _base_fitness = get_parameter_value("breed_selection_disperse_fitness_threshold");
   else
     _base_fitness = 0.01;
   
   unsigned int model = this->getDispersalModel();
   if(model == 2)
     _breed_selection_disperse = &LCE_Breed_Selection_Disperse::breed_selection_disperse_propagule;
   else
     _breed_selection_disperse = &LCE_Breed_Selection_Disperse::breed_selection_disperse;
   
   return true;
 }