LCE_PhenotypeExpression Class Reference

#include <LCEphenoexpression.h>

Inheritance diagram for LCE_PhenotypeExpression:

Collaboration diagram for LCE_PhenotypeExpression:

Public Member Functions
	LCE_PhenotypeExpression ()
virtual	~LCE_PhenotypeExpression ()
bool	set_g_value_matrix (Param *param, TMatrix &mat)
bool	check_g_index_matrix (Param *param, TMatrix &mat)
bool	set_env_cue ()
void	set_phenot_no_evol (unsigned int patch, TTQuanti *trait)
void	set_phenot_g1_evol (unsigned int patch, TTQuanti *trait)
void	set_phenot_g2_evol (unsigned int patch, TTQuanti *trait)
void	set_phenot_g1_g2_evol (unsigned int patch, TTQuanti *trait)
double	get_env_cue_no_noise (unsigned int patch, unsigned int trait)
double	get_env_cue_noise (unsigned int patch, unsigned int trait)
virtual void	execute ()
void	setIndPhenotype (Patch *patch, sex_t SEX, age_idx AGE)
void	setIndPhenotype_labile (Patch *patch, sex_t SEX, age_idx AGE)
void	setIndLiability (Patch *patch, sex_t SEX, age_idx AGE)
void	setIndLiability_evolving (Patch *patch, sex_t SEX, age_idx AGE)
void	setIndLiability_sigmoid (Patch *patch, sex_t SEX, age_idx AGE)
void	setIndLiability_evolving_sigmoid (Patch *patch, sex_t SEX, age_idx AGE)
virtual LifeCycleEvent *	clone ()
virtual bool	setParameters ()
virtual void	loadFileServices (FileServices *loader)
virtual void	loadStatServices (StatServices *loader)
virtual bool	resetParameterFromSource (std::string param, SimComponent *cmpt)
virtual age_t	removeAgeClass ()
virtual age_t	addAgeClass ()
virtual age_t	requiredAgeClass ()
Public Member Functions inherited from LifeCycleEvent
	LifeCycleEvent (const char *name, const char *trait_link)
	Cstor. More...
virtual	~LifeCycleEvent ()
virtual void	init (Metapop *popPtr)
	Sets the pointer to the current Metapop and the trait link if applicable. More...
virtual bool	attach_trait (string trait)
virtual void	set_paramset (std::string name, bool required, SimComponent *owner)
virtual void	set_event_name (std::string &name)
	Set the name of the event (name of the ParamSet) and add the corresponding parameter to the set. More...
virtual void	set_event_name (const char *name)
virtual string &	get_event_name ()
	Accessor to the LCE's name. More...
virtual int	get_rank ()
	Accessor to the LCE rank in the life cycle. More...
virtual void	set_pop_ptr (Metapop *popPtr)
	Accessors for the population pointer. More...
virtual Metapop *	get_pop_ptr ()
Public Member Functions inherited from SimComponent
	SimComponent ()
virtual	~SimComponent ()
virtual void	loadUpdaters (UpdaterServices *loader)
	Loads the parameters and component updater onto the updater manager. More...
virtual void	set_paramset (ParamSet *paramset)
	Sets the ParamSet member. More...
virtual void	set_paramsetFromCopy (const ParamSet &PSet)
	Reset the set of parameters from a another set. More...
virtual ParamSet *	get_paramset ()
	ParamSet accessor. More...
virtual void	add_parameter (Param *param)
	Interface to add a parameter to the set. More...
virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd)
	Interface to add a parameter to the set. More...
virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd, ParamUpdaterBase *updater)
	Interface to add a parameter and its updater to the set. More...
virtual Param *	get_parameter (std::string name)
	Param getter. More...
virtual double	get_parameter_value (std::string name)
	Param value getter. More...
virtual string	get_name ()
	Returnd the name of the ParamSet, i.e. More...
virtual bool	has_parameter (std::string name)
	Param getter. More...

Private Attributes
unsigned int	_num_trait
	Number of plastic phenotypes. More...
TMatrix	_env_cue
	A matrix to hold the environmental cues (e value). More...
TMatrix	_e_noise
	A matrix to hold the environmental noise (e reliability). More...
TMatrix	_e_rate
	A matrix to hold the per generation rate of change of the environmental cues. More...
bool	_e_copy_trait_optimum_value
	A flag to set whether environmental cue values are equal to and copied from the trait local optimum values from LCE_selection. More...
TMatrix	_g0_linked_index
TMatrix	_g1_linked_index
TMatrix	_g2_linked_index
TMatrix	_g1_values
TMatrix	_g2_values
TMatrix	_e_values
bool	_g1_evolves
bool	_g2_evolves
bool	_do_change_cue
bool	_is_labile
bool	_has_plasticity
bool	_has_liability
unsigned int	_num_liability_trait
bool	_has_evolving_threshold
TMatrix	_liability_linked_index
TMatrix	_liability_threshold_linked_index
vector< vector< double > >	_liability_threshold
vector< vector< double > >	_liability_values
bool	_has_liability_sigmoid
TMatrix	_liability_steepness_linked_index
vector< double >	_liability_steepness_fixed
bool	_liability_steepness_allow_negative
void(LCE_PhenotypeExpression::*	_set_phenotype_func )(unsigned int, TTQuanti *)
double(LCE_PhenotypeExpression::*	_get_env_cue_func )(unsigned int, unsigned int)
void(LCE_PhenotypeExpression::*	_set_liability_func )(Patch *, sex_t, age_idx)
TProtoQuanti *	_QuantiProto
	A pointer to the plastic trait prototype. More...

Additional Inherited Members
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...

Constructor & Destructor Documentation

LCE_PhenotypeExpression()

LCE_PhenotypeExpression::LCE_PhenotypeExpression

(

)

                                                   : LifeCycleEvent("phenotype_expression","quant"),
    _num_trait(0),
    _e_copy_trait_optimum_value(0),
    _QuantiProto(0),
    _g1_evolves(0),
    _g2_evolves(0),
    _do_change_cue(0),
    _is_labile(0),
    _has_plasticity(0),
    _has_liability(0),
    _num_liability_trait(0),
    _has_evolving_threshold(false),
    _has_liability_sigmoid(false),
    _liability_steepness_allow_negative(false),
    _set_phenotype_func(0),
    _get_env_cue_func(0),
    _set_liability_func(0)
 {
 
  ParamUpdater<LCE_PhenotypeExpression> *updater;
  
  updater = new ParamUpdater<LCE_PhenotypeExpression>(&LCE_PhenotypeExpression::set_env_cue);
  add_parameter("pheno_plastic_e_value", MAT, false, false, 0, 0, updater); // environmental cue for phenotype expression
 
  updater = new ParamUpdater<LCE_PhenotypeExpression>(&LCE_PhenotypeExpression::setParameters);
  add_parameter("pheno_plastic_g0_quanti_trait", INT, false, false, 0, 0, updater); // link to quantitative trait (trait index)
 
  // non-mandatory parameters
  add_parameter("pheno_plastic_e_is_selection_optimum_value", BOOL, false, false, 0, 0, updater);
  add_parameter("pheno_plastic_e_rate_change", MAT, false, false,0,0,updater);
  add_parameter("pheno_plastic_e_noise",MAT, false, false,0,0,updater);
  add_parameter("pheno_plastic_is_labile", BOOL, false, false, 0, 0, 0);  // FALSE - developmental plasticity
    
  // NOR - QUANTITATIVE TRAITS ----------------------------------------------------
  add_parameter("pheno_plastic_g1_value", DBL, false, false, 0, 0, updater); // only with constant plasticity
  add_parameter("pheno_plastic_g1_quanti_trait", INT, false, false, 0, 0, updater); // link to quantitative trait (trait index)
  add_parameter("pheno_plastic_g2_value", DBL, false, false, 0, 0, updater); // only with evolving plasticity
  add_parameter("pheno_plastic_g2_quanti_trait", INT, false, false, 0, 0, updater); // link to quantitative trait (trait index)
 
  // LIABILITY TRAITS ---------------------------------------------------------------
  add_parameter("pheno_liability_quanti_trait", INT, false, false, 0, 0, updater);
  add_parameter("pheno_liability_threshold", MAT, false, false, 0, 0, updater);
  add_parameter("pheno_liability_values", MAT, false, false, 0, 0, updater);
  add_parameter("pheno_liability_threshold_quanti_trait", INT, false, false, 0, 0, updater);
  add_parameter("pheno_liability_steepness", MAT, false, false, 0, 0, updater);
  add_parameter("pheno_liability_steepness_quanti_trait", INT, false, false, 0, 0, updater);
  add_parameter("pheno_liability_steepness_negative", BOOL, false, false, 0, 0, updater);
 
 }

References SimComponent::add_parameter(), BOOL, DBL, INT, MAT, set_env_cue(), and setParameters().

Referenced by clone().

~LCE_PhenotypeExpression()

virtual LCE_PhenotypeExpression::~LCE_PhenotypeExpression ( )

inlinevirtual

{ }

Member Function Documentation

addAgeClass()

virtual age_t LCE_PhenotypeExpression::addAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return 0;}

check_g_index_matrix()

bool LCE_PhenotypeExpression::check_g_index_matrix	(	Param *	param,
		TMatrix &	mat
	)

{
 
  for(unsigned int t = 0; t < mat.length(); ++t) {
    if( mat.get(0,t) > _QuantiProto->get_num_traits() || mat.get(0,t) < 1)
      return error("phenotype_expression::quanti trait index %i provided in \"%s\" is not valid. It must be > 0 and not higher than the number of \"quanti_traits\".\n",
          (unsigned int)mat.get(0,t), param->getName().c_str());
    // the index must be zero-based => deduce 1 from input index values:
    mat.minus(0, t, 1.0);
  }
  return true;
}

References _QuantiProto, error(), TMatrix::get(), TProtoQuanti::get_num_traits(), Param::getName(), TMatrix::length(), and TMatrix::minus().

Referenced by setParameters().

clone()

virtual LifeCycleEvent* LCE_PhenotypeExpression::clone ( )

inlinevirtual

Implements LifeCycleEvent.

{return new LCE_PhenotypeExpression();}

References LCE_PhenotypeExpression().

execute()

void LCE_PhenotypeExpression::execute ( )

virtual

Implements LifeCycleEvent.

{
 
  unsigned int stage_nb = _popPtr->getNumAgeClasses();
 
  age_idx age;
 
  Patch *patch;
 
  // =====================================================================
  //  PLASTICITY (NOR)
  // =====================================================================
 
  if(_has_plasticity) {
 
    if(_popPtr->getCurrentGeneration() == 1){
 
      // reset the e values to their original values for a new replicate
      set_env_cue();
 
    }
 
    if(_e_copy_trait_optimum_value) {
 
      // set the cue _e_ equal to the local trait optima, which may change over time
 
      const TMatrix& trait_optima = dynamic_cast<LCE_Selection_base*>(SIMenv::MainSim->get_LCE("viability_selection"))->getLocalOptima();
 
      _env_cue.copy(trait_optima);
 
    } else
 
      if(_do_change_cue) {
        // apply rate of change to the e values
        for(unsigned int p = 0; p < _popPtr->getPatchNbr(); ++p) {
          for(unsigned int t = 0; t < _num_trait; ++t) {
            _env_cue.plus(p, t,_e_rate.get(p,t));
          }
        }
      }
 
    if(_is_labile) {
 
      // (re)set the individuals' phenotypes in all age classes
      // phenotypes are recalculated from genotypic values to avoid compounding
      for(unsigned int p = 0; p < _popPtr->getPatchNbr(); ++p)
      {
        patch = _popPtr->getPatch(p);
 
        for(unsigned int s = 0; s < stage_nb; ++s)
        {
          age = age_idx(s);
 
          setIndPhenotype_labile (patch, FEM, age);
 
          setIndPhenotype_labile (patch, MAL, age);
 
        }
      }
    } else {
      // Developmental plasticity
      // set the phenotypes in the offspring only
      for(unsigned int p = 0; p < _popPtr->getPatchNbr(); ++p)
      {
        patch = _popPtr->getPatch(p);
 
        setIndPhenotype (patch, FEM, OFFSx);
 
        setIndPhenotype (patch, MAL, OFFSx);
 
      }
    }
 
  } // end _has_plasticity
 
  // =====================================================================
  //  LIABILITY TRAITS
  // =====================================================================
 
  if(_has_liability) {
 
    if(_is_labile) {
      // we want to re-calculate the phenotype when the underlying trait is labile
      for(unsigned int p = 0; p < _popPtr->getPatchNbr(); ++p)
      {
        patch = _popPtr->getPatch(p);
 
        for(unsigned int s = 0; s < stage_nb; ++s)
        {
          age = age_idx(s);
 
          (this->*_set_liability_func)(patch, FEM, age);
 
          (this->*_set_liability_func)(patch, MAL, age);
 
        }
      }
    } else {
      // Developmental: set liability phenotypes in offspring only
      for(unsigned int p = 0; p < _popPtr->getPatchNbr(); ++p)
      {
        patch = _popPtr->getPatch(p);
 
        (this->*_set_liability_func)(patch, FEM, OFFSx);
 
        (this->*_set_liability_func)(patch, MAL, OFFSx);
 
      }
    }
 
  } // end _has_liability
 
}

References _do_change_cue, _e_copy_trait_optimum_value, _e_rate, _env_cue, _has_liability, _has_plasticity, _is_labile, _num_trait, LifeCycleEvent::_popPtr, _set_liability_func, TMatrix::copy(), FEM, TMatrix::get(), ComponentManager::get_LCE(), Metapop::getCurrentGeneration(), Metapop::getNumAgeClasses(), Metapop::getPatch(), Metapop::getPatchNbr(), SIMenv::MainSim, MAL, OFFSx, TMatrix::plus(), set_env_cue(), setIndPhenotype(), and setIndPhenotype_labile().

get_env_cue_no_noise()

double LCE_PhenotypeExpression::get_env_cue_no_noise	(	unsigned int	patch,
		unsigned int	trait
	)

{
  return _env_cue.get(patch, trait);
}

References _env_cue, and TMatrix::get().

Referenced by setParameters().

get_env_cue_noise()

double LCE_PhenotypeExpression::get_env_cue_noise	(	unsigned int	patch,
		unsigned int	trait
	)

{
  return _env_cue.get(patch, trait) + RAND::Gaussian(_e_noise.get(patch, trait));
}

References _e_noise, _env_cue, RAND::Gaussian(), and TMatrix::get().

Referenced by setParameters().

loadFileServices()

virtual void LCE_PhenotypeExpression::loadFileServices ( FileServices *  loader )

inlinevirtual

Implements SimComponent.

{}

loadStatServices()

virtual void LCE_PhenotypeExpression::loadStatServices ( StatServices *  loader )

inlinevirtual

Implements SimComponent.

{}

removeAgeClass()

virtual age_t LCE_PhenotypeExpression::removeAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return 0;}

requiredAgeClass()

virtual age_t LCE_PhenotypeExpression::requiredAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return 0;}

resetParameterFromSource()

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

inlinevirtual

Implements SimComponent.

{return false;}

set_env_cue()

bool LCE_PhenotypeExpression::set_env_cue

(

)

{
  TMatrix tmp_mat;
 
  _env_cue.reset(_popPtr->getPatchNbr(), _num_trait);
 
  _paramSet->getMatrix("pheno_plastic_e_value", &tmp_mat);
 
  if( !setSpatialMatrix("pheno_plastic_e_value", "\"pheno_plastic_traits\"", &tmp_mat, &_env_cue,
      (unsigned)_num_trait, _popPtr->getPatchNbr(), false) )
    return false;
 
  return true;
}

References _env_cue, _num_trait, SimComponent::_paramSet, LifeCycleEvent::_popPtr, ParamSet::getMatrix(), Metapop::getPatchNbr(), TMatrix::reset(), and setSpatialMatrix().

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

set_g_value_matrix()

bool LCE_PhenotypeExpression::set_g_value_matrix	(	Param *	param,
		TMatrix &	mat
	)

{
  if( param->isMatrix() ) {
 
    param->getMatrix(&mat);
 
    if(mat.nrows() > 1)
      return error("phenotype_expression::the array of trait indices for parameter \"%s\" should have one row only\n.", param->getName().c_str());
 
    if(mat.ncols() > _QuantiProto->get_num_traits())
      return error("phenotype_expression::the number of trait indices in \"%s\" is larger than the number of quantitative traits.\n", param->getName().c_str());
  }
  else
  {
    mat.reset(1,1, param->getValue());
  }
 
  return true;
}

References _QuantiProto, error(), TProtoQuanti::get_num_traits(), Param::getMatrix(), Param::getName(), Param::getValue(), Param::isMatrix(), TMatrix::ncols(), TMatrix::nrows(), and TMatrix::reset().

Referenced by setParameters().

set_phenot_g1_evol()

void LCE_PhenotypeExpression::set_phenot_g1_evol	(	unsigned int	patch,
		TTQuanti *	trait
	)

{
  double pheno = 0;
  for(unsigned int t = 0, ID0, ID1; t < _num_trait; ++t) {
    ID0 = _g0_linked_index.get(0,t);
    ID1 = _g1_linked_index.get(0,t);
    pheno = trait->get_phenotype(ID0) + trait->get_phenotype(ID1) *
            ( (this->*_get_env_cue_func)(patch, t) - _g2_values.get(0, t) );
    trait->set_phenotype(ID0, pheno);
  }
}

References _g0_linked_index, _g1_linked_index, _g2_values, _get_env_cue_func, _num_trait, TMatrix::get(), TTQuanti::get_phenotype(), and TTQuanti::set_phenotype().

Referenced by setParameters().

set_phenot_g1_g2_evol()

void LCE_PhenotypeExpression::set_phenot_g1_g2_evol	(	unsigned int	patch,
		TTQuanti *	trait
	)

{
  double pheno = 0;
  for(unsigned int t = 0, ID0, ID1, ID2; t < _num_trait; ++t) {
    ID0 = _g0_linked_index.get(0,t);
    ID1 = _g1_linked_index.get(0,t);
    ID2 = _g2_linked_index.get(0,t);
    pheno = trait->get_phenotype(ID0) + trait->get_phenotype(ID1) *
            ( (this->*_get_env_cue_func)(patch, t) - trait->get_phenotype(ID2) );
    trait->set_phenotype(ID0, pheno);
  }
}

References _g0_linked_index, _g1_linked_index, _g2_linked_index, _get_env_cue_func, _num_trait, TMatrix::get(), TTQuanti::get_phenotype(), and TTQuanti::set_phenotype().

Referenced by setParameters().

set_phenot_g2_evol()

void LCE_PhenotypeExpression::set_phenot_g2_evol	(	unsigned int	patch,
		TTQuanti *	trait
	)

{
  double pheno = 0;
  for(unsigned int t = 0, ID0, ID2; t < _num_trait; ++t) {
    ID0 = _g0_linked_index.get(0,t);
    ID2 = _g2_linked_index.get(0,t);
    pheno = trait->get_phenotype(ID0) + _g1_values.get(0, t) *
            ( (this->*_get_env_cue_func)(patch, t) - trait->get_phenotype(ID2) );
    trait->set_phenotype(ID0, pheno);
  }
}

References _g0_linked_index, _g1_values, _g2_linked_index, _get_env_cue_func, _num_trait, TMatrix::get(), TTQuanti::get_phenotype(), and TTQuanti::set_phenotype().

Referenced by setParameters().

set_phenot_no_evol()

void LCE_PhenotypeExpression::set_phenot_no_evol	(	unsigned int	patch,
		TTQuanti *	trait
	)

{
  double pheno = 0;
  for(unsigned int t = 0, ID0; t < _num_trait; ++t) {
    ID0 = _g0_linked_index.get(0,t);
    pheno = trait->get_phenotype(ID0) + _g1_values.get(0, t) *
            ( (this->*_get_env_cue_func)(patch, t) -  _g2_values.get(0, t) );
    trait->set_phenotype(ID0, pheno);
  }
}

References _g0_linked_index, _g1_values, _g2_values, _get_env_cue_func, _num_trait, TMatrix::get(), TTQuanti::get_phenotype(), and TTQuanti::set_phenotype().

Referenced by setParameters().

setIndLiability()

void LCE_PhenotypeExpression::setIndLiability	(	Patch *	patch,
		sex_t	SEX,
		age_idx	AGE
	)

{
  TTQuanti *trait;
  unsigned int ID, num_thresh, cls;
  double liability;
 
  for(unsigned int i = 0; i < patch->size(SEX, AGE); ++i)
  {
    trait = dynamic_cast<TTQuanti*> (patch->get(SEX, AGE, i)->getTrait(_LCELinkedTraitIndex));
 
    for(unsigned int t = 0; t < _num_liability_trait; ++t) {
 
      ID = _liability_linked_index.get(0, t);
      liability = trait->get_phenotype(ID);
 
      // find which class the liability falls into
      num_thresh = _liability_threshold[t].size();
      cls = num_thresh; // default: above all thresholds
 
      for(unsigned int k = 0; k < num_thresh; ++k) {
        if(liability < _liability_threshold[t][k]) {
          cls = k;
          break;
        }
      }
 
      trait->set_phenotype(ID, _liability_values[t][cls]);
    }
  }
}

References LifeCycleEvent::_LCELinkedTraitIndex, _liability_linked_index, _liability_threshold, _liability_values, _num_liability_trait, Patch::get(), TMatrix::get(), TTQuanti::get_phenotype(), Individual::getTrait(), TTQuanti::set_phenotype(), and Patch::size().

Referenced by setParameters().

setIndLiability_evolving()

void LCE_PhenotypeExpression::setIndLiability_evolving	(	Patch *	patch,
		sex_t	SEX,
		age_idx	AGE
	)

{
  TTQuanti *trait;
  unsigned int ID, num_thresh, cls;
  int threshIdx;
  double liability, threshold, val0, val1;
 
  for(unsigned int i = 0; i < patch->size(SEX, AGE); ++i)
  {
    trait = dynamic_cast<TTQuanti*> (patch->get(SEX, AGE, i)->getTrait(_LCELinkedTraitIndex));
 
    for(unsigned int t = 0; t < _num_liability_trait; ++t) {
 
      ID = _liability_linked_index.get(0, t);
      liability = trait->get_phenotype(ID);
      threshIdx = (int)_liability_threshold_linked_index.get(0, t);
 
      if(threshIdx >= 0) {
        // evolving: single threshold from quanti trait phenotype
        threshold = trait->get_phenotype((unsigned int)threshIdx);
        val0 = _liability_values[t][0];
        val1 = _liability_values[t][1];
        // no sigmoid: hard step
        cls = (liability < threshold) ? 0 : 1;
        trait->set_phenotype(ID, _liability_values[t][cls]);
 
      } else {
        // fixed: multi-threshold from variable vector
        num_thresh = _liability_threshold[t].size();
        cls = num_thresh;
        for(unsigned int k = 0; k < num_thresh; ++k) {
          if(liability < _liability_threshold[t][k]) {
            cls = k;
            break;
          }
        }
        trait->set_phenotype(ID, _liability_values[t][cls]);
      }
    }
  }
}

References LifeCycleEvent::_LCELinkedTraitIndex, _liability_linked_index, _liability_threshold, _liability_threshold_linked_index, _liability_values, _num_liability_trait, Patch::get(), TMatrix::get(), TTQuanti::get_phenotype(), Individual::getTrait(), TTQuanti::set_phenotype(), and Patch::size().

Referenced by setParameters().

setIndLiability_evolving_sigmoid()

void LCE_PhenotypeExpression::setIndLiability_evolving_sigmoid	(	Patch *	patch,
		sex_t	SEX,
		age_idx	AGE
	)

{
  TTQuanti *trait;
  unsigned int ID, num_thresh, cls;
  int threshIdx, steepIdx;
  double liability, threshold, val0, val1, steepness, sigmoid;
 
  for(unsigned int i = 0; i < patch->size(SEX, AGE); ++i)
  {
    trait = dynamic_cast<TTQuanti*> (patch->get(SEX, AGE, i)->getTrait(_LCELinkedTraitIndex));
 
    for(unsigned int t = 0; t < _num_liability_trait; ++t) {
 
      ID = _liability_linked_index.get(0, t);
      liability = trait->get_phenotype(ID);
      threshIdx = (int)_liability_threshold_linked_index.get(0, t);
 
      if(threshIdx >= 0) {
        // evolving: single threshold from quanti trait phenotype
        threshold = trait->get_phenotype((unsigned int)threshIdx);
        val0 = _liability_values[t][0];
        val1 = _liability_values[t][1];
        steepIdx = (int)_liability_steepness_linked_index.get(0, t);
 
        if(steepIdx >= 0) {
          // evolving steepness from quanti trait
          steepness = trait->get_phenotype((unsigned int)steepIdx);
          if(!_liability_steepness_allow_negative && steepness < 0) steepness = 0;
          sigmoid = 1.0 / (1.0 + exp(-steepness * (liability - threshold)));
          trait->set_phenotype(ID, val0 + (val1 - val0) * sigmoid);
 
        } else if(steepIdx == -1) {
          // fixed steepness
          steepness = _liability_steepness_fixed[t];
          sigmoid = 1.0 / (1.0 + exp(-steepness * (liability - threshold)));
          trait->set_phenotype(ID, val0 + (val1 - val0) * sigmoid);
 
        } else {
          // no sigmoid (steepIdx == -2): hard step (backward compatible)
           cls = (liability < threshold) ? 0 : 1;
          trait->set_phenotype(ID, _liability_values[t][cls]);
        }
      } else {
        // fixed: multi-threshold from variable vector
        num_thresh = _liability_threshold[t].size();
        cls = num_thresh;
        for(unsigned int k = 0; k < num_thresh; ++k) {
          if(liability < _liability_threshold[t][k]) {
            cls = k;
            break;
          }
        }
        trait->set_phenotype(ID, _liability_values[t][cls]);
      }
    }
  }
}

References LifeCycleEvent::_LCELinkedTraitIndex, _liability_linked_index, _liability_steepness_allow_negative, _liability_steepness_fixed, _liability_steepness_linked_index, _liability_threshold, _liability_threshold_linked_index, _liability_values, _num_liability_trait, Patch::get(), TMatrix::get(), TTQuanti::get_phenotype(), Individual::getTrait(), TTQuanti::set_phenotype(), and Patch::size().

Referenced by setParameters().

setIndLiability_sigmoid()

void LCE_PhenotypeExpression::setIndLiability_sigmoid	(	Patch *	patch,
		sex_t	SEX,
		age_idx	AGE
	)

{
  TTQuanti *trait;
  unsigned int ID, num_thresh, cls;
  double liability, val0, val1, threshold, steepness, sigmoid;
  int steepIdx;
 
  for(unsigned int i = 0; i < patch->size(SEX, AGE); ++i)
  {
    trait = dynamic_cast<TTQuanti*> (patch->get(SEX, AGE, i)->getTrait(_LCELinkedTraitIndex));
 
    for(unsigned int t = 0; t < _num_liability_trait; ++t) {
 
      ID = _liability_linked_index.get(0, t);
      liability = trait->get_phenotype(ID);
      val0 = _liability_values[t][0];
      val1 = _liability_values[t][1];
      steepIdx = (int)_liability_steepness_linked_index.get(0, t); //in case steepness evolves
      threshold = _liability_threshold[t][0];
 
      if(steepIdx >= 0) {
        // evolving steepness from quanti trait, non-evolving threshold
        steepness = trait->get_phenotype((unsigned int)steepIdx);
 
        if(!_liability_steepness_allow_negative && steepness < 0)
          steepness = 0;
 
        sigmoid = 1.0 / (1.0 + exp(-steepness * (liability - threshold)));
 
        trait->set_phenotype(ID, val0 + (val1 - val0) * sigmoid);
 
      } else if(steepIdx == -1) {
        // fixed steepness
        steepness = _liability_steepness_fixed[t];
        sigmoid = 1.0 / (1.0 + exp(-steepness * (liability - threshold)));
 
        trait->set_phenotype(ID, val0 + (val1 - val0) * sigmoid);
 
      } else {
        // no evolving trait, no sigmoid (steepIdx == -2): hard step(s)
        // since threshold is not evolving, multiple thresholds may exist
        // find which class the liability falls into
        num_thresh = _liability_threshold[t].size();
        cls = num_thresh; // default: above all thresholds
 
        for(unsigned int k = 0; k < num_thresh; ++k) {
          if(liability < _liability_threshold[t][k]) {
            cls = k;
            break;
          }
        }
        trait->set_phenotype(ID, _liability_values[t][cls]);
      } // END_no sigmoid
    } // END_for all traits
  } // END_for all individuals
}

References LifeCycleEvent::_LCELinkedTraitIndex, _liability_linked_index, _liability_steepness_allow_negative, _liability_steepness_fixed, _liability_steepness_linked_index, _liability_threshold, _liability_values, _num_liability_trait, Patch::get(), TMatrix::get(), TTQuanti::get_phenotype(), Individual::getTrait(), TTQuanti::set_phenotype(), and Patch::size().

Referenced by setParameters().

setIndPhenotype()

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

{
  TTQuanti *trait;
 
  for(unsigned int i = 0; i < patch->size(SEX, AGE); ++i)
  {
 
    trait = dynamic_cast<TTQuanti*> (patch->get(SEX, AGE, i)->getTrait(_LCELinkedTraitIndex));
 
    (this->*_set_phenotype_func)(patch->getID(), trait);
 
  }
}

References LifeCycleEvent::_LCELinkedTraitIndex, _set_phenotype_func, Patch::get(), Patch::getID(), Individual::getTrait(), and Patch::size().

Referenced by execute().

setIndPhenotype_labile()

void LCE_PhenotypeExpression::setIndPhenotype_labile	(	Patch *	patch,
		sex_t	SEX,
		age_idx	AGE
	)

{
  TTQuanti *trait;
 
  for(unsigned int i = 0; i < patch->size(SEX, AGE); ++i)
  {
 
    trait = dynamic_cast<TTQuanti*> (patch->get(SEX, AGE, i)->getTrait(_LCELinkedTraitIndex));
 
    // reset phenotypes to genotypic values before applying the NOR
    // this prevents compounding of the plasticity effect across generations
    trait->reset_phenotype_to_genotypic_value();
 
    (this->*_set_phenotype_func)(patch->getID(), trait);
 
  }
}

References LifeCycleEvent::_LCELinkedTraitIndex, _set_phenotype_func, Patch::get(), Patch::getID(), Individual::getTrait(), TTQuanti::reset_phenotype_to_genotypic_value(), and Patch::size().

Referenced by execute().

setParameters()

bool LCE_PhenotypeExpression::setParameters ( )

virtual

Implements SimComponent.

{
 
  _QuantiProto = dynamic_cast<TProtoQuanti*> ( _popPtr->getTraitPrototype("quant"));
 
  // =====================================================================
  //  PLASTICITY (NOR)
  // =====================================================================
 
  _has_plasticity = _paramSet->isSet("pheno_plastic_g0_quanti_trait");
 
  if(_has_plasticity) {
 
    if(!_paramSet->isSet("pheno_plastic_e_value"))
      return error("phenotype_expression::\"pheno_plastic_e_value\" is required when plastic traits are defined.\n");
 
    // ...........................................................................
    // dimension of the NOR, how many g0's?
    if(!set_g_value_matrix(_paramSet->get_param("pheno_plastic_g0_quanti_trait") , _g0_linked_index))
      return false;
 
    if(!check_g_index_matrix(_paramSet->get_param("pheno_plastic_g0_quanti_trait") , _g0_linked_index))
      return false;
 
    _num_trait = _g0_linked_index.length();
 
    // check if g1 evolves:
    if(_paramSet->isSet("pheno_plastic_g1_quanti_trait")) {
 
      if(!set_g_value_matrix(_paramSet->get_param("pheno_plastic_g1_quanti_trait") , _g1_linked_index)) {
        return false;
 
      } else {
 
        if(!check_g_index_matrix(_paramSet->get_param("pheno_plastic_g1_quanti_trait") , _g1_linked_index))
          return false;
 
        _g1_evolves = true;
      }
 
      if( _g1_linked_index.length() != _num_trait)
        return error("phenotype_expression::the number of evolving n-o-r (g1) should be equal to the number of g0 linked traits.\n");
 
    } else {
      _g1_evolves = false;
    }
 
    // check if g2 evolves;
    if(_paramSet->isSet("pheno_plastic_g2_quanti_trait")) {
       if(!set_g_value_matrix(_paramSet->get_param("pheno_plastic_g2_quanti_trait") , _g2_linked_index)) {
 
           return false;
 
       } else {
 
         if(!check_g_index_matrix(_paramSet->get_param("pheno_plastic_g2_quanti_trait") , _g2_linked_index))
           return false;
 
         _g2_evolves = true;
       }
 
       if( _g2_linked_index.length() != _num_trait)
         return error("phenotype_expression::the number of evolving g2-values should be equal to the number of g0 linked traits.\n");
 
     } else {
       _g2_evolves = false;
     }
 
    // G!
    if(_paramSet->isSet("pheno_plastic_g1_value")) {
 
      if(_g1_evolves)
 
        warning("phenotype_expression::parameter \"pheno_plastic_g1_value\" is set but g1 evolves. Fixed g1 values will be ignored.\n");
 
      else {
 
        if(!set_g_value_matrix(_paramSet->get_param("pheno_plastic_g1_value"), _g1_values))
          return false;
 
        if(_g1_values.length() != _num_trait)
          return error("phenotype_expression::the number of slope values (g1) should be equal to the number of g0 linked traits.\n");
      }
    }
    else
      if(!_g1_evolves) {
 
      return error("phenotype_expression::the slope values (g1) of the modelled n-o-r are missing.\n");
 
    }
 
    // G2
    if(_paramSet->isSet("pheno_plastic_g2_value")) {
 
      if(_g2_evolves)
 
        warning("phenotype_expression::parameter \"pheno_plastic_g2_value\" is set but g2 evolves. Fixed g2 values will be ignored.\n");
 
      else {
 
        if(!set_g_value_matrix(_paramSet->get_param("pheno_plastic_g2_value"), _g2_values))
          return false;
 
        if(_g2_values.length() != _num_trait)
          return error("phenotype_expression::the number of reference values (g2) should be equal to the number of g0 linked traits.\n");
      }
    }
    else
      if(!_g2_evolves) {
 
      warning("phenotype_expression::reference values (g2) of the n-o-r modeled are set to 0 by default.\n");
 
      _g2_values.reset(1, _num_trait, 0.0);
    }
 
    if(_g1_evolves) {
 
      if(_g2_evolves)
        _set_phenotype_func = &LCE_PhenotypeExpression::set_phenot_g1_g2_evol;
      else
        _set_phenotype_func = &LCE_PhenotypeExpression::set_phenot_g1_evol;
 
    } else if(_g2_evolves) {
 
      _set_phenotype_func = &LCE_PhenotypeExpression::set_phenot_g2_evol;
 
    } else
      _set_phenotype_func = &LCE_PhenotypeExpression::set_phenot_no_evol;
 
 
    TMatrix tmp_mat;
 
    // ...........................................................................
    // plastic_e_value - the environmental cue(s) "e" relevant for phenotype expression
 
    if(!set_env_cue()) return false;
 
    // ...........................................................................
    // plastic_e_value_noise - the reliability of the environmental cue(s) "e"
    if(get_parameter("pheno_plastic_e_noise")->isSet() ){
 
      _e_noise.reset(_popPtr->getPatchNbr(), _num_trait);
 
      _paramSet->getMatrix("pheno_plastic_e_noise", &tmp_mat);
 
      if( !setSpatialMatrix("pheno_plastic_e_noise", "\"pheno_plastic_traits\"", &tmp_mat, &_e_noise,
          (unsigned)_num_trait, _popPtr->getPatchNbr(), false) )
        return false;
 
      _get_env_cue_func = &LCE_PhenotypeExpression::get_env_cue_noise;
 
    } else {
 
      _get_env_cue_func = &LCE_PhenotypeExpression::get_env_cue_no_noise;
 
      _e_noise.reset(_popPtr->getPatchNbr(), _num_trait, 0.0);
    }
 
    // ...........................................................................
    // plastic_e_value_change_rate - the rate of change for the environmental cue(s) "e"
    if(get_parameter("pheno_plastic_e_rate_change")->isSet() ){
 
      _e_rate.reset(_popPtr->getPatchNbr(), (unsigned)_num_trait);
 
      _paramSet->getMatrix("pheno_plastic_e_rate_change", &tmp_mat);
 
      if( !setSpatialMatrix("pheno_plastic_e_rate_change", "\"pheno_plastic_traits\"", &tmp_mat, &_e_rate,
          (unsigned)_num_trait, _popPtr->getPatchNbr(), false) )
        return false;
 
      _do_change_cue = true;
 
    } else {
 
      _e_rate.reset(_popPtr->getPatchNbr(), (unsigned)_num_trait, 0.0);
 
      _do_change_cue = false;
    }
 
    // set matrix of environmental gains   ..................................................
    // to keep track of the change of environmental cues
 
    if(get_parameter("pheno_plastic_e_is_selection_optimum_value")->isSet()) {
 
      _e_copy_trait_optimum_value = get_parameter_value("pheno_plastic_e_is_selection_optimum_value");
 
    } else {
      _e_copy_trait_optimum_value = false;
    }
 
  } // end _has_plasticity
 
  // =====================================================================
  //  LIABILITY TRAITS
  // =====================================================================
 
  _has_liability = _paramSet->isSet("pheno_liability_quanti_trait");
 
  if(_has_liability) {
 
    // check that traits are not assigned multiple times to liability, threshold or steepness
    std::unordered_set<int> trait_seen;
 
    // trait indices
    if(!set_g_value_matrix(_paramSet->get_param("pheno_liability_quanti_trait"), _liability_linked_index))
      return false;
 
    if(!check_g_index_matrix(_paramSet->get_param("pheno_liability_quanti_trait"), _liability_linked_index))
      return false;
 
    _num_liability_trait = _liability_linked_index.length();
 
    // check for duplicates in trait assignments
    for(unsigned int t = 0; t < _num_liability_trait; ++t) {
      if(!trait_seen.insert(_liability_linked_index.get(0, t)).second)  // the index is already 0-based
        return error("phenotype_expression::quanti trait index %i is already assigned to a liability trait.\n",
            (unsigned int)(_liability_linked_index.get(0,t)+1.0));
    }
 
    // ---- EVOLVING THRESHOLDS ----
    _has_evolving_threshold = false;
 
    if(_paramSet->isSet("pheno_liability_threshold_quanti_trait")) {
 
      if(!set_g_value_matrix(_paramSet->get_param("pheno_liability_threshold_quanti_trait"),
          _liability_threshold_linked_index))
        return false;
 
      // we don't check the index here because we allow for value 0 as "not evolving threshold"
 
      if(_liability_threshold_linked_index.length() != _num_liability_trait)
        return error("phenotype_expression::number of entries in \"pheno_liability_threshold_quanti_trait\" (%i) != number of liability traits (%i).\n",
                     _liability_threshold_linked_index.length(), _num_liability_trait);
 
      // validate & convert: 0 -> -1 (fixed), >0 -> 0-based index
      for(unsigned int t = 0; t < _num_liability_trait; ++t) {
        double val = _liability_threshold_linked_index.get(0, t);
        if(val < 0)
          return error("phenotype_expression::negative entry in \"pheno_liability_threshold_quanti_trait\".\n");
        if(val == 0) {
          _liability_threshold_linked_index.set(0, t, -1.0);
        } else {
 
          if((unsigned int)val > _QuantiProto->get_num_traits())
            return error("phenotype_expression::invalid quanti trait index %i in \"pheno_liability_threshold_quanti_trait\".\n", (unsigned int)val);
 
          // check that the trait index is unique
          if (!trait_seen.insert(val - 1.0).second)
            return error("phenotype_expression::quanti trait index %i in \"pheno_liability_threshold_quanti_trait\" "
                "is already assigned to a liability or threshold trait.\n", (unsigned int)val);
 
          _liability_threshold_linked_index.set(0, t, val - 1.0); // 0-based
          _has_evolving_threshold = true;
        }
      }
    }
 
    // ---- FIXED THRESHOLDS (variable matrix) ----
    // we allow the parameter pheno_liability_threshold to receive a matrix with empty rows for the evolving thresholds
    bool needs_fixed_threshold = false;
    if(!_has_evolving_threshold) {
      needs_fixed_threshold = true;
    } else {
      for(unsigned int t = 0; t < _num_liability_trait; ++t)
        if(_liability_threshold_linked_index.get(0, t) < 0) { needs_fixed_threshold = true; break; }
    }
 
    if(needs_fixed_threshold) {
      if(!_paramSet->isSet("pheno_liability_threshold"))
        return error("phenotype_expression::\"pheno_liability_threshold\" is required when fixed-threshold liability traits exist.\n");
    }
 
    if(_paramSet->isSet("pheno_liability_threshold")) {
      _paramSet->get_param("pheno_liability_threshold")->getVariableMatrix(&_liability_threshold);
 
      if(_liability_threshold.size() != _num_liability_trait)
        return error("phenotype_expression::rows in \"pheno_liability_threshold\" (%i) != number of liability traits (%i).\n",
                     (int)_liability_threshold.size(), _num_liability_trait);
 
      // validate ascending order per trait
      for(unsigned int t = 0; t < _num_liability_trait; ++t)
        for(unsigned int k = 1; k < _liability_threshold[t].size(); ++k)
          if(_liability_threshold[t][k] <= _liability_threshold[t][k-1])
            return error("phenotype_expression::thresholds for liability trait %i are not in strictly ascending order.\n", t+1);
 
    } else {
      // no fixed thresholds needed (all evolving): init empty rows
      _liability_threshold.resize(_num_liability_trait);
    }
 
    // validate evolving-threshold traits have empty threshold rows
    if(_has_evolving_threshold) {
      for(unsigned int t = 0; t < _num_liability_trait; ++t) {
        if(_liability_threshold_linked_index.get(0, t) >= 0 && _liability_threshold[t].size() != 0)
          return error("phenotype_expression::liability trait %i uses evolving threshold but has fixed thresholds in \"pheno_liability_threshold\".\n", t+1);
      }
    }
 
    // ---- PHENOTYPE VALUES (variable matrix) ----
    if(!_paramSet->isSet("pheno_liability_values"))
      return error("phenotype_expression::\"pheno_liability_values\" is required when liability traits are defined.\n");
 
    _paramSet->get_param("pheno_liability_values")->getVariableMatrix(&_liability_values);
 
    if(_liability_values.size() != _num_liability_trait)
      return error("phenotype_expression::rows in \"pheno_liability_values\" (%i) != number of liability traits (%i).\n",
                   (int)_liability_values.size(), _num_liability_trait);
 
    // per-trait validation: values.size == thresholds.size + 1
    for(unsigned int t = 0; t < _num_liability_trait; ++t) {
      unsigned int expected_nvals;
      if(_has_evolving_threshold && _liability_threshold_linked_index.get(0, t) >= 0)
        expected_nvals = 2;  // evolving: single threshold, 2 values
      else
        expected_nvals = _liability_threshold[t].size() + 1;
 
      if(_liability_values[t].size() != expected_nvals)
        return error("phenotype_expression::liability trait %i has %i values but expected %i.\n",
                     t+1, (int)_liability_values[t].size(), expected_nvals);
    }
 
    // ---- debug
#ifdef _DEBUG_
    for(unsigned int i=0; i < _liability_linked_index.length(); ++i) {
      cout << "---- LIABILITY TRAIT: "<< _liability_linked_index.get(0,i)+1 << "\n"
           << "      "<<_liability_threshold[i].size()<< " threshold values";
      if(_liability_threshold[i].size() != 0) {
        cout << ": ";
        for(unsigned int j=0; j < _liability_threshold[i].size(); ++j)
          cout << _liability_threshold[i][j]<<" ";
      }
      cout << "\n";
      cout << "      "<<_liability_values[i].size() << " phenotype values";
      if(_liability_values[i].size() != 0) {
        cout << ": ";
        for(unsigned int j=0; j < _liability_values[i].size(); ++j)
          cout << _liability_values[i][j]<<" ";
      }
      cout << "\n";
    }
#endif
 
    // ---- SIGMOIDAL (LOGISTIC) STEEPNESS ----
    _has_liability_sigmoid = false;
    _liability_steepness_linked_index.reset(1, _num_liability_trait, -2.0);
    _liability_steepness_fixed.assign(_num_liability_trait, 0.0);
 
    if(_paramSet->isSet("pheno_liability_steepness_negative"))
      _liability_steepness_allow_negative = (bool)_paramSet->getValue("pheno_liability_steepness_negative");
    else
      _liability_steepness_allow_negative = false;
 
    // evolving steepness from quanti trait
    if(_paramSet->isSet("pheno_liability_steepness_quanti_trait")) {
 
      TMatrix steepIdx_mat;
      if(!set_g_value_matrix(_paramSet->get_param("pheno_liability_steepness_quanti_trait"), steepIdx_mat))
        return false;
 
      if(steepIdx_mat.length() != _num_liability_trait)
        return error("phenotype_expression::number of entries in \"pheno_liability_steepness_quanti_trait\" (%i) != number of liability traits (%i).\n",
                     steepIdx_mat.length(), _num_liability_trait);
 
 
      for(unsigned int t = 0; t < _num_liability_trait; ++t) {
        double val = steepIdx_mat.get(0, t);
        if(val < 0)
          return error("phenotype_expression::negative entry in \"pheno_liability_steepness_quanti_trait\".\n");
        if(val == 0) continue; // no sigmoid for this trait
 
        if((unsigned int)val > _QuantiProto->get_num_traits())
          return error("phenotype_expression::invalid quanti trait index %i in \"pheno_liability_steepness_quanti_trait\".\n", (unsigned int)val);
 
        // check that the trait index is unique
        if (!trait_seen.insert(val - 1.0).second)
          return error("phenotype_expression::quanti trait index %i in \"pheno_liability_steepness_quanti_trait\" "
              "is already assigned to a liability, threshold or steepness trait.\n", (unsigned int)val);
 
        // check that the threshold and values are correctly set, for non-evolving threshold
        // we expect one threshold value and two liability values
        if(!_has_evolving_threshold || _liability_threshold_linked_index.get(0, t) < 0) {
 
          if(_liability_threshold[t].size() != 1)
            return error("phenotype_expression::liability trait %i has %i threshold(s) but expected %i.\n",
                t+1, (int)_liability_threshold[t].size(), 1);
 
          if(_liability_values[t].size() != 2)
            return error("phenotype_expression::liability trait %i has %i values but expected %i.\n",
                t+1, (int)_liability_values[t].size(), 2);
        }
 
        _liability_steepness_linked_index.set(0, t, val - 1.0); // 0-based
        _has_liability_sigmoid = true;
      }
    }
 
    // fixed steepness
    if(_paramSet->isSet("pheno_liability_steepness")) {
 
      TMatrix steepVal_mat;
      if(!set_g_value_matrix(_paramSet->get_param("pheno_liability_steepness"), steepVal_mat))
        return false;
 
      if(steepVal_mat.length() != _num_liability_trait)
        return error("phenotype_expression::number of entries in \"pheno_liability_steepness\" (%i) != number of liability traits (%i).\n",
                     steepVal_mat.length(), _num_liability_trait);
 
      for(unsigned int t = 0; t < _num_liability_trait; ++t) {
 
        double val = steepVal_mat.get(0, t);
 
        if(_liability_steepness_linked_index.get(0, t) >= 0) {
          if(val != 0) warning("phenotype_expression::liability trait %i has evolving steepness; fixed steepness value ignored.\n", t+1);
          continue;
        }
 
        if(val == 0) continue; // no sigmoid for this trait
 
        if(val < 0)
          return error("phenotype_expression::fixed steepness for liability trait %i must be > 0.\n", t+1);
 
        _liability_steepness_linked_index.set(0, t, -1.0); // fixed
        _liability_steepness_fixed[t] = val;
        _has_liability_sigmoid = true;
      }
    }
 
  } else {
    _num_liability_trait = 0;
    _has_evolving_threshold = false;
    _has_liability_sigmoid = false;
  }
 
  // =====================================================================
  //  CHECK AT LEAST ONE FEATURE IS CONFIGURED
  // =====================================================================
 
  if(!_has_plasticity && !_has_liability)
    return error("phenotype_expression::at least \"pheno_plastic_g0_quanti_trait\" or \"pheno_liability_quanti_trait\" must be set.\n");
 
  // labile plasticity ? ------------------------------------------------------------------
  if(_paramSet->isSet("pheno_plastic_is_labile")) {
    _is_labile = _paramSet->getValue("pheno_plastic_is_labile");
  }
  else {
    _is_labile = false;
  }
 
  // set liability function pointer
  if(_has_liability) {
    if(_has_evolving_threshold) {
     if(_has_liability_sigmoid)
       _set_liability_func = &LCE_PhenotypeExpression::setIndLiability_evolving_sigmoid;
     else
       _set_liability_func = &LCE_PhenotypeExpression::setIndLiability_evolving;
    } else {
      if(_has_liability_sigmoid)
        _set_liability_func = &LCE_PhenotypeExpression::setIndLiability_sigmoid;
      else
        _set_liability_func = &LCE_PhenotypeExpression::setIndLiability;
    }
  }
 
  return true;
 
}

References _do_change_cue, _e_copy_trait_optimum_value, _e_noise, _e_rate, _g0_linked_index, _g1_evolves, _g1_linked_index, _g1_values, _g2_evolves, _g2_linked_index, _g2_values, _get_env_cue_func, _has_evolving_threshold, _has_liability, _has_liability_sigmoid, _has_plasticity, _is_labile, _liability_linked_index, _liability_steepness_allow_negative, _liability_steepness_fixed, _liability_steepness_linked_index, _liability_threshold, _liability_threshold_linked_index, _liability_values, _num_liability_trait, _num_trait, SimComponent::_paramSet, LifeCycleEvent::_popPtr, _QuantiProto, _set_liability_func, _set_phenotype_func, check_g_index_matrix(), error(), TMatrix::get(), get_env_cue_no_noise(), get_env_cue_noise(), TProtoQuanti::get_num_traits(), ParamSet::get_param(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), ParamSet::getMatrix(), Metapop::getPatchNbr(), IndFactory::getTraitPrototype(), ParamSet::getValue(), Param::getVariableMatrix(), ParamSet::isSet(), TMatrix::length(), TMatrix::reset(), TMatrix::set(), set_env_cue(), set_g_value_matrix(), set_phenot_g1_evol(), set_phenot_g1_g2_evol(), set_phenot_g2_evol(), set_phenot_no_evol(), setIndLiability(), setIndLiability_evolving(), setIndLiability_evolving_sigmoid(), setIndLiability_sigmoid(), setSpatialMatrix(), and warning().

Referenced by LCE_PhenotypeExpression().

Member Data Documentation

_do_change_cue

bool LCE_PhenotypeExpression::_do_change_cue

private

Referenced by execute(), and setParameters().

_e_copy_trait_optimum_value

bool LCE_PhenotypeExpression::_e_copy_trait_optimum_value

private

A flag to set whether environmental cue values are equal to and copied from the trait local optimum values from LCE_selection.

Referenced by execute(), and setParameters().

_e_noise

TMatrix LCE_PhenotypeExpression::_e_noise

private

A matrix to hold the environmental noise (e reliability).

Referenced by get_env_cue_noise(), and setParameters().

_e_rate

TMatrix LCE_PhenotypeExpression::_e_rate

private

A matrix to hold the per generation rate of change of the environmental cues.

Referenced by execute(), and setParameters().

_e_values

TMatrix LCE_PhenotypeExpression::_e_values

private

_env_cue

TMatrix LCE_PhenotypeExpression::_env_cue

private

A matrix to hold the environmental cues (e value).

Referenced by execute(), get_env_cue_no_noise(), get_env_cue_noise(), and set_env_cue().

_g0_linked_index

TMatrix LCE_PhenotypeExpression::_g0_linked_index

private

Referenced by set_phenot_g1_evol(), set_phenot_g1_g2_evol(), set_phenot_g2_evol(), set_phenot_no_evol(), and setParameters().

_g1_evolves

bool LCE_PhenotypeExpression::_g1_evolves

private

Referenced by setParameters().

_g1_linked_index

TMatrix LCE_PhenotypeExpression::_g1_linked_index

private

Referenced by set_phenot_g1_evol(), set_phenot_g1_g2_evol(), and setParameters().

_g1_values

TMatrix LCE_PhenotypeExpression::_g1_values

private

Referenced by set_phenot_g2_evol(), set_phenot_no_evol(), and setParameters().

_g2_evolves

bool LCE_PhenotypeExpression::_g2_evolves

private

Referenced by setParameters().

_g2_linked_index

TMatrix LCE_PhenotypeExpression::_g2_linked_index

private

Referenced by set_phenot_g1_g2_evol(), set_phenot_g2_evol(), and setParameters().

_g2_values

TMatrix LCE_PhenotypeExpression::_g2_values

private

Referenced by set_phenot_g1_evol(), set_phenot_no_evol(), and setParameters().

_get_env_cue_func

double(LCE_PhenotypeExpression::* LCE_PhenotypeExpression::_get_env_cue_func) (unsigned int, unsigned int)

private

Referenced by set_phenot_g1_evol(), set_phenot_g1_g2_evol(), set_phenot_g2_evol(), set_phenot_no_evol(), and setParameters().

_has_evolving_threshold

bool LCE_PhenotypeExpression::_has_evolving_threshold

private

Referenced by setParameters().

_has_liability

bool LCE_PhenotypeExpression::_has_liability

private

Referenced by execute(), and setParameters().

_has_liability_sigmoid

bool LCE_PhenotypeExpression::_has_liability_sigmoid

private

Referenced by setParameters().

_has_plasticity

bool LCE_PhenotypeExpression::_has_plasticity

private

Referenced by execute(), and setParameters().

_is_labile

bool LCE_PhenotypeExpression::_is_labile

private

Referenced by execute(), and setParameters().

_liability_linked_index

TMatrix LCE_PhenotypeExpression::_liability_linked_index

private

Referenced by setIndLiability(), setIndLiability_evolving(), setIndLiability_evolving_sigmoid(), setIndLiability_sigmoid(), and setParameters().

_liability_steepness_allow_negative

bool LCE_PhenotypeExpression::_liability_steepness_allow_negative

private

Referenced by setIndLiability_evolving_sigmoid(), setIndLiability_sigmoid(), and setParameters().

_liability_steepness_fixed

vector<double> LCE_PhenotypeExpression::_liability_steepness_fixed

private

Referenced by setIndLiability_evolving_sigmoid(), setIndLiability_sigmoid(), and setParameters().

_liability_steepness_linked_index

TMatrix LCE_PhenotypeExpression::_liability_steepness_linked_index

private

Referenced by setIndLiability_evolving_sigmoid(), setIndLiability_sigmoid(), and setParameters().

_liability_threshold

vector< vector<double> > LCE_PhenotypeExpression::_liability_threshold

private

Referenced by setIndLiability(), setIndLiability_evolving(), setIndLiability_evolving_sigmoid(), setIndLiability_sigmoid(), and setParameters().

_liability_threshold_linked_index

TMatrix LCE_PhenotypeExpression::_liability_threshold_linked_index

private

Referenced by setIndLiability_evolving(), setIndLiability_evolving_sigmoid(), and setParameters().

_liability_values

vector< vector<double> > LCE_PhenotypeExpression::_liability_values

private

Referenced by setIndLiability(), setIndLiability_evolving(), setIndLiability_evolving_sigmoid(), setIndLiability_sigmoid(), and setParameters().

_num_liability_trait

unsigned int LCE_PhenotypeExpression::_num_liability_trait

private

Referenced by setIndLiability(), setIndLiability_evolving(), setIndLiability_evolving_sigmoid(), setIndLiability_sigmoid(), and setParameters().

_num_trait

unsigned int LCE_PhenotypeExpression::_num_trait

private

Number of plastic phenotypes.

Referenced by execute(), set_env_cue(), set_phenot_g1_evol(), set_phenot_g1_g2_evol(), set_phenot_g2_evol(), set_phenot_no_evol(), and setParameters().

_QuantiProto

TProtoQuanti* LCE_PhenotypeExpression::_QuantiProto

private

A pointer to the plastic trait prototype.

Referenced by check_g_index_matrix(), set_g_value_matrix(), and setParameters().

_set_liability_func

void(LCE_PhenotypeExpression::* LCE_PhenotypeExpression::_set_liability_func) (Patch *, sex_t, age_idx)

private

Referenced by execute(), and setParameters().

_set_phenotype_func

void(LCE_PhenotypeExpression::* LCE_PhenotypeExpression::_set_phenotype_func) (unsigned int, TTQuanti *)

private

Referenced by setIndPhenotype(), setIndPhenotype_labile(), and setParameters().

---

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

• LCEphenoexpression.h
• LCEphenoexpression.cc