LCE_Selection_base Class Reference

Base class performing (viability) selection on an arbitrary trait. More...

#include <LCEselection.h>

Inheritance diagram for LCE_Selection_base:

Collaboration diagram for LCE_Selection_base:

Public Member Functions
	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...
Implementations
virtual bool	setParameters ()
virtual void	execute ()
virtual void	loadStatServices (StatServices *loader)
virtual void	loadFileServices (FileServices *loader)
virtual bool	resetParameterFromSource (std::string param, SimComponent *cmpt)
virtual LifeCycleEvent *	clone ()
virtual age_t	removeAgeClass ()
virtual age_t	addAgeClass ()
virtual age_t	requiredAgeClass ()
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...

Protected Attributes
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
Quantitative traits parameters
int	_selectTraitDimension
	Number of quantitative traits under selection. More...
vector< double >	_selection_variance
	Patch-specific selection variance. More...
double	_eVariance
	Evironmental variance. More...
Pointers to functions, set in LCE_Selection_base::setParameters
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...
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
Gaussian selection variables
vector< TMatrix * >	_selection_matrix
vector< gsl_matrix * >	_gsl_selection_matrix
gsl_vector *	_diffs
gsl_vector *	_res1
TMatrix *	_local_optima
TMatrix	_rate_of_change_local_optima
bool	_do_change_local_opt
bool	_rate_of_change_is_std
unsigned int	_set_std_rate_at_generation
int	_std_rate_reference_patch
double *	_phe
	Array to temporarily hold the phenotypic values of an individual, is never allocated. More...
Fixed selection (lethal-equivalents-based) parameters
double	_Fpedigree [5]
	Array of pedigree values used in the fixed-selection model. More...
double	_FitnessFixModel [5]
	Absolute fitness values of the five pedigree class for the fixed selection model (lethal equivalents model). More...

Friends
class	LCE_SelectionSH
	The StatHandler associated class is a friend. More...
class	LCE_SelectionFH
class	LCE_Breed_Selection

Detailed Description

Base class performing (viability) selection on an arbitrary trait.

Implements several types of selection models, from fixed inbreeding depression-type model to Gaussian stabilizing selection on an adaptive landscape. This class is the base-class for the composite LCEs breed_selection and breed_selection_disperse.

Constructor & Destructor Documentation

LCE_Selection_base()

LCE_Selection_base::LCE_Selection_base

(

)

                                         : LifeCycleEvent("viability_selection", ""),
_selection_matrix(0), _gsl_selection_matrix(0), _diffs(0), _res1(0), _local_optima(0), _phe(0),
_selectTraitDimension(1), _base_fitness(1), _mean_fitness(0), _max_fitness(0), _scaling_factor(1), 
_is_local(0), _is_absolute(1), _eVariance(0), _getRawFitness(0), _getFitness(0), _stater(0),_writer(0)
{ 
  // mandatory parameter (no default):
  add_parameter("selection_trait", STR, true, false, 0, 0); //no updaters here, to keep it safe...
  
  ParamUpdater< LCE_Selection_base > * updater = 
    new ParamUpdater<LCE_Selection_base>(&LCE_Selection_base::set_fit_model);
  
  add_parameter("selection_fitness_model",STR,false,false,0,0, updater);
  
  updater = new ParamUpdater<LCE_Selection_base>(&LCE_Selection_base::set_sel_model);
  
  add_parameter("selection_model",STR,true,false,0,0, updater); //mandatory, depends on trait
  add_parameter("selection_matrix",MAT,false,false,0,0, updater);
  add_parameter("selection_variance",DBL,false,false,0,0, updater);
  add_parameter("selection_correlation",DBL,false,false,0,0, updater);
  add_parameter("selection_trait_dimension",INT,false,false,0,0, updater);
  add_parameter("selection_base_fitness",DBL,false,true,0,1, updater);
  add_parameter("selection_lethal_equivalents",DBL,false,false,0,0, updater);
  add_parameter("selection_pedigree_F",MAT,false,false,0,0, updater);
  add_parameter("selection_randomize",BOOL,false,false,0,0, updater);
  add_parameter("selection_environmental_variance", DBL, false, false, 0, 0, updater);
  
  updater = new ParamUpdater<LCE_Selection_base>(&LCE_Selection_base::set_local_optima);
  add_parameter("selection_local_optima",DBL,false,false,0,0, updater);
  
  updater = new ParamUpdater<LCE_Selection_base>(&LCE_Selection_base::set_param_rate_of_change);
  add_parameter("selection_rate_environmental_change", DBL, false, false, 0, 0, updater);
  add_parameter("selection_std_rate_environmental_change", DBL, false, false, 0, 0, updater);
  add_parameter("selection_std_rate_set_at_generation", INT, false, false, 0, 0, updater);
  add_parameter("selection_std_rate_reference_patch", INT, false, false, 0, 0, updater);
  
  
  add_parameter("selection_output", BOOL, false, false, 0, 0, 0);
  add_parameter("selection_output_logtime", INT, false, false, 0, 0, 0);
  add_parameter("selection_output_dir", STR, false, false, 0, 0, 0);
}

References SimComponent::add_parameter(), BOOL, DBL, INT, MAT, set_fit_model(), set_local_optima(), set_param_rate_of_change(), set_sel_model(), and STR.

Referenced by clone().

Here is the caller graph for this function:

~LCE_Selection_base()

LCE_Selection_base::~LCE_Selection_base ( )

virtual

{
  vector< TMatrix* >::iterator selIT = _selection_matrix.begin();
  for(; selIT != _selection_matrix.end(); ++selIT)
    if((*selIT)) delete (*selIT);
  _selection_matrix.clear();
  
  for(unsigned int i  = 0; i < _gsl_selection_matrix.size(); ++i)
    if(_gsl_selection_matrix[i]) gsl_matrix_free(_gsl_selection_matrix[i]);
  _gsl_selection_matrix.clear();
  
  if(_local_optima) delete _local_optima;
  if(_diffs) gsl_vector_free(_diffs);
  if(_res1) gsl_vector_free(_res1);
  if(_stater) delete _stater;
}

References _diffs, _gsl_selection_matrix, _local_optima, _res1, _selection_matrix, and _stater.

Member Function Documentation

addAgeClass()

virtual age_t LCE_Selection_base::addAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection, and LCE_Breed_Selection_Disperse.

{return NONE;}

References NONE.

addPhenotypicSD()

void LCE_Selection_base::addPhenotypicSD	(	unsigned int	deme,
		double *	stDev
	)

{
  Patch *patch = _popPtr->getPatch(deme);
  Individual* ind;
  unsigned int table_size = patch->size(OFFSx);
  
  double **phenot = new double* [_selectTraitDimension];
 
  for (int i = 0; i < _selectTraitDimension; ++i) {
    
    phenot[i] = new double [table_size];
    
  }
  
  unsigned int pos = 0;
  
  for (unsigned int j = 0; j < patch->size(FEM, OFFSx) && pos < table_size; ++j) {
    
    ind = patch->get(FEM, OFFSx, j);
    _phe = (double*)ind->getTraitValue(_LCELinkedTraitIndex);
    
    for (int i = 0; i < _selectTraitDimension; ++i)
      phenot[i][pos] = _phe[i];
    
    pos++;
    
  }
  
  for (unsigned int j = 0; j < patch->size(MAL, OFFSx) && pos < table_size; ++j) {
    
    ind = patch->get(MAL, OFFSx, j);
    _phe = (double*)ind->getTraitValue(_LCELinkedTraitIndex);
    
    for (int i = 0; i < _selectTraitDimension; ++i)
      phenot[i][pos] = _phe[i];
    
    pos++;
    
  }
    
  assert(pos == table_size);
  
  for (int i = 0; i < _selectTraitDimension; ++i) {
    stDev[i] += sqrt( my_variance_with_fixed_mean( phenot[i], table_size, my_mean(phenot[i], table_size) ) );
    delete [] phenot[i];
  }
  
  delete [] phenot;
}

References LifeCycleEvent::_LCELinkedTraitIndex, _phe, LifeCycleEvent::_popPtr, _selectTraitDimension, FEM, Patch::get(), Metapop::getPatch(), Individual::getTraitValue(), MAL, my_mean(), my_variance_with_fixed_mean(), OFFSx, and Patch::size().

Referenced by set_std_rate_of_change().

Here is the caller graph for this function:

changeLocalOptima()

void LCE_Selection_base::changeLocalOptima

(

)

{
  for (int i = 0; i < _selectTraitDimension; ++i)
    for (unsigned int j = 0; j < _local_optima->nrows(); ++j) {
      _local_optima->plus(j, i, _rate_of_change_local_optima.get(j, i));
    }
}

References _local_optima, _rate_of_change_local_optima, _selectTraitDimension, TMatrix::get(), TMatrix::nrows(), and TMatrix::plus().

Referenced by set_param_rate_of_change(), and set_std_rate_of_change().

Here is the caller graph for this function:

clone()

virtual LifeCycleEvent * LCE_Selection_base::clone ( )

inlinevirtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection, and LCE_Breed_Selection_Disperse.

{return new LCE_Selection_base();}

References LCE_Selection_base().

doViabilitySelection()

void LCE_Selection_base::doViabilitySelection	(	sex_t	SEX,
		age_idx	AGE,
		Patch *	patch,
		unsigned int	p
	)

Selectively removes individuals in the population depending on their fitness.

Calls the fitness function for each individual. Updates the fitness counters. The fitness scaling factor is set outside this function, in the execute() procedure.

Parameters

SEX	the sex class
AGE	the age-class index
patch	the focal patch
p	the focal patch index

{
  register Individual* ind;
  register double fitness;
  register unsigned int cat;
  
  for(unsigned int i = 0; i < patch->size(SEX, AGE); i++) {
  
    ind = patch->get(SEX, AGE, i);
    cat = ind->getPedigreeClass();
    fitness = getFitness( ind, p);
       
    _fitness[cat] += fitness;
    _ind_cntr[cat]++;
    
    if(RAND::Uniform() > fitness ) {
      //this individual dies
      patch->remove(SEX, AGE, i);
      
      _popPtr->recycle(ind);
    
      i--;
      
    } //else; this individual stays in the patch
    else {
      _survival[cat]++;
    }
 
  }
}

References _fitness, _ind_cntr, LifeCycleEvent::_popPtr, _survival, Patch::get(), getFitness(), Individual::getPedigreeClass(), IndFactory::recycle(), Patch::remove(), Patch::size(), and RAND::Uniform().

Referenced by execute().

Here is the caller graph for this function:

execute()

void LCE_Selection_base::execute ( )

virtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection, and LCE_Breed_Selection_Disperse.

{
  Patch * patch;
  unsigned int popSize = _popPtr->size(OFFSPRG);
 
#ifdef _DEBUG_
  message("LCE_Selection_base::execute (tot offsprg nb: %i", popSize);
#endif
  
  resetCounters();
 
  if(_do_change_local_opt) {
  
    if(_popPtr->getCurrentGeneration() == 1) {
      set_local_optima(); //reset local optima to initial values
      if(_rate_of_change_is_std) //reset rate of change relative to SD of that replicate
        _setNewLocalOptima = &LCE_Selection_base::set_std_rate_of_change;
    }
    
    (this->*_setNewLocalOptima)();
  }
  
  for(unsigned int p = 0; p < _popPtr->getPatchNbr(); p++) {
    
    (this->*_setScalingFactor)(OFFSx, p);
    
    patch = _popPtr->getPatch(p);
    
    doViabilitySelection(FEM, OFFSx, patch, p);
    
    doViabilitySelection(MAL, OFFSx, patch, p);
  }
 
  setMeans(popSize);
 
#ifdef _DEBUG_
  message(", after selection: %i, mean fitness offspring=%f)\n",_popPtr->size(OFFSPRG), _mean_fitness);
#endif
}

References _do_change_local_opt, _mean_fitness, LifeCycleEvent::_popPtr, _rate_of_change_is_std, _setNewLocalOptima, _setScalingFactor, doViabilitySelection(), FEM, Metapop::getCurrentGeneration(), Metapop::getPatch(), Metapop::getPatchNbr(), MAL, message(), OFFSPRG, OFFSx, resetCounters(), set_local_optima(), set_std_rate_of_change(), setMeans(), and Metapop::size().

getFitness()

double LCE_Selection_base::getFitness ( Individual *  ind, unsigned int  patch  )

inline

Calls the fitness function according to the fitness model.

The fitness model can be "absolute", "relative_local" or "relative_global".

Parameters

ind	the focal indvidual, we want to know its fitness
patch	the index of the patch of the focal individual

  {
    return (this->*_getFitness)(ind, patch);
  }

References _getFitness.

Referenced by LCE_Breed_Selection::do_breed_selection_FecFitness(), doViabilitySelection(), getMaxPatchFitness(), getMeanFitness(), getMeanPatchFitness(), LCE_Breed_Selection::makeOffspringWithSelection(), LCE_SelectionSH::setDataTable(), and LCE_Breed_Selection::setReproScaledFitness_sum().

Here is the caller graph for this function:

getFitnessAbsolute()

double LCE_Selection_base::getFitnessAbsolute	(	Individual *	ind,
		unsigned int	patch
	)

Returns the raw fitness of the individual, without adjustment (absolute fitness).

Calls the fitness function according to the right selection model.

Parameters

ind	the focal indvidual, we want to know its fitness
patch	the index of the patch of the focal individual

{
  double fitness = 1;
  //at this point, _getRawFitness.size() == _TraitIndices.size()
  //and we assume that the functions are "aligned" with the traits
  for(unsigned int i = 0; i < _getRawFitness.size(); i++)
    fitness *= (this->*_getRawFitness[i])(ind, patch, _TraitIndices[i]);
  return fitness;
}

References _getRawFitness, and _TraitIndices.

Referenced by getFitnessRelative(), and set_fit_model().

Here is the caller graph for this function:

getFitnessDirect()

double LCE_Selection_base::getFitnessDirect ( Individual *  offsprg, unsigned int  patch, unsigned int  trait  )

inline

Returns the fitness of an individual following the direct selection model.

  { 
    return *(double*)offsprg->getTraitValue(trait); 
  }

References Individual::getTraitValue().

Referenced by set_sel_model().

Here is the caller graph for this function:

getFitnessFixedEffect()

double LCE_Selection_base::getFitnessFixedEffect ( Individual *  offsprg, unsigned int  patch, unsigned int  trait  )

inline

Returns the fitness of an individual in the fixed selection model.

  {
    return _FitnessFixModel[ offsprg->getPedigreeClass() ];
  }

References _FitnessFixModel, and Individual::getPedigreeClass().

Referenced by set_sel_model().

Here is the caller graph for this function:

getFitnessMultivariateGaussian()

double LCE_Selection_base::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.

{
  register double res2;
  
//  if(!ind) fatal("passing NULL ind ptr to LCE_Selection_base::getFitnessMultivariateGaussian!!!\n");
  
  _phe = (double*)ind->getTraitValue(trait);
  
  for( int i = 0; i < _selectTraitDimension; i++)
    gsl_vector_set(_diffs, i, _phe[i] - _local_optima->get(patch, i));
  
  //(diff)T * W * diff:  
  //right partial product:
  gsl_blas_dsymv(CblasUpper, 1.0, _gsl_selection_matrix[patch], _diffs, 0.0, _res1);
  //left product:
  gsl_blas_ddot(_diffs, _res1, &res2);
  
  return exp( -0.5 * res2 );
}

References _diffs, _gsl_selection_matrix, _local_optima, _phe, _res1, _selectTraitDimension, TMatrix::get(), and Individual::getTraitValue().

Referenced by set_sel_model().

Here is the caller graph for this function:

getFitnessMultivariateGaussian_VE()

double LCE_Selection_base::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.

{
  register double res2;
  
  _phe = (double*)ind->getTraitValue(trait);
  
  //add the environmental variance here:
  for( int i = 0; i < _selectTraitDimension; i++)
    gsl_vector_set(_diffs, i, _phe[i]  + RAND::Gaussian(_eVariance) - _local_optima->get(patch, i));
  
  //(diff)T * W * diff:  
  //right partial product:
  gsl_blas_dsymv(CblasUpper, 1.0, _gsl_selection_matrix[patch], _diffs, 0.0, _res1);
  //left product:
  gsl_blas_ddot(_diffs, _res1, &res2);
  
  return exp( -0.5 * res2 );
}

References _diffs, _eVariance, _gsl_selection_matrix, _local_optima, _phe, _res1, _selectTraitDimension, RAND::Gaussian(), TMatrix::get(), and Individual::getTraitValue().

Referenced by set_sel_model().

Here is the caller graph for this function:

getFitnessRelative()

double LCE_Selection_base::getFitnessRelative ( Individual *  ind, unsigned int  patch  )

inline

Returns the relative fitness of the individual, adjusted by a scaling factor.

The scaling factor is set according to the relative fitness model (local or global) outside of this function. If the scaling factor is one, this is the absolute fitness of the individual. Calls the fitness function according to the right selection model.

Parameters

ind	the focal indvidual, we want to know its fitness
patch	the index of the patch of the focal individual

  {
    return getFitnessAbsolute(ind, patch) * _scaling_factor;
  }

References _scaling_factor, and getFitnessAbsolute().

Referenced by set_fit_model().

Here is the caller graph for this function:

getFitnessUnivariateGaussian()

double LCE_Selection_base::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.

{
  register double res2, diff;
 
  _phe = (double*)ind->getTraitValue(trait);
 
  diff = _phe[0] - _local_optima->get(patch, 0);
  
  res2 = diff*diff / _selection_variance[patch];
 
  return exp( -0.5 * res2 );
}

References _local_optima, _phe, _selection_variance, TMatrix::get(), and Individual::getTraitValue().

Referenced by set_sel_model().

Here is the caller graph for this function:

getFitnessUnivariateGaussian_VE()

double LCE_Selection_base::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.

{
  register double res2, diff;
  
  _phe = (double*)ind->getTraitValue(trait);
  
  //add the environmental variance here:
  diff = _phe[0] + RAND::Gaussian(_eVariance) - _local_optima->get(patch, 0);
  
  res2 = diff*diff / _selection_variance[patch];
  
  return exp( -0.5 * res2 );
}

References _eVariance, _local_optima, _phe, _selection_variance, RAND::Gaussian(), TMatrix::get(), and Individual::getTraitValue().

Referenced by set_sel_model().

Here is the caller graph for this function:

getFitnessUnivariateQuadratic()

double LCE_Selection_base::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.

{
  register double res2, diff;
  
   _phe = (double*)ind->getTraitValue(trait);
  
  diff = _phe[0] - _local_optima->get(patch, 0);
  
  res2 = diff*diff / _selection_variance[patch];
  
  return 1 - res2;
}

References _local_optima, _phe, _selection_variance, TMatrix::get(), and Individual::getTraitValue().

Referenced by set_sel_model().

Here is the caller graph for this function:

getMaxFitness()

double LCE_Selection_base::getMaxFitness

(

age_idx

age

)

Computes the maximum fitness value of the whole population for a given age class.

Parameters

age	the age-class index

{
  double max = 0, local_max;
  
  for(unsigned int i = 0, npatch = _popPtr->getPatchNbr(); i < npatch; i++) {
    
    local_max = getMaxPatchFitness(age, i);
    
    max = (local_max > max ? local_max : max);
  }
  
  return max;
}

References LifeCycleEvent::_popPtr, getMaxPatchFitness(), and Metapop::getPatchNbr().

Referenced by setScalingFactorMaxGlobal().

Here is the caller graph for this function:

getMaxPatchFitness()

double LCE_Selection_base::getMaxPatchFitness	(	age_idx	age,
		unsigned int	p
	)

Computes the maximum fitness value in a given patch for a given age class.

Parameters

age	the age-class index
p	the patch index

{
  double max = 0, fit;
  Patch *patch = _popPtr->getPatch(p);
  
  for(unsigned int j = 0, size = patch->size(FEM, age); j < size; j++) {
    fit = getFitness( patch->get(FEM, age, j), p);
    max = (fit > max ? fit : max);
  }
  for(unsigned int j = 0, size = patch->size(MAL, age); j < size; j++){
    fit = getFitness( patch->get(MAL, age, j), p);
    max = (fit > max ? fit : max);
  }
  
  return max;
}

References LifeCycleEvent::_popPtr, FEM, Patch::get(), getFitness(), Metapop::getPatch(), MAL, and Patch::size().

Referenced by getMaxFitness(), and setScalingFactorMaxLocal().

Here is the caller graph for this function:

getMeanFitness()

double LCE_Selection_base::getMeanFitness

(

age_idx

age

)

Computes the mean fitness of the whole population for a given age class.

Parameters

age	the age-class index

{
  double mean = 0;
  Patch *patch;
//  age_idx age = (AGE == ADULTS ? ADLTx : OFFSx);
  
  for(unsigned int i = 0, npatch = _popPtr->getPatchNbr(); i < npatch; i++) {
    patch = _popPtr->getPatch(i);
    for(unsigned int j = 0, size = patch->size(FEM, age); j < size; j++)
      mean += getFitness( patch->get(FEM, age, j), i);
    for(unsigned int j = 0, size = patch->size(MAL, age); j < size; j++)
      mean += getFitness( patch->get(MAL, age, j), i);
  }
  return mean/_popPtr->size(age);
}

References LifeCycleEvent::_popPtr, FEM, Patch::get(), getFitness(), Metapop::getPatch(), Metapop::getPatchNbr(), MAL, Metapop::size(), and Patch::size().

Referenced by LCE_Breed_Selection_Disperse::execute(), setMeanFitness(), and setScalingFactorGlobal().

Here is the caller graph for this function:

getMeanPatchFitness()

double LCE_Selection_base::getMeanPatchFitness	(	age_idx	age,
		unsigned int	p
	)

Computes the mean fitness in a given patch for a given age class.

Parameters

age	the age-class index
p	the patch index

{
  double mean = 0;
  Patch *patch = _popPtr->getPatch(p);
  
  for(unsigned int j = 0, size = patch->size(FEM, age); j < size; j++)
    mean += getFitness( patch->get(FEM, age, j), p);
  
  for(unsigned int j = 0, size = patch->size(MAL, age); j < size; j++)
    mean += getFitness( patch->get(MAL, age, j), p);
  
  return mean/patch->size(age);
}

References LifeCycleEvent::_popPtr, FEM, Patch::get(), getFitness(), Metapop::getPatch(), MAL, and Patch::size().

Referenced by LCE_Breed_Selection_Disperse::breed_selection_disperse(), and setScalingFactorLocal().

Here is the caller graph for this function:

loadFileServices()

void LCE_Selection_base::loadFileServices ( FileServices *  loader )

virtual

Implements SimComponent.

Reimplemented in LCE_Breed_Selection, and LCE_Breed_Selection_Disperse.

{
  if(_paramSet->isSet("selection_output")) {
  
    if(_writer == NULL) _writer = new LCE_SelectionFH(this);
    
    Param* param = get_parameter("selection_output_logtime");
    
    if(!param->isSet()) fatal("parameter \"selection_output_logtime\" is missing\n");
 
    if(param->isMatrix()) {
      
      TMatrix temp;
      
      param->getMatrix(&temp);
      
      _writer->set_multi(true, true, 1, &temp, get_parameter("selection_output_dir")->getArg());
    //           rpl_per, gen_per, rpl_occ, gen_occ, rank, path, self-ref
    } else _writer->set(true, param->isSet(), 1, (param->isSet() ? (int)param->getValue() : 0), 0, get_parameter("selection_output_dir")->getArg(), this);
    
  
    loader->attach(_writer);
  
  } else {
    
    if(_writer) delete _writer;
    
    return;
  }
    
  
}

References SimComponent::_paramSet, _writer, FileServices::attach(), fatal(), SimComponent::get_parameter(), Param::getMatrix(), Param::getValue(), Param::isMatrix(), Param::isSet(), ParamSet::isSet(), LCE_SelectionFH, EventFileHandler< LCE >::set(), and FileHandler::set_multi().

loadStatServices()

void LCE_Selection_base::loadStatServices ( StatServices *  loader )

virtual

Implements SimComponent.

Reimplemented in LCE_Breed_Selection, and LCE_Breed_Selection_Disperse.

{
  if(_stater == NULL) _stater = new LCE_SelectionSH(this);
  loader->attach(_stater);
}

References _stater, StatServices::attach(), and LCE_SelectionSH.

Referenced by LCE_Breed_Selection::loadStatServices(), and LCE_Breed_Selection_Disperse::loadStatServices().

Here is the caller graph for this function:

removeAgeClass()

virtual age_t LCE_Selection_base::removeAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection, and LCE_Breed_Selection_Disperse.

{return NONE;}

References NONE.

requiredAgeClass()

virtual age_t LCE_Selection_base::requiredAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection, and LCE_Breed_Selection_Disperse.

{return OFFSPRG;}

References OFFSPRG.

resetCounters()

void LCE_Selection_base::resetCounters

(

)

Resets the fitness counters.

{
  for(unsigned int i = 0; i < 5; i++) {
    _fitness[i] = 0;
    _survival[i] = 0;
    _ind_cntr[i] = 0;
  }
}

References _fitness, _ind_cntr, and _survival.

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

Here is the caller graph for this function:

resetParameterFromSource()

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

inlinevirtual

Implements SimComponent.

Reimplemented in LCE_Breed_Selection, and LCE_Breed_Selection_Disperse.

{return false;}

set_fit_model()

bool LCE_Selection_base::set_fit_model

(

)

{  
    
  if(_paramSet->isSet("selection_fitness_model")) {
    
    string fit_model = _paramSet->getArg("selection_fitness_model");
    
    if( fit_model == "absolute") {
      
      _is_local = false;
      _is_absolute = true;
      _getFitness = &LCE_Selection_base::getFitnessAbsolute;
      _setScalingFactor = &LCE_Selection_base::setScalingFactorAbsolute;
      
    } else if( fit_model == "relative_local" ) {
      
      _is_local = true;      
      _is_absolute = false;
      _getFitness = &LCE_Selection_base::getFitnessRelative;
      _setScalingFactor = &LCE_Selection_base::setScalingFactorLocal;
      
    } else if(fit_model == "relative_global") {
            
      _is_local = false;
      _is_absolute = false;
      _getFitness = &LCE_Selection_base::getFitnessRelative;
      _setScalingFactor = &LCE_Selection_base::setScalingFactorGlobal;
      
    } else if(fit_model == "relative_max_local") {
      
      _is_local = true;      
      _is_absolute = false;
      _getFitness = &LCE_Selection_base::getFitnessRelative;
      _setScalingFactor = &LCE_Selection_base::setScalingFactorMaxLocal;
      
    } else if(fit_model == "relative_max_global") {
      
      _is_local = false;
      _is_absolute = false;
      _getFitness = &LCE_Selection_base::getFitnessRelative;
      _setScalingFactor = &LCE_Selection_base::setScalingFactorMaxGlobal;
            
    } else {
      return error("Unknown fitness model \"%s\"", fit_model.c_str());
    }  
  } //default case:
  else {
    _is_local = false;
    _is_absolute = true;
    _getFitness = &LCE_Selection_base::getFitnessAbsolute;
    _setScalingFactor = &LCE_Selection_base::setScalingFactorAbsolute;
  }
 
  return true;
}

References _getFitness, _is_absolute, _is_local, SimComponent::_paramSet, _setScalingFactor, error(), ParamSet::getArg(), getFitnessAbsolute(), getFitnessRelative(), ParamSet::isSet(), setScalingFactorAbsolute(), setScalingFactorGlobal(), setScalingFactorLocal(), setScalingFactorMaxGlobal(), and setScalingFactorMaxLocal().

Referenced by LCE_Selection_base(), and setParameters().

Here is the caller graph for this function:

set_local_optima()

bool LCE_Selection_base::set_local_optima

(

)

{//set the traits' local optima, _selectTraitDimension must be set before that (= nbr of traits to select on)    
  string model = _paramSet->getArg("selection_model");
  
  if( model == "fix"  || model == "direct") return true;
  
  if( (model == "gaussian" || model == "quadratic")
     && !get_parameter("selection_local_optima")->isSet()) {
    
    return error("parameter \"selection_local_optima\" must be set to have Gaussian or quadratic selection.\n");
    
  } else {
    
    TMatrix tmp_mat;
    
    if(_local_optima == 0) _local_optima = new TMatrix();
    
    _local_optima->reset(_popPtr->getPatchNbr(), _selectTraitDimension);
    
    _paramSet->getMatrix("selection_local_optima", &tmp_mat);
    
    return setSpatialMatrix("selection_local_optima", "\"selection_trait_dimension\"", &tmp_mat, _local_optima, 
                            _selectTraitDimension, _popPtr->getPatchNbr(), _paramSet->isSet("selection_randomize"));
  }
  
  return true;
}

References _local_optima, SimComponent::_paramSet, LifeCycleEvent::_popPtr, _selectTraitDimension, error(), SimComponent::get_parameter(), ParamSet::getArg(), ParamSet::getMatrix(), Metapop::getPatchNbr(), ParamSet::isSet(), TMatrix::reset(), and setSpatialMatrix().

Referenced by execute(), LCE_Selection_base(), and setParameters().

Here is the caller graph for this function:

set_param_rate_of_change()

bool LCE_Selection_base::set_param_rate_of_change

(

)

{
  _rate_of_change_is_std = false;
  _do_change_local_opt = false;
  _setNewLocalOptima = 0;
  _rate_of_change_local_optima.reset();
  
  
  if (!get_parameter("selection_rate_environmental_change")->isSet() 
      && !get_parameter("selection_std_rate_environmental_change")->isSet() )
    return true;
  
  if (get_parameter("selection_rate_environmental_change")->isSet() 
      && get_parameter("selection_std_rate_environmental_change")->isSet() ) {
    return error("both \"selection_rate_environmental_change\" and \"selection_std_rate_environmental_change\" are set, need only one.\n");
  }
  
  TMatrix tmpMat;
  
  if (get_parameter("selection_rate_environmental_change")->isSet()) {
    
    if(!get_parameter("selection_rate_environmental_change")->isMatrix()) {
      
      double val = get_parameter_value("selection_rate_environmental_change");
      
      tmpMat.reset(1, _selectTraitDimension);
      tmpMat.assign(val);
      
    } else {
      get_parameter("selection_rate_environmental_change")->getMatrix(&tmpMat);
    }
    
    _setNewLocalOptima = &LCE_Selection_base::changeLocalOptima;
  
  } else if (get_parameter("selection_std_rate_environmental_change")->isSet()){
    
    if(!get_parameter("selection_std_rate_environmental_change")->isMatrix()) {
      
      double val = get_parameter_value("selection_std_rate_environmental_change");
      
      tmpMat.reset(1, _selectTraitDimension);
      tmpMat.assign(val);
      
    } else {
      get_parameter("selection_std_rate_environmental_change")->getMatrix(&tmpMat);
    }
    
    _rate_of_change_is_std = true;
    
    if(get_parameter("selection_std_rate_set_at_generation")->isSet())
      _set_std_rate_at_generation = (unsigned int)get_parameter_value("selection_std_rate_set_at_generation");
    else
      _set_std_rate_at_generation = 1;
    
    //check if phenotypic SD is to be computed in a single reference patch
    //is -1 if parameter not set, which corresponds to the whole population then
    _std_rate_reference_patch = get_parameter_value("selection_std_rate_reference_patch");
    
    _setNewLocalOptima = &LCE_Selection_base::set_std_rate_of_change;
  }
 
  if(tmpMat.nrows() > _popPtr->getPatchNbr())
    return error("The matrix of rate of change in local optima has more rows than the number of patches\n");
  
  if((int)tmpMat.ncols() > _selectTraitDimension)
    return error("The matrix of rate of change in local optima has more columns than the number of quantitative traits\n");
  
  _do_change_local_opt = true;
 
  _rate_of_change_local_optima.reset(_popPtr->getPatchNbr(), _selectTraitDimension);
  
  unsigned int nCol = tmpMat.ncols(), nRow = tmpMat.nrows();
 
  //copy values, with pattern propagation
  for (int p = 0; p < _popPtr->getPatchNbr(); ++p) {
  for (int i = 0; i < _selectTraitDimension; ++i) {
      _rate_of_change_local_optima.set(p, i, tmpMat.get(p % nRow, i % nCol));
    }
  }
  
  return true;
}

References _do_change_local_opt, LifeCycleEvent::_popPtr, _rate_of_change_is_std, _rate_of_change_local_optima, _selectTraitDimension, _set_std_rate_at_generation, _setNewLocalOptima, _std_rate_reference_patch, TMatrix::assign(), changeLocalOptima(), error(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getMatrix(), Metapop::getPatchNbr(), TMatrix::ncols(), TMatrix::nrows(), TMatrix::reset(), TMatrix::set(), and set_std_rate_of_change().

Referenced by LCE_Selection_base(), and setParameters().

Here is the caller graph for this function:

set_sel_model()

bool LCE_Selection_base::set_sel_model

(

)

{  
  
  _selectTraitDimension = (int)get_parameter_value("selection_trait_dimension");
  
  _base_fitness = get_parameter_value("selection_base_fitness");
 
  // -------------------------------------------------------------------------------------
  // ENVIRONMENTAL VARIANCE
 
  if(get_parameter("selection_environmental_variance")->isSet())
    //the variable actually holds the standard dev...
    _eVariance =  sqrt(get_parameter_value("selection_environmental_variance"));
  else
    _eVariance = 0;
  
  // -------------------------------------------------------------------------------------
  // SELECTION MODELS
 
  // empty containers:
  _SelectionModels.clear();
  _getRawFitness.clear();
  
  // default case: direct fitness model
  if(!_paramSet->isSet("selection_model")) {
    
    _getRawFitness.push_back(&LCE_Selection_base::getFitnessDirect);
    
    _SelectionModels.push_back("direct");
      
  } else {
    
    _SelectionModels = get_parameter("selection_model")->getMultiArgs();
  } //end_if isSet()
 
  // check consistency with selection_trait info
  if (_SelectionModels.size() != _TraitIndices.size())
    return error("\"selection_trait\" and \"selection_model\" must have the same number of arguments.");
 
  // -------------------------------------------------------------------------------------
  // SET FUNCTION POINTERS TO FITNESS FUNCTIONS
 
  string sel_model;
  
  for(unsigned int t = 0; t < _SelectionModels.size(); t++) {
 
    sel_model = _SelectionModels[t];
  
 
    // FIX -----------------------------------------------------------------------
    if(sel_model == "fix") {
      
      //check if the trait type in the trait table is correct
      if(_Traits[t] != "fix")
        return error("the selection model \"fix\" does not match with the trait type \"%s\"\n", _Traits[t].c_str());
 
      if(!get_parameter("selection_lethal_equivalents")->isSet()) {
 
        return error("\"selection_lethal_equivalents\" parameter is missing with \"fix\" selection!\n");
 
      } else
        _letheq = get_parameter_value("selection_lethal_equivalents");
      
      if(!get_parameter("selection_base_fitness")->isSet()) {
 
        warning("\"selection_base_fitness\" parameter is missing under fix selection model, setting it to 1.\n");
 
        _base_fitness = 1.0;
      }
      
      if(!get_parameter("selection_pedigree_F")->isSet()) {
      
        return error("\"selection_pedigree_F\" parameter is missing with \"fix\" selection!\n");
     
      } else {
        
        TMatrix tmp_mat;
        
        get_parameter("selection_pedigree_F")->getMatrix(&tmp_mat);
        
        if(tmp_mat.getNbCols() != 5) {
          return error("\"selection_pedigree_F\" must be an array of size 5.\n");
        }
 
        for(unsigned int i = 0; i < 5; i++) _Fpedigree[i] = tmp_mat.get(0,i);
      }
      
      for(unsigned int i = 0; i < 5; i++)
        _FitnessFixModel[i] = _base_fitness * exp( -_letheq * _Fpedigree[i] );
            
      //everything has been set correctly, add function pointer to container
      _getRawFitness.push_back(&LCE_Selection_base::getFitnessFixedEffect);
 
    // DIRECT -----------------------------------------------------------------------
    } else if(sel_model == "direct") {
      
      //check if the trait type in the trait table is correct
      if(_Traits[t] != "delet" && _Traits[t] != "dmi")
        return error("the selection model \"direct\" does not match with the trait type \"%s\"\n", _Traits[t].c_str());
 
       _getRawFitness.push_back(&LCE_Selection_base::getFitnessDirect);
 
    // QUADRATIC --------------------------------------------------------------------
    } else if(sel_model == "quadratic") {
      
      //check if the trait type in the trait table is correct
      if(_Traits[t] != "quant")
        return error("the selection model \"quadratic\" does not match with the trait type \"%s\"\n", _Traits[t].c_str());
 
      if( get_parameter("selection_trait_dimension")->isSet())
        _selectTraitDimension = get_parameter_value("selection_trait_dimension");
      else
        _selectTraitDimension = 1;
 
      if(_selectTraitDimension == 1){
 
        //check if the number of quanti traits modeled match with the dimensionality:
        if((int)_popPtr->getTraitPrototype("quant")->get_parameter_value("quanti_traits") != _selectTraitDimension)
          return error("The number of quantitative traits in \"quanti_traits\" does not match with\
   the selection trait dimensionality in \"selection_trait_dimension\"\n");
      
        if(!setSelectionMatrix()) return false; //this to set the selection variance params
 
        //now add the pointer to fitness function:
         _getRawFitness.push_back(&LCE_Selection_base::getFitnessUnivariateQuadratic);
      
      } else return error("\"quadratic\" fitness model implemented for a single trait only.\n");
    
 
    // GAUSSIAN --------------------------------------------------------------------
    } else if(sel_model == "gaussian") {
      
      //check if the trait type in the trait table is correct
      if(_Traits[t] != "quant")
        return error("the selection model \"gaussian\" does not match with the trait type \"%s\"\n", _Traits[t].c_str());
 
      if( get_parameter("selection_trait_dimension")->isSet() )
        _selectTraitDimension = (unsigned int)get_parameter_value("selection_trait_dimension");
      else
        _selectTraitDimension = 1;
 
      //check if the number of quanti traits modeled match with the dimensionality:
      if(_popPtr->getTraitPrototype("quant")->get_parameter_value("quanti_traits") != _selectTraitDimension)
        return error("The number of quantitative traits in \"quanti_traits\" does not match with\
 the selection trait dimensionality in \"selection_trait_dimension\"\n");
 
     // set the selection matrices for multi-stage or spatially variable cases
     if( !setSelectionMatrix() ) return false;
      
      if(_selectTraitDimension > 1) {
 
          if(_eVariance > 0)
                  _getRawFitness.push_back(&LCE_Selection_base::getFitnessMultivariateGaussian_VE);
          else
                  _getRawFitness.push_back(&LCE_Selection_base::getFitnessMultivariateGaussian);
 
      } else {
 
          if(_eVariance > 0)
                  _getRawFitness.push_back(&LCE_Selection_base::getFitnessUnivariateGaussian_VE);
          else
                  _getRawFitness.push_back(&LCE_Selection_base::getFitnessUnivariateGaussian);
 
      }
 
    } else return error("wrong selection model, must be either \"fix\", \"direct\", \"quadratic\", or \"gaussian\".\n");
    
  }
  
  if(sel_model != "fix" && !_paramSet->isSet("selection_trait"))
    return error("trait under selection is not set, please add parameter \"selection_trait\"\n");
 
  return true;
}

References _base_fitness, _eVariance, _FitnessFixModel, _Fpedigree, _getRawFitness, _letheq, SimComponent::_paramSet, LifeCycleEvent::_popPtr, _SelectionModels, _selectTraitDimension, _TraitIndices, _Traits, error(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), getFitnessDirect(), getFitnessFixedEffect(), getFitnessMultivariateGaussian(), getFitnessMultivariateGaussian_VE(), getFitnessUnivariateGaussian(), getFitnessUnivariateGaussian_VE(), getFitnessUnivariateQuadratic(), Param::getMatrix(), Param::getMultiArgs(), TMatrix::getNbCols(), IndFactory::getTraitPrototype(), ParamSet::isSet(), setSelectionMatrix(), and warning().

Referenced by LCE_Selection_base(), and setParameters().

Here is the caller graph for this function:

set_std_rate_of_change()

void LCE_Selection_base::set_std_rate_of_change

(

)

{
  if(_popPtr->getCurrentGeneration() == _set_std_rate_at_generation) {
    
    //reset rate_of_change matrix in each new replicate:
    TMatrix tmpMat;
    
    if(!get_parameter("selection_std_rate_environmental_change")->isMatrix()) {
      
      double val = get_parameter_value("selection_std_rate_environmental_change");
      
      tmpMat.reset(_popPtr->getPatchNbr(), _selectTraitDimension);
      tmpMat.assign(val);
      
    } else {
      get_parameter("selection_std_rate_environmental_change")->getMatrix(&tmpMat);
    }
    
    unsigned int nCol = tmpMat.ncols(), nRow = tmpMat.nrows();
 
    _rate_of_change_local_optima.reset(_popPtr->getPatchNbr(), _selectTraitDimension);
 
    //copy values, with pattern propagation
    for (int p = 0; p < _popPtr->getPatchNbr(); ++p) {
    for (int i = 0; i < _selectTraitDimension; ++i) {
        _rate_of_change_local_optima.set(p, i, tmpMat.get(p % nRow, i % nCol));
      }
    }
    
    double* SD = new double [_selectTraitDimension];
    
    for (int i = 0; i < _selectTraitDimension; ++i) {
      SD[i] = 0;
    }
    
    // check if SD is taken in a reference patch instead of the whole pop
    if (_std_rate_reference_patch > -1) {
      
      if( _popPtr->getPatch(_std_rate_reference_patch)->size(OFFSx) != 0 )
        addPhenotypicSD(_std_rate_reference_patch, SD);
    
    } else {
      // compute SD as the mean within-patch SD
      
      unsigned int cnt = 0;
      
      //get SD only in extant demes, to avoid nans
      for(unsigned int i = 0; i < _popPtr->getPatchNbr(); ++i) {
        if (_popPtr->getPatch(i)->size(OFFSx) != 0 ) {
          cnt++;
          addPhenotypicSD(i, SD);
        }
      }
      
      //compute mean within-patch phenotypic standard deviation:
      for (int i = 0; i < _selectTraitDimension; ++i) {
        SD[i]/= cnt;
        
      }
    } //end if
    
    //multiply the per-trait rates of change by SD:
    for (int p = 0; p < _popPtr->getPatchNbr(); ++p) {
    for (int i = 0; i < _selectTraitDimension; ++i){
        _rate_of_change_local_optima.multi(p, i, SD[i]);
    }
    
    }
    //log the rates in the simulation log file:
    SIMenv::MainSim->_FileServices.log("#selection_rate_environmental_change " +
                                       _rate_of_change_local_optima.to_string());
    
    //compute the change of local optima for current generation:
    changeLocalOptima();
    
    //now reset the function pointer to changeLocalOptima() for next generation:
    _setNewLocalOptima = &LCE_Selection_base::changeLocalOptima;
    
    delete [] SD;
  }
}

References SimRunner::_FileServices, LifeCycleEvent::_popPtr, _rate_of_change_local_optima, _selectTraitDimension, _set_std_rate_at_generation, _setNewLocalOptima, _std_rate_reference_patch, addPhenotypicSD(), TMatrix::assign(), changeLocalOptima(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Metapop::getCurrentGeneration(), Param::getMatrix(), Metapop::getPatch(), Metapop::getPatchNbr(), FileServices::log(), SIMenv::MainSim, TMatrix::multi(), TMatrix::ncols(), TMatrix::nrows(), OFFSx, TMatrix::reset(), TMatrix::set(), Patch::size(), and TMatrix::to_string().

Referenced by execute(), and set_param_rate_of_change().

Here is the caller graph for this function:

setLocalOptima()

bool LCE_Selection_base::setLocalOptima

(

)

setMeanFitness()

double LCE_Selection_base::setMeanFitness ( age_idx  age )

inline

Sets the _mean_fitness variable to the value of the mean population fitness.

Parameters

age	the age-class index

{ return (_mean_fitness = getMeanFitness(age));}

References _mean_fitness, and getMeanFitness().

setMeans()

void LCE_Selection_base::setMeans

(

unsigned int

tot_ind

)

Computes the average fitness of each pedigree class.

Called after selection has been done in the whole population.

Parameters

tot_ind

count of the total number of individuals produced

{
  _mean_fitness = 0;
 
  for(unsigned int i = 0; i < 5; i++) {
    _mean_fitness += _fitness[i];
    _fitness[i] /= _ind_cntr[i];
    _survival[i] /= _ind_cntr[i];
    _ind_cntr[i] /= tot_ind;
  }
 
  _mean_fitness /= tot_ind;
}

References _fitness, _ind_cntr, _mean_fitness, and _survival.

Referenced by LCE_Breed_Selection::execute(), LCE_Breed_Selection_Disperse::execute(), and execute().

Here is the caller graph for this function:

setParameters()

bool LCE_Selection_base::setParameters ( )

virtual

Implements SimComponent.

Reimplemented in LCE_Breed_Selection, and LCE_Breed_Selection_Disperse.

{   
  //selection may act on more than one trait at a time
  _Traits.clear();
  _Traits = get_parameter("selection_trait")->getMultiArgs();
  
  _TraitIndices.clear();
 
  for(unsigned int i = 0; i < _Traits.size(); i++)  {
 
    if(_popPtr->getTraitIndex(_Traits[i].c_str()) == -1) {
 
      return error("cannot attach trait \"%s\" to life cycle event \"%s\", trait has not been initiated.\n",
            _Traits[i].c_str(), _event_name.c_str());
 
    } else {
      _TraitIndices.push_back(_popPtr->getTraitIndex(_Traits[i].c_str()));
 
 
#ifdef _DEBUG_
      cout<<"#### attaching trait \""<<_Traits[i].c_str()<<"\" to selection LCE, index = "<<_TraitIndices[i]<<endl;
#endif
 
    }
    
  }
  
 
  if(!set_fit_model()) return false;
  
  if(!set_sel_model()) return false;
  
  if(!set_local_optima()) return false;
  
  if(!set_param_rate_of_change()) return false;
  
  _mean_fitness = _max_fitness = 0;
  _scaling_factor = 1;
  resetCounters();
 
  assert(_TraitIndices.size() == _getRawFitness.size());
 
#ifdef _DEBUG_
  cout<<"#### selection is acting on "<<_TraitIndices.size()<<" traits\n";
  cout<<"#### selection is using "<< _getRawFitness.size() <<" fitness functions\n";
#endif
 
 
  return true; 
}

References LifeCycleEvent::_event_name, _getRawFitness, _max_fitness, _mean_fitness, LifeCycleEvent::_popPtr, _scaling_factor, _TraitIndices, _Traits, error(), SimComponent::get_parameter(), Param::getMultiArgs(), IndFactory::getTraitIndex(), resetCounters(), set_fit_model(), set_local_optima(), set_param_rate_of_change(), and set_sel_model().

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

Here is the caller graph for this function:

setScalingFactorAbsolute()

void LCE_Selection_base::setScalingFactorAbsolute ( age_idx  age, unsigned int  p  )

inline

Resets the fitness scaling factor equal to one.

Parameters

age	the age-class index
p	the focal patch index

{ _scaling_factor = 1; }

References _scaling_factor.

Referenced by set_fit_model().

Here is the caller graph for this function:

setScalingFactorGlobal()

void LCE_Selection_base::setScalingFactorGlobal	(	age_idx	age,
		unsigned int	p
	)

Sets the fitness scaling factor equal to the inverse of the mean population fitness.

Function exits on p != 0; the mean population fitness is computed only once in the execute() procedure, at the beginning of the patch loop.

Parameters

age	the age-class index
p	the focal patch index

{
  if(p != 0) return; //we compupte the mean fitness only once
  _scaling_factor = 1;
  _scaling_factor = 1.0/getMeanFitness(age);
}

References _scaling_factor, and getMeanFitness().

Referenced by set_fit_model(), and LCE_SelectionSH::setDataTable().

Here is the caller graph for this function:

setScalingFactorLocal()

void LCE_Selection_base::setScalingFactorLocal	(	age_idx	age,
		unsigned int	p
	)

Sets the fitness scaling factor equal to the inverse of the mean local patch fitness.

Parameters

age	the age-class index
p	the focal patch index

{
  _scaling_factor = 1; //this to have the raw mean fitness below
  _scaling_factor = 1.0/getMeanPatchFitness(age, p);
}

References _scaling_factor, and getMeanPatchFitness().

Referenced by set_fit_model(), and LCE_SelectionSH::setDataTable().

Here is the caller graph for this function:

setScalingFactorMaxGlobal()

void LCE_Selection_base::setScalingFactorMaxGlobal	(	age_idx	age,
		unsigned int	p
	)

Sets the fitness scaling factor equal to the inverse of the maximum population fitness value.

Function exits on p != 0; the mean population fitness is computed only once in the execute() procedure, at the beginning of the patch loop.

Parameters

age	the age-class index
p	the focal patch index

{
  if(p != 0) return; //we compute the max fitness only once
  _scaling_factor = 1;
  _scaling_factor = 1.0/getMaxFitness(age);
}

References _scaling_factor, and getMaxFitness().

Referenced by set_fit_model().

Here is the caller graph for this function:

setScalingFactorMaxLocal()

void LCE_Selection_base::setScalingFactorMaxLocal	(	age_idx	age,
		unsigned int	p
	)

Sets the fitness scaling factor equal to the inverse of the maximum local patch fitness value.

Parameters

age	the age-class index
p	the focal patch index

{
  _scaling_factor = 1; //this to have the raw fitness when computing fitnesses below
  _scaling_factor = 1.0/getMaxPatchFitness(age, p);
}

References _scaling_factor, and getMaxPatchFitness().

Referenced by set_fit_model().

Here is the caller graph for this function:

setSelectionMatrix()

bool LCE_Selection_base::setSelectionMatrix

(

)

{
  TMatrix tmp_mat; 
  unsigned int patchNbr = _popPtr->getPatchNbr();
  
  if(!get_parameter("selection_matrix")->isSet() && !get_parameter("selection_variance")->isSet()) 
    return error("\"selection_matrix\" or \"selection_variance\" must be set with selection model = \"gaussian\".\n");
 
  
  if(get_parameter("selection_variance")->isSet() && !get_parameter("selection_trait_dimension")->isSet())
    return error("parameter \"selection_trait_dimension\" is missing!\n");
   
  
  //clear the selection matrix container
  vector< TMatrix* >::iterator selIT = _selection_matrix.begin();
  
  for(; selIT != _selection_matrix.end(); ++selIT) if((*selIT)) delete (*selIT);  
  
  _selection_matrix.clear();
  
  
  if(get_parameter("selection_matrix")->isSet()) {
    
    //selection matrix provided, same selection surface in each patch
    _paramSet->getMatrix("selection_matrix", &tmp_mat);
    
    if(tmp_mat.getNbCols() != tmp_mat.getNbRows())
      return error("\"selection_matrix\" must be a square matrix!\n");
 
    _selectTraitDimension = tmp_mat.getNbCols();
    
    //we have one selection matrix per patch, copy it in the container for each patch
    for(unsigned int i = 0; i < patchNbr; ++i)
      _selection_matrix.push_back( new TMatrix(tmp_mat) );
    
  } else {
    //we have to check for spatial variation in variance and covariances
    _selectTraitDimension = (unsigned int)get_parameter_value("selection_trait_dimension");
    
    TMatrix var_spatmat, corr_spatmat;
    
    //setting variance spatial matrix:
    var_spatmat.reset(patchNbr, (unsigned)_selectTraitDimension);
    
    if(get_parameter("selection_variance")->isMatrix()) {
    
      _paramSet->getMatrix("selection_variance", &tmp_mat);
 
      if( !setSpatialMatrix("selection_variance","\"selection_trait_dimension\"", &tmp_mat, &var_spatmat,
                            (unsigned)_selectTraitDimension, patchNbr, _paramSet->isSet("selection_randomize") ) ) 
        return false;
    
    } else {
      
      var_spatmat.assign(get_parameter_value("selection_variance"));
    }
    
    //setting correlation spatial matrix:
    corr_spatmat.reset(patchNbr, (unsigned)_selectTraitDimension*(_selectTraitDimension-1)/2);
    
    if(get_parameter("selection_correlation")->isMatrix()) {
      
      _paramSet->getMatrix("selection_correlation", &tmp_mat);
      
      if( !setSpatialMatrix("selection_correlation","the num of correlation coefficients", &tmp_mat, &corr_spatmat, 
                            (unsigned)_selectTraitDimension*(_selectTraitDimension-1)/2, patchNbr, _paramSet->isSet("selection_randomize") ) )
        return false;
      
    } else {
      
      corr_spatmat.assign((get_parameter("selection_correlation")->isSet() ?
                           get_parameter_value("selection_correlation") : 0.0 ));
    }
    
    //set the selection matrix:
    tmp_mat.reset(_selectTraitDimension, _selectTraitDimension);
    double covar;
    unsigned int col;
    for( unsigned int p = 0; p < patchNbr; p++) {
      col = 0;
      for( int i = 0; i < _selectTraitDimension; i++) {
        tmp_mat.set(i, i, var_spatmat.get(p, i));
        for( int j = i+1; j < _selectTraitDimension; j++) {
          covar = corr_spatmat.get(p, col) * sqrt( var_spatmat.get(p, i) * var_spatmat.get(p, j) );
          tmp_mat.set(i, j, covar);
          tmp_mat.set(j, i, covar);
          col++;
        }
      }
      _selection_matrix.push_back(new TMatrix(tmp_mat));
    }
  }
  
  if(_selectTraitDimension > 1) {
    
    //selection on more than one trait
    
    //inverting the selection matrices:
    if(_gsl_selection_matrix.size() != 0)
      for(unsigned int i = 0; i < _gsl_selection_matrix.size(); ++i)
        if(_gsl_selection_matrix[i] != NULL) gsl_matrix_free( _gsl_selection_matrix[i] );
    
    _gsl_selection_matrix.clear();
    
    for( unsigned int p = 0; p < patchNbr; p++) {
      _selection_matrix[p]->inverse();
 
      _gsl_selection_matrix.push_back( gsl_matrix_alloc(_selectTraitDimension, _selectTraitDimension) );
      
      _selection_matrix[p]->get_gsl_matrix(_gsl_selection_matrix[p]);
    }
 
    //allocate the vectors used by the fitness function:
    if(_diffs != NULL) gsl_vector_free(_diffs);
    _diffs = gsl_vector_alloc( _selectTraitDimension );
    
    if(_res1 != NULL) gsl_vector_free(_res1);
    _res1 = gsl_vector_alloc( _selectTraitDimension );
    
  } else {
 
    //selection on one trait only
    _selection_variance.clear();
 
    for(unsigned int p = 0; p < patchNbr; p++)
      _selection_variance.push_back( _selection_matrix[p]->get(0, 0) );
  }
  
  
  return true;
}

References _diffs, _gsl_selection_matrix, SimComponent::_paramSet, LifeCycleEvent::_popPtr, _res1, _selection_matrix, _selection_variance, _selectTraitDimension, TMatrix::assign(), error(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), ParamSet::getMatrix(), TMatrix::getNbCols(), TMatrix::getNbRows(), Metapop::getPatchNbr(), Param::isMatrix(), Param::isSet(), ParamSet::isSet(), TMatrix::reset(), TMatrix::set(), and setSpatialMatrix().

Referenced by set_sel_model().

Here is the caller graph for this function:

Friends And Related Function Documentation

LCE_Breed_Selection

friend class LCE_Breed_Selection

friend

LCE_SelectionFH

friend class LCE_SelectionFH

friend

Referenced by loadFileServices().

LCE_SelectionSH

friend class LCE_SelectionSH

friend

The StatHandler associated class is a friend.

Referenced by loadStatServices().

Member Data Documentation

_base_fitness

double LCE_Selection_base::_base_fitness

protected

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

_diffs

gsl_vector* LCE_Selection_base::_diffs

private

Referenced by getFitnessMultivariateGaussian(), getFitnessMultivariateGaussian_VE(), setSelectionMatrix(), and ~LCE_Selection_base().

_do_change_local_opt

bool LCE_Selection_base::_do_change_local_opt

private

Referenced by execute(), and set_param_rate_of_change().

_eVariance

double LCE_Selection_base::_eVariance

protected

Evironmental variance.

Referenced by getFitnessMultivariateGaussian_VE(), getFitnessUnivariateGaussian_VE(), and set_sel_model().

_fitness

double LCE_Selection_base::_fitness[5]

protected

Fitness counters, one for each pedigree class.

Referenced by LCE_Breed_Selection::do_breed_selection_FecFitness(), doViabilitySelection(), LCE_SelectionSH::getFitness(), LCE_Breed_Selection::makeOffspringWithSelection(), resetCounters(), and setMeans().

_FitnessFixModel

double LCE_Selection_base::_FitnessFixModel[5]

private

Absolute fitness values of the five pedigree class for the fixed selection model (lethal equivalents model).

Fitness is computed as: _FitnessFixModel[i] = _base_fitness * exp( -_letheq * _Fpedigree[i] );

Referenced by getFitnessFixedEffect(), and set_sel_model().

_Fpedigree

double LCE_Selection_base::_Fpedigree[5]

private

Array of pedigree values used in the fixed-selection model.

Referenced by set_sel_model().

_getFitness

double(LCE_Selection_base::* LCE_Selection_base::_getFitness) (Individual *, unsigned int)

protected

Pointer to the function returning the individual fitness.

May point to LCE_Selection_base::getFitnessAbsolute or LCE_Selection_base::getFitnessRelative.

Referenced by getFitness(), and set_fit_model().

_getRawFitness

vector< double (LCE_Selection_base::* ) (Individual*, unsigned int, unsigned int) > LCE_Selection_base::_getRawFitness

protected

A vector containing pointers to fitness function related to each trait under selection.

Referenced by getFitnessAbsolute(), LCE_SelectionFH::print(), set_sel_model(), and setParameters().

_gsl_selection_matrix

vector< gsl_matrix* > LCE_Selection_base::_gsl_selection_matrix

private

Referenced by getFitnessMultivariateGaussian(), getFitnessMultivariateGaussian_VE(), setSelectionMatrix(), and ~LCE_Selection_base().

_ind_cntr

double LCE_Selection_base::_ind_cntr[5]

protected

Referenced by LCE_Breed_Selection::do_breed_selection_FecFitness(), doViabilitySelection(), LCE_SelectionSH::getPedProp(), LCE_Breed_Selection::makeOffspringWithSelection(), resetCounters(), and setMeans().

_is_absolute

bool LCE_Selection_base::_is_absolute

protected

Referenced by set_fit_model(), and LCE_SelectionSH::setDataTable().

_is_local

bool LCE_Selection_base::_is_local

protected

Referenced by set_fit_model(), and LCE_SelectionSH::setDataTable().

_letheq

double LCE_Selection_base::_letheq

protected

Referenced by set_sel_model().

_local_optima

TMatrix* LCE_Selection_base::_local_optima

private

Referenced by changeLocalOptima(), getFitnessMultivariateGaussian(), getFitnessMultivariateGaussian_VE(), getFitnessUnivariateGaussian(), getFitnessUnivariateGaussian_VE(), getFitnessUnivariateQuadratic(), set_local_optima(), and ~LCE_Selection_base().

_max_fitness

double LCE_Selection_base::_max_fitness

protected

Referenced by setParameters().

_mean_fitness

double LCE_Selection_base::_mean_fitness

protected

Referenced by LCE_Breed_Selection_Disperse::breed_selection_disperse(), LCE_Breed_Selection::execute(), LCE_Breed_Selection_Disperse::execute(), execute(), LCE_SelectionSH::getMeanFitness(), setMeanFitness(), setMeans(), and setParameters().

_phe

double* LCE_Selection_base::_phe

private

Array to temporarily hold the phenotypic values of an individual, is never allocated.

Referenced by addPhenotypicSD(), getFitnessMultivariateGaussian(), getFitnessMultivariateGaussian_VE(), getFitnessUnivariateGaussian(), getFitnessUnivariateGaussian_VE(), and getFitnessUnivariateQuadratic().

_rate_of_change_is_std

bool LCE_Selection_base::_rate_of_change_is_std

private

Referenced by execute(), and set_param_rate_of_change().

_rate_of_change_local_optima

TMatrix LCE_Selection_base::_rate_of_change_local_optima

private

Referenced by changeLocalOptima(), set_param_rate_of_change(), and set_std_rate_of_change().

_res1

gsl_vector * LCE_Selection_base::_res1

private

Referenced by getFitnessMultivariateGaussian(), getFitnessMultivariateGaussian_VE(), setSelectionMatrix(), and ~LCE_Selection_base().

_scaling_factor

double LCE_Selection_base::_scaling_factor

protected

Referenced by LCE_Breed_Selection_Disperse::breed_selection_disperse(), LCE_Breed_Selection::execute(), LCE_Breed_Selection_Disperse::execute(), getFitnessRelative(), setParameters(), LCE_Breed_Selection::setReproScaledFitness_sum(), setScalingFactorAbsolute(), setScalingFactorGlobal(), setScalingFactorLocal(), setScalingFactorMaxGlobal(), and setScalingFactorMaxLocal().

_selection_matrix

vector< TMatrix* > LCE_Selection_base::_selection_matrix

private

Referenced by setSelectionMatrix(), and ~LCE_Selection_base().

_selection_variance

vector< double > LCE_Selection_base::_selection_variance

protected

Patch-specific selection variance.

Referenced by getFitnessUnivariateGaussian(), getFitnessUnivariateGaussian_VE(), getFitnessUnivariateQuadratic(), and setSelectionMatrix().

_SelectionModels

vector< string > LCE_Selection_base::_SelectionModels

protected

The selection models associated with each trait under selection.

Referenced by set_sel_model().

_selectTraitDimension

int LCE_Selection_base::_selectTraitDimension

protected

Number of quantitative traits under selection.

Referenced by addPhenotypicSD(), changeLocalOptima(), getFitnessMultivariateGaussian(), getFitnessMultivariateGaussian_VE(), set_local_optima(), set_param_rate_of_change(), set_sel_model(), set_std_rate_of_change(), and setSelectionMatrix().

_set_std_rate_at_generation

unsigned int LCE_Selection_base::_set_std_rate_at_generation

private

Referenced by set_param_rate_of_change(), and set_std_rate_of_change().

_setNewLocalOptima

void(LCE_Selection_base::* LCE_Selection_base::_setNewLocalOptima) (void)

protected

Pointer to the function used to change the local phenotypic optima or its rate of change.

May point to LCE_Selection_base::changeLocalOptima or LCE_Selection_base::set_std_rate_of_change.

Referenced by execute(), set_param_rate_of_change(), and set_std_rate_of_change().

_setScalingFactor

void(LCE_Selection_base::* LCE_Selection_base::_setScalingFactor) (age_idx, unsigned int)

protected

Pointer to the function used to set the fitness scaling factor when fitness is relative.

May point to LCE_Selection_base::setScalingFactorGlobal, LCE_Selection_base::setScalingFactorLocal, or LCE_Selection_base::setScalingFactorAbsolute (returns 1).

Referenced by LCE_Breed_Selection::do_breed_selection_FecFitness(), execute(), and set_fit_model().

_stater

LCE_SelectionSH* LCE_Selection_base::_stater

protected

Referenced by loadStatServices(), and ~LCE_Selection_base().

_std_rate_reference_patch

int LCE_Selection_base::_std_rate_reference_patch

private

Referenced by set_param_rate_of_change(), and set_std_rate_of_change().

_survival

double LCE_Selection_base::_survival[5]

protected

Referenced by LCE_Breed_Selection::do_breed_selection_FecFitness(), doViabilitySelection(), LCE_SelectionSH::getSurvival(), LCE_Breed_Selection::makeOffspringWithSelection(), resetCounters(), and setMeans().

_TraitIndices

vector< unsigned int > LCE_Selection_base::_TraitIndices

protected

The indices of the traits under selection.

Referenced by LCE_SelectionFH::FHwrite(), getFitnessAbsolute(), LCE_Breed_Selection::makeOffspringWithSelection(), LCE_SelectionFH::print(), set_sel_model(), LCE_Breed_Selection::setNonSelectedTraitTable(), and setParameters().

_Traits

vector< string > LCE_Selection_base::_Traits

protected

The list of trait types under selection.

Referenced by set_sel_model(), and setParameters().

_writer

LCE_SelectionFH* LCE_Selection_base::_writer

protected

Referenced by loadFileServices().

---

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

• LCEselection.h
• LCEselection.cc