LCE_BreedAssortativeMating Class Reference

Implementation of the basic breeding and mating procedures, does not link to any trait. More...

#include <LCEbreed.h>

Inheritance diagram for LCE_BreedAssortativeMating:

Collaboration diagram for LCE_BreedAssortativeMating:

Public Member Functions
	LCE_BreedAssortativeMating ()
virtual	~LCE_BreedAssortativeMating ()
void	ScrambleContainer (const int length, deque< Individual * > &array)
Individual *	breed_lamprey (Individual *mother, Individual *father, unsigned int LocalPatch)
void	setPhenotypeAncestryBased (Individual *ind)
void	setPhenotypeMotherInherited (Individual *ind)
Assortative mating functions
bool	testAssortativeMatingCouple (const double female_trait_value, const double male_trait_value)
	Test whether male and female match for mating. More...
Individual *	non_assortative_mating (Patch *patch, Individual *mother, unsigned int motherIndex)
	Proceed with non-assortative mating, choosing a male at random in the patch, conditioned on him being a "virgin". More...
Individual *	assortative_mating (deque< Individual * > &males, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male chosen relative to its phenotypic resemblance with the mother. More...
Implementations
virtual bool	setParameters ()
virtual void	execute ()
virtual LifeCycleEvent *	clone ()
virtual void	loadFileServices (FileServices *loader)
virtual void	loadStatServices (StatServices *loader)
virtual bool	resetParameterFromSource (std::string param, SimComponent *cmpt)
virtual age_t	removeAgeClass ()
virtual age_t	addAgeClass ()
virtual age_t	requiredAgeClass ()
Public Member Functions inherited from LCE_Breed_base
	LCE_Breed_base ()
virtual	~LCE_Breed_base ()
virtual Individual *	getFatherPtr (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Calls the mating function according to the model chosen using the function pointer, used to get the father from the mother in a patch. More...
void	NonWrightFisherPopulation ()
void	WrightFisherPopulation ()
Individual *	breed (Individual *mother, Individual *father, unsigned int LocalPatch)
	Makes a new individual with the right parents. More...
Individual *	breed_cloning (Individual *mother, Individual *father, unsigned int LocalPatch)
	Makes a new individual by doing a deep copy of the mother (copies the mother's genes into the offspring). More...
Individual *	makeOffspring (Individual *ind)
	Last step of the breeding process, does inheritance and mutation of the parents' genes. More...
Individual *	do_breed (Individual *mother, Individual *father, unsigned int LocalPatch)
	Calls the breeding function unsing its pointer. More...
bool	checkMatingCondition (Patch *thePatch)
	Checks if any mating will take place in the patch passed as argument. More...
bool	checkNoSelfing (Patch *thePatch)
	Checks whether mating will take place in the current patch when mating is not selfing or cloning. More...
bool	checkPolygyny (Patch *thePatch)
	Checks whether mating will take place in the current patch when mating is polygynous. More...
bool	checkSelfing (Patch *thePatch)
	Checks whether mating will take place in the current patch when mating is selfing. More...
bool	checkCloning (Patch *thePatch)
	Checks whether mating will take place in the current patch when mating is cloning. More...
bool	setMatingSystem ()
bool	setFecundity ()
bool	setSexRatio ()
double	getMatingProportion ()
double	getMeanFecundity (unsigned int patch)
int	getMatingSystem ()
bool	doInheritance ()
double	getPoissonFecundity (double mean)
double	getFixedFecundity (double mean)
double	getGaussianFecundity (double mean)
double	getLogNormalFecundity (double mean)
double	getFecundity (unsigned int patch)
double	getFecundity (double mean)
sex_t	getOffsprgSex ()
sex_t	getOffsprgSexRandom ()
sex_t	getOffsprgSexFixed ()
sex_t	getOffsprgSexSelfing ()
sex_t	getOffsprgSexCloning ()
bool	isWrightFisher ()
Individual *	RandomMating (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male drawn randomly from a patch. More...
Individual *	fullPolyginy (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to the alpha male of the patch. More...
Individual *	fullPolyginy_manyMales (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to one of the first _mating_males males of the patch. More...
Individual *	partialPolyginy (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male from a patch chosen at random if _mating_proportion != 1, or the first male otherwise. More...
Individual *	partialPolyginy_manyMales (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male from a patch chosen at random if _mating_proportion != 1, or one of the _mating_males first males otherwise. More...
Individual *	fullMonoginy (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male with same index as mother (if available) from the focal patch. More...
Individual *	partialMonoginy (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male with same index as mother (if available) from the focal patch. More...
Individual *	fullSelfing (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns the mother pointer. More...
Individual *	partialSelfing (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns the mother pointer or a random female if _mating_proportion != 1. More...
Individual *	random_hermaphrodite (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a random female from the patch, will be the same mother with probability 1/N (Wright-Fisher model). More...
Public Member Functions inherited from LifeCycleEvent
	LifeCycleEvent (const char *name, const char *trait_link)
	Cstor. More...
virtual	~LifeCycleEvent ()
virtual void	init (Metapop *popPtr)
	Sets the pointer to the current Metapop and the trait link if applicable. More...
virtual bool	attach_trait (string trait)
virtual void	set_paramset (std::string name, bool required, SimComponent *owner)
virtual void	set_event_name (std::string &name)
	Set the name of the event (name of the ParamSet) and add the corresponding parameter to the set. More...
virtual void	set_event_name (const char *name)
virtual string &	get_event_name ()
	Accessor to the LCE's name. More...
virtual int	get_rank ()
	Accessor to the LCE rank in the life cycle. More...
virtual void	set_pop_ptr (Metapop *popPtr)
	Accessors for the population pointer. More...
virtual Metapop *	get_pop_ptr ()
Public Member Functions inherited from SimComponent
	SimComponent ()
virtual	~SimComponent ()
virtual void	loadUpdaters (UpdaterServices *loader)
	Loads the parameters and component updater onto the updater manager. More...
virtual void	set_paramset (ParamSet *paramset)
	Sets the ParamSet member. More...
virtual void	set_paramsetFromCopy (const ParamSet &PSet)
	Reset the set of parameters from a another set. More...
virtual ParamSet *	get_paramset ()
	ParamSet accessor. More...
virtual void	add_parameter (Param *param)
	Interface to add a parameter to the set. More...
virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd)
	Interface to add a parameter to the set. More...
virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd, ParamUpdaterBase *updater)
	Interface to add a parameter and its updater to the set. More...
virtual Param *	get_parameter (std::string name)
	Param getter. More...
virtual double	get_parameter_value (std::string name)
	Param value getter. More...
virtual string	get_name ()
	Returnd the name of the ParamSet, i.e. More...
virtual bool	has_parameter (std::string name)
	Param getter. More...

Private Attributes
double	_assortative_value
double	_assortative_tolerance
double	assortative_value_with_tolerance
std::function< bool(double, double)>	_assortative_predicate
double	_prop_non_assortative
Individual *(LCE_Breed_base::*	MatingFuncPtr_base )(Patch *, Individual *, unsigned int)
Individual *(LCE_Breed_base::*	AssortativeMatingFuncPtr )(Patch *, Individual *, unsigned int)

Additional Inherited Members
Protected Attributes inherited from LCE_Breed_base
TMatrix	_mean_fecundity
Individual *(LCE_Breed_base::*	MatingFuncPtr )(Patch *, Individual *, unsigned int)
Individual *(LCE_Breed_base::*	DoBreedFuncPtr )(Individual *mother, Individual *father, unsigned int LocalPatch)
double(LCE_Breed_base::*	FecundityFuncPtr )(double mean)
bool(LCE_Breed_base::*	CheckMatingConditionFuncPtr )(Patch *thePatch)
sex_t(LCE_Breed_base::*	GetOffsprgSex )()
void(LCE_Breed_base::*	PopModelFuncPtr )(void)
Protected Attributes inherited from LifeCycleEvent
std::string	_event_name
	The param name to be read in the init file. More...
Metapop *	_popPtr
	The ptr to the current Metapop. More...
std::string	_LCELinkedTraitType
	The name of the linked trait. More...
int	_LCELinkedTraitIndex
	The index in the individual's trait table of the linked trait. More...
Protected Attributes inherited from SimComponent
ParamSet *	_paramSet
	The parameters container. More...

Detailed Description

Implementation of the basic breeding and mating procedures, does not link to any trait.

Individuals mate according to the mating system chosen. The mated adults are not removed from the population. The offspring containers are filled with the new generation. Note that they are first emptied if still containing offspring individuals when starting the breeding process.

The population's age is set to ALL. The mating and realized fecundity counters of the reproducing males and females are updated.

See also

LCE_Breed_base

Constructor & Destructor Documentation

LCE_BreedAssortativeMating()

LCE_BreedAssortativeMating::LCE_BreedAssortativeMating

(

)

                                                         : LifeCycleEvent("breed_assortative",""),
    _assortative_value(0), _assortative_tolerance(0), assortative_value_with_tolerance(0),
    _assortative_predicate(0),_prop_non_assortative(0), MatingFuncPtr_base(0), AssortativeMatingFuncPtr(0)
{
  ParamUpdater<LCE_BreedAssortativeMating> * updater = new ParamUpdater<LCE_BreedAssortativeMating> (&LCE_BreedAssortativeMating::setParameters);
 
  add_parameter("breed_assortative_trait", STR, true, false, 0, 0, updater);     //the trait used for the assortment
  add_parameter("breed_assortative_tolerance", DBL, false, false, 0, 0, updater); //the threshold used for mating
  add_parameter("breed_assortative_condition", STR, false, false, 0, 0, updater); //the predicate used to test for assortment
  add_parameter("breed_assortative_value", DBL, false, false, 0, 0, updater); //the value matched by the difference b/n male and female
 
 // get_parameter("mating_system")->setIsRequired(false);
 
}

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

Referenced by clone().

~LCE_BreedAssortativeMating()

virtual LCE_BreedAssortativeMating::~LCE_BreedAssortativeMating ( )

inlinevirtual

{ }

Member Function Documentation

addAgeClass()

virtual age_t LCE_BreedAssortativeMating::addAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return OFFSPRG;}

References OFFSPRG.

assortative_mating()

Individual * LCE_BreedAssortativeMating::assortative_mating	(	deque< Individual * > &	males,
		Individual *	mother,
		unsigned int	motherIndex
	)

Returns a pointer to a male chosen relative to its phenotypic resemblance with the mother.

{
  Individual* father = NULL;
 
  if(males.size() >= motherIndex+1)
    father = males[motherIndex];  // we model monogamy, the female mates with a single male, if they match
  else
    father = males[0]; // start from first males in the array if not enough males
 
  unsigned int cnt = 0;
 
//  cout<<" "<<motherIndex<<" - LCE_BreedAssortativeMating::assortative_mating\n";
  double fem_trait_value = ((double*)mother->getTraitValue(_LCELinkedTraitIndex))[0]; //works for quanti trait only
//  cout<<"     female trait value: "<<fem_trait_value<<endl;
  double mal_trait_value = ((double*)father->getTraitValue(_LCELinkedTraitIndex))[0];
//  cout<<"     male trait value: "<<mal_trait_value<<endl;
 
  bool match = testAssortativeMatingCouple(fem_trait_value, mal_trait_value);
 
//  cout<<"     trait match: "<<std::boolalpha<<match<<" || mated: "<<(father->getTotMatings() != 0)<<endl;
 
  // these are Lamprey-specific conditions for strictly monogamous couples.
  while( (!match || father->getTotMatings() != 0) && cnt < males.size())
  {
    // the male doesn't match or the male has already reproduced, we need to change it
    if(males.size() > motherIndex+1)
      motherIndex++;
    else
      motherIndex = 0; //restart from the beginning
 
    father = males[motherIndex];
 
    mal_trait_value = ((double*)father->getTraitValue(_LCELinkedTraitIndex))[0];
 
    match = testAssortativeMatingCouple(fem_trait_value, mal_trait_value);
 
    cnt++;
  }
//  cout<<"   + match trials: "<<cnt<< ";  father: "<<motherIndex <<"("<<father->getID()<<")"<<endl;
//  cout<<"     male trait value: "<<mal_trait_value<<endl;
//  cout<<"     trait match: "<<std::boolalpha<<match<<" || mated: "<<(father->getTotMatings() != 0)<<endl;
  if( !match || father->getTotMatings() != 0) {
//  cout<<"  @@ FAIL\n";
    return NULL;  // no more matching mating partner available
  }
 
  return father;
}

References LifeCycleEvent::_LCELinkedTraitIndex, Individual::getTotMatings(), Individual::getTraitValue(), and testAssortativeMatingCouple().

Referenced by execute().

breed_lamprey()

Individual* LCE_BreedAssortativeMating::breed_lamprey	(	Individual *	mother,
		Individual *	father,
		unsigned int	LocalPatch
	)

clone()

virtual LifeCycleEvent* LCE_BreedAssortativeMating::clone ( )

inlinevirtual

Implements LifeCycleEvent.

{return new LCE_BreedAssortativeMating();}

References LCE_BreedAssortativeMating().

execute()

void LCE_BreedAssortativeMating::execute ( )

virtual

Implements LifeCycleEvent.

{
  Patch* patch;
  Individual* mother;
  Individual* father;
  Individual* NewOffsprg;
  deque<Individual*> randmales;
  unsigned int nbBaby;
  double fec, fec_factor;
 
#ifdef _DEBUG_
  message("LCE_BreedAssortativeMating::execute (Patch nb: %i offsprg nb: %i adlt nb: %i)\n"
          ,_popPtr->getPatchNbr(),_popPtr->size( OFFSPRG ),_popPtr->size( ADULTS ));
#endif
 
  for(unsigned int i = 0; i < _popPtr->getPatchNbr(); i++) {
 
    patch = _popPtr->getPatch(i);
 
    if( !checkMatingCondition(patch) ) continue;  // set to checkNoSelfing()
 
    randmales.clear();
    // randomize the males within the patch
    patch->getCopy(MAL, ADLTx, randmales);
 
    ScrambleContainer(randmales.size(), randmales);
 
    for(unsigned int size = patch->size(FEM, ADLTx), indexOfMother = 0;
        indexOfMother < size;
        indexOfMother++)
    {
      mother = patch->get(FEM, ADLTx, indexOfMother);
 
      nbBaby = (unsigned int)mother->setFecundity( fec ) ;
 
      if(nbBaby == 0) continue;  // skip this female
 
      // choose a male:
      if( RAND::Uniform() < _prop_non_assortative )
        father = non_assortative_mating(patch, mother, indexOfMother);
      else
        father = assortative_mating(randmales, mother, indexOfMother);
 
      if(father == NULL) continue; // move to the next female if mating wasn't possible
 
      for(unsigned int j = 0; j < nbBaby; ++j) {
 
        // LAMPREY SPECIFIC !!!
//       NewOffsprg = breed_lamprey(mother, father, i);
//
//        patch->add(NewOffsprg->getSex(), OFFSx, NewOffsprg);
 
      }
    }
  }
}

References LifeCycleEvent::_popPtr, _prop_non_assortative, ADLTx, ADULTS, assortative_mating(), LCE_Breed_base::checkMatingCondition(), Patch::clear(), FEM, Patch::get(), Patch::getCopy(), Metapop::getPatch(), Metapop::getPatchNbr(), MAL, message(), non_assortative_mating(), OFFSPRG, ScrambleContainer(), Individual::setFecundity(), Metapop::size(), Patch::size(), and RAND::Uniform().

loadFileServices()

virtual void LCE_BreedAssortativeMating::loadFileServices ( FileServices *  loader )

inlinevirtual

Implements SimComponent.

{}

loadStatServices()

virtual void LCE_BreedAssortativeMating::loadStatServices ( StatServices *  loader )

inlinevirtual

Implements SimComponent.

{}

non_assortative_mating()

Individual * LCE_BreedAssortativeMating::non_assortative_mating	(	Patch *	patch,
		Individual *	mother,
		unsigned int	motherIndex
	)

Proceed with non-assortative mating, choosing a male at random in the patch, conditioned on him being a "virgin".

{
  Individual* father = NULL;
  unsigned int cnt = 0;
 
  do {
    father = RandomMating(patch, mother, motherIndex);
    cnt++;
  } while( father->getTotMatings() != 0 && cnt < patch->size(MAL, ADLTx) );
 
  if(father->getTotMatings() != 0)
    return NULL;
 
  return father;
}

References ADLTx, Individual::getTotMatings(), MAL, and LCE_Breed_base::RandomMating().

Referenced by execute().

removeAgeClass()

virtual age_t LCE_BreedAssortativeMating::removeAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return 0;}

requiredAgeClass()

virtual age_t LCE_BreedAssortativeMating::requiredAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return ADULTS;}

References ADULTS.

resetParameterFromSource()

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

inlinevirtual

Implements SimComponent.

{return false;}

ScrambleContainer()

void LCE_BreedAssortativeMating::ScrambleContainer ( const int  length, deque< Individual * > &  array  )

inline

{
  unsigned int size = length, pos, last = length - 1, num = length -1;
  Individual* el;
 
  // with stop after 2 elements are left
  // this algo allows swapping an element with itself, which is fine
  for (unsigned int i = 0; i < num; i++) {
    pos = RAND::Uniform(size);
    el = array[last];
    array[last] = array[pos];
    array[pos] = el;
    size--; last--;
  }
 
   assert(size == 1); //we stopped before swapping the last (first) element with itself
}

References RAND::Uniform().

Referenced by execute().

setParameters()

bool LCE_BreedAssortativeMating::setParameters ( )

virtual

Reimplemented from LCE_Breed_base.

{
  if(!LCE_Breed_base::setParameters( )) return false;
 
  // trait link to query for the phenotypic value
  _LCELinkedTraitType = get_parameter("breed_assortative_trait")->getArg();
  _LCELinkedTraitIndex = _popPtr->getTraitIndex(_LCELinkedTraitType);
 
  if(_LCELinkedTraitIndex == -1)
    return error("assortative mating trait \"%s\" cannot be found in loaded traits\n",_LCELinkedTraitType.c_str());
 
 
  // value of trait difference b/n male and female to initiate mating, it is 0 by default
  if ( get_parameter("breed_assortative_value")->isSet() )
    _assortative_value = get_parameter_value("breed_assortative_value");
  else
    _assortative_value = 0;
 
 
  // tolerance value around the assortative value, it 0 by default
  if (get_parameter("breed_assortative_tolerance")->isSet()) {
 
    _assortative_tolerance = get_parameter_value("breed_assortative_tolerance");
 
  } else {
 
    _assortative_tolerance = 0;
 
  }
 
  assortative_value_with_tolerance = _assortative_value + _assortative_tolerance;
 
  string _assortative_test_condition;
 
  // predicate for the choice of mating
  if (get_parameter("breed_assortative_condition")->isSet()) {
 
    _assortative_test_condition = tstring::removeEnclosingChar(get_parameter("breed_assortative_condition")->getArg(), '"', '"', true) ;
 
    if(_assortative_test_condition == "==") {
 
      _assortative_predicate = std::equal_to<double>{};
 
    } else if (_assortative_test_condition == "!=") {
 
      _assortative_predicate = std::not_equal_to<double>{};
 
    } else if (_assortative_test_condition == ">") {
 
      _assortative_predicate = std::greater<double>{};
 
    } else if (_assortative_test_condition == "<") {
 
      _assortative_predicate = std::less<double>{};
 
    } else if (_assortative_test_condition == "<=") {
 
      _assortative_predicate = std::less_equal<double>{};
 
    } else if (_assortative_test_condition == ">=") {
 
      _assortative_predicate = std::greater_equal<double>{};
 
    } else
      return error("value for \"breed_assortative_condition\" could not be understood\n");
 
  } else {
    _assortative_predicate = std::equal_to<double>{};
  }
 
  if( get_parameter("mating_proportion")->isSet()) {
    // proportion of time mating is done at random
    _prop_non_assortative = get_parameter_value("mating_proportion");
  }
  else
    _prop_non_assortative = 0;
 
  // backup the mating function
  MatingFuncPtr_base = this->MatingFuncPtr;
 
 
 
  return true;
}

References _assortative_predicate, _assortative_tolerance, _assortative_value, LifeCycleEvent::_LCELinkedTraitIndex, LifeCycleEvent::_LCELinkedTraitType, LifeCycleEvent::_popPtr, _prop_non_assortative, assortative_value_with_tolerance, error(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getArg(), IndFactory::getTraitIndex(), LCE_Breed_base::MatingFuncPtr, MatingFuncPtr_base, tstring::removeEnclosingChar(), and LCE_Breed_base::setParameters().

Referenced by LCE_BreedAssortativeMating().

setPhenotypeAncestryBased()

void LCE_BreedAssortativeMating::setPhenotypeAncestryBased

(

Individual *

ind

)

setPhenotypeMotherInherited()

void LCE_BreedAssortativeMating::setPhenotypeMotherInherited

(

Individual *

ind

)

testAssortativeMatingCouple()

bool LCE_BreedAssortativeMating::testAssortativeMatingCouple	(	const double	female_trait_value,
		const double	male_trait_value
	)

Test whether male and female match for mating.

{
  // we test the difference between the male and female values
  // to match with the predicate, we take diff = male - female
  // predicate tells how the male value must be relative to the female value:
  // "<=": males must be smaller or equal to the female to mate,
  //       thus, male - female <= 0 to match.
  double diff = male_trait_value - female_trait_value;
 
  // by default the assortative value is 0 (diff b/n female and male phenotype)
  if(abs(diff) <= (_assortative_value + _assortative_tolerance))
    diff = _assortative_value;
 
  return _assortative_predicate( diff, _assortative_value );
}

References _assortative_predicate, _assortative_tolerance, and _assortative_value.

Referenced by assortative_mating().

Member Data Documentation

_assortative_predicate

std::function<bool(double,double)> LCE_BreedAssortativeMating::_assortative_predicate

private

Referenced by setParameters(), and testAssortativeMatingCouple().

_assortative_tolerance

double LCE_BreedAssortativeMating::_assortative_tolerance

private

Referenced by setParameters(), and testAssortativeMatingCouple().

_assortative_value

double LCE_BreedAssortativeMating::_assortative_value

private

Referenced by setParameters(), and testAssortativeMatingCouple().

_prop_non_assortative

double LCE_BreedAssortativeMating::_prop_non_assortative

private

Referenced by execute(), and setParameters().

assortative_value_with_tolerance

double LCE_BreedAssortativeMating::assortative_value_with_tolerance

private

Referenced by setParameters().

AssortativeMatingFuncPtr

Individual*(LCE_Breed_base::* LCE_BreedAssortativeMating::AssortativeMatingFuncPtr) (Patch *, Individual *, unsigned int)

private

MatingFuncPtr_base

Individual*(LCE_Breed_base::* LCE_BreedAssortativeMating::MatingFuncPtr_base) (Patch *, Individual *, unsigned int)

private

Referenced by setParameters().

---

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

• LCEbreed.h
• LCEbreed.cc