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	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...
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	_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< 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...
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
Linear selection parameters
Array to temporarily hold the phenotypic values of an individual, is never allocated.
TMatrix	_linear_selection_strength
vector< double >	_mean_trait_value
unsigned int	_linearSelTraitIndex
age_idx	_linearSelAgeClass
Shared selection offset (used by linear, disruptive, and truncation models)
TMatrix	_selection_offset
Truncation selection parameters
TMatrix	_truncation_threshold
bool	_truncation_upper
Fixed selection (lethal-equivalents-based) parameters
double	_letheq
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),
_selectTraitDimension(1),
_do_change_local_opt(0),
_rate_of_change_is_std(0),
_set_std_rate_at_generation(0),
_std_rate_reference_patch(0),
_linearSelTraitIndex(0),
_linearSelAgeClass(OFFSx),
_truncation_upper(true),
_letheq(0),
_base_fitness(1),
_mean_fitness(0),
_max_fitness(0),
_scaling_factor(1),
_is_local(0),
_is_absolute(1),
_eVariance(0),
_getRawFitness(0),
_getFitness(0),
_setScalingFactor(0),
_setNewLocalOptima(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);
  
  // linear selection:
  add_parameter("selection_linear_strength", DBL, false, false, 0, 0, updater);
  add_parameter("selection_offset", DBL, false, false, 0, 0, updater);
  add_parameter("selection_at_stage", STR, false, false, 0, 0, updater);
 
  // truncation selection:
  add_parameter("selection_truncation_threshold", DBL, false, false, 0, 0, updater);
  add_parameter("selection_truncation_direction", STR, 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().

~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(_diffs) gsl_vector_free(_diffs);
  if(_res1) gsl_vector_free(_res1);
  if(_stater) delete _stater;
}

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

Member Function Documentation

addAgeClass()

virtual age_t LCE_Selection_base::addAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Selection.

{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* _phe;
  
  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[_selectTraitMapping[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[_selectTraitMapping[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, LifeCycleEvent::_popPtr, _selectTraitDimension, _selectTraitMapping, 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().

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

checkChangeLocalOptima()

void LCE_Selection_base::checkChangeLocalOptima

(

)

Check is rate of change in local optima has been set and must be applied.

{
  // check if change in local optima for quantitative traits
  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)();
  }
}

References _do_change_local_opt, LifeCycleEvent::_popPtr, _rate_of_change_is_std, _setNewLocalOptima, Metapop::getCurrentGeneration(), set_local_optima(), and set_std_rate_of_change().

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

clone()

virtual LifeCycleEvent* LCE_Selection_base::clone ( )

inlinevirtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Selection.

{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

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

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

Referenced by execute().

execute()

void LCE_Selection_base::execute ( )

virtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Selection.

{
  Patch * patch;
  unsigned int popSize = _popPtr->size(OFFSPRG);
 
#ifdef _DEBUG_
  message("LCE_Selection_base::execute (tot offsprg nb: %i", popSize);
#endif
  
  resetCounters();
 
  // check if change in local optima for quantitative traits
  checkChangeLocalOptima();
  
  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 _mean_fitness, LifeCycleEvent::_popPtr, _setScalingFactor, checkChangeLocalOptima(), doViabilitySelection(), FEM, Metapop::getPatch(), Metapop::getPatchNbr(), MAL, message(), OFFSPRG, OFFSx, resetCounters(), 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(), LCE_Breed_Selection::setReproScaledFitness_gsl(), and LCE_Breed_Selection::setReproScaledFitness_sum().

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

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

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

getFitnessMultivariateDisruptive()

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

{
  double res2;
 
  double *_phe = (double*)ind->getTraitValue(trait);
 
  // W = offset * (1 - exp(-0.5 * dT * Sigma^-1 * d))  inverted multivariate Gaussian
  for( int i = 0; i < _selectTraitDimension; i++)
    gsl_vector_set(_diffs, i, _phe[_selectTraitMapping[i]] - _local_optima.get(patch, i));
 
  // (diff)T * W * diff:
  gsl_blas_dsymv(CblasUpper, 1.0, _gsl_selection_matrix[patch], _diffs, 0.0, _res1);
  gsl_blas_ddot(_diffs, _res1, &res2);
 
  return _selection_offset.get(patch, 0) * (1.0 - exp( -0.5 * res2 ));
}

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

Referenced by set_sel_model().

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.

{
  double res2;
 
  double *_phe = (double*)ind->getTraitValue(trait);
 
  for( int i = 0; i < _selectTraitDimension; i++)
    gsl_vector_set(_diffs, i, _phe[_selectTraitMapping[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, _res1, _selectTraitDimension, _selectTraitMapping, TMatrix::get(), and Individual::getTraitValue().

Referenced by set_sel_model().

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.

{
  double res2;
 
  double *_phe = (double*)ind->getTraitValue(trait);
 
  //add the environmental variance here:
  for( int i = 0; i < _selectTraitDimension; i++)
    gsl_vector_set(_diffs, i, _phe[_selectTraitMapping[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, _res1, _selectTraitDimension, _selectTraitMapping, RAND::Gaussian(), TMatrix::get(), and Individual::getTraitValue().

Referenced by set_sel_model().

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

getFitnessTruncation()

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

Returns the fitness of an individual following a Truncation selection model.

Fitness = 1 + offset if phenotype passes the threshold test, offset otherwise.

{
  double *_phe = (double*)ind->getTraitValue(trait);
 
  double w = 1.0;
 
  // W = prod_t [ (1 + offset) if z passes threshold, offset otherwise ]
  for(int t = 0; t < _selectTraitDimension; ++t) {
 
    bool passes = _truncation_upper
                ? (_phe[_selectTraitMapping[t]] >= _truncation_threshold.get(patch, t))
                : (_phe[_selectTraitMapping[t]] <= _truncation_threshold.get(patch, t));
 
    w *= passes ? (1.0 + _selection_offset.get(patch, t)) : _selection_offset.get(patch, t);
  }
 
  return w;
}

References _selection_offset, _selectTraitDimension, _selectTraitMapping, _truncation_threshold, _truncation_upper, TMatrix::get(), and Individual::getTraitValue().

Referenced by set_sel_model().

getFitnessUnivariateDisruptive()

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

{
  double *_phe = (double*)ind->getTraitValue(trait);
 
  // W = offset * (1 - exp(-d^2 / (2*Vs)))  inverted Gaussian, single trait
  double diff = _phe[_selectTraitMapping[0]] - _local_optima.get(patch, 0);
 
  return _selection_offset.get(patch, 0) * (1.0 - exp( -0.5 * diff * diff / _selection_variance[patch] ));
}

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

Referenced by set_sel_model().

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.

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

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

Referenced by set_sel_model().

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.

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

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

Referenced by set_sel_model().

getFitnessUnivariateLinear()

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

{
  double *_phe = (double*)ind->getTraitValue(trait);
 
  double w = 1.0;
 
  // W = prod_t [ offset(patch,t) + strength(patch,t) * (z_t - z_bar_t) ]
  // With defaults: W = prod_t [ 1 + beta * (z_t - z_bar_t) ]  (Carter et al. 2005)
  for(int t = 0; t < _selectTraitDimension; ++t)
    w *= _selection_offset.get(patch, t)
       + _linear_selection_strength.get(patch, t) * (_phe[_selectTraitMapping[t]] - _mean_trait_value[t]);
 
  return (w < 0 ? 0 : w);
}

References _linear_selection_strength, _mean_trait_value, _selection_offset, _selectTraitDimension, _selectTraitMapping, TMatrix::get(), and Individual::getTraitValue().

Referenced by set_sel_model().

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.

{
  double res2, diff, w = 1.0;
 
  double *_phe = (double*)ind->getTraitValue(trait);
  
  for(unsigned int t = 0; t < _selectTraitDimension; ++t){
 
    diff = _phe[_selectTraitMapping[t]] - _local_optima.get(patch, t);
 
    res2 = 1 - diff*diff / _selection_variance[patch];
 
    w *= (res2 < 0 ? 0 : res2);
  }
 
  return w;
}

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

Referenced by set_sel_model().

getLocalOptima()

const TMatrix& LCE_Selection_base::getLocalOptima ( ) const

inline

{return _local_optima;}

References _local_optima.

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

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

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::breed_selection_disperse(), LCE_Breed_Selection_Disperse::execute(), setMeanFitness(), and setScalingFactorGlobal().

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

loadFileServices()

void LCE_Selection_base::loadFileServices ( FileServices *  loader )

virtual

Implements SimComponent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Selection.

{
  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());
    
    } else
      //           rpl_per, gen_per, rpl_occ, gen_occ, rank, path, self-ref
      _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_Disperse, and LCE_Breed_Selection.

{
  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().

removeAgeClass()

virtual age_t LCE_Selection_base::removeAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Selection.

{return NONE;}

References NONE.

requiredAgeClass()

virtual age_t LCE_Selection_base::requiredAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Selection.

{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().

resetParameterFromSource()

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

inlinevirtual

Implements SimComponent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Selection.

{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().

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" || model == "linear" || model == "truncation") return true;
 
  if( (model == "gaussian" || model == "quadratic" || model == "disruptive")
     && !get_parameter("selection_local_optima")->isSet()) {
 
    return error("parameter \"selection_local_optima\" must be set to have Gaussian, quadratic, or disruptive selection.\n");
    
  } else {
    
    TMatrix tmp_mat;
    
    _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 checkChangeLocalOptima(), LCE_Selection_base(), and setParameters().

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

set_sel_model()

bool LCE_Selection_base::set_sel_model

(

)

{  
  
  // _selectTraitDimension is set per-model in gaussian/quadratic via setSelectTraitMapping()
  _selectTraitDimension = 1;
  _selectTraitMapping.clear();
  _selectTraitMapping.push_back(0);
 
  // -------------------------------------------------------------------------------------
  // 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;
 
      } else {
 
        _base_fitness = get_parameter_value("selection_base_fitness");
 
      }
      
      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\" works only with the \"quant\" trait, your trait %i has type \"%s\"\n",
            t, _Traits[t].c_str());
 
      if(!setSelectTraitMapping((unsigned int)_popPtr->getTraitPrototype("quant")->get_parameter_value("quanti_traits")))
        return false;
 
      //set the selection variance params
      if(!setSelectionMatrix()) return error("LCE selection::failed to set the selection matrix\n");
 
      //now add the pointer to fitness function:
        _getRawFitness.push_back(&LCE_Selection_base::getFitnessUnivariateQuadratic);
 
    // 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\" works only with the \"quant\" trait, your trait type is \"%s\"\n", _Traits[t].c_str());
 
      if(!setSelectTraitMapping((unsigned int)_popPtr->getTraitPrototype("quant")->get_parameter_value("quanti_traits")))
        return false;
 
     // set the selection matrices for multi-stage or spatially variable cases
     if( !setSelectionMatrix() ) return error("LCE selection::failed to set the selection matrix\n");
      
      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);
 
      }
 
 
      // LINEAR --------------------------------------------------------------------
 
    } else if(sel_model == "linear") {
 
      //check if the trait type in the trait table is correct
      if(_Traits[t] != "quant")
        return error("the selection model \"linear\" works only with the \"quant\" trait, your trait type is \"%s\"\n", _Traits[t].c_str());
 
      if(!setSelectTraitMapping((unsigned int)_popPtr->getTraitPrototype("quant")->get_parameter_value("quanti_traits")))
        return false;
 
      unsigned int patchNbr = _popPtr->getPatchNbr();
      TMatrix tmp_matx;
 
      // store the quanti trait index for mean phenotype computation
      _linearSelTraitIndex = _TraitIndices[t];
 
      // selection gradient beta, default 1.0 (Carter et al. 2005)
      _linear_selection_strength.reset(patchNbr, _selectTraitDimension, 1.0);
 
      if(get_parameter("selection_linear_strength")->isSet()) {
 
        if(get_parameter("selection_linear_strength")->isMatrix()) {
          get_parameter("selection_linear_strength")->getMatrix(&tmp_matx);
 
          if(tmp_matx.getNbRows() > patchNbr)
            return error("\"selection_linear_strength\" must have at max as many rows as the number of patches.\n");
 
          if(tmp_matx.ncols() > (unsigned)_selectTraitDimension)
            return error("\"selection_linear_strength\" must have at max as many columns as the number of selected traits.\n");
 
          _linear_selection_strength.copy_recycle(tmp_matx);
        } else {
          // scalar value: uniform strength across patches and traits
          _linear_selection_strength.assign(get_parameter_value("selection_linear_strength"));
        }
      }
 
      // offset defaults to 1.0, giving W = 1 + beta*(z - z_bar) (Carter et al. 2005)
      if(!setSelectionOffset(1.0, 0.0)) return false;
 
      _mean_trait_value.assign(_selectTraitDimension, 0.0);
 
      // age class for computing mean phenotype: offspring (default) or adults
      _linearSelAgeClass = OFFSx;
      if(get_parameter("selection_at_stage")->isSet()) {
        string age_str = get_parameter("selection_at_stage")->getArg();
        if(age_str == "adults")
          _linearSelAgeClass = ADLTx;
        else if(age_str == "offspring")
          _linearSelAgeClass = OFFSx;
        else
          return error("\"selection_at_stage\" must be \"offspring\" or \"adults\".\n");
      }
 
      // override scaling factor to compute per-patch mean phenotypes before fitness evaluation
      _setScalingFactor = &LCE_Selection_base::setScalingFactorForLinearSelection;
 
      _getRawFitness.push_back(&LCE_Selection_base::getFitnessUnivariateLinear);
 
      // DISRUPTIVE ----------------------------------------------------------------
 
    } else if(sel_model == "disruptive") {
 
      //check if the trait type in the trait table is correct
      if(_Traits[t] != "quant")
        return error("the selection model \"disruptive\" works only with the \"quant\" trait, your trait type is \"%s\"\n", _Traits[t].c_str());
 
      if(!setSelectTraitMapping((unsigned int)_popPtr->getTraitPrototype("quant")->get_parameter_value("quanti_traits")))
        return false;
 
      // reuse the selection matrix/variance infrastructure (same as Gaussian)
      if(!setSelectionMatrix()) return error("LCE selection::failed to set the selection matrix\n");
 
      unsigned int patchNbr = _popPtr->getPatchNbr();
      TMatrix tmp_matx;
 
      // offset = asymptotic fitness far from optimum, default 1.0
      // W = offset * (1 - exp(-d^2 / (2*Vs)))
      if(!setSelectionOffset(1.0, 0.0)) return false;
 
      if(_selectTraitDimension > 1)
        _getRawFitness.push_back(&LCE_Selection_base::getFitnessMultivariateDisruptive);
      else
        _getRawFitness.push_back(&LCE_Selection_base::getFitnessUnivariateDisruptive);
 
      // TRUNCATION ----------------------------------------------------------------
 
    } else if(sel_model == "truncation") {
 
      if(_Traits[t] != "quant")
        return error("the selection model \"truncation\" works only with the \"quant\" trait, your trait type is \"%s\"\n", _Traits[t].c_str());
 
      if(!setSelectTraitMapping((unsigned int)_popPtr->getTraitPrototype("quant")->get_parameter_value("quanti_traits")))
        return false;
 
      unsigned int patchNbr = _popPtr->getPatchNbr();
      TMatrix tmp_matx;
 
      // threshold is mandatory
      if(!get_parameter("selection_truncation_threshold")->isSet())
        return error("\"selection_truncation_threshold\" must be set with selection model \"truncation\".\n");
 
      _truncation_threshold.reset(patchNbr, _selectTraitDimension, 0.0);
 
      if(get_parameter("selection_truncation_threshold")->isMatrix()) {
        get_parameter("selection_truncation_threshold")->getMatrix(&tmp_matx);
 
        if(tmp_matx.getNbRows() > patchNbr)
          return error("\"selection_truncation_threshold\" must have at max as many rows as the number of patches.\n");
 
        if(tmp_matx.ncols() > (unsigned)_selectTraitDimension)
          return error("\"selection_truncation_threshold\" must have at max as many columns as the number of selected traits.\n");
 
        _truncation_threshold.copy_recycle(tmp_matx);
      } else {
        _truncation_threshold.assign(get_parameter_value("selection_truncation_threshold"));
      }
 
      // direction: "upper" (default) selects for z >= threshold; "lower" selects for z <= threshold
      _truncation_upper = true;
      if(get_parameter("selection_truncation_direction")->isSet()) {
        string dir_str = get_parameter("selection_truncation_direction")->getArg();
        if(dir_str == "lower")
          _truncation_upper = false;
        else if(dir_str == "upper")
          _truncation_upper = true;
        else
          return error("\"selection_truncation_direction\" must be \"upper\" or \"lower\".\n");
      }
 
      // offset: default 0 (hard truncation: W=0 below, W=1 above)
      if(!setSelectionOffset(0.0, 0.0)) return false;
 
      _getRawFitness.push_back(&LCE_Selection_base::getFitnessTruncation);
 
    } else return error("wrong selection model, must be either \"fix\", \"direct\", \"quadratic\", \"gaussian\", \"linear\", \"disruptive\", or \"truncation\".\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, _linear_selection_strength, _linearSelAgeClass, _linearSelTraitIndex, _mean_trait_value, SimComponent::_paramSet, LifeCycleEvent::_popPtr, _SelectionModels, _selectTraitDimension, _selectTraitMapping, _setScalingFactor, _TraitIndices, _Traits, _truncation_threshold, _truncation_upper, ADLTx, TMatrix::assign(), TMatrix::copy_recycle(), error(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getArg(), getFitnessDirect(), getFitnessFixedEffect(), getFitnessMultivariateDisruptive(), getFitnessMultivariateGaussian(), getFitnessMultivariateGaussian_VE(), getFitnessTruncation(), getFitnessUnivariateDisruptive(), getFitnessUnivariateGaussian(), getFitnessUnivariateGaussian_VE(), getFitnessUnivariateLinear(), getFitnessUnivariateQuadratic(), Param::getMatrix(), Param::getMultiArgs(), TMatrix::getNbCols(), TMatrix::getNbRows(), Metapop::getPatchNbr(), IndFactory::getTraitPrototype(), ParamSet::isSet(), TMatrix::ncols(), OFFSx, TMatrix::reset(), setScalingFactorForLinearSelection(), setSelectionMatrix(), setSelectionOffset(), setSelectTraitMapping(), and warning().

Referenced by LCE_Selection_base(), and setParameters().

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 checkChangeLocalOptima(), and set_param_rate_of_change().

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

setParameters()

bool LCE_Selection_base::setParameters ( )

virtual

Implements SimComponent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Selection.

{   
  //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
 
    }
    
  }
  
#ifdef _DEBUG_
      cout<<"#### setting fitness model "<<endl;
#endif
 
  if(!set_fit_model()) return false;
 
#ifdef _DEBUG_
      cout<<"#### setting selection model "<<endl;
#endif
  
  if(!set_sel_model()) return false;
  
#ifdef _DEBUG_
      cout<<"#### setting local optima "<<endl;
#endif
 
  if(!set_local_optima()) return false;
  
#ifdef _DEBUG_
      cout<<"#### setting rate of environmental change "<<endl;
#endif
 
  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().

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

setScalingFactorForLinearSelection()

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

Parameters

age	the age-class index
p	the focal patch index

{
  // use the configured age class (overrides the caller's age argument)
  age = _linearSelAgeClass;
 
  // compute the mean phenotypic value per selected trait dimension from the specified age class
  _mean_trait_value.assign(_selectTraitDimension, 0.0);
 
  Patch *patch = _popPtr->getPatch(p);
  Individual* ind;
  double* phe;
 
  unsigned int sizeFEM = patch->size(FEM, age),
               sizeMAL = patch->size(MAL, age);
  unsigned int patchSize = sizeFEM + sizeMAL;
 
  if(patchSize == 0) {
    _scaling_factor = 1;
    return;
  }
 
  for(unsigned int j = 0; j < sizeFEM; j++) {
    ind = patch->get(FEM, age, j);
    phe = (double*)ind->getTraitValue(_linearSelTraitIndex);
    for(int i = 0; i < _selectTraitDimension; i++)
      _mean_trait_value[i] += phe[_selectTraitMapping[i]];
  }
 
  for(unsigned int j = 0; j < sizeMAL; j++) {
    ind = patch->get(MAL, age, j);
    phe = (double*)ind->getTraitValue(_linearSelTraitIndex);
    for(int i = 0; i < _selectTraitDimension; i++)
      _mean_trait_value[i] += phe[_selectTraitMapping[i]];
  }
 
  for(int i = 0; i < _selectTraitDimension; i++)
    _mean_trait_value[i] /= patchSize;
 
  _scaling_factor = 1;
}

References _linearSelAgeClass, _linearSelTraitIndex, _mean_trait_value, LifeCycleEvent::_popPtr, _scaling_factor, _selectTraitDimension, _selectTraitMapping, FEM, Patch::get(), Metapop::getPatch(), Individual::getTraitValue(), MAL, and Patch::size().

Referenced by set_sel_model().

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

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

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

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

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");
 
    if( get_parameter("selection_trait_dimension")->isSet() ) {
 
      if( (unsigned int)get_parameter_value("selection_trait_dimension") != tmp_mat.ncols() ) {
        return error("dimensionality of \"selection_matrix\" does not match with \"selection_trait_dimension\"\n");
      }
 
    } else {
 
      //check if the number of quanti traits modeled match with the dimensionality of the selection matrix:
      if(_popPtr->getTraitPrototype("quant")->get_parameter_value("quanti_traits") < tmp_mat.ncols())
        return error("The number of quantitative traits set with \"quanti_traits\" does not match with\
      the dimensionality of the selection matrix set with \"selection_matrix\"\n");
      else
      _selectTraitDimension = tmp_mat.ncols();
 
    }
    
    //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 {
    // selection_matrix not set in input, only selection_variance is set
 
    // _selectTraitDimension and _selectTraitMapping already set by setSelectTraitMapping()
    if( get_parameter("selection_trait_dimension")->isSet() ) {
 
      //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 set with \"quanti_traits\" does not match with\
 the selection trait dimensionality set with \"selection_trait_dimension\"\n");
 
    } // alternative case already checked at the onset
 
    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 error("LCE selection::failed to set patch-specific selection matrices from \"selection_variance\"\n");
 
    } else {
      
      var_spatmat.assign(get_parameter_value("selection_variance"));
    }
    
    //setting correlation spatial matrix:
    if(get_parameter("selection_correlation")->isSet() && _selectTraitDimension > 1)
    {
      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 error("LCE selection::failed to set patch-specific selection matrices from \"selection_correlation\"\n");;
 
      } else {
 
        corr_spatmat.assign(get_parameter_value("selection_correlation"));
      }
    } else {
      //a single trait or not set in input; matrix has a single row.
      corr_spatmat.reset(patchNbr, 1, 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);
          if(corr_spatmat.ncols() > 1) 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(), IndFactory::getTraitPrototype(), ParamSet::isSet(), TMatrix::ncols(), TMatrix::reset(), TMatrix::set(), and setSpatialMatrix().

Referenced by set_sel_model().

setSelectionOffset()

bool LCE_Selection_base::setSelectionOffset	(	double	default_val,
		double	min_val
	)

{
  unsigned int patchNbr = _popPtr->getPatchNbr();
 
  _selection_offset.reset(patchNbr, _selectTraitDimension, default_val);
 
  if(get_parameter("selection_offset")->isSet()) {
 
    if(get_parameter("selection_offset")->isMatrix()) {
      TMatrix tmp_matx;
      get_parameter("selection_offset")->getMatrix(&tmp_matx);
 
      if(tmp_matx.getNbRows() > patchNbr)
        return error("\"selection_offset\" must have at max as many rows as the number of patches.\n");
 
      if(tmp_matx.ncols() > (unsigned)_selectTraitDimension)
        return error("\"selection_offset\" must have at max as many columns as the number of selected traits.\n");
 
      _selection_offset.copy_recycle(tmp_matx);
    } else {
      _selection_offset.assign(get_parameter_value("selection_offset"));
    }
  }
 
  for(unsigned int i = 0; i < patchNbr; ++i)
    for(int j = 0; j < _selectTraitDimension; ++j)
      if(_selection_offset.get(i, j) < min_val)
        return error("\"selection_offset\" value %g at patch %i, trait %i is below the minimum allowed value (%g).\n",
                     _selection_offset.get(i, j), i+1, j+1, min_val);
 
  return true;
}

References LifeCycleEvent::_popPtr, _selection_offset, _selectTraitDimension, TMatrix::assign(), TMatrix::copy_recycle(), error(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getMatrix(), TMatrix::getNbRows(), Metapop::getPatchNbr(), TMatrix::ncols(), and TMatrix::reset().

Referenced by set_sel_model().

setSelectTraitMapping()

bool LCE_Selection_base::setSelectTraitMapping

(

unsigned int

num_quanti_traits

)

{
  _selectTraitMapping.clear();
 
  if(get_parameter("selection_trait_dimension")->isSet()) {
 
    if(get_parameter("selection_trait_dimension")->isMatrix()) {
 
      // matrix mode: array of 1-based trait indices
      TMatrix tmp;
      get_parameter("selection_trait_dimension")->getMatrix(&tmp);
 
      if(tmp.nrows() > 1)
        return error("\"selection_trait_dimension\" must be a single row array when specifying trait indices.\n");
 
      for(unsigned int i = 0; i < tmp.ncols(); ++i) {
        int idx = (int)tmp.get(0, i);
        if(idx < 1 || idx > (int)num_quanti_traits)
          return error("\"selection_trait_dimension\" trait index %i is out of range [1, %i].\n", idx, num_quanti_traits);
        _selectTraitMapping.push_back((unsigned int)idx - 1);  // 1-based to 0-based
      }
 
    } else {
 
      // integer mode: number of traits, identity mapping
      unsigned int N = (unsigned int)get_parameter_value("selection_trait_dimension");
 
      if(N > num_quanti_traits)
        return error("\"selection_trait_dimension\" (%i) exceeds the number of quantitative traits (%i).\n", N, num_quanti_traits);
 
      for(unsigned int i = 0; i < N; ++i)
        _selectTraitMapping.push_back(i);
    }
 
  } else {
    // default: single trait
    _selectTraitMapping.push_back(0);
  }
 
  _selectTraitDimension = _selectTraitMapping.size();
 
  return true;
}

References _selectTraitDimension, _selectTraitMapping, error(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getMatrix(), TMatrix::ncols(), and TMatrix::nrows().

Referenced by set_sel_model().

updateFitnessCounters()

void LCE_Selection_base::updateFitnessCounters	(	double	fitness,
		unsigned int	ped_class,
		bool	survived
	)

Updates the fitness and survival mean counters.

Parameters

fitness	the fitness of an individual
ped_class	the pedigree class of the individual
survived	boolean telling whether the individual survived (true) or not (false)

{
 
  _fitness[ped_class] += fitness;
  _ind_cntr[ped_class]++;
 
  if(survived) _survival[ped_class]++;
 
}

References _fitness, _ind_cntr, and _survival.

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

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 getFitnessMultivariateDisruptive(), getFitnessMultivariateGaussian(), getFitnessMultivariateGaussian_VE(), setSelectionMatrix(), and ~LCE_Selection_base().

_do_change_local_opt

bool LCE_Selection_base::_do_change_local_opt

private

Referenced by checkChangeLocalOptima(), 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(), LCE_SelectionSH::getFitness(), resetCounters(), setMeans(), and updateFitnessCounters().

_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 getFitnessMultivariateDisruptive(), 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(), LCE_SelectionSH::getPedProp(), resetCounters(), setMeans(), and updateFitnessCounters().

_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

private

Referenced by set_sel_model().

_linear_selection_strength

TMatrix LCE_Selection_base::_linear_selection_strength

private

Referenced by getFitnessUnivariateLinear(), and set_sel_model().

_linearSelAgeClass

age_idx LCE_Selection_base::_linearSelAgeClass

private

Referenced by set_sel_model(), and setScalingFactorForLinearSelection().

_linearSelTraitIndex

unsigned int LCE_Selection_base::_linearSelTraitIndex

private

Referenced by set_sel_model(), and setScalingFactorForLinearSelection().

_local_optima

TMatrix LCE_Selection_base::_local_optima

private

Referenced by changeLocalOptima(), getFitnessMultivariateDisruptive(), getFitnessMultivariateGaussian(), getFitnessMultivariateGaussian_VE(), getFitnessUnivariateDisruptive(), getFitnessUnivariateGaussian(), getFitnessUnivariateGaussian_VE(), getFitnessUnivariateQuadratic(), getLocalOptima(), and set_local_optima().

_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().

_mean_trait_value

vector<double> LCE_Selection_base::_mean_trait_value

private

Referenced by getFitnessUnivariateLinear(), set_sel_model(), and setScalingFactorForLinearSelection().

_rate_of_change_is_std

bool LCE_Selection_base::_rate_of_change_is_std

private

Referenced by checkChangeLocalOptima(), 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 getFitnessMultivariateDisruptive(), 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_gsl(), LCE_Breed_Selection::setReproScaledFitness_sum(), setScalingFactorAbsolute(), setScalingFactorForLinearSelection(), setScalingFactorGlobal(), setScalingFactorLocal(), setScalingFactorMaxGlobal(), and setScalingFactorMaxLocal().

_selection_matrix

vector< TMatrix* > LCE_Selection_base::_selection_matrix

private

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

_selection_offset

TMatrix LCE_Selection_base::_selection_offset

private

Referenced by getFitnessMultivariateDisruptive(), getFitnessTruncation(), getFitnessUnivariateDisruptive(), getFitnessUnivariateLinear(), and setSelectionOffset().

_selection_variance

vector< double > LCE_Selection_base::_selection_variance

protected

Patch-specific selection variance.

Referenced by getFitnessUnivariateDisruptive(), 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(), getFitnessMultivariateDisruptive(), getFitnessMultivariateGaussian(), getFitnessMultivariateGaussian_VE(), getFitnessTruncation(), getFitnessUnivariateLinear(), getFitnessUnivariateQuadratic(), set_local_optima(), set_param_rate_of_change(), set_sel_model(), set_std_rate_of_change(), setScalingFactorForLinearSelection(), setSelectionMatrix(), setSelectionOffset(), and setSelectTraitMapping().

_selectTraitMapping

vector<unsigned int> LCE_Selection_base::_selectTraitMapping

protected

Mapping from selection dimension index to quanti trait index (0-based).

Referenced by addPhenotypicSD(), getFitnessMultivariateDisruptive(), getFitnessMultivariateGaussian(), getFitnessMultivariateGaussian_VE(), getFitnessTruncation(), getFitnessUnivariateDisruptive(), getFitnessUnivariateGaussian(), getFitnessUnivariateGaussian_VE(), getFitnessUnivariateLinear(), getFitnessUnivariateQuadratic(), set_sel_model(), setScalingFactorForLinearSelection(), and setSelectTraitMapping().

_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 checkChangeLocalOptima(), 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_Disperse::breed_selection_disperse(), LCE_Breed_Selection::do_breed_selection_FecFitness(), LCE_Breed_Selection::do_breed_selection_OffSurvival(), LCE_Breed_Selection::do_breed_selection_WrightFisher_1sex(), LCE_Breed_Selection::do_breed_selection_WrightFisher_2sex(), execute(), set_fit_model(), and set_sel_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(), LCE_SelectionSH::getSurvival(), resetCounters(), setMeans(), and updateFitnessCounters().

_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().

_truncation_threshold

TMatrix LCE_Selection_base::_truncation_threshold

private

Referenced by getFitnessTruncation(), and set_sel_model().

_truncation_upper

bool LCE_Selection_base::_truncation_upper

private

Referenced by getFitnessTruncation(), and set_sel_model().

_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