LCE_Breed_Disperse Class Reference

Performs breeding and migration in one, migration rates are backward rates. More...

#include <LCEcomposite.h>

Inheritance diagram for LCE_Breed_Disperse:

Collaboration diagram for LCE_Breed_Disperse:

Public Member Functions
	LCE_Breed_Disperse ()
virtual	~LCE_Breed_Disperse ()
void	do_breed_disperse ()
void	do_breed_disperse_propagule ()
void	do_breed_disperse_in_patch (sex_t SEX, Patch *patch, unsigned int ID, unsigned int num_offsprg)
void	do_breed_disperse_in_empty_patch (sex_t SEX, Patch *patch, unsigned int ID, unsigned int num_offsprg)
unsigned int	numFemOffspring (Patch *patch)
unsigned int	numFemOffspring_colonizers (Patch *patch)
	The number of females produced in case a max number of colonizers was specified. More...
unsigned int	numMalOffspring_notrandom (Patch *patch)
	The number of males produced is always zero when the mating system is not random mating. More...
unsigned int	numMalOffspring_random (Patch *patch)
unsigned int	numMalOffspring_random_colonizers (Patch *patch)
Growth Functions
unsigned int	instantGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced corresponds to the carrying capacity of the patch. More...
unsigned int	logisticGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced is given by the logistic growth function. More...
unsigned int	stochasticLogisticGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced is drawn from a Poisson with mean equal to the logistic growth predicate. More...
unsigned int	conditionalLogisticGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced depends on the adult density. More...
unsigned int	conditionalStochasticLogisticGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced depends on the adult density, similar to 'conditionalLogisticGrowth' except that this time, the fecundities are drawn from Poisson distributions. More...
unsigned int	fixedFecundityGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced is equal to the current number of breeders multiplied by the mean fecundity of the focal patch. More...
unsigned int	stochasticFecundityGrowth (Patch *patch, sex_t SEX)
	The number of offspring produced is a random number drawn from a Poisson distribution with mean equal to the current number of breeders multiplied by the mean fecundity of the focal patch. More...
unsigned int	exponentialGrowth (Patch *patch, sex_t SEX)
	Exponential growth using current patch size as basis to calculate future sizes, set once the function is first called. More...
Mating Functions
Individual *	mate_random (sex_t SEX, Patch *patch, unsigned int LocalPatch, gsl_ran_discrete_t *rate_fem, gsl_ran_discrete_t *rate_mal)
Individual *	mate_random_hermaphrodite (sex_t SEX, Patch *patch, unsigned int LocalPatch, gsl_ran_discrete_t *rate_fem, gsl_ran_discrete_t *rate_mal)
Individual *	mate_selfing (sex_t SEX, Patch *patch, unsigned int LocalPatch, gsl_ran_discrete_t *rate_fem, gsl_ran_discrete_t *rate_mal)
Individual *	mate_full_selfing (sex_t SEX, Patch *patch, unsigned int LocalPatch, gsl_ran_discrete_t *rate_fem, gsl_ran_discrete_t *rate_mal)
Individual *	mate_cloning (sex_t SEX, Patch *patch, unsigned int LocalPatch, gsl_ran_discrete_t *rate_fem, gsl_ran_discrete_t *rate_mal)
Individual *	makeOffspring (Individual *ind)
Individual *	get_parent (sex_t SEX, sex_t DispSex, Patch *LocalPatch, unsigned int patchID, gsl_ran_discrete_t *rates)
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 ()
void	doAgingInWFpop ()
Individual *	breed (Individual *mother, Individual *father, unsigned int LocalPatch)
	Makes a new individual with the right parents. More...
Individual *	breed_cloning (Individual *mother, Individual *father, unsigned int LocalPatch)
	Makes a new individual by doing a deep copy of the mother (copies the mother's genes into the offspring). More...
Individual *	makeOffspring (Individual *ind)
	Last step of the breeding process, does inheritance and mutation of the parents' genes. More...
Individual *	makeOffspring (Individual *newind, Individual *mother, Individual *father, unsigned int natalPatch)
	Overloads previous function when a new offspring is created "in-place", that is from existing pointer in a patch. More...
Individual *	do_breed (Individual *mother, Individual *father, unsigned int LocalPatch)
	Calls the breeding function unsing its pointer. More...
bool	checkMatingCondition (Patch *thePatch)
	Checks if any mating will take place in the patch passed as argument. More...
bool	checkNoSelfing (Patch *thePatch)
	Checks whether mating will take place in the current patch when mating is not selfing or cloning. More...
bool	checkPolygyny (Patch *thePatch)
	Checks whether mating will take place in the current patch when mating is polygynous. More...
bool	checkSelfing (Patch *thePatch)
	Checks whether mating will take place in the current patch when mating is selfing. More...
bool	checkCloning (Patch *thePatch)
	Checks whether mating will take place in the current patch when mating is cloning. More...
bool	setMatingSystem ()
bool	setFecundity ()
bool	setSexRatio ()
double	getMatingProportion ()
double	getMeanFecundity (unsigned int patch)
int	getMatingSystem ()
bool	doInheritance ()
double	getPoissonFecundity (double mean)
double	getFixedFecundity (double mean)
double	getGaussianFecundity (double mean)
double	getLogNormalFecundity (double mean)
double	getFecundity (unsigned int patch)
double	getFecundity (double mean)
sex_t	getOffsprgSex ()
sex_t	getOffsprgSexRandom ()
sex_t	getOffsprgSexFixed ()
sex_t	getOffsprgSexSelfing ()
sex_t	getOffsprgSexCloning ()
bool	isWrightFisher ()
Individual *	RandomMating (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male drawn randomly from a patch. More...
Individual *	fullPolyginy (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to the alpha male of the patch. More...
Individual *	fullPolyginy_manyMales (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to one of the first _mating_males males of the patch. More...
Individual *	partialPolyginy (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male from a patch chosen at random if _mating_proportion != 1, or the first male otherwise. More...
Individual *	partialPolyginy_manyMales (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male from a patch chosen at random if _mating_proportion != 1, or one of the _mating_males first males otherwise. More...
Individual *	fullMonoginy (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male with same index as mother (if available) from the focal patch. More...
Individual *	partialMonoginy (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a pointer to a male with same index as mother (if available) from the focal patch. More...
Individual *	fullSelfing (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns the mother pointer. More...
Individual *	partialSelfing (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns the mother pointer or a random female if _mating_proportion != 1. More...
Individual *	random_hermaphrodite (Patch *thePatch, Individual *mother, unsigned int motherIndex)
	Returns a random female from the patch, will be the same mother with probability 1/N (Wright-Fisher model). More...
Public Member Functions inherited from LifeCycleEvent
	LifeCycleEvent (const char *name, const char *trait_link)
	Cstor. More...
virtual	~LifeCycleEvent ()
virtual void	init (Metapop *popPtr)
	Sets the pointer to the current Metapop and the trait link if applicable. More...
virtual bool	attach_trait (string trait)
virtual void	set_paramset (std::string name, bool required, SimComponent *owner)
virtual void	set_event_name (std::string &name)
	Set the name of the event (name of the ParamSet) and add the corresponding parameter to the set. More...
virtual void	set_event_name (const char *name)
virtual string &	get_event_name ()
	Accessor to the LCE's name. More...
virtual int	get_rank ()
	Accessor to the LCE rank in the life cycle. More...
virtual void	set_pop_ptr (Metapop *popPtr)
	Accessors for the population pointer. More...
virtual Metapop *	get_pop_ptr ()
Public Member Functions inherited from SimComponent
	SimComponent ()
virtual	~SimComponent ()
virtual void	loadUpdaters (UpdaterServices *loader)
	Loads the parameters and component updater onto the updater manager. More...
virtual void	set_paramset (ParamSet *paramset)
	Sets the ParamSet member. More...
virtual void	set_paramsetFromCopy (const ParamSet &PSet)
	Reset the set of parameters from a another set. More...
virtual ParamSet *	get_paramset ()
	ParamSet accessor. More...
virtual void	add_parameter (Param *param)
	Interface to add a parameter to the set. More...
virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd)
	Interface to add a parameter to the set. More...
virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd, ParamUpdaterBase *updater)
	Interface to add a parameter and its updater to the set. More...
virtual Param *	get_parameter (std::string name)
	Param getter. More...
virtual double	get_parameter_value (std::string name)
	Param value getter. More...
virtual string	get_name ()
	Returnd the name of the ParamSet, i.e. More...
virtual bool	has_parameter (std::string name)
	Param getter. More...
Public Member Functions inherited from LCE_Disperse_base
	LCE_Disperse_base ()
virtual	~LCE_Disperse_base ()
	Deallocates the disp matrix. More...
bool	setBaseParameters (string prefix)
void	setParamPrefix (string pref)
void	addParameters (string prefix, ParamUpdaterBase *updater)
void	setIndentityDispMatrix (TMatrix *mat)
unsigned int	getMigrationPatchForward (sex_t SEX, unsigned int LocalPatch)
unsigned int	getMigrationPatchBackward (sex_t SEX, unsigned int LocalPatch)
unsigned int	getMigrationIndex (vector< double > &rates)
unsigned int	getMigrationIndexGSLdiscrete (gsl_ran_discrete_t *rates)
void	setPropaguleTargets ()
void	swapPostDisp ()
void	reset_counters ()
void	set_isForward (bool val)
bool	checkForwardDispersalMatrix (TMatrix *mat)
bool	checkBackwardDispersalMatrix (TMatrix *mat)
void	allocateDispMatrix (sex_t sex, unsigned int dim)
bool	updateDispMatrix ()
bool	setDispMatrix ()
bool	setReducedMatricesBySex (sex_t SEX, Param &connectivity, Param &rate)
bool	setReducedDispMatrix ()
	The reduced dispersal matrix contains the indices of the patches to which each patch is connected. More...
bool	setIsland_MigrantPool_Matrix ()
bool	setIsland_PropagulePool_Matrix ()
bool	setSteppingStone1DMatrix ()
bool	setLatticeMatrix ()
	Sets the dispersal matrices for the Lattice dispersal model. More...
bool	setBasicLatticeMatrix (int rows, int cols, double phi_mal, double phi_fem, double disp_mal, double disp_fem)
bool	setLatticeTorrusMatrix (int rows, int cols, double disp_mal, double disp_fem, TMatrix *grid)
bool	setLatticeAbsorbingMatrix ()
bool	setLatticeReflectingMatrix (int rows, int cols, TMatrix *grid)
bool	isForward ()
bool	isByNumber ()
unsigned int	getDispersalModel ()
double	getPropaguleProb ()
unsigned int	getPropaguleTarget (unsigned int home)
vector< double >	getConnectedPatches (sex_t SEX, unsigned int local_patch)
vector< double >	getConnectedRates (sex_t SEX, unsigned int local_patch)
double	getReducedDispersalRate (sex_t SEX, unsigned int row, unsigned int col)
unsigned int	getReducedDispersalPatchID (sex_t SEX, unsigned int row, unsigned int col)

Protected Attributes
TMatrix	_num_colonizers
	Maximum size of a patch after colonisation. More...
sex_t	_dispersing_sex
	Which part of the population is dispersing its gametes. More...
Individual *(LCE_Breed_Disperse::*	_make_offspring )(sex_t SEX, Patch *patch, unsigned int LocalPatch, gsl_ran_discrete_t *rate_fem, gsl_ran_discrete_t *rate_mal)
unsigned int(LCE_Breed_Disperse::*	_get_numFemOffspring )(Patch *patch)
unsigned int(LCE_Breed_Disperse::*	_get_numMalOffspring )(Patch *patch)
unsigned int(LCE_Breed_Disperse::*	_get_patchFecundity )(Patch *patch, sex_t SEX)
Protected Attributes inherited from LCE_Breed_base
TMatrix	_mean_fecundity
Individual *(LCE_Breed_base::*	MatingFuncPtr )(Patch *, Individual *, unsigned int)
Individual *(LCE_Breed_base::*	DoBreedFuncPtr )(Individual *mother, Individual *father, unsigned int LocalPatch)
double(LCE_Breed_base::*	FecundityFuncPtr )(double mean)
bool(LCE_Breed_base::*	CheckMatingConditionFuncPtr )(Patch *thePatch)
sex_t(LCE_Breed_base::*	GetOffsprgSex )()
void(LCE_Breed_base::*	PopModelFuncPtr )(void)
Protected Attributes inherited from LifeCycleEvent
std::string	_event_name
	The param name to be read in the init file. More...
Metapop *	_popPtr
	The ptr to the current Metapop. More...
std::string	_LCELinkedTraitType
	The name of the linked trait. More...
int	_LCELinkedTraitIndex
	The index in the individual's trait table of the linked trait. More...
Protected Attributes inherited from SimComponent
ParamSet *	_paramSet
	The parameters container. More...
Protected Attributes inherited from LCE_Disperse_base
unsigned int	_npatch
	Number of patches in the population. More...
vector< vector< double > >	_reducedDispMat [2]
	Matrix containing the indexes of the patches connected to each patch. More...
vector< vector< double > >	_reducedDispMatProba [2]
	Matrix containing the probability to migrate to/from the connected patches. More...

Private Attributes
void(LCE_Breed_Disperse::*	_breed_disperse )()
TMatrix	_growthRates
	Patch-specific growth rates. More...
TMatrix	_N_at_T0
	Recorder of original patch sizes used to compute future sizes depending on growth rate model. More...
unsigned int	_T0_exp_growth
	Starting time of the growing phase, can be reset by a parameter update. More...

Detailed Description

Performs breeding and migration in one, migration rates are backward rates.

Inherits parameters from LCE_Breed_base and LCE_Disperse_base. Population size is constant, There is no demographic stochasticity with this LCE. The number of colonizers of extinct patches can be set differently from the patch carrying capacities.

Constructor & Destructor Documentation

LCE_Breed_Disperse()

LCE_Breed_Disperse::LCE_Breed_Disperse

(

)

                                       : LifeCycleEvent("breed_disperse",""),_breed_disperse(0), _T0_exp_growth(0),
_dispersing_sex(FEM), _make_offspring(0), _get_numFemOffspring(0),_get_numMalOffspring(0),_get_patchFecundity(0)
{
  ParamUpdater<LCE_Breed_Disperse>* updater = new ParamUpdater<LCE_Breed_Disperse>(&LCE_Breed_Disperse::setParameters);
  
  LCE_Disperse_base::addParameters("breed_disperse", updater);
  
  add_parameter("breed_disperse_dispersing_sex", STR, false, false, 0, 0, updater);
  add_parameter("breed_disperse_colonizers", INT,false,false,0,0, updater);
  add_parameter("breed_disperse_growth_model", INT, false, true, 1, 8, updater);
  add_parameter("breed_disperse_growth_rate", DBL, false, false, 0, 0, updater);
}

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

Referenced by clone().

Here is the caller graph for this function:

~LCE_Breed_Disperse()

virtual LCE_Breed_Disperse::~LCE_Breed_Disperse ( )

inlinevirtual

{}

Member Function Documentation

addAgeClass()

virtual age_t LCE_Breed_Disperse::addAgeClass ( )

inlinevirtual

Reimplemented from LCE_Disperse_base.

Reimplemented in LCE_Breed_Selection_Disperse.

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

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

clone()

virtual LifeCycleEvent* LCE_Breed_Disperse::clone ( )

inlinevirtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection_Disperse.

{return new LCE_Breed_Disperse();}

References LCE_Breed_Disperse().

conditionalLogisticGrowth()

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

inline

The number of offspring produced depends on the adult density.

A minimum number of offspring is produced when less than half of the carrying capacity of adults is present. It is logistic otherwise.

  {
    if (patch->size(SEX, ADLTx) < patch->get_K(SEX)/2) {
      return fixedFecundityGrowth(patch, SEX);
    } else {
      return logisticGrowth(patch, SEX);
    }
  }

References ADLTx, fixedFecundityGrowth(), Patch::get_K(), logisticGrowth(), and Patch::size().

Referenced by setParameters().

Here is the caller graph for this function:

conditionalStochasticLogisticGrowth()

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

inline

The number of offspring produced depends on the adult density, similar to 'conditionalLogisticGrowth' except that this time, the fecundities are drawn from Poisson distributions.

  {
    if (patch->size(SEX, ADLTx) < patch->get_K(SEX)/2) {
      return stochasticFecundityGrowth(patch, SEX);
    } else {
      return stochasticLogisticGrowth(patch, SEX);
    }
  }

References ADLTx, Patch::get_K(), Patch::size(), stochasticFecundityGrowth(), and stochasticLogisticGrowth().

Referenced by setParameters().

Here is the caller graph for this function:

do_breed_disperse()

void LCE_Breed_Disperse::do_breed_disperse

(

)

{
  Patch* patch;
  unsigned int nfem, nmal;
  
//  cout << endl;
 
  for(unsigned int i = 0; i < _popPtr->getPatchNbr(); i++) {
    
    patch = _popPtr->getPatch(i);
    
    if(patch->size(OFFSx) != 0) patch->flush(OFFSx, _popPtr);
 
    nfem = (this->* _get_numFemOffspring)(patch);
    nmal = (this->* _get_numMalOffspring)(patch);
 
#ifdef _DEBUG_
    cout << ">>> patch "<<i<<" (size="<<patch->size(ADULTS)<<") nfem = "<<nfem<<"; nmal = "<<nmal<<endl;
#endif
    // we want the catch the cases with empty (extinct) patches to avoid hanging time
    if(patch->size(FEM, ADLTx) == 0) {
 
      if(nfem) do_breed_disperse_in_empty_patch(FEM, patch, i, nfem);
      if(nmal) do_breed_disperse_in_empty_patch(MAL, patch, i, nmal);
 
    } else if (patch->size(MAL, ADLTx) == 0 && this->getMatingSystem() == 1) {
 
      if(nfem) do_breed_disperse_in_empty_patch(FEM, patch, i, nfem);
      if(nmal) do_breed_disperse_in_empty_patch(MAL, patch, i, nmal);
 
    } else {
 
      if(nfem) do_breed_disperse_in_patch(FEM, patch, i, nfem);
      if(nmal) do_breed_disperse_in_patch(MAL, patch, i, nmal);
 
    }
  }
}

References _get_numFemOffspring, _get_numMalOffspring, LifeCycleEvent::_popPtr, ADLTx, ADULTS, do_breed_disperse_in_empty_patch(), do_breed_disperse_in_patch(), FEM, Patch::flush(), Metapop::getPatch(), Metapop::getPatchNbr(), MAL, OFFSx, and Patch::size().

Referenced by do_breed_disperse_propagule(), and setParameters().

Here is the caller graph for this function:

do_breed_disperse_in_empty_patch()

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

"males" (dispersing sex matrix)

{
  Individual* newind;
 
//  cout<<"---- do_breed_disperse_in_empty_patch ----\n";
//
//  cout<<"         ---- patch "<<ID<<" ----\n";
  // check that the connected patches are not also empty
  vector<double> disp_rate_connected_fem = LCE_Disperse_base::getConnectedRates(FEM, ID);
  vector<double> disp_rate_connected_mal = LCE_Disperse_base::getConnectedRates(MAL, ID);
 
  // set local patch disp rate (philopatry) to zero, it is empty
//  disp_rate_connected_fem[0] = 0;
//  disp_rate_connected_mal[0] = 0;
 
  double disp_table_fem[disp_rate_connected_fem.size()];
  double disp_table_mal[disp_rate_connected_mal.size()];
 
  unsigned int size, c_size_fem = 0;
  vector< double > connected_patches = LCE_Disperse_base::getConnectedPatches(FEM, ID);
 
//  cout<<"\t - female dispersal:\n";
  // copy vector into table, and count size of connected patches
  for(unsigned int i = 0; i < disp_rate_connected_fem.size(); ++i){
    size = _popPtr->size(FEM, ADLTx, (unsigned int)connected_patches[i]);
    if( size )
      disp_table_fem[i] = disp_rate_connected_fem[i];
    else
      disp_table_fem[i] = 0;
 
//    cout<<"\t > "<<(unsigned int)connected_patches[i]<<": "
//        <<size<<" adlt female ("<<disp_table_fem[i]<<")"<<endl;
 
    c_size_fem += size;
  }
 
  unsigned int c_size_mal = 0;
 
  // use the dispersal matrices for the dispersing sex
  connected_patches = LCE_Disperse_base::getConnectedPatches(_dispersing_sex, ID);
 
//  cout<<"\t - male dispersal:\n";
  // the sex patch size to check depends on the mating system; male for random mating, fem otherwise
  sex_t sex2check = (this->getMatingSystem() == 1 ? MAL : FEM);
 
  for(unsigned int i = 0; i < disp_rate_connected_mal.size(); ++i){
    size = _popPtr->size(sex2check, ADLTx, (unsigned int)connected_patches[i]);
 
    if(size)
      disp_table_mal[i] = disp_rate_connected_mal[i];
    else
      disp_table_mal[i] = 0;
 
//    cout<<"\t > "<<(unsigned int)connected_patches[i]<<": "
//        <<size<<" adlt "<<(sex2check == MAL? "male" :"female")
//        <<"("<<disp_table_mal[i]<<")"<<endl;
 
    c_size_mal += size;
  }
 
//  cout<<"\t - size of connected patch; fem = "<<c_size_fem<<", mal = "<<c_size_mal<<endl;
  // no reproduction can happen if all connected patches are empty as well
  if( c_size_fem == 0 ) return;
 
  // check for the dispersing sex, which is male under random mating
  if( c_size_mal == 0 ) return;
 
  // these allocations are costly but there isn't an easy workaround when the number of connected patches varies dynamically
  gsl_ran_discrete_t* gsltable_fem = gsl_ran_discrete_preproc(disp_rate_connected_fem.size(), disp_table_fem);
  gsl_ran_discrete_t* gsltable_mal = gsl_ran_discrete_preproc(disp_rate_connected_mal.size(), disp_table_mal);
 
//  cout<<"\t  generating "<<num_offsprg<<" offspring:  ";
  for(unsigned int j = 0; j < num_offsprg; j++) {
 
    newind = (this->*_make_offspring)(SEX, patch, ID, gsltable_fem, gsltable_mal);
 
    // it is possible that a null pointer is returned when patches are extinct and no migration is possible
    if(!newind) continue;
 
//    cout<<j+1<<" ";
 
    patch->add(SEX, OFFSx, LCE_Breed_base::makeOffspring( newind ));
    patch->nbKolonisers++;
 
  }
 
//  cout<< "\n\t - num colonizers: "<<patch->nbKolonisers<<endl;
 
  gsl_ran_discrete_free(gsltable_fem);
  gsl_ran_discrete_free(gsltable_mal);
}

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

Referenced by do_breed_disperse().

Here is the caller graph for this function:

do_breed_disperse_in_patch()

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

{
  Individual* newind;
 
  vector<double> disp_rate_connected_fem = LCE_Disperse_base::getConnectedRates(FEM, ID);
  vector<double> disp_rate_connected_mal = LCE_Disperse_base::getConnectedRates(MAL, ID);
 
  double disp_table_fem[disp_rate_connected_fem.size()];
  double disp_table_mal[disp_rate_connected_mal.size()];
 
  for(unsigned int i = 0; i < disp_rate_connected_fem.size(); ++i){
    disp_table_fem[i] = disp_rate_connected_fem[i];
  }
 
  for(unsigned int i = 0; i < disp_rate_connected_mal.size(); ++i){
    disp_table_mal[i] = disp_rate_connected_mal[i];
  }
 
  gsl_ran_discrete_t* gsltable_fem = gsl_ran_discrete_preproc(disp_rate_connected_fem.size(), disp_table_fem);
  gsl_ran_discrete_t* gsltable_mal = gsl_ran_discrete_preproc(disp_rate_connected_mal.size(), disp_table_mal);
 
 
  for(unsigned int j = 0; j < num_offsprg; j++) {
 
    newind = (this->*_make_offspring)(SEX, patch, ID, gsltable_fem, gsltable_mal);
 
    // it is possible that a null pointer is returned when connected patches are extinct and no migration is possible
    if(!newind) continue;
 
    patch->add(SEX, OFFSx, LCE_Breed_base::makeOffspring( newind ));
 
  }
 
  gsl_ran_discrete_free(gsltable_fem);
  gsl_ran_discrete_free(gsltable_mal);
}

References _make_offspring, Patch::add(), FEM, LCE_Disperse_base::getConnectedRates(), LCE_Breed_base::makeOffspring(), MAL, and OFFSx.

Referenced by do_breed_disperse().

Here is the caller graph for this function:

do_breed_disperse_propagule()

void LCE_Breed_Disperse::do_breed_disperse_propagule

(

)

{
  this->setIsland_PropagulePool_Matrix();
  do_breed_disperse();
}

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

Referenced by setParameters().

Here is the caller graph for this function:

execute()

void LCE_Breed_Disperse::execute ( )

virtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection_Disperse.

{
#ifdef _DEBUG_
  message("LCE_Breed_Disperse::execute (Patch nb: %i offsprg nb: %i adlt nb: %i "
          ,_popPtr->getPatchNbr(), _popPtr->size( OFFSPRG ), _popPtr->size( ADULTS ));
#endif
  
  if(_npatch != _popPtr->getPatchNbr()) {
    _npatch = _popPtr->getPatchNbr();
    if(!updateDispMatrix()) fatal("bailing out\n");
  }
  
  LCE_Disperse_base::reset_counters();
  
  (this->*_breed_disperse)();
  
  // swap parents and offspring in WF populations
  if(isWrightFisher()) LCE_Breed_base::doAgingInWFpop();
 
#ifdef _DEBUG_
  unsigned int a = 0, b = 0, c = 0;
  for(unsigned int i = 0; i < _popPtr->getPatchNbr(); i++){
    a += _popPtr->getPatch(i)->nbEmigrant;
    b += _popPtr->getPatch(i)->nbImigrant;
    c += _popPtr->getPatch(i)->nbPhilopat;
  }
  message("immigrate: %f, emigrants: %i, imigrants: %i)\n",(double)b/(b+c), a, b);
#endif
}

References _breed_disperse, LCE_Disperse_base::_npatch, LifeCycleEvent::_popPtr, ADULTS, LCE_Breed_base::doAgingInWFpop(), fatal(), Metapop::getPatch(), Metapop::getPatchNbr(), LCE_Breed_base::isWrightFisher(), message(), Patch::nbEmigrant, Patch::nbImigrant, Patch::nbPhilopat, OFFSPRG, LCE_Disperse_base::reset_counters(), Metapop::size(), and LCE_Disperse_base::updateDispMatrix().

exponentialGrowth()

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

Exponential growth using current patch size as basis to calculate future sizes, set once the function is first called.

{
//  static unsigned int t0 = 0;
  unsigned int idx = patch->getID();
  unsigned int cGen = _popPtr->getCurrentGeneration();
  unsigned int nGen;
  unsigned int N;
 
//  if(t0 == 0) { //mark starting generation of growth model, when first call (in first patch)
//    t0 = cGen; //cGen can be zero
//  }
 
  if(_T0_exp_growth == cGen) { // that means we have just (re)set t0
    _N_at_T0.set(0, idx, patch->size(SEX, ADULTS)); //record initial patch size
  }
 
  // patch grows until K; a growth rate of 0 is interpreted as exponential growth is off
  if(patch->size(SEX, ADULTS) < patch->get_K(SEX) && _growthRates.get(0,idx) != 0) {
 
    nGen = cGen - _T0_exp_growth + 1; //we're calculating the size at time = t+1
 
    N = _N_at_T0.get(0, idx)*exp(_growthRates.get(0,idx)*nGen);
 
  } else {
    N = patch->get_K(SEX);
  }
 
  return N;
}

References _growthRates, _N_at_T0, LifeCycleEvent::_popPtr, _T0_exp_growth, ADULTS, TMatrix::get(), Patch::get_K(), Metapop::getCurrentGeneration(), Patch::getID(), TMatrix::set(), and Patch::size().

Referenced by setParameters().

Here is the caller graph for this function:

fixedFecundityGrowth()

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

inline

The number of offspring produced is equal to the current number of breeders multiplied by the mean fecundity of the focal patch.

  {
    return patch->size(SEX,ADULTS)*LCE_Breed_base::getMeanFecundity(patch->getID());
  }

References ADULTS, Patch::getID(), LCE_Breed_base::getMeanFecundity(), and Patch::size().

Referenced by conditionalLogisticGrowth(), and setParameters().

Here is the caller graph for this function:

get_parent()

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

{
  unsigned int SourcePatch = 0;
  Patch* src_patch;
 
  //first check if individuals are available in other patches:
  if(local_patch->size(SEX, ADLTx) == _popPtr->size(SEX, ADLTx)) {
    
    //other patches are empty, force philopatry:
    SourcePatch = LocalPatch;
    src_patch = local_patch;
    
  } else  {
 
    // find immigrants from the connected patches
 
    unsigned int index;
 
    do {
 
      index = getMigrationIndexGSLdiscrete(rates);
 
      SourcePatch = LCE_Disperse_base::getReducedDispersalPatchID(DispSex, LocalPatch, index);
 
      src_patch = _popPtr->getPatchPtr(SourcePatch);  // checked version of getPatch, safe to use if SourcePatch if outside range
 
    } while (src_patch->size( SEX, ADLTx ) == 0);
 
  }
 
  //set migrant counters for the stats
  if(LocalPatch != SourcePatch) {
    src_patch->nbEmigrant++;
    
    if( local_patch->size(ADLTx) != 0 ) // only count immigrants, not colonizers
      local_patch->nbImigrant++;
    
  } else
    src_patch->nbPhilopat++;
  
  //return a pointer to an individual randomly chosen from the source patch:
  return src_patch->get(SEX, ADLTx, RAND::Uniform( src_patch->size( SEX, ADLTx ) ) );
}

References LifeCycleEvent::_popPtr, ADLTx, Patch::get(), LCE_Disperse_base::getMigrationIndexGSLdiscrete(), Metapop::getPatchPtr(), LCE_Disperse_base::getReducedDispersalPatchID(), Patch::nbEmigrant, Patch::nbImigrant, Patch::nbPhilopat, Metapop::size(), Patch::size(), and RAND::Uniform().

Referenced by mate_cloning(), mate_full_selfing(), mate_random(), mate_random_hermaphrodite(), and mate_selfing().

Here is the caller graph for this function:

instantGrowth()

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

inline

The number of offspring produced corresponds to the carrying capacity of the patch.

  {
    return patch->get_K(SEX);
  }

References Patch::get_K().

Referenced by setParameters().

Here is the caller graph for this function:

loadFileServices()

virtual void LCE_Breed_Disperse::loadFileServices ( FileServices *  loader )

inlinevirtual

Reimplemented from LCE_Disperse_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{}

loadStatServices()

virtual void LCE_Breed_Disperse::loadStatServices ( StatServices *  loader )

inlinevirtual

Reimplemented from LCE_Disperse_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{}

logisticGrowth()

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

inline

The number of offspring produced is given by the logistic growth function.

  {
    double K = (double)patch->get_K(SEX);
    double r = _growthRates.get(0, patch->getID());
    double N = (double)patch->size(ADLTx);
    if( K <= N )
      return K;
    else
      return (unsigned int)ceil(N + r*N*((K-N)/K));
  }

References _growthRates, ADLTx, TMatrix::get(), Patch::get_K(), Patch::getID(), and Patch::size().

Referenced by conditionalLogisticGrowth(), setParameters(), and stochasticLogisticGrowth().

Here is the caller graph for this function:

makeOffspring()

Individual* LCE_Breed_Disperse::makeOffspring

(

Individual *

ind

)

mate_cloning()

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

{
  Individual *mom = get_parent(FEM, FEM, patch, LocalPatch, rate_fem);
 
  if(!mom) return NULL;
 
  return LCE_Breed_base::breed_cloning(mom, mom, LocalPatch);
}

References LCE_Breed_base::breed_cloning(), FEM, and get_parent().

Referenced by setParameters().

Here is the caller graph for this function:

mate_full_selfing()

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

{
  Individual *mom = get_parent(FEM, FEM, patch, LocalPatch, rate_fem);
 
  if(!mom) return NULL;
  
  return _popPtr->makeNewIndividual(mom, mom, FEM, LocalPatch);
}

References LifeCycleEvent::_popPtr, FEM, get_parent(), and IndFactory::makeNewIndividual().

Referenced by setParameters().

Here is the caller graph for this function:

mate_random()

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

{
  Individual* p1 = get_parent(FEM, FEM, patch, LocalPatch, rate_fem);
  Individual* p2 = get_parent(MAL, MAL, patch, LocalPatch, rate_mal);
 
  if(! (p1 && p2)) return NULL;
 
  return _popPtr->makeNewIndividual(p1, p2, SEX, LocalPatch);
}

References LifeCycleEvent::_popPtr, FEM, get_parent(), IndFactory::makeNewIndividual(), and MAL.

Referenced by setParameters().

Here is the caller graph for this function:

mate_random_hermaphrodite()

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

{
  Individual* p1 = get_parent(FEM, FEM, patch, LocalPatch, rate_fem);
  Individual* p2 = get_parent(FEM, _dispersing_sex, patch, LocalPatch,
                                (_dispersing_sex == MAL ? rate_mal : rate_fem));
 
  if(! (p1 && p2)) return NULL;
 
  return _popPtr->makeNewIndividual(p1, p2, FEM, LocalPatch);
}

References _dispersing_sex, LifeCycleEvent::_popPtr, FEM, get_parent(), IndFactory::makeNewIndividual(), and MAL.

Referenced by setParameters().

Here is the caller graph for this function:

mate_selfing()

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

{
  Individual *mom, *dad;
  //  cout << "--- choosing mum in patch "<<LocalPatch<<" ("<<patch->size(FEM, ADLTx)<<")\n";
  mom = get_parent(FEM, FEM, patch, LocalPatch, rate_fem);
  
  //  cout << "--- choosing dad \n";
  
  if( RAND::Uniform() > this->getMatingProportion() ) {
    //random mating
    do{
      dad = get_parent(FEM, _dispersing_sex, patch, LocalPatch,
          (_dispersing_sex == MAL ? rate_mal : rate_fem));
    }while(dad == mom && _popPtr->getPatchNbr() != 1 && patch->size(FEM, ADLTx) > 1);
  } else
    dad = mom;
  
  //  cout << "--- make offspring by crossing "<<mom->getID()<<" with "<<dad->getID()<<endl;
  
  if(! (mom && dad)) return NULL;
  
  return _popPtr->makeNewIndividual(mom, dad, FEM, LocalPatch);
}

References _dispersing_sex, LifeCycleEvent::_popPtr, ADLTx, FEM, get_parent(), LCE_Breed_base::getMatingProportion(), Metapop::getPatchNbr(), IndFactory::makeNewIndividual(), MAL, Patch::size(), and RAND::Uniform().

Referenced by setParameters().

Here is the caller graph for this function:

numFemOffspring()

unsigned int LCE_Breed_Disperse::numFemOffspring ( Patch *  patch )

inline

  {
//    if (patch->size(FEM, ADLTx) == 0 && _dispersing_sex != FEM)//to avoid choosing a local female when there is none
//      return 0;
//    else
      return (this->*_get_patchFecundity)(patch, FEM);
  }

References _get_patchFecundity, and FEM.

Referenced by setParameters().

Here is the caller graph for this function:

numFemOffspring_colonizers()

unsigned int LCE_Breed_Disperse::numFemOffspring_colonizers ( Patch *  patch )

inline

The number of females produced in case a max number of colonizers was specified.

  {
    if(patch->isEmpty()) {
//      //check if only one sex sends gametes around, capturing the case of pollen dispersal
//      if(_dispersing_sex != FEM)
//        return 0;
//      else
 
      return _num_colonizers.get(1, patch->getID()); // Females on second row
 
    } else
      return (this->*_get_patchFecundity)(patch, FEM);
  }

References _get_patchFecundity, _num_colonizers, FEM, TMatrix::get(), Patch::getID(), and Patch::isEmpty().

Referenced by setParameters().

Here is the caller graph for this function:

numMalOffspring_notrandom()

unsigned int LCE_Breed_Disperse::numMalOffspring_notrandom ( Patch *  patch )

inline

The number of males produced is always zero when the mating system is not random mating.

  {
    return 0;
  }

Referenced by setParameters().

Here is the caller graph for this function:

numMalOffspring_random()

unsigned int LCE_Breed_Disperse::numMalOffspring_random ( Patch *  patch )

inline

  { //return 0 if only males gametes migrate and there is no females in the patch
    //to avoid choosing a local female when there is none
    //(we assume it doesn't make sense to have only female gametes migrating)
//    if (patch->size(FEM, ADLTx) == 0 && _dispersing_sex != FEM)
//      return 0;
//    else
      return (this->*_get_patchFecundity)(patch, MAL);
  }

References _get_patchFecundity, and MAL.

Referenced by setParameters().

Here is the caller graph for this function:

numMalOffspring_random_colonizers()

unsigned int LCE_Breed_Disperse::numMalOffspring_random_colonizers ( Patch *  patch )

inline

  {
    if(patch->isEmpty()) {
//      //check if only one sex sends gametes around, capturing the case of pollen dispersal
//      if(_dispersing_sex != FEM)
//        return 0;
//      else
        return _num_colonizers.get(0, patch->getID()); // Males on first row
    } else
      return (this->*_get_patchFecundity)(patch, MAL);
  }

References _get_patchFecundity, _num_colonizers, TMatrix::get(), Patch::getID(), Patch::isEmpty(), and MAL.

Referenced by setParameters().

Here is the caller graph for this function:

removeAgeClass()

virtual age_t LCE_Breed_Disperse::removeAgeClass ( )

inlinevirtual

Reimplemented from LCE_Disperse_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{return NONE;}

References NONE.

requiredAgeClass()

virtual age_t LCE_Breed_Disperse::requiredAgeClass ( )

inlinevirtual

Reimplemented from LCE_Disperse_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{return ADULTS;}

References ADULTS.

resetParameterFromSource()

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

inlinevirtual

Reimplemented from LCE_Disperse_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{return false;}

setParameters()

bool LCE_Breed_Disperse::setParameters ( )

virtual

Reimplemented from LCE_Breed_base.

Reimplemented in LCE_Breed_Selection_Disperse.

{
  if(!LCE_Breed_base::setParameters()) return false;
  
  LCE_Disperse_base::set_isForward(false);
  
  if(!LCE_Disperse_base::setBaseParameters("breed_disperse")) return false;
  
  if(get_parameter("breed_disperse_colonizers")->isSet()) {
    if(get_parameter("breed_disperse_colonizers")->isMatrix()) {
 
      TMatrix tmp;
 
      get_parameter("breed_disperse_colonizers")->getMatrix(&tmp);
 
      if(tmp.nrows() > 2)
        return error("breed_disperse_colonizers::matrix should have at most two rows, one for each sex\n");
 
      if(tmp.ncols() > _npatch)
        return error("breed_disperse_colonizers::matrix or array can have at most as many columns (elements) as the number of patches\n");
 
      // always fill a 2 x num_patch matrix, even if only one sex
      // (see numFemOffspring_colonizers())
      _num_colonizers.reset(2, _npatch);
 
      _num_colonizers.copy_recycle(tmp);
 
    } else {
      // not a matrix, copy single value to default 2 x num patch matrix
      _num_colonizers.reset(2, _npatch, get_parameter_value("breed_disperse_colonizers"));
 
    }
 
  } else {
    _num_colonizers.reset();
 
  }
  //some default settings, reset below depending on mating system
  _get_numFemOffspring = (_num_colonizers.length() == 0 ?
                          &LCE_Breed_Disperse::numFemOffspring : 
                          &LCE_Breed_Disperse::numFemOffspring_colonizers);
  _get_numMalOffspring = &LCE_Breed_Disperse::numMalOffspring_notrandom;
  
  if(get_parameter("breed_disperse_dispersing_sex")->isSet()) {
    
    if (get_parameter("breed_disperse_dispersing_sex")->getArg() == "female") {
      _dispersing_sex = FEM;
    } else if (get_parameter("breed_disperse_dispersing_sex")->getArg() == "male") {
      _dispersing_sex = MAL;
    } else {
      error("the \"breed_disperse_dispersing_sex\" parameter only takes \"female\" or \"male\" as argument\n");
    }
    
  } else { //default depends on mating system
    // males are the dispersing sex for random mating, female dispersal is always checked, male dispersal is optional
    if(this->getMatingSystem() == 1)
      _dispersing_sex = MAL;
    else // all others use females only, since monogamy and polygyny are not allowed here
      _dispersing_sex = FEM;
  }
  
  //check mating system:  
  unsigned int model = this->getMatingSystem();
  
  if(model == 2 || model == 3) {
  
    return error("Polygyny and Monogamy are not implemented within the breed_disperse LCE.\n");
 
  } else if(model == 1) { //promiscuity/random mating
    
    _make_offspring = &LCE_Breed_Disperse::mate_random;
    
    _get_numMalOffspring = (_num_colonizers.length() == 0 ?
                            &LCE_Breed_Disperse::numMalOffspring_random : 
                            &LCE_Breed_Disperse::numMalOffspring_random_colonizers);
    
  } else if(model == 4) { //selfing
    
    if(this->getMatingProportion() != 1)
      _make_offspring = &LCE_Breed_Disperse::mate_selfing;
    else
      _make_offspring = &LCE_Breed_Disperse::mate_full_selfing;
  
  } else if(model == 5) { //cloning
  
    _make_offspring = &LCE_Breed_Disperse::mate_cloning;
  
  } else if(model == 6) { //random mating among hermaphrodites (selfing = 1/N)
   
    _make_offspring = &LCE_Breed_Disperse::mate_random_hermaphrodite;
 
  }
  
  //check dispersal model:
  model = this->getDispersalModel();
  
  if(model == 2) //propagule-pool island model
    _breed_disperse = &LCE_Breed_Disperse::do_breed_disperse_propagule;
  else
    _breed_disperse = &LCE_Breed_Disperse::do_breed_disperse;
  
  //growth model
  if(_paramSet->isSet("breed_disperse_growth_model"))
    model = get_parameter_value("breed_disperse_growth_model");
  else 
    model = 1;
  
  switch (model) {
    case 1:
      _get_patchFecundity = &LCE_Breed_Disperse::instantGrowth;
      break;
    case 2:
      _get_patchFecundity = &LCE_Breed_Disperse::logisticGrowth;
      break;
    case 3:
      _get_patchFecundity = &LCE_Breed_Disperse::stochasticLogisticGrowth;
      break;
    case 4:
      _get_patchFecundity = &LCE_Breed_Disperse::conditionalLogisticGrowth;
      break;
    case 5:
      _get_patchFecundity = &LCE_Breed_Disperse::conditionalStochasticLogisticGrowth;
      break;
    case 6:
      _get_patchFecundity = &LCE_Breed_Disperse::fixedFecundityGrowth;
      break;
    case 7:
      _get_patchFecundity = &LCE_Breed_Disperse::stochasticFecundityGrowth;
      break;
    case 8:
      _get_patchFecundity = &LCE_Breed_Disperse::exponentialGrowth;
      break;
    default:
      _get_patchFecundity = &LCE_Breed_Disperse::instantGrowth;
      break;
  }
  //mean fecundity
  if(_mean_fecundity.get(0,0) == -1) //wasn't set
    if(model > 3 && model < 8) //4 - 7: conditional logistic growth, fecundity growth
      return error("parameter \"mean_fecundity\" is needed with growth models 4 to 7 in LCE breed_disperse\n");
 
  //growth rate ---------------------------------------------------------------
 
  _growthRates.reset();
 
  if ((model > 1 && model < 6) || model == 8) {
    
    if(!_paramSet->isSet("breed_disperse_growth_rate")) {
    
      return error("parameter \"breed_disperse_growth_rate\" needs to be set\n");
 
    }
    
    _growthRates.reset(1, _popPtr->getPatchNbr() );
    
    if(_paramSet->isMatrix("breed_disperse_growth_rate")) {
      
      TMatrix tmp;
      
      _paramSet->getMatrix("breed_disperse_growth_rate", &tmp);
      
      if(tmp.ncols() > _popPtr->getPatchNbr()){
        return error("breed_disperse_growth_rate::number of elements in array must be < or = to the number of patches.\n");
      }
      
      _growthRates.copy_recycle(tmp);
      
    } else { //not a matrix
      
      _growthRates.set_row(0, get_parameter_value("breed_disperse_growth_rate"));
      
    }
    
    if(model == 8) { //exponential growth
      // reset counters
      _N_at_T0.reset(1, _popPtr->getPatchNbr());
      _T0_exp_growth = _popPtr->getCurrentGeneration();
    }
  }
  
  return true;
}

References _breed_disperse, _dispersing_sex, _get_numFemOffspring, _get_numMalOffspring, _get_patchFecundity, _growthRates, _make_offspring, LCE_Breed_base::_mean_fecundity, _N_at_T0, LCE_Disperse_base::_npatch, _num_colonizers, SimComponent::_paramSet, LifeCycleEvent::_popPtr, _T0_exp_growth, conditionalLogisticGrowth(), conditionalStochasticLogisticGrowth(), TMatrix::copy_recycle(), do_breed_disperse(), do_breed_disperse_propagule(), error(), exponentialGrowth(), FEM, fixedFecundityGrowth(), TMatrix::get(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), Param::getArg(), Metapop::getCurrentGeneration(), LCE_Disperse_base::getDispersalModel(), LCE_Breed_base::getMatingProportion(), LCE_Breed_base::getMatingSystem(), ParamSet::getMatrix(), Param::getMatrix(), Metapop::getPatchNbr(), instantGrowth(), ParamSet::isMatrix(), Param::isSet(), ParamSet::isSet(), TMatrix::length(), logisticGrowth(), MAL, mate_cloning(), mate_full_selfing(), mate_random(), mate_random_hermaphrodite(), mate_selfing(), TMatrix::ncols(), TMatrix::nrows(), numFemOffspring(), numFemOffspring_colonizers(), numMalOffspring_notrandom(), numMalOffspring_random(), numMalOffspring_random_colonizers(), TMatrix::reset(), LCE_Disperse_base::set_isForward(), TMatrix::set_row(), LCE_Disperse_base::setBaseParameters(), LCE_Breed_base::setParameters(), stochasticFecundityGrowth(), and stochasticLogisticGrowth().

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

Here is the caller graph for this function:

stochasticFecundityGrowth()

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

inline

The number of offspring produced is a random number drawn from a Poisson distribution with mean equal to the current number of breeders multiplied by the mean fecundity of the focal patch.

  {
    return RAND::Uniform(patch->size(SEX,ADULTS)*LCE_Breed_base::getMeanFecundity(patch->getID()));
  }

References ADULTS, Patch::getID(), LCE_Breed_base::getMeanFecundity(), Patch::size(), and RAND::Uniform().

Referenced by conditionalStochasticLogisticGrowth(), and setParameters().

Here is the caller graph for this function:

stochasticLogisticGrowth()

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

inline

The number of offspring produced is drawn from a Poisson with mean equal to the logistic growth predicate.

  {
    return (unsigned int)RAND::Poisson((double)logisticGrowth(patch, SEX));
  }

References logisticGrowth(), and RAND::Poisson().

Referenced by conditionalStochasticLogisticGrowth(), and setParameters().

Here is the caller graph for this function:

Member Data Documentation

_breed_disperse

void(LCE_Breed_Disperse::* LCE_Breed_Disperse::_breed_disperse) ()

private

Referenced by execute(), and setParameters().

_dispersing_sex

sex_t LCE_Breed_Disperse::_dispersing_sex

protected

Which part of the population is dispersing its gametes.

Referenced by LCE_Breed_Selection_Disperse::do_breed(), do_breed_disperse_in_empty_patch(), mate_random_hermaphrodite(), mate_selfing(), and setParameters().

_get_numFemOffspring

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

protected

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

_get_numMalOffspring

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

protected

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

_get_patchFecundity

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

protected

Referenced by numFemOffspring(), numFemOffspring_colonizers(), numMalOffspring_random(), numMalOffspring_random_colonizers(), and setParameters().

_growthRates

TMatrix LCE_Breed_Disperse::_growthRates

private

Patch-specific growth rates.

Referenced by exponentialGrowth(), logisticGrowth(), and setParameters().

_make_offspring

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

protected

Referenced by LCE_Breed_Selection_Disperse::do_breed(), do_breed_disperse_in_empty_patch(), do_breed_disperse_in_patch(), and setParameters().

_N_at_T0

TMatrix LCE_Breed_Disperse::_N_at_T0

private

Recorder of original patch sizes used to compute future sizes depending on growth rate model.

Referenced by exponentialGrowth(), and setParameters().

_num_colonizers

TMatrix LCE_Breed_Disperse::_num_colonizers

protected

Maximum size of a patch after colonisation.

Referenced by numFemOffspring_colonizers(), numMalOffspring_random_colonizers(), and setParameters().

_T0_exp_growth

unsigned int LCE_Breed_Disperse::_T0_exp_growth

private

Starting time of the growing phase, can be reset by a parameter update.

Referenced by exponentialGrowth(), and setParameters().

---

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

• LCEcomposite.h
• LCEcomposite.cc