LCE_Disperse_base Class Reference

The base class of the dispersal LCEs, all events move offspring to the post-dispersal patch containers. More...

#include <LCEdisperse.h>

Inheritance diagram for LCE_Disperse_base:

Collaboration diagram for LCE_Disperse_base:

Public Member Functions
	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 ()
Dispersal Matrix
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)
Accessors
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)
Implementations
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 ()
virtual void	execute ()=0
	Execute the event on the pop. More...
virtual LifeCycleEvent *	clone ()=0
	Cloning interface. More...
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 bool	setParameters ()=0
	Default interface needed to initialize the component's variables from its input parameters value. More...
virtual void	set_paramset (ParamSet *paramset)
	Sets the ParamSet member. More...
virtual void	set_paramsetFromCopy (const ParamSet &PSet)
	Reset the set of parameters from a another set. More...
virtual ParamSet *	get_paramset ()
	ParamSet accessor. More...
virtual void	add_parameter (Param *param)
	Interface to add a parameter to the set. More...
virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd)
	Interface to add a parameter to the set. More...
virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd, ParamUpdaterBase *updater)
	Interface to add a parameter and its updater to the set. More...
virtual Param *	get_parameter (std::string name)
	Param getter. More...
virtual double	get_parameter_value (std::string name)
	Param value getter. More...
virtual string	get_name ()
	Returnd the name of the ParamSet, i.e. More...
virtual bool	has_parameter (std::string name)
	Param getter. More...

Protected Attributes
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...
Protected Attributes inherited from LifeCycleEvent
std::string	_event_name
	The param name to be read in the init file. More...
Metapop *	_popPtr
	The ptr to the current Metapop. More...
std::string	_LCELinkedTraitType
	The name of the linked trait. More...
int	_LCELinkedTraitIndex
	The index in the individual's trait table of the linked trait. More...
Protected Attributes inherited from SimComponent
ParamSet *	_paramSet
	The parameters container. More...

Private Attributes
int	_disp_model
double	_disp_propagule_prob
vector< unsigned int >	_PropaguleTargets
double	_fem_rate
double	_mal_rate
bool	_isForward
bool	_isByNumber
TMatrix *	_DispMatrix [2]
	The sex-specific dispersal matrices, [0] for males, [1] for females, might be used as connectivity matrix as well. More...
string	_prefix
	Parameter name prefix (dispersal, seed_disp, breed_disp, etc.) More...

Friends
class	LCE_Disperse_ConstDisp
class	LCE_Disperse_EvolDisp

Detailed Description

The base class of the dispersal LCEs, all events move offspring to the post-dispersal patch containers.

Stores the dispersal matrices and dispersal model parameters and interface.

Constructor & Destructor Documentation

LCE_Disperse_base()

LCE_Disperse_base::LCE_Disperse_base

(

)

: LifeCycleEvent("", ""), _disp_model(-1), _disp_propagule_prob(-1.0), _PropaguleTargets()
, _fem_rate (-1), _mal_rate(-1), _isForward(1), _isByNumber(0), _npatch(0)
{
  _DispMatrix[0] = NULL;
  _DispMatrix[1] = NULL;
}

References _DispMatrix.

~LCE_Disperse_base()

LCE_Disperse_base::~LCE_Disperse_base ( )

virtual

Deallocates the disp matrix.

{
  if(NULL != _DispMatrix[0])
    delete _DispMatrix[0];
 
  if(NULL != _DispMatrix[1])
    delete _DispMatrix[1];
}

References _DispMatrix.

Member Function Documentation

addAgeClass()

virtual age_t LCE_Disperse_base::addAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Disperse.

{return NONE;}

References NONE.

addParameters()

void LCE_Disperse_base::addParameters	(	string	prefix,
		ParamUpdaterBase *	updater
	)

{
  add_parameter(prefix + "_model",INT,false,true,1,4,updater);
  add_parameter(prefix + "_border_model",INT,false,true,1,3,updater);
  add_parameter(prefix + "_lattice_range",INT,false,true,1,2,updater);
  add_parameter(prefix + "_lattice_rows",INT,false,false,0,0,updater);
  add_parameter(prefix + "_lattice_columns",INT,false,false,0,0,updater);
  add_parameter(prefix + "_propagule_prob",DBL,false,true,0,1,updater);
  add_parameter(prefix + "_matrix",MAT,false,false,0,0,updater);
  add_parameter(prefix + "_matrix_fem",STR,false,false,0,0,updater);
  add_parameter(prefix + "_matrix_mal",STR,false,false,0,0,updater);
  add_parameter(prefix + "_rate",DBL,false,true,0,1,updater);
  add_parameter(prefix + "_rate_fem",DBL,false,true,0,1,updater);
  add_parameter(prefix + "_rate_mal",DBL,false,true,0,1,updater);
  add_parameter(prefix + "_connectivity_matrix",MAT,false,false,0,0,updater);
  add_parameter(prefix + "_reduced_matrix",MAT,false,false,0,0,updater);
  add_parameter(prefix + "_connectivity_matrix_fem",MAT,false,false,0,0,updater);
  add_parameter(prefix + "_connectivity_matrix_mal",MAT,false,false,0,0,updater);
  add_parameter(prefix + "_reduced_matrix_fem",MAT,false,false,0,0,updater);
  add_parameter(prefix + "_reduced_matrix_mal",MAT,false,false,0,0,updater);
 
  add_parameter(prefix + "_by_number", BOOL,false,false,0,0,0);
}

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

Referenced by LCE_Breed_Disperse::LCE_Breed_Disperse(), LCE_Disperse_ConstDisp::LCE_Disperse_ConstDisp(), LCE_Disperse_EvolDisp::LCE_Disperse_EvolDisp(), and LCE_SeedDisp::LCE_SeedDisp().

allocateDispMatrix()

void LCE_Disperse_base::allocateDispMatrix	(	sex_t	sex,
		unsigned int	dim
	)

{
  if(_DispMatrix[sex] != NULL)
    _DispMatrix[sex]->reset(dim,dim);
  else
    _DispMatrix[sex] = new TMatrix(dim,dim);
}

References _DispMatrix, and TMatrix::reset().

Referenced by setIsland_MigrantPool_Matrix(), setIsland_PropagulePool_Matrix(), setLatticeMatrix(), and setSteppingStone1DMatrix().

checkBackwardDispersalMatrix()

bool LCE_Disperse_base::checkBackwardDispersalMatrix

(

TMatrix *

mat

)

{
  double cntr;
 
  for(unsigned int i = 0; i < mat->getNbCols(); ++i) {
    cntr = 0;
    for(unsigned int j = 0; j < mat->getNbRows(); ++j) {
 
      if(mat->get(i,j) < 0 )
       return error("elements of the dispersal matrix cannot be negative (row %i, column %i)!\n", i, j);
 
      cntr += mat->get(j,i);
    }
 
    if(cntr < 0.999999 || cntr > 1.000001) {
      error("The elements of column %i of the dispersal matrix do not sum to 1!\n",i+1);
      error("sum of row %i is: %f\n",i+1, cntr);
      return false;
    }
  }
  return true;
}

References error(), TMatrix::get(), TMatrix::getNbCols(), and TMatrix::getNbRows().

Referenced by setBaseParameters(), and setDispMatrix().

checkForwardDispersalMatrix()

bool LCE_Disperse_base::checkForwardDispersalMatrix

(

TMatrix *

mat

)

{
  double cntr;
 
  for(unsigned int i = 0; i < mat->getNbRows(); ++i) {
    cntr = 0;
    for(unsigned int j = 0; j < mat->getNbCols(); ++j) {
 
      if(mat->get(i,j) < 0 )
       return error("elements of the dispersal matrix cannot be negative (row %i, column %i)!\n", i, j);
 
      cntr += mat->get(i,j);
    }
    if(cntr < 0.999999 || cntr > 1.000001) {
      error("the elements of row %i of the dispersal matrix do not sum to 1!\n",i+1);
      error("sum of row %i is: %f\n",i+1, cntr);
      return false;
    }
  }
  return true;
}

References error(), TMatrix::get(), TMatrix::getNbCols(), and TMatrix::getNbRows().

Referenced by setBaseParameters(), and setDispMatrix().

getConnectedPatches()

vector< double > LCE_Disperse_base::getConnectedPatches	(	sex_t	SEX,
		unsigned int	local_patch
	)

{
//  vector<double> cpatches = _reducedDispMat[SEX][local_patch];
//
//  cpatches.erase(cpatches.begin());
 
  return _reducedDispMat[SEX][local_patch];
}

References _reducedDispMat.

Referenced by LCE_Breed_Selection_Disperse::do_breed(), and LCE_Breed_Disperse::do_breed_disperse_in_empty_patch().

getConnectedRates()

vector< double > LCE_Disperse_base::getConnectedRates	(	sex_t	SEX,
		unsigned int	local_patch
	)

{
//  vector<double> cpatches = _reducedDispMatProba[SEX][local_patch];
 
//  cpatches.erase(cpatches.begin());
 
  return _reducedDispMatProba[SEX][local_patch];
}

References _reducedDispMatProba.

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

getDispersalModel()

unsigned int LCE_Disperse_base::getDispersalModel ( )

inline

{return _disp_model;}

References _disp_model.

Referenced by LCE_Disperse_EvolDisp::execute(), setDispMatrix(), LCE_Breed_Disperse::setParameters(), LCE_Breed_Selection_Disperse::setParameters(), LCE_Disperse_EvolDisp::setParameters(), LCE_Disperse_ConstDisp::setParameters(), and updateDispMatrix().

getMigrationIndex()

unsigned int LCE_Disperse_base::getMigrationIndex

(

vector< double > &

rates

)

{
  double sum = 0, random = RAND::Uniform();
  unsigned int SourcePatch = 0;
 
  if(random > 0.999999) random = 0.999999;//this to avoid overflows when random == 1
 
  sum = rates[SourcePatch];
 
  while (random > sum) {
    SourcePatch++;
    sum += rates[SourcePatch];
  }
 
  return SourcePatch;
}

References RAND::Uniform().

getMigrationIndexGSLdiscrete()

unsigned int LCE_Disperse_base::getMigrationIndexGSLdiscrete

(

gsl_ran_discrete_t *

rates

)

{
  return RAND::Discrete(rates);
}

References RAND::Discrete().

Referenced by LCE_Breed_Disperse::get_parent().

getMigrationPatchBackward()

unsigned int LCE_Disperse_base::getMigrationPatchBackward	(	sex_t	SEX,
		unsigned int	LocalPatch
	)

{
  double sum = 0, random = RAND::Uniform();
  unsigned int SourcePatch = 0;
 
  if(random > 0.999999) random = 0.999999;//this to avoid overflows when random == 1
 
  sum = _reducedDispMatProba[SEX][LocalPatch][SourcePatch];
 
  while (random > sum) {
    SourcePatch++;
    sum += _reducedDispMatProba[SEX][LocalPatch][SourcePatch];
  }
 
  return _reducedDispMat[SEX][LocalPatch][SourcePatch];
}

References _reducedDispMat, _reducedDispMatProba, and RAND::Uniform().

getMigrationPatchForward()

unsigned int LCE_Disperse_base::getMigrationPatchForward	(	sex_t	SEX,
		unsigned int	LocalPatch
	)

{
  double sum = 0, random = RAND::Uniform();
  unsigned int AimedPatch = 0;
 
  if(random > 0.999999) random = 0.999999;//this to avoid overflows when random == 1
 
  sum = _reducedDispMatProba[SEX][LocalPatch][AimedPatch];
 
  while (random > sum) {
    AimedPatch++;
    sum += _reducedDispMatProba[SEX][LocalPatch][AimedPatch];
  }
 
  //return the patch ID stored in the connectivity matrix:
  return _reducedDispMat[SEX][LocalPatch][AimedPatch];
}

References _reducedDispMat, _reducedDispMatProba, and RAND::Uniform().

Referenced by LCE_Disperse_ConstDisp::MigratePatch(), and LCE_Disperse_ConstDisp::MigratePatch_AbsorbingBorder().

getPropaguleProb()

double LCE_Disperse_base::getPropaguleProb ( )

inline

{return _disp_propagule_prob;}

References _disp_propagule_prob.

Referenced by LCE_Disperse_EvolDisp::Migrate_Island_Propagule(), and setIsland_PropagulePool_Matrix().

getPropaguleTarget()

unsigned int LCE_Disperse_base::getPropaguleTarget ( unsigned int  home )

inline

{return _PropaguleTargets[home];}

References _PropaguleTargets.

Referenced by LCE_Disperse_EvolDisp::Migrate_Island_Propagule(), and setIsland_PropagulePool_Matrix().

getReducedDispersalPatchID()

unsigned int LCE_Disperse_base::getReducedDispersalPatchID	(	sex_t	SEX,
		unsigned int	row,
		unsigned int	col
	)

{
  if(col < _reducedDispMat[SEX][row].size())
    return _reducedDispMat[SEX][row][col];
  else
    return -1;
}

References _reducedDispMat.

Referenced by LCE_Breed_Disperse::get_parent().

getReducedDispersalRate()

double LCE_Disperse_base::getReducedDispersalRate	(	sex_t	SEX,
		unsigned int	row,
		unsigned int	col
	)

{
  if(col < _reducedDispMatProba[SEX][row].size())
    return _reducedDispMatProba[SEX][row][col];
  else
    return -1.0;
}

References _reducedDispMatProba.

isByNumber()

bool LCE_Disperse_base::isByNumber ( )

inline

{return _isByNumber;}

References _isByNumber.

Referenced by LCE_Disperse_ConstDisp::setParameters().

isForward()

bool LCE_Disperse_base::isForward ( )

inline

{return _isForward;}

References _isForward.

loadFileServices()

virtual void LCE_Disperse_base::loadFileServices ( FileServices *  loader )

inlinevirtual

Implements SimComponent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Disperse.

{}

loadStatServices()

virtual void LCE_Disperse_base::loadStatServices ( StatServices *  loader )

inlinevirtual

Implements SimComponent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Disperse.

{}

removeAgeClass()

virtual age_t LCE_Disperse_base::removeAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Disperse.

{return NONE;}

References NONE.

requiredAgeClass()

virtual age_t LCE_Disperse_base::requiredAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Disperse.

{return OFFSPRG;}

References OFFSPRG.

reset_counters()

void LCE_Disperse_base::reset_counters

(

)

{
  Patch *patch;
  for(unsigned int i = 0; i < _npatch; i++) {
 
    patch = _popPtr->getPatch(i);
 
    patch->reset_counters();
 
    patch->flush(PDISPx, _popPtr);
  }
}

References _npatch, LifeCycleEvent::_popPtr, Patch::flush(), Metapop::getPatch(), PDISPx, and Patch::reset_counters().

Referenced by LCE_Breed_Disperse::execute(), LCE_Breed_Selection_Disperse::execute(), LCE_Disperse_ConstDisp::execute(), and LCE_Disperse_EvolDisp::execute().

resetParameterFromSource()

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

inlinevirtual

Implements SimComponent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Disperse.

{return false;}

set_isForward()

void LCE_Disperse_base::set_isForward ( bool  val )

inline

{_isForward = val;}

References _isForward.

Referenced by LCE_Breed_Disperse::setParameters().

setBaseParameters()

bool LCE_Disperse_base::setBaseParameters

(

string

prefix

)

{
  _prefix = prefix;
 
  _npatch = _popPtr->getPatchNbr();
 
  _disp_model = (int)_paramSet->getValue(prefix + "_model");
 
  _disp_propagule_prob = _paramSet->getValue(prefix + "_propagule_prob");
 
  if(get_parameter(prefix + "_by_number")->isSet())
    _isByNumber = true;
  else
    _isByNumber = false;
 
  // SET MATRICES FROM INPUT MODELS --------------------------------------------------------
 
  if(_DispMatrix[0]) delete _DispMatrix[0];
  _DispMatrix[0] = NULL;
 
  if(_DispMatrix[1]) delete _DispMatrix[1];
  _DispMatrix[1] = NULL;
 
  //skip this if there is only one patch
//  if(_npatch == 1) {
//    warning("not setting the dispersal LCE whith only one patch in the population\n");
//    return false;
//  }
 
  // connectivity matrix is specified in input --------------------------------------------
 
  if( (_paramSet->isSet(prefix + "_connectivity_matrix")     && _paramSet->isSet(prefix + "_reduced_matrix") ) ||
      (_paramSet->isSet(prefix + "_connectivity_matrix_mal") && _paramSet->isSet(prefix + "_reduced_matrix_mal") ) ||
      (_paramSet->isSet(prefix + "_connectivity_matrix_fem") && _paramSet->isSet(prefix + "_reduced_matrix_fem")) )
  {
 
    _disp_model=0;
 
    // both sex identical matrices
    if(_paramSet->isSet(prefix + "_connectivity_matrix")     && _paramSet->isSet(prefix + "_reduced_matrix")){
      if( ! setReducedMatricesBySex(FEM, (*get_parameter(prefix + "_connectivity_matrix")), (*get_parameter(prefix + "_reduced_matrix"))) )
        return false;
      if( ! setReducedMatricesBySex(MAL, (*get_parameter(prefix + "_connectivity_matrix")), (*get_parameter(prefix + "_reduced_matrix"))) )
         return false;
    }
 
    // female specific matrices
    if(_paramSet->isSet(prefix + "_connectivity_matrix_fem")     && _paramSet->isSet(prefix + "_reduced_matrix_fem")){
      if( ! setReducedMatricesBySex(FEM, (*get_parameter(prefix + "_connectivity_matrix_fem")), (*get_parameter(prefix + "_reduced_matrix_fem"))) )
        return false;
    }
 
    // male specific matrices
    if(_paramSet->isSet(prefix + "_connectivity_matrix_mal")     && _paramSet->isSet(prefix + "_reduced_matrix_mal")){
      if( ! setReducedMatricesBySex(MAL, (*get_parameter(prefix + "_connectivity_matrix_mal")), (*get_parameter(prefix + "_reduced_matrix_mal"))) )
        return false;
    }
 
    if( (_paramSet->isSet(prefix + "_connectivity_matrix_fem") && !_paramSet->isSet(prefix + "_connectivity_matrix_mal")  ) ||
        (_paramSet->isSet(prefix + "_connectivity_matrix_mal") && !_paramSet->isSet(prefix + "_connectivity_matrix_fem")  ))
      return error("both \"%s_connectivity_matrix\" and \"%s_reduced_matrix\" must be set for each sex together\n", prefix.c_str(), prefix.c_str());
 
 
#ifdef _DEBUG_
    cout << "=== female reduced dispersal matrix ===\n";
    for (unsigned int i = 0; i < _npatch; ++i) {
      cout << "  [";
      for (unsigned int k = 0; k < _reducedDispMat[FEM][i].size(); k++) {
        cout << _reducedDispMatProba[FEM][i][k] << " [" << _reducedDispMat[FEM][i][k] <<"] ";
      }
      cout<<"]\n";
    }
 
    cout << "=== male reduced dispersal matrix ===\n";
    for (unsigned int i = 0; i < _npatch; ++i) {
      cout << "  [";
      for (unsigned int k = 0; k < _reducedDispMat[MAL][i].size(); k++) {
        cout << _reducedDispMatProba[MAL][i][k] << " [" << _reducedDispMat[MAL][i][k] <<"] ";
      }
      cout<<"]\n";
 
    }
#endif
 
  }
  // dispersal matrix is specified in input -----------------------------------------------
 
  else if ( (_paramSet->isSet(prefix + "_connectivity_matrix") &&
      !_paramSet->isSet(prefix + "_reduced_matrix")) ||
      (!_paramSet->isSet(prefix + "_connectivity_matrix") &&
          _paramSet->isSet(prefix + "_reduced_matrix")))
 
  {
    return error("both \"%s_connectivity_matrix\" and \"%s_reduced_matrix\" must be set together\n", prefix.c_str(), prefix.c_str());
  }
 
  // connectivity or reduced matrices not given in input
  else
 
  {
 
    if(_paramSet->isSet(prefix + "_matrix")) {
 
      _DispMatrix[0] = new TMatrix();
 
      _paramSet->getMatrix(prefix + "_matrix",_DispMatrix[0]);
 
      //same dispersal matrix for males and females
      _DispMatrix[1] = new TMatrix(*_DispMatrix[0]);
 
    } else {
 
      if(_paramSet->isSet(prefix + "_matrix_fem")) {
 
        _DispMatrix[FEM] = new TMatrix();
 
        _paramSet->getMatrix(prefix + "_matrix_fem",_DispMatrix[FEM]);
 
      }
 
      if(_paramSet->isSet(prefix + "_matrix_mal")) {
 
        _DispMatrix[MAL] = new TMatrix();
 
        _paramSet->getMatrix(prefix + "_matrix_mal",_DispMatrix[MAL]);
 
      }
    }
 
    if( _paramSet->isSet(prefix + "_matrix") ||
        ( _paramSet->isSet(prefix + "_matrix_fem") && _paramSet->isSet(prefix + "_matrix_mal") )  )
    {
 
      if(  ( _paramSet->isSet(prefix + "_rate") ||
          ( _paramSet->isSet(prefix + "_rate_fem") &&  _paramSet->isSet(prefix + "_rate_mal")) )
          || _paramSet->isSet(prefix + "_model") )
        warning("parameter \"dispersal_matrix\" takes precedence over parameters \"dispersal_rate\" and \"dispersal_model\"\n");
 
      _disp_model = 0;
 
      if(_DispMatrix[FEM]) {
 
        //check if we want the Identity matrix
        if(_DispMatrix[FEM]->length() == 1 && _DispMatrix[FEM]->get(0,0) == 1)
          setIndentityDispMatrix(_DispMatrix[FEM]);
 
        //check dimensions
        if(_DispMatrix[FEM]->length() != _npatch*_npatch)
          return error("the size of the female dispersal matrix is not equal to patch_number X patch_number (%i[%i,%i] != %i)!\n",
              _DispMatrix[FEM]->length(),_DispMatrix[FEM]->getNbRows(),_DispMatrix[FEM]->getNbCols(),_npatch*_npatch);
 
        //check that migration rates sum to 1 per row or column
        if(!_isByNumber) {
          if(_isForward) {
            if(!checkForwardDispersalMatrix(_DispMatrix[FEM])) return false;
          } else {
            if(!checkBackwardDispersalMatrix(_DispMatrix[FEM])) return false;
          }
        }
      }
 
      if(_DispMatrix[MAL]) {
 
        //check if we want the Identity matrix
        if(_DispMatrix[MAL]->length() == 1 && _DispMatrix[MAL]->get(0,0) == 1)
          setIndentityDispMatrix(_DispMatrix[MAL]);
 
        //check dimensions
        if(_DispMatrix[MAL]->length() != _npatch*_npatch)
          return error("the size of the male dispersal matrix is not equal to patch_number X patch_number (%i[%i,%i] != %i)!\n",
              _DispMatrix[MAL]->length(),_DispMatrix[MAL]->getNbRows(),_DispMatrix[MAL]->getNbCols(),_npatch*_npatch);
 
 
        //check that migration rates sum to 1 per row or column
        if(!_isByNumber) {
          if(_isForward) {
            if(!checkForwardDispersalMatrix(_DispMatrix[MAL])) return false;
          } else {
            if(!checkBackwardDispersalMatrix(_DispMatrix[MAL])) return false;
          }
        }
      }
 
      setReducedDispMatrix();
 
    // dispersal rate is given in input ---------------------------------------------------
    } else {
 
      if(!_paramSet->isSet(prefix + "_model")) return error("Dispersal model is not set!\n");
 
      if(_paramSet->isSet(prefix + "_rate"))
 
      {
 
        _fem_rate = _mal_rate = _paramSet->getValue(prefix + "_rate");
 
        if(!setDispMatrix()) return false;
 
      }
 
      else if(  _paramSet->isSet(prefix + "_rate_fem") &&  _paramSet->isSet(prefix + "_rate_mal")  )
 
      {
        _fem_rate = _paramSet->getValue(prefix + "_rate_fem");
 
        _mal_rate = _paramSet->getValue(prefix + "_rate_mal");
 
        if(!setDispMatrix()) return false;
      }
 
      else {
        return error("Dispersal rate parameters not set!\n");
      }
 
    }
 
  }
  return true;
}

References _disp_model, _disp_propagule_prob, _DispMatrix, _fem_rate, _isByNumber, _isForward, _mal_rate, _npatch, SimComponent::_paramSet, LifeCycleEvent::_popPtr, _prefix, _reducedDispMat, _reducedDispMatProba, checkBackwardDispersalMatrix(), checkForwardDispersalMatrix(), error(), FEM, SimComponent::get_parameter(), ParamSet::getMatrix(), Metapop::getPatchNbr(), ParamSet::getValue(), Param::isSet(), ParamSet::isSet(), MAL, setDispMatrix(), setIndentityDispMatrix(), setReducedDispMatrix(), setReducedMatricesBySex(), and warning().

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

setBasicLatticeMatrix()

bool LCE_Disperse_base::setBasicLatticeMatrix	(	int	rows,
		int	cols,
		double	phi_mal,
		double	phi_fem,
		double	disp_mal,
		double	disp_fem
	)

{
  TMatrix* mmat = _DispMatrix[MAL];
  TMatrix* fmat = _DispMatrix[FEM];
 
  //init:
  fmat->assign(0.0);
  mmat->assign(0.0);
 
  TMatrix grid(rows, cols);
 
  int p = 0;
  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < cols ; ++j) {
      grid.set(i, j, p++);
    }
  }
  assert( p == rows*cols );
 
  //diagonal:
  for (unsigned int i = 0; i < _npatch; ++i){
    fmat->set(i, i, phi_fem);
    mmat->set(i, i, phi_mal);
  }
 
  int connect;
 
  for (int x = 0; x < rows; ++x) {
    for (int y = 0; y < cols; ++y) {
 
      p = grid.get(x, y);
 
      connect = p + 1; //patch to the right
 
      if (connect < (x + 1)*cols) { //stay on the same row
        fmat->set(p, connect, disp_fem);
        mmat->set(p, connect, disp_mal);
      }
 
      connect = p - 1; //patch to the left
 
      if (connect >= x*cols ) {
        fmat->set(p, connect, disp_fem);
        mmat->set(p, connect, disp_mal);
      }
 
      connect = p + cols; //patch one row up
 
      if (connect < (int)_npatch ) {
        fmat->set(p, connect, disp_fem);
        mmat->set(p, connect, disp_mal);
      }
 
      connect = p - cols; //patch one row down
 
      if (connect >= 0 ) {
        fmat->set(p, connect, disp_fem);
        mmat->set(p, connect, disp_mal);
      }
 
      //diagonal steps:
      if((unsigned int)get_parameter_value(_prefix + "_lattice_range") == 2) {
 
        connect = p + cols; //patches one row up
 
        if (connect < (int)_npatch ) { //we are not on the last row
 
          if (connect + 1 < (x + 2)*cols) { //do not reach past the right border
            fmat->set(p, connect + 1, disp_fem);
            mmat->set(p, connect + 1, disp_mal);
          }
 
          if (connect - 1 >= (x + 1)*cols) { //do not reach past the left border
            fmat->set(p, connect - 1, disp_fem);
            mmat->set(p, connect - 1, disp_mal);
          }
        }
 
        connect = p - cols; //patches one row down
 
        if (connect >= 0) { //we are not on the first row
 
          if (connect + 1 < (x + 1)*cols) {
            fmat->set(p, connect + 1, disp_fem);
            mmat->set(p, connect + 1, disp_mal);
          }
 
          if (connect - 1 >= (x - 1)*cols) {
            fmat->set(p, connect - 1, disp_fem);
            mmat->set(p, connect - 1, disp_mal);
          }
        }
      } //lattice range == 2
 
    } //y
  } //x
 
  switch((unsigned int)get_parameter_value(_prefix + "_border_model")) {
  case 1:
    return setLatticeTorrusMatrix(rows, cols, disp_mal, disp_fem, &grid);
  case 2:
    return setLatticeReflectingMatrix(rows, cols, &grid);
  case 3:
    return setLatticeAbsorbingMatrix();
  default:
    error("parameter \"%s_border_model\" accepts only three values: [1,2,3]\n", _prefix.c_str());
    break;
  }
 
  return false;
}

References _DispMatrix, _npatch, _prefix, TMatrix::assign(), error(), FEM, TMatrix::get(), SimComponent::get_parameter_value(), MAL, TMatrix::set(), setLatticeAbsorbingMatrix(), setLatticeReflectingMatrix(), and setLatticeTorrusMatrix().

Referenced by setLatticeMatrix().

setDispMatrix()

bool LCE_Disperse_base::setDispMatrix

(

)

{
 
  switch ( getDispersalModel() ) {
  case 1:
    if( !setIsland_MigrantPool_Matrix() ) return false;
    break;
  case 2:
    if( !setIsland_PropagulePool_Matrix() ) return false;
    break;
  case 3:
    if( !setSteppingStone1DMatrix() ) return false;
    break;
  case 4:
    if( !setLatticeMatrix() ) return false;
    break;
  default:
    return error("Dispersal model '%i' not yet implemented\n",getDispersalModel());
  }
 
  if(_isForward) {
    if(!checkForwardDispersalMatrix(_DispMatrix[FEM])) return false;
    if(!checkForwardDispersalMatrix(_DispMatrix[MAL])) return false;
  } else {
    if(!checkBackwardDispersalMatrix(_DispMatrix[FEM])) return false;
    if(!checkBackwardDispersalMatrix(_DispMatrix[MAL])) return false;
  }
 
  return setReducedDispMatrix();
}

References _DispMatrix, _isForward, checkBackwardDispersalMatrix(), checkForwardDispersalMatrix(), error(), FEM, getDispersalModel(), MAL, setIsland_MigrantPool_Matrix(), setIsland_PropagulePool_Matrix(), setLatticeMatrix(), setReducedDispMatrix(), and setSteppingStone1DMatrix().

Referenced by setBaseParameters(), and updateDispMatrix().

setIndentityDispMatrix()

void LCE_Disperse_base::setIndentityDispMatrix

(

TMatrix *

mat

)

{
  mat->reset(_npatch, _npatch);
  mat->assign(0);
  for(unsigned int i = 0; i < _npatch; ++i) mat->set(i, i, 1);
}

References _npatch, TMatrix::assign(), TMatrix::reset(), and TMatrix::set().

Referenced by setBaseParameters().

setIsland_MigrantPool_Matrix()

bool LCE_Disperse_base::setIsland_MigrantPool_Matrix

(

)

{
#ifdef _DEBUG_
  cout<<"setIsland_MigrantPool_Matrix(_npatch="<<_npatch<<", _mal_rate="
      <<_mal_rate<<", _fem_rate="<<_fem_rate<<")"<<endl;
#endif
  allocateDispMatrix(MAL, _npatch);
  allocateDispMatrix(FEM, _npatch);
 
  TMatrix* mmat = _DispMatrix[MAL];
  TMatrix* fmat = _DispMatrix[FEM];
  double pmal = 1 - _mal_rate;
  double pfem = 1 - _fem_rate;
  double mmal = _mal_rate/(_npatch-1);
  double mfem = _fem_rate/(_npatch-1);
 
  for (unsigned int i=0; i<_npatch; ++i){
    for (unsigned int j=0; j<_npatch; ++j){
      mmat->set(i,j, mmal);
      fmat->set(i,j, mfem);
    }
  }
 
  for (unsigned int i=0; i<_npatch; ++i){
    mmat->set(i,i, pmal);
    fmat->set(i,i, pfem);
  }
  return true;
}

References _DispMatrix, _fem_rate, _mal_rate, _npatch, allocateDispMatrix(), FEM, MAL, and TMatrix::set().

Referenced by setDispMatrix().

setIsland_PropagulePool_Matrix()

bool LCE_Disperse_base::setIsland_PropagulePool_Matrix

(

)

{
#ifdef _DEBUG_
  cout<<"setIsland_PropagulePool_Matrix(_npatch="<<_npatch<<", _mal_rate="
      <<_mal_rate<<", _fem_rate="<<_fem_rate<<")"<<endl;
#endif
 
  allocateDispMatrix(MAL, _npatch);
  allocateDispMatrix(FEM, _npatch);
 
  if( !_paramSet->isSet(_prefix + "_propagule_prob") ) {
    error("Missing parameter \"dispersal_propagule_prob\" with dispersal model 2!\n");
    return false;
  }
 
  setPropaguleTargets();
 
  double propagulePHI = getPropaguleProb();
  double c1 = (1 - _fem_rate), c2 = (_fem_rate*propagulePHI),
      c3 = (_fem_rate*(1.0 - propagulePHI)/(_npatch-2));
 
  TMatrix* mmat = _DispMatrix[MAL];
  TMatrix* fmat = _DispMatrix[FEM];
 
  for (unsigned int i=0; i < _npatch; ++i){
 
    fmat->set(i, i, c1);
 
    for (unsigned int j=i+1; j < _npatch; ++j){
      fmat->set(i, j, c3);
      fmat->set(j, i, c3);
    }
    fmat->set(i, getPropaguleTarget(i), c2);
  }
 
  c1 = (1 - _mal_rate);
  c2 = (_mal_rate*propagulePHI);
  c3 = (_mal_rate*(1.0 - propagulePHI)/(_npatch-2));
 
  for (unsigned int i=0; i < _npatch; ++i){
 
    mmat->set(i, i, c1);
 
    for (unsigned int j=i+1; j< _npatch; ++j) {
      mmat->set(i, j, c3);
      mmat->set(j, i, c3);
    }
    mmat->set(i, getPropaguleTarget(i), c2);
  }
 
  return true;
}

References _DispMatrix, _fem_rate, _mal_rate, _npatch, SimComponent::_paramSet, _prefix, allocateDispMatrix(), error(), FEM, getPropaguleProb(), getPropaguleTarget(), ParamSet::isSet(), MAL, TMatrix::set(), and setPropaguleTargets().

Referenced by LCE_Breed_Selection_Disperse::breed_selection_disperse_propagule(), LCE_Breed_Disperse::do_breed_disperse_propagule(), LCE_Disperse_ConstDisp::Migrate_propagule(), and setDispMatrix().

setLatticeAbsorbingMatrix()

bool LCE_Disperse_base::setLatticeAbsorbingMatrix

(

)

{
  TMatrix* mmat = _DispMatrix[MAL];
  TMatrix* fmat = _DispMatrix[FEM];
 
  fmat->set(_npatch, _npatch, 1.0);
  mmat->set(_npatch, _npatch, 1.0);
 
  double sum;
 
  if(_isForward) {
    //set the absorbing patch probs to 1 - sum(row)
    for(unsigned int i = 0; i < _npatch; ++i) {
      sum = 0;
      for (unsigned int j = 0; j < _npatch; ++j) {
        sum += fmat->get(i, j);
      }
      fmat->set(i, _npatch, 1.0 - sum);
    }
 
    for(unsigned int i = 0; i < _npatch; ++i) {
      sum = 0;
      for (unsigned int j = 0; j < _npatch; ++j) {
        sum += mmat->get(i, j);
      }
      mmat->set(i, _npatch, 1.0 - sum);
    }
    //backward migration:
  }else {
    //the missing immigrant rate from non-existing patches must be added to the "philopatric" rate
    for(unsigned int i = 0; i < _npatch; ++i) {
      sum = 0;
      for (unsigned int j = 0; j < _npatch; ++j) {
        sum += fmat->get(j, i);
      }
      fmat->plus(i, i, 1.0 - sum);
    }
 
    for(unsigned int i = 0; i < _npatch; ++i) {
      sum = 0;
      for (unsigned int j = 0; j < _npatch; ++j) {
        sum += mmat->get(j, i);
      }
      mmat->plus(i, i, 1.0 - sum);
    }
  }
 
  return true;
}

References _DispMatrix, _isForward, _npatch, FEM, TMatrix::get(), MAL, TMatrix::plus(), and TMatrix::set().

Referenced by setBasicLatticeMatrix().

setLatticeMatrix()

bool LCE_Disperse_base::setLatticeMatrix

(

)

Sets the dispersal matrices for the Lattice dispersal model.

Each matrix has 'patch number' x 'patch number' cells unless the lattice model is the absorbing boundaries model where we add the sink patch.

The "dispersal_lattice_range" parameter defines the number of neighbouring patches to disperse into. Option 1 sets this number to 4 (left and right, up and down patches) whereas option 2 allows to disperse to the 8 neighbouring patches, including the patches on the diagonals.

{
#ifdef _DEBUG_
  message("setLatticeMatrix()\n");
#endif
  if(!_paramSet->isSet(_prefix + "_border_model"))
    return error("Missing parameter \"dispersal_border_model\" with dispersal model 4!\n");
 
  if(!_paramSet->isSet(_prefix + "_lattice_range") )
    return error("Missing parameter \"dispersal_lattice_range\" with dispersal model 4!\n");
 
  int rows, cols;
 
  if( !_paramSet->isSet(_prefix + "_lattice_rows") && !_paramSet->isSet(_prefix + "_lattice_columns") ) {
 
    rows = cols = (int) sqrt((double)_npatch);
 
    if( rows*cols != (int)_npatch )
      return error("The number of patches is not a square number in the lattice dispersal model\n");
 
  } else {
 
    rows = _paramSet->getValue(_prefix + "_lattice_rows");
 
    cols = _paramSet->getValue(_prefix + "_lattice_columns");
 
    if(rows == -1) return error("number of rows of the dispersal lattice is not specified\n");
    if(cols == -1) return error("number of columns of the dispersal lattice is not specified\n");
 
    if( rows*cols != (int)_npatch ){
      error("The size of the dispersal matrix in the lattice model is not equal to the number of patches,\n");
      return error("parameters %s_lattice_rows and %s_lattice_columns must be set.\n", _prefix.c_str(), _prefix.c_str());
    }
  }
 
  if((unsigned int)get_parameter_value(_prefix + "_border_model") == 3) {
    allocateDispMatrix(MAL, _npatch+1);
    allocateDispMatrix(FEM, _npatch+1);
  } else {
    allocateDispMatrix(MAL, _npatch);
    allocateDispMatrix(FEM, _npatch);
  }
 
  unsigned int range = (unsigned int)get_parameter_value(_prefix + "_lattice_range");
  //philopatry:
  double pmal = 1 - _mal_rate, pfem = 1 - _fem_rate;
  //migration:
  double mmal = _mal_rate/(range == 1 ? 4 : 8), mfem = _fem_rate/(range == 1 ? 4 : 8);
 
  setBasicLatticeMatrix(rows, cols, pmal, pfem, mmal, mfem);
 
 
  return true;
}

References _fem_rate, _mal_rate, _npatch, SimComponent::_paramSet, _prefix, allocateDispMatrix(), error(), FEM, SimComponent::get_parameter_value(), ParamSet::getValue(), ParamSet::isSet(), MAL, message(), and setBasicLatticeMatrix().

Referenced by setDispMatrix(), and LCE_Disperse_EvolDisp::setParameters().

setLatticeReflectingMatrix()

bool LCE_Disperse_base::setLatticeReflectingMatrix	(	int	rows,
		int	cols,
		TMatrix *	grid
	)

{
  TMatrix* mmat = _DispMatrix[MAL];
  TMatrix* fmat = _DispMatrix[FEM];
 
  vector<unsigned int> border_cells;
 
  for (unsigned int i = 0; i < _npatch; ++i) {
 
    for (int j = 0; j < cols; ++j)
      border_cells.push_back( j ); //first row
 
    for (int j = 1; j < rows - 1; ++j) { //intermediate rows, only the two border cells
      border_cells.push_back( j*cols );
      border_cells.push_back( (j + 1)*cols - 1 );
    }
 
    for (unsigned int j = cols*(rows-1); j < _npatch; ++j)
      border_cells.push_back( j ); //last row
 
  }
 
  double sum;
  // individuals who can't disperse past the border stay in place:
  for (unsigned int i = 0; i < border_cells.size(); ++i) {
    //sum of dispersal rates:
    sum = fmat->rowSum( border_cells[i] ) - fmat->get(border_cells[i], border_cells[i]);
    //difference gives 1 - m:
    fmat->set(border_cells[i], border_cells[i], 1 - sum);
 
    sum = mmat->rowSum( border_cells[i] ) - mmat->get(border_cells[i], border_cells[i]);
    mmat->set(border_cells[i], border_cells[i], 1 - sum);
  }
 
  if(!_isForward) {  fmat->transpose();  mmat->transpose(); }
 
  return true;
}

References _DispMatrix, _isForward, _npatch, FEM, TMatrix::get(), MAL, TMatrix::rowSum(), TMatrix::set(), and TMatrix::transpose().

Referenced by setBasicLatticeMatrix().

setLatticeTorrusMatrix()

bool LCE_Disperse_base::setLatticeTorrusMatrix	(	int	rows,
		int	cols,
		double	disp_mal,
		double	disp_fem,
		TMatrix *	grid
	)

{
  TMatrix* mmat = _DispMatrix[MAL];
  TMatrix* fmat = _DispMatrix[FEM];
 
  int x, y;
 
  x = 0; //first row, connect with upper row
  for (y = 0; y < cols; ++y) {
    fmat->set( grid->get(x, y), grid->get( rows-1, y ), disp_fem);
    mmat->set( grid->get(x, y), grid->get( rows-1, y ), disp_mal);
  }
 
  x = rows - 1; //last row, connect with bottom row
  for (y = 0; y < cols; ++y) {
    fmat->set( grid->get(x, y), grid->get( 0, y ), disp_fem);
    mmat->set( grid->get(x, y), grid->get( 0, y ), disp_mal);
  }
 
  y = 0; //left column, connect with right-most column
  for (x = 0; x < rows; ++x) {
    fmat->set( grid->get(x, y), grid->get( x, cols - 1 ), disp_fem);
    mmat->set( grid->get(x, y), grid->get( x, cols - 1 ), disp_mal);
  }
 
  y = cols - 1; //right-most column, connect with left-most column
  for (x = 0; x < rows; ++x) {
    fmat->set( grid->get(x, y), grid->get( x, 0 ), disp_fem);
    mmat->set( grid->get(x, y), grid->get( x, 0 ), disp_mal);
  }
 
  //connect along diagonals
 
  if((int)get_parameter_value(_prefix + "_lattice_range") == 2) {
 
 
    //CORNERS:
 
    //first patch on first row, wrap around to top right border (last patch)
    fmat->set( grid->get(0, 0), grid->get( rows - 1, cols - 1 ), disp_fem);
    mmat->set( grid->get(0, 0), grid->get( rows - 1, cols - 1 ), disp_mal);
    //last patch to first patch
    fmat->set( grid->get( rows - 1, cols - 1 ), grid->get(0, 0), disp_fem);
    mmat->set( grid->get( rows - 1, cols - 1 ), grid->get(0, 0), disp_mal);
 
    //last patch on first row, wrap around to top left border
    fmat->set( grid->get(0, cols - 1), grid->get( rows - 1, 0 ), disp_fem);
    mmat->set( grid->get(0, cols - 1), grid->get( rows - 1, 0 ), disp_mal);
    //third corner to second corner
    fmat->set( grid->get( rows - 1, 0 ), grid->get(0, cols - 1), disp_fem);
    mmat->set( grid->get( rows - 1, 0 ), grid->get(0, cols - 1), disp_mal);
 
 
    //BORDERS:
 
    x = 0;//we are on the first row
 
    for (y = 0; y < cols - 1; ++y) {
      //diagonal step to the right, move to the other side of the grid
      fmat->set( grid->get(x, y), grid->get( rows-1, y + 1 ), disp_fem);
      mmat->set( grid->get(x, y), grid->get( rows-1, y + 1 ), disp_mal);
    }
    for (y = 1; y < cols; ++y) {
      //diagonal step to the left, move to the other side of the grid
      fmat->set( grid->get(x, y), grid->get( rows-1, y - 1 ), disp_fem);
      mmat->set( grid->get(x, y), grid->get( rows-1, y - 1 ), disp_mal);
    }
 
    x = rows - 1; //last row
 
    for (y = 0; y < cols - 1; ++y) {
      //diagonal step to the right, move to the first row
      fmat->set( grid->get(x, y), grid->get( 0, y + 1 ), disp_fem);
      mmat->set( grid->get(x, y), grid->get( 0, y + 1 ), disp_mal);
    }
    for (y = 1; y < cols; ++y) {
      //diagonal step to the left, move to the first row
      fmat->set( grid->get(x, y), grid->get( 0, y - 1 ), disp_fem);
      mmat->set( grid->get(x, y), grid->get( 0, y - 1 ), disp_mal);
    }
 
    //in-between rows, connect first and last columns
    for (x = 0; x < rows; ++x) {
 
      if(x > 0) {
        //diagonal step down, to previous row
        y = 0; //first column
        fmat->set( grid->get(x, y), grid->get( x - 1, cols - 1 ), disp_fem);
        mmat->set( grid->get(x, y), grid->get( x - 1, cols - 1 ), disp_mal);
        y = cols - 1; //last column
        fmat->set( grid->get(x, y), grid->get( x - 1, 0 ), disp_fem);
        mmat->set( grid->get(x, y), grid->get( x - 1, 0 ), disp_mal);
      }
      if(x < rows - 1){
        //diagonal step up, to next row
        y = 0;
        fmat->set( grid->get(x, y), grid->get( x + 1, cols - 1 ), disp_fem);
        mmat->set( grid->get(x, y), grid->get( x + 1, cols - 1 ), disp_mal);
        y = cols - 1;
        fmat->set( grid->get(x, y), grid->get( x + 1, 0 ), disp_fem);
        mmat->set( grid->get(x, y), grid->get( x + 1, 0 ), disp_mal);
      }
    }
  }
  //the matrix is symmetrical no need to transpose for backward migration
  return true;
}

References _DispMatrix, _prefix, FEM, TMatrix::get(), SimComponent::get_parameter_value(), MAL, and TMatrix::set().

Referenced by setBasicLatticeMatrix().

setParamPrefix()

void LCE_Disperse_base::setParamPrefix ( string  pref )

inline

{_prefix = pref;}

References _prefix.

setPropaguleTargets()

void LCE_Disperse_base::setPropaguleTargets

(

)

{
  unsigned int nb_patch = _popPtr->getPatchNbr();
  unsigned int tmp_array[nb_patch];
  unsigned int table_index, target_patch;
  unsigned int size, last;
 
  //shuffling algorithm:
  do {
    for(unsigned int i = 0; i < nb_patch; ++i)
      tmp_array[i] = i;
 
    size = nb_patch;
 
    for(unsigned int orig_patch = 0; orig_patch < nb_patch-1; ++orig_patch) {
 
      do{
 
        table_index = RAND::Uniform( size );
 
        target_patch = tmp_array[ table_index ];
 
      }while(target_patch == orig_patch);
 
      size--;
 
      last = tmp_array[size];
 
      tmp_array[table_index] = last;
 
      tmp_array[size] = target_patch;
    }
    //do this until the last element left is not the last patch:
  }while (tmp_array[0] == nb_patch-1);
 
  _PropaguleTargets.assign(nb_patch,0);
 
  unsigned int reverse_i = nb_patch;
 
  //we read the shuffled array in reverse order:
  for(unsigned int i=0; i < _PropaguleTargets.size(); i++) {
    _PropaguleTargets[i] = tmp_array[--reverse_i];
 
#ifdef _DEBUG_
    cout<<" -- Patch "<<i<<" : assigned Patch "<<_PropaguleTargets[i]<<endl;
#endif
 
  }
}

References LifeCycleEvent::_popPtr, _PropaguleTargets, Metapop::getPatchNbr(), and RAND::Uniform().

Referenced by LCE_Disperse_EvolDisp::execute(), and setIsland_PropagulePool_Matrix().

setReducedDispMatrix()

bool LCE_Disperse_base::setReducedDispMatrix

(

)

The reduced dispersal matrix contains the indices of the patches to which each patch is connected.

The connected patches are further ordered in descending order of the migration rates. The migration rates are stored in a reduced dispersal matrix. The original dispersal matrices are cleared (de-allocated). This offers a double speed-up compared to the classical method.

{
  unsigned int border_model = (unsigned int)get_parameter_value(_prefix + "_border_model");
  unsigned int num_patch = (border_model == 3 ? _npatch + 1 : _npatch);
 
  //multimap automatically orders the key values in ascending order
  multimap<double, unsigned int> ordered_rates_fem, ordered_rates_mal;
 
  typedef multimap<double, unsigned int>::const_iterator CI;
 
#ifdef _DEBUG_
  message("== Dispersal matrices ==\n");
  _DispMatrix[FEM]->show_up();
  _DispMatrix[MAL]->show_up();
  message("== setting reduced dispersal matrices ==\n");
#endif
 
  // purge the connectivity and reduced dipsersal matrices
  for (unsigned int sex = 0; sex < 2; sex++) {
    _reducedDispMat[sex].clear();
    _reducedDispMatProba[sex].clear();
  }
  // build them from full dispersal matrices given in input
  for (unsigned int i = 0; i < num_patch; ++i) {
 
    _reducedDispMat[0].push_back(vector<double>());
    _reducedDispMat[1].push_back(vector<double>());
 
    _reducedDispMatProba[0].push_back(vector<double>());
    _reducedDispMatProba[1].push_back(vector<double>());
 
    ordered_rates_fem.clear();
    ordered_rates_mal.clear();
 
    if(_isForward) {
      //make pairs: {disp proba, patch connected}, will be ordered by dispersal probabilities:
      for (unsigned int j = 0; j < num_patch; ++j)
        if(_DispMatrix[MAL]->get(i, j) != 0) ordered_rates_mal.insert(make_pair(_DispMatrix[MAL]->get(i, j), j));
 
 
      for (unsigned int j = 0; j < num_patch; ++j)
        if(_DispMatrix[FEM]->get(i, j) != 0) ordered_rates_fem.insert(make_pair(_DispMatrix[FEM]->get(i, j),j));
 
 
    } else {
      //backward migration matrices are read column-wise
      for (unsigned int j = 0; j < num_patch; ++j)
        if(_DispMatrix[MAL]->get(j, i) != 0) ordered_rates_mal.insert(make_pair(_DispMatrix[MAL]->get(j, i),j));
 
      for (unsigned int j = 0; j < num_patch; ++j)
        if(_DispMatrix[FEM]->get(j, i) != 0) ordered_rates_fem.insert(make_pair(_DispMatrix[FEM]->get(j, i),j));
    }
 
    if(ordered_rates_fem.size() == 1) {
 
      _reducedDispMat[FEM][i].push_back(ordered_rates_fem.begin()->second);
 
      _reducedDispMatProba[FEM][i].push_back(ordered_rates_fem.begin()->first);
 
    } else {
 
      //store the patch indices in reverse order of the migration rates:
      //store the dispersal rates as well in a separate reduced matrix
      CI p;
 
      for (p = --ordered_rates_fem.end(); p != ordered_rates_fem.begin(); --p) {
        _reducedDispMat[FEM][i].push_back(p->second);
        _reducedDispMatProba[FEM][i].push_back(p->first);
      }
      _reducedDispMat[FEM][i].push_back(ordered_rates_fem.begin()->second);
      _reducedDispMatProba[FEM][i].push_back(ordered_rates_fem.begin()->first);
 
    }
 
    //same for the male dispersal matrices
    if(ordered_rates_mal.size() == 1) {
 
      _reducedDispMat[MAL][i].push_back(ordered_rates_mal.begin()->second);
 
      _reducedDispMatProba[MAL][i].push_back(ordered_rates_mal.begin()->first);
 
    } else {
 
      CI p;
 
      for (p = --ordered_rates_mal.end(); p != ordered_rates_mal.begin(); --p) {
        _reducedDispMat[MAL][i].push_back(p->second);
        _reducedDispMatProba[MAL][i].push_back(p->first);
      }
      _reducedDispMat[MAL][i].push_back(ordered_rates_mal.begin()->second);
      _reducedDispMatProba[MAL][i].push_back(ordered_rates_mal.begin()->first);
 
    }
  }
 
  //we can now get rid of the dispersal matrices...
  for (unsigned int sex = 0; sex < 2; sex++) {
    delete _DispMatrix[sex];
    _DispMatrix[sex] = NULL;
  }
 
#ifdef _DEBUG_
  cout << "=== female reduced dispersal matrix ===\n";
  for (unsigned int i = 0; i < num_patch; ++i) {
    cout << "  ["<<i<<": ";
    for (unsigned int k = 0; k < _reducedDispMat[FEM][i].size(); k++) {
      cout <<"m="<< _reducedDispMatProba[FEM][i][k] << " -> " << _reducedDispMat[FEM][i][k]<<", ";
    }
    cout<<"]\n";
  }
 
  cout << "=== male reduced dispersal matrix ===\n";
  for (unsigned int i = 0; i < num_patch; ++i) {
    cout << "  ["<<i<<": ";
    for (unsigned int k = 0; k < _reducedDispMat[MAL][i].size(); k++) {
      cout <<"m="<< _reducedDispMatProba[MAL][i][k] << " -> " << _reducedDispMat[MAL][i][k]<<", ";
    }
    cout<<"]\n";
 
  }
#endif
 
  return true;
}

References _DispMatrix, _isForward, _npatch, _prefix, _reducedDispMat, _reducedDispMatProba, FEM, SimComponent::get_parameter_value(), MAL, message(), and TMatrix::show_up().

Referenced by setBaseParameters(), setDispMatrix(), and LCE_Disperse_EvolDisp::setParameters().

setReducedMatricesBySex()

bool LCE_Disperse_base::setReducedMatricesBySex	(	sex_t	SEX,
		Param &	connectivity,
		Param &	rate
	)

{
  string sex = (SEX == FEM ? "female" : "male");
 
  connectivity.getVariableMatrix(&_reducedDispMat[SEX]);
 
  rate.getVariableMatrix(&_reducedDispMatProba[SEX]);
 
  if(_reducedDispMat[SEX].size() != _npatch)
    return error("The %s connectivity dispersal matrix must have as many rows (%i) as the number of patches in the population (%i)\n", sex.c_str(), _reducedDispMat[SEX].size(), _npatch);
 
  if(_reducedDispMatProba[SEX].size() != _npatch)
    return error("The %s reduced dispersal rate matrix must have as many rows (%i) as the number of patches in the population (%i)\n", sex.c_str(), _reducedDispMatProba[SEX].size(), _npatch);
 
  if (_reducedDispMat[SEX].size() != _reducedDispMatProba[SEX].size())
    return error("The %s connectivity and reduced dispersal matrices don't have same number of rows\n", sex.c_str());
 
  // check match between the two matrices
  for (unsigned int i = 0; i < _reducedDispMat[SEX].size(); ++i) {
 
    if (_reducedDispMat[SEX][i].size() != _reducedDispMatProba[SEX][i].size())
      return error("Row %i of the %s connectivity and reduced dispersal matrices are not of same size\n", i+1, sex.c_str());
 
    double row_sum = 0;
 
    // we here deduce 1 from the patch ID in the connectivity matrix
    // this is because IDs are given in range [1 - num patch] in input (in principle)
    for (unsigned int j = 0; j < _reducedDispMat[SEX][i].size(); ++j) {
 
      _reducedDispMat[SEX][i][j]--; //remove 1 to make sure that the indexes start with 0, not 1!!!!
 
      if(_reducedDispMatProba[SEX][i][j] < 0 )
       return error("elements of the reduced dispersal matrix for the %s cannot be negative (row %i, column %i)!\n", (SEX==FEM?"females":"males"), i,j);
 
      row_sum += _reducedDispMatProba[SEX][i][j];
    }
 
    if(!_isByNumber && (row_sum < 0.999999 || row_sum > 1.000001))
      return error("the elements of row %i of the %s reduced dispersal matrix do not sum to 1!\n",i+1, sex.c_str());
 
  }
  return true;
}

References _isByNumber, _npatch, _reducedDispMat, _reducedDispMatProba, error(), FEM, and Param::getVariableMatrix().

Referenced by setBaseParameters().

setSteppingStone1DMatrix()

bool LCE_Disperse_base::setSteppingStone1DMatrix

(

)

{
#ifdef _DEBUG_
  message("setSteppingStone1DMatrix()\n");
#endif
  int border_model = (unsigned int)get_parameter_value(_prefix + "_border_model");
 
  //check for the border model, the extra patch is the absorbing patch
  if(border_model == 3) {
    allocateDispMatrix(MAL, _npatch+1);
    allocateDispMatrix(FEM, _npatch+1);
  } else {
    allocateDispMatrix(MAL, _npatch);
    allocateDispMatrix(FEM, _npatch);
  }
 
  TMatrix* mmat = _DispMatrix[MAL];
  TMatrix* fmat = _DispMatrix[FEM];
 
  //philopatry:
  double pmal = 1 - _mal_rate, pfem = 1 - _fem_rate;
  //migration:
  double mmal = _mal_rate/2, mfem = _fem_rate/2;
 
  fmat->assign(0);
  mmat->assign(0);
 
  //diagonal:
  for (unsigned int i = 0; i < _npatch; ++i){
    fmat->set(i, i, pfem);
    mmat->set(i, i, pmal);
  }
  //around the diagonal
  for (unsigned int i = 0; i < _npatch-1; ++i){
    fmat->set(i, i+1, mfem);
    fmat->set(i+1, i, mfem);
    mmat->set(i, i+1, mmal);
    mmat->set(i+1, i, mmal);
  }
 
  if(border_model == 3) {
    //absorbing boders
    //emigrants who leave the population are put in the sink patch
    fmat->set(0, _npatch, mfem);
    mmat->set(0, _npatch, mmal);
    fmat->set(_npatch -1, _npatch, mfem);
    mmat->set(_npatch -1, _npatch, mmal);
    fmat->set(_npatch, _npatch, 1);
    mmat->set(_npatch, _npatch, 1);
 
    if(!_isForward) {
      fmat->transpose();  mmat->transpose(); //this creates artificial immigration from sink
      //need to reset border patches as immigration from sink not allowed:
      fmat->set(0, 0, pfem + mfem); //the proportion not comming from the sink must be added
      fmat->set(_npatch, 0, 0);  //no immigration from sink
      fmat->set(_npatch-1, _npatch-1, pfem + mfem);
      fmat->set(_npatch, _npatch-1, 0);
 
      mmat->set(0, 0, pmal + mmal);
      mmat->set(_npatch, 0, 0);
      mmat->set(_npatch-1, _npatch-1, pmal + mmal);
      mmat->set(_npatch, _npatch-1, 0);
    }
 
  } else if (border_model == 2) {
    //reflective borders,
    //emigrants that cannot leave stay in place
    fmat->set(0, 0, pfem+mfem);
    mmat->set(0, 0, pmal+mmal);
    fmat->set(_npatch -1, _npatch -1, pfem+mfem);
    mmat->set(_npatch -1, _npatch -1, pmal+mmal);
 
    //no need to transpose for backward migration as the matrix is symmetrical
 
  } else { //is a torus by default
    //the 2 last elements, this is a ring population!
    fmat->set(0, _npatch -1, mfem);
    mmat->set(0, _npatch -1, mmal);
    fmat->set(_npatch -1, 0, mfem);
    mmat->set(_npatch -1, 0, mmal);
  }
  return true;
}

References _DispMatrix, _fem_rate, _isForward, _mal_rate, _npatch, _prefix, allocateDispMatrix(), TMatrix::assign(), FEM, SimComponent::get_parameter_value(), MAL, message(), TMatrix::set(), and TMatrix::transpose().

Referenced by setDispMatrix().

swapPostDisp()

void LCE_Disperse_base::swapPostDisp

(

)

{
  Patch *patch;
 
  for(unsigned int i = 0; i < _npatch; i++) {
    patch = _popPtr->getPatch(i);
    patch->move(FEM, PDISPx, OFFSx);
    patch->move(MAL, PDISPx, OFFSx);
  }
}

References _npatch, LifeCycleEvent::_popPtr, FEM, Metapop::getPatch(), MAL, Patch::move(), OFFSx, and PDISPx.

Referenced by LCE_Disperse_EvolDisp::execute(), and LCE_Disperse_ConstDisp::Migrate().

updateDispMatrix()

bool LCE_Disperse_base::updateDispMatrix

(

)

{
  //called by the 'execute' function when a change in patch number is detected
 
  if ( getDispersalModel() == 0 )
    return error("cannot update the dispersal matrix provided in input when the number of population changes.\n");
 
  return setDispMatrix();
}

References error(), getDispersalModel(), and setDispMatrix().

Referenced by LCE_Breed_Disperse::execute(), LCE_Breed_Selection_Disperse::execute(), and LCE_Disperse_ConstDisp::execute().

Friends And Related Function Documentation

LCE_Disperse_ConstDisp

friend class LCE_Disperse_ConstDisp

friend

LCE_Disperse_EvolDisp

friend class LCE_Disperse_EvolDisp

friend

Member Data Documentation

_disp_model

int LCE_Disperse_base::_disp_model

private

Referenced by getDispersalModel(), setBaseParameters(), and LCE_Disperse_EvolDisp::setParameters().

_disp_propagule_prob

double LCE_Disperse_base::_disp_propagule_prob

private

Referenced by getPropaguleProb(), setBaseParameters(), and LCE_Disperse_EvolDisp::setParameters().

_DispMatrix

TMatrix* LCE_Disperse_base::_DispMatrix[2]

private

The sex-specific dispersal matrices, [0] for males, [1] for females, might be used as connectivity matrix as well.

Referenced by allocateDispMatrix(), LCE_Disperse_base(), setBaseParameters(), setBasicLatticeMatrix(), setDispMatrix(), setIsland_MigrantPool_Matrix(), setIsland_PropagulePool_Matrix(), setLatticeAbsorbingMatrix(), setLatticeReflectingMatrix(), setLatticeTorrusMatrix(), setReducedDispMatrix(), setSteppingStone1DMatrix(), and ~LCE_Disperse_base().

_fem_rate

double LCE_Disperse_base::_fem_rate

private

Referenced by setBaseParameters(), setIsland_MigrantPool_Matrix(), setIsland_PropagulePool_Matrix(), setLatticeMatrix(), and setSteppingStone1DMatrix().

_isByNumber

bool LCE_Disperse_base::_isByNumber

private

Referenced by isByNumber(), setBaseParameters(), and setReducedMatricesBySex().

_isForward

bool LCE_Disperse_base::_isForward

private

Referenced by isForward(), set_isForward(), setBaseParameters(), setDispMatrix(), setLatticeAbsorbingMatrix(), setLatticeReflectingMatrix(), setReducedDispMatrix(), and setSteppingStone1DMatrix().

_mal_rate

double LCE_Disperse_base::_mal_rate

private

Referenced by setBaseParameters(), setIsland_MigrantPool_Matrix(), setIsland_PropagulePool_Matrix(), setLatticeMatrix(), and setSteppingStone1DMatrix().

_npatch

unsigned int LCE_Disperse_base::_npatch

protected

Number of patches in the population.

Referenced by LCE_Disperse_EvolDisp::evoldisp(), LCE_Breed_Disperse::execute(), LCE_Breed_Selection_Disperse::execute(), LCE_Disperse_ConstDisp::execute(), LCE_Disperse_EvolDisp::execute(), LCE_Disperse_EvolDisp::fixdisp(), LCE_Disperse_ConstDisp::Migrate(), LCE_Disperse_EvolDisp::Migrate_Island(), LCE_Disperse_EvolDisp::Migrate_Island_Propagule(), LCE_Disperse_EvolDisp::Migrate_SteppingStone1D(), LCE_Disperse_ConstDisp::MigratePatch(), LCE_Disperse_ConstDisp::MigratePatch_AbsorbingBorder(), LCE_Disperse_ConstDisp::MigratePatchByNumber(), reset_counters(), setBaseParameters(), setBasicLatticeMatrix(), setIndentityDispMatrix(), setIsland_MigrantPool_Matrix(), setIsland_PropagulePool_Matrix(), setLatticeAbsorbingMatrix(), setLatticeMatrix(), setLatticeReflectingMatrix(), LCE_Disperse_EvolDisp::setParameters(), setReducedDispMatrix(), setReducedMatricesBySex(), setSteppingStone1DMatrix(), and swapPostDisp().

_prefix

string LCE_Disperse_base::_prefix

private

Parameter name prefix (dispersal, seed_disp, breed_disp, etc.)

Referenced by setBaseParameters(), setBasicLatticeMatrix(), setIsland_PropagulePool_Matrix(), setLatticeMatrix(), setLatticeTorrusMatrix(), LCE_Disperse_EvolDisp::setParameters(), setParamPrefix(), setReducedDispMatrix(), and setSteppingStone1DMatrix().

_PropaguleTargets

vector<unsigned int> LCE_Disperse_base::_PropaguleTargets

private

Referenced by getPropaguleTarget(), and setPropaguleTargets().

_reducedDispMat

vector< vector<double> > LCE_Disperse_base::_reducedDispMat[2]

protected

Matrix containing the indexes of the patches connected to each patch.

Has npatch rows, varying number of columns per row.

Referenced by getConnectedPatches(), getMigrationPatchBackward(), getMigrationPatchForward(), getReducedDispersalPatchID(), LCE_Disperse_EvolDisp::Migrate_Lattice(), LCE_Disperse_ConstDisp::MigratePatchByNumber(), setBaseParameters(), LCE_Disperse_EvolDisp::setParameters(), setReducedDispMatrix(), and setReducedMatricesBySex().

_reducedDispMatProba

vector< vector<double> > LCE_Disperse_base::_reducedDispMatProba[2]

protected

Matrix containing the probability to migrate to/from the connected patches.

Mirror the _reducedDispMat.

Referenced by getConnectedRates(), getMigrationPatchBackward(), getMigrationPatchForward(), getReducedDispersalRate(), LCE_Disperse_ConstDisp::MigratePatchByNumber(), setBaseParameters(), setReducedDispMatrix(), and setReducedMatricesBySex().

---

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

• LCEdisperse.h
• LCEdisperse.cc