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:

List of all members.

Public Member Functions
	LCE_Disperse_base ()
virtual	~LCE_Disperse_base ()
	Deallocates the disp matrix.
unsigned int	getMigrationPatchForward (sex_t SEX, unsigned int LocalPatch)
unsigned int	getMigrationPatchBackward (sex_t SEX, unsigned int LocalPatch)
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	setDispMatrix ()
bool	updateDispMatrix ()
bool	setIsland_MigrantPool_Matrix ()
bool	setIsland_PropagulePool_Matrix ()
bool	setSteppingStone1DMatrix ()
bool	setLatticeMatrix ()
	Sets the dispersal matrices for the Lattice dispersal model.
bool	setBasicLatticeMatrix (unsigned int side, double phi_mal, double phi_fem, double disp_mal, double disp_fem)
bool	setLatticeTorrusMatrix (unsigned int side, double disp_mal, double disp_fem)
bool	setLatticeAbsorbingMatrix ()
bool	setLatticeReflectingMatrix (unsigned int side)
Accessors
unsigned int	getDispersalModel ()
double	getPropaguleProb ()
unsigned int	getPropaguleTarget (unsigned int home)
Implementations
virtual bool	setParameters ()
	Default interface needed to initialize the component's variables from its input parameters value.
virtual void	loadFileServices (FileServices *loader)
	Loads the component's FileHandler onto the FileServices.
virtual void	loadStatServices (StatServices *loader)
	Loads the component's StatHandler onto the StatServices.
virtual age_t	removeAgeClass ()
	Removes the returned age-class flag(s) from the current Metapop age-class flags.
virtual age_t	addAgeClass ()
	Adds the returned age-class flag(s) to the current Metapop age-class flags.
virtual age_t	requiredAgeClass ()
	Specifies what age-classes are required by the LCE to execute.
Protected Attributes
unsigned int	_npatch
Private Attributes
int	_disp_model
double	_disp_propagule_prob
vector< unsigned int >	_PropaguleTargets
double	_fem_rate
double	_mal_rate
bool	_isForward
TMatrix *	_DispMatrix [2]
	The sex-specific dispersal matrices, [0] for males, [1] for females, might be used as connectivity matrix as well.
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.

Definition at line 39 of file LCEdisperse.h.

---

Constructor & Destructor Documentation

LCE_Disperse_base::LCE_Disperse_base

(

)

Definition at line 44 of file LCEdisperse.cc.

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

: LifeCycleEvent("", ""), _disp_model(-1), _disp_propagule_prob(-1.0), _PropaguleTargets()
, _fem_rate (-1), _mal_rate(-1), _isForward(1)
{
  _DispMatrix[0] = NULL;
  _DispMatrix[1] = NULL;
  
  ParamUpdater< LCE_Disperse_base > * updater = 
  new ParamUpdater< LCE_Disperse_base > (&LCE_Disperse_base::setParameters);
  
  add_parameter("dispersal_model",INT,false,true,1,4,updater);
  add_parameter("dispersal_border_model",INT,false,true,1,3,updater);
  add_parameter("dispersal_lattice_range",INT,false,true,1,2,updater);
  add_parameter("dispersal_propagule_prob",DBL,false,true,0,1,updater);
  add_parameter("dispersal_matrix",MAT,false,false,0,0,updater);
  add_parameter("dispersal_matrix_fem",STR,false,false,0,0,updater);
  add_parameter("dispersal_matrix_mal",STR,false,false,0,0,updater);
  add_parameter("dispersal_rate",DBL,false,true,0,1,updater);
  add_parameter("dispersal_rate_fem",DBL,false,true,0,1,updater);
  add_parameter("dispersal_rate_mal",DBL,false,true,0,1,updater);
}

LCE_Disperse_base::~LCE_Disperse_base

(

)

[virtual]

Deallocates the disp matrix.

Definition at line 66 of file LCEdisperse.cc.

References _DispMatrix.

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

---

Member Function Documentation

virtual age_t LCE_Disperse_base::addAgeClass

(

)

[inline, virtual]

Adds the returned age-class flag(s) to the current Metapop age-class flags.

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Disperse.

Definition at line 99 of file LCEdisperse.h.

References NONE.

{return NONE;}

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

Definition at line 216 of file LCEdisperse.cc.

References _DispMatrix, and TMatrix::reset().

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

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

bool LCE_Disperse_base::checkBackwardDispersalMatrix

(

TMatrix *

mat

)

Definition at line 251 of file LCEdisperse.cc.

References LifeCycleEvent::_popPtr, error(), TMatrix::get(), TMatrix::getNbCols(), TMatrix::getNbRows(), Metapop::getPatchNbr(), and TMatrix::length().

Referenced by setParameters().

{
  //first check that the matrix is properly set in the forward way:
  //checkForwardDispersalMatrix(mat);
  //normalize the columns:
  unsigned int dim = _popPtr->getPatchNbr();
  double cntr;
  
  if(mat->length() != dim*dim) {
    error("The size of the dispersal matrix is not equal to patch_number X patch_number (%i[%i,%i] != %i)!\n",
          mat->length(),mat->getNbRows(),mat->getNbCols(),dim*dim);
    return false;
  }
  
  for(unsigned int i = 0; i < dim; ++i) {
    cntr = 0;
    for(unsigned int j = 0; j < dim; ++j)
      cntr += mat->get(j,i);
    if(cntr < 0.999 || cntr > 1.001) {
      error("The elements of column %i of the dispersal matrix do not sum to 1!\n",i+1);
      return false;
    }
  }
  return true;
}

bool LCE_Disperse_base::checkForwardDispersalMatrix

(

TMatrix *

mat

)

Definition at line 226 of file LCEdisperse.cc.

References LifeCycleEvent::_popPtr, error(), TMatrix::get(), TMatrix::getNbCols(), TMatrix::getNbRows(), Metapop::getPatchNbr(), and TMatrix::length().

Referenced by setParameters().

{
  unsigned int dim = _popPtr->getPatchNbr();
  double cntr;
  
  if(mat->length() != dim*dim) {
    error("the size of the dispersal matrix is not equal to patch_number X patch_number (%i[%i,%i] != %i)!\n",
          mat->length(),mat->getNbRows(),mat->getNbCols(),dim*dim);
    return false;
  }
  
  for(unsigned int i = 0; i < dim; ++i) {
    cntr = 0;
    for(unsigned int j = 0; j < dim; ++j)
      cntr += mat->get(i,j);
    if(cntr < 0.999 || cntr > 1.001) {
      error("the elements of row %i of the dispersal matrix do not sum to 1!\n",i+1);
      return false;
    }
  }
  return true;
}

unsigned int LCE_Disperse_base::getDispersalModel

(

)

[inline]

Definition at line 88 of file LCEdisperse.h.

References _disp_model.

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

{return _disp_model;}

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

Definition at line 884 of file LCEdisperse.cc.

References _DispMatrix, _npatch, TMatrix::get(), and RAND::Uniform().

Referenced by LCE_Breed_Disperse::get_parent().

{
  double sum = 0, random = RAND::Uniform();
  unsigned int SourcePatch = 0;
  unsigned int Limit = _npatch -1;
  
  sum = _DispMatrix[SEX]->get(SourcePatch, LocalPatch);
  
  while (random > sum && SourcePatch < Limit) {
    SourcePatch++;
    sum += _DispMatrix[SEX]->get(SourcePatch, LocalPatch);
  }
  
  return SourcePatch;
}

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

Definition at line 866 of file LCEdisperse.cc.

References _DispMatrix, _npatch, TMatrix::get(), and RAND::Uniform().

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

{
  double sum = 0, random = RAND::Uniform();
  unsigned int AimedPatch = 0;  
  unsigned int Limit = _npatch -1;
  
  sum = _DispMatrix[SEX]->get(LocalPatch, AimedPatch);
  
  while (random > sum && AimedPatch < Limit) {
    AimedPatch++;
    sum += _DispMatrix[SEX]->get(LocalPatch, AimedPatch);
  }
  
  return AimedPatch;
}

double LCE_Disperse_base::getPropaguleProb

(

)

[inline]

Definition at line 89 of file LCEdisperse.h.

References _disp_propagule_prob.

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

{return _disp_propagule_prob;}

unsigned int LCE_Disperse_base::getPropaguleTarget

(

unsigned int

home

)

[inline]

Definition at line 90 of file LCEdisperse.h.

References _PropaguleTargets.

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

{return _PropaguleTargets[home];}

virtual void LCE_Disperse_base::loadFileServices

(

FileServices *

loader

)

[inline, virtual]

Loads the component's FileHandler onto the FileServices.

Parameters:

loader

the file service

Implements SimComponent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Disperse.

Definition at line 96 of file LCEdisperse.h.

{}

virtual void LCE_Disperse_base::loadStatServices

(

StatServices *

loader

)

[inline, virtual]

Loads the component's StatHandler onto the StatServices.

Parameters:

loader

the stat service

Implements SimComponent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Disperse.

Definition at line 97 of file LCEdisperse.h.

{}

virtual age_t LCE_Disperse_base::removeAgeClass

(

)

[inline, virtual]

Removes the returned age-class flag(s) from the current Metapop age-class flags.

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Disperse.

Definition at line 98 of file LCEdisperse.h.

References NONE.

{return NONE;}

virtual age_t LCE_Disperse_base::requiredAgeClass

(

)

[inline, virtual]

Specifies what age-classes are required by the LCE to execute.

Implements LifeCycleEvent.

Reimplemented in LCE_Breed_Selection_Disperse, and LCE_Breed_Disperse.

Definition at line 100 of file LCEdisperse.h.

References OFFSPRG.

{return OFFSPRG;}

void LCE_Disperse_base::reset_counters

(

)

Definition at line 201 of file LCEdisperse.cc.

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

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

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

void LCE_Disperse_base::set_isForward

(

bool

val

)

[inline]

Definition at line 66 of file LCEdisperse.h.

References _isForward.

Referenced by LCE_Breed_Disperse::setParameters().

{_isForward = val;}

bool LCE_Disperse_base::setBasicLatticeMatrix	(	unsigned int	side,
		double	phi_mal,
		double	phi_fem,
		double	disp_mal,
		double	disp_fem
	)

Definition at line 571 of file LCEdisperse.cc.

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

Referenced by setLatticeMatrix().

{  
  unsigned int I, J;
  TMatrix* mmat = _DispMatrix[MAL];
  TMatrix* fmat = _DispMatrix[FEM];
  //init:
  for (unsigned int i=0; i<_npatch; ++i){
    for (unsigned int j=0; j<_npatch; ++j){
      fmat->set(i, j, 0.);
      mmat->set(i, j, 0.);
    }}
  //diagonal:
  for (unsigned int i = 0; i < _npatch; ++i){
    fmat->set(i, i, phi_fem);
    mmat->set(i, i, phi_mal);
  }
  //around the diagonal:
  for (unsigned int i = 0; i < _npatch-1; ++i){
    //left and right elements:
    fmat->set(i, i+1, disp_fem);
    fmat->set(i+1, i, disp_fem);
    mmat->set(i, i+1, disp_mal);
    mmat->set(i+1, i, disp_mal);
  }
  for (unsigned int i = 0; i < _npatch - side; ++i){
    //one row up and down elements:
    J = i + side;
    fmat->set(i, J, disp_fem);
    fmat->set(J, i, disp_fem);
    mmat->set(i, J, disp_mal);
    mmat->set(J, i, disp_mal);
  }
  //diagonal steps:
  if((unsigned int)get_parameter_value("dispersal_lattice_range") == 2) {
    unsigned int step = side + 1;
    for (unsigned int i = 0; i < _npatch - step; ++i){
      //diagonal step elements, to the right:
      J = i + step;
      fmat->set(i, J, disp_fem);
      fmat->set(J, i, disp_fem);
      mmat->set(i, J, disp_mal);
      mmat->set(J, i, disp_mal);
    }
    step = side - 1;
    for (unsigned int i = 0; i < _npatch - step; ++i){
      //diagonal step elements, to the left:
      J = i + step;
      fmat->set(i, J, disp_fem);
      fmat->set(J, i, disp_fem);
      mmat->set(i, J, disp_mal);
      mmat->set(J, i, disp_mal);
    }
    for (unsigned int i = 1; i < side - 1; ++i){
      //inconsistent diagonale steps in any models
      I = i * side - 1;
      J = (i + 1) * side;
      fmat->set(I, J, 0.0);
      fmat->set(J, I, 0.0);
      mmat->set(I, J, 0.0);
      mmat->set(J, I, 0.0);
    }
  }
  
  if((unsigned int)get_parameter_value("dispersal_border_model") != 1) {
    //remove corners
    for (unsigned int i = 0; i < side; ++i){
      //inconsistent rigth and left steps (these were set in the case lattice range = 2 and step = side -1 above)
      I = i * side;
      J = ((i + 1) * side) - 1;
      fmat->set(I, J, 0.0);
      fmat->set(J, I, 0.0);
      mmat->set(I, J, 0.0);
      mmat->set(J, I, 0.0);
    }
    for (unsigned int i = 1; i < side; ++i){
      //inconsistent diagonale steps
      I = i * side - 1;
      J = i * side;
      fmat->set(I, J, 0.0);
      fmat->set(J, I, 0.0);
      mmat->set(I, J, 0.0);
      mmat->set(J, I, 0.0);
    }
  }  
  return true;
}

bool LCE_Disperse_base::setDispMatrix

(

)

Definition at line 331 of file LCEdisperse.cc.

References error(), getDispersalModel(), setIsland_MigrantPool_Matrix(), setIsland_PropagulePool_Matrix(), setLatticeMatrix(), and setSteppingStone1DMatrix().

Referenced by setParameters(), and updateDispMatrix().

{  
  switch ( getDispersalModel() ) {
    case 1:
      return setIsland_MigrantPool_Matrix();
    case 2:
      return setIsland_PropagulePool_Matrix();
    case 3:
      return setSteppingStone1DMatrix();
    case 4:
      return setLatticeMatrix();
    default: {
      error("\nDispersal model '%i' not yet implemented\n",getDispersalModel());
      return false;
    }
  }
  return true;
}

bool LCE_Disperse_base::setIsland_MigrantPool_Matrix

(

)

Definition at line 352 of file LCEdisperse.cc.

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

Referenced by setDispMatrix().

{
#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;
}

bool LCE_Disperse_base::setIsland_PropagulePool_Matrix

(

)

Definition at line 383 of file LCEdisperse.cc.

References _DispMatrix, _fem_rate, _mal_rate, _npatch, SimComponent::_paramSet, 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().

{
  allocateDispMatrix(MAL, _npatch);
  allocateDispMatrix(FEM, _npatch);
  
  if( !_paramSet->isSet("dispersal_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;
}

bool LCE_Disperse_base::setLatticeAbsorbingMatrix

(

)

Definition at line 849 of file LCEdisperse.cc.

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

Referenced by setLatticeMatrix().

{
  TMatrix* mmat = _DispMatrix[MAL];
  TMatrix* fmat = _DispMatrix[FEM];
  
  //set the absorbing patch probs to 1
  for(unsigned int i = 0; i < _npatch+1; ++i) {
    fmat->set(i, _npatch, 1.0);
    mmat->set(i, _npatch, 1.0);
  }
  if(!_isForward) {  fmat->transpose();  mmat->transpose(); }
  
  return true;
}

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

Definition at line 507 of file LCEdisperse.cc.

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

Referenced by setDispMatrix().

{
#ifdef _DEBUG_
  message("setLatticeMatrix()\n");
#endif
  if(!_paramSet->isSet("dispersal_border_model")) {
    error("Missing parameter \"dispersal_border_model\" with dispersal model 4!\n");
    return false;
  }
  
  if(!_paramSet->isSet("dispersal_lattice_range") ) {
    error("Missing parameter \"dispersal_lattice_range\" with dispersal model 4!\n");
    return false;
  }
  
  unsigned int side = (unsigned int) sqrt((double)_npatch);
  
  if( side*side != _npatch ) {
    error("The number of patches is not a square number in the lattice dispersal model\n");
    return false;
  }
  
  if((unsigned int)get_parameter_value("dispersal_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("dispersal_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(side, pmal, pfem, mmal, mfem);
  
  switch((unsigned int)get_parameter_value("dispersal_border_model")) {
    case 1:
      return setLatticeTorrusMatrix(side, mmal, mfem);
    case 2:
      return setLatticeReflectingMatrix(side);
    case 3:
      return setLatticeAbsorbingMatrix();
  }
  
  return true;
  
  //  TMatrix* fmat = _DispMatrix[FEM];
  //  for (unsigned int i=0; i<_npatch; ++i){
  //    for (unsigned int j=0; j<_npatch; ++j)
  //      cout<<fmat->get(i,j)<<"\t";
  //    cout<<endl;
  //  }
} 

bool LCE_Disperse_base::setLatticeReflectingMatrix

(

unsigned int

side

)

Definition at line 735 of file LCEdisperse.cc.

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

Referenced by setLatticeMatrix().

{
  TMatrix* mmat = _DispMatrix[MAL];
  TMatrix* fmat = _DispMatrix[FEM];
  
  double dm, df;
  unsigned int range = (unsigned int)get_parameter_value("dispersal_lattice_range");
  
  //the sum of the corner and border cells disp probs must be one!
  
  //CORNERS
  unsigned int corners[4] = {0, side -1, side*(side -1), _npatch -1};
  
  dm = _mal_rate/(range == 1 ? 2.0 : 3.0);
  df = _fem_rate/(range == 1 ? 2.0 : 3.0);
  
  for(unsigned int i = 0; i < 4; i++) {
    
    fmat->set(corners[i], (corners[i] % side ? corners[i] - 1 : corners[i] + 1), df);
    fmat->set(corners[i], (i < 2 ? corners[i] + side : corners[i] - side), df);
    
    mmat->set(corners[i], (corners[i] % side ? corners[i] - 1 : corners[i] + 1), dm);
    mmat->set(corners[i], (i < 2 ? corners[i] + side : corners[i] - side), dm);
  }
  
  if(range == 2) {
    fmat->set(corners[0], corners[0] + side + 1, df);
    fmat->set(corners[1], corners[1] + side - 1, df);
    fmat->set(corners[2], corners[2] - side + 1, df);
    fmat->set(corners[3], corners[3] - side - 1, df);
    mmat->set(corners[0], corners[0] + side + 1, dm);
    mmat->set(corners[1], corners[1] + side - 1, dm);
    mmat->set(corners[2], corners[2] - side + 1, dm);
    mmat->set(corners[3], corners[3] - side - 1, dm);
  }
  
  //BORDERS
  unsigned int nb_borders = (side - 2) * 4, nb_per_border = side - 2;
  unsigned int borders[nb_borders];
  
  for(unsigned int i = 0; i < nb_per_border; ++i) {
    borders[i] = i + 1; //top row
    borders[i + nb_per_border] = (i+1) * side; //left column
    borders[i + 2*nb_per_border] = (i+2) * side -1; //right column
    borders[i + 3*nb_per_border] = side*(side - 1) + i + 1; //bottom row
  }
  
  dm = _mal_rate/(range == 1 ? 3.0 : 5.0);
  df = _fem_rate/(range == 1 ? 3.0 : 5.0);
  
  for(unsigned int i = 0; i < nb_per_border; ++i) {
    //left and right steps
    //top border:
    fmat->set(borders[i], borders[i] + 1, df);
    fmat->set(borders[i], borders[i] - 1, df);
    //left border, move to the right only
    fmat->set(borders[i + nb_per_border], borders[i + nb_per_border] + 1, df);
    //right border, move to the left only
    fmat->set(borders[i + 2*nb_per_border], borders[i + 2*nb_per_border] - 1, df);
    //bottom border
    fmat->set(borders[i + 3*nb_per_border], borders[i + 3*nb_per_border] + 1, df);
    fmat->set(borders[i + 3*nb_per_border], borders[i + 3*nb_per_border] - 1, df);
    
    mmat->set(borders[i], borders[i] + 1, dm);
    mmat->set(borders[i], borders[i] - 1, dm);
    mmat->set(borders[i + nb_per_border], borders[i+ nb_per_border] + 1, dm);
    mmat->set(borders[i + 2*nb_per_border], borders[i + 2*nb_per_border] - 1, dm);
    mmat->set(borders[i + 3*nb_per_border], borders[i + 3*nb_per_border] + 1, dm);
    mmat->set(borders[i + 3*nb_per_border], borders[i + 3*nb_per_border] - 1, dm);
    //up and down
    fmat->set(borders[i], borders[i] + side, df);
    fmat->set(borders[i + nb_per_border], borders[i + nb_per_border] + side, df);
    fmat->set(borders[i + nb_per_border], borders[i + nb_per_border] - side, df);
    fmat->set(borders[i + 2*nb_per_border], borders[i + 2*nb_per_border] - side, df);
    fmat->set(borders[i + 2*nb_per_border], borders[i + 2*nb_per_border] + side, df);
    fmat->set(borders[i + 3*nb_per_border], borders[i + 3*nb_per_border] - side, df);
    
    mmat->set(borders[i], borders[i] + side, dm);
    mmat->set(borders[i + nb_per_border], borders[i + nb_per_border] + side, dm);
    mmat->set(borders[i + nb_per_border], borders[i + nb_per_border] - side, dm);
    mmat->set(borders[i + 2*nb_per_border], borders[i + 2*nb_per_border] - side, dm);
    mmat->set(borders[i + 2*nb_per_border], borders[i + 2*nb_per_border] + side, dm);
    mmat->set(borders[i + 3*nb_per_border], borders[i + 3*nb_per_border] - side, dm);
  }
  
  if(range == 2) {
    for(unsigned int i = 0; i < nb_per_border; ++i) {
      fmat->set(borders[i], borders[i] + side + 1, df);
      fmat->set(borders[i], borders[i] + side - 1, df);
      fmat->set(borders[i + nb_per_border], borders[i + nb_per_border] - side + 1, df);
      fmat->set(borders[i + nb_per_border], borders[i + nb_per_border] + side + 1, df);
      fmat->set(borders[i + 2*nb_per_border], borders[i + 2*nb_per_border] - side - 1, df);
      fmat->set(borders[i + 2*nb_per_border], borders[i + 2*nb_per_border] + side - 1, df);
      fmat->set(borders[i + 3*nb_per_border], borders[i + 3*nb_per_border] - side + 1, df);
      fmat->set(borders[i + 3*nb_per_border], borders[i + 3*nb_per_border] - side - 1, df);
      
      mmat->set(borders[i], borders[i] + side + 1, dm);
      mmat->set(borders[i], borders[i] + side - 1, dm);
      mmat->set(borders[i + nb_per_border], borders[i + nb_per_border] - side + 1, dm);
      mmat->set(borders[i + nb_per_border], borders[i + nb_per_border] + side + 1, dm);
      mmat->set(borders[i + 2*nb_per_border], borders[i + 2*nb_per_border] - side - 1, dm);
      mmat->set(borders[i + 2*nb_per_border], borders[i + 2*nb_per_border] + side - 1, dm);
      mmat->set(borders[i + 3*nb_per_border], borders[i + 3*nb_per_border] - side + 1, dm);
      mmat->set(borders[i + 3*nb_per_border], borders[i + 3*nb_per_border] - side - 1, dm);
    }    
  }
  
  if(!_isForward) {  fmat->transpose();  mmat->transpose(); }
  
  return true;
}

bool LCE_Disperse_base::setLatticeTorrusMatrix	(	unsigned int	side,
		double	disp_mal,
		double	disp_fem
	)

Definition at line 661 of file LCEdisperse.cc.

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

Referenced by setLatticeMatrix().

{
  unsigned int I, J;
  
  TMatrix* mmat = _DispMatrix[MAL];
  TMatrix* fmat = _DispMatrix[FEM];
  
  for (unsigned int i = 0; i < side; ++i){
    //rigth and left steps across the borders
    I = i * side;
    J = ((i + 1) * side) - 1;
    fmat->set(I, J, disp_fem);
    fmat->set(J, I, disp_fem);
    mmat->set(I, J, disp_mal);
    mmat->set(J, I, disp_mal);
  }
  for (unsigned int i = 0; i < side; ++i){
    //up and down steps across the borders
    J = ((side - 1) * side) + i;
    fmat->set(i, J, disp_fem);
    fmat->set(J, i, disp_fem);
    mmat->set(i, J, disp_mal);
    mmat->set(J, i, disp_mal);
  }
  if((unsigned int)get_parameter_value("dispersal_lattice_range") != 2) {
    for (unsigned int i = 1; i < side; ++i){
      //remove diagonale steps across the borders
      I = i * side - 1;
      J = i * side;
      fmat->set(I, J, 0.0);
      fmat->set(J, I, 0.0);
      mmat->set(I, J, 0.0);
      mmat->set(J, I, 0.0);
    }
  } else {
    //add diagonale steps across the borders
    for (unsigned int i = 0; i < side - 1; ++i){
      I = i * side;
      J = ((i + 2) * side) - 1;
      fmat->set(I, J, disp_fem);
      fmat->set(J, I, disp_fem);
      mmat->set(I, J, disp_mal);
      mmat->set(J, I, disp_mal);
    }
    for (unsigned int i = 0; i < side-1; ++i){
      J = (side - 1) * side + i + 1;
      fmat->set(i, J, disp_fem);
      fmat->set(J, i, disp_fem);
      mmat->set(i, J, disp_mal);
      mmat->set(J, i, disp_mal);
    }
    for (unsigned int i = 1; i < side; ++i){
      J = (side - 1) * side + i - 1;
      fmat->set(i, J, disp_fem);
      fmat->set(J, i, disp_fem);
      mmat->set(i, J, disp_mal);
      mmat->set(J, i, disp_mal);
    }
    //add the corners:
    unsigned int corners[4] = {0, side -1, side*(side -1), _npatch -1};
    fmat->set(corners[0], corners[3], disp_fem);
    fmat->set(corners[3], corners[0], disp_fem);
    fmat->set(corners[1], corners[2], disp_fem);
    fmat->set(corners[2], corners[1], disp_fem);
    mmat->set(corners[0], corners[3], disp_mal);
    mmat->set(corners[3], corners[0], disp_mal);
    mmat->set(corners[1], corners[2], disp_mal);
    mmat->set(corners[2], corners[1], disp_mal);
  }
  return true;
}

bool LCE_Disperse_base::setParameters

(

)

[virtual]

Default interface needed to initialize the component's variables from its input parameters value.

Formerly called 'init'.

Implements SimComponent.

Reimplemented in LCE_Breed_Selection_Disperse, LCE_Disperse_EvolDisp, LCE_Disperse_ConstDisp, and LCE_Breed_Disperse.

Definition at line 78 of file LCEdisperse.cc.

References _disp_model, _disp_propagule_prob, _DispMatrix, _fem_rate, _isForward, _mal_rate, _npatch, SimComponent::_paramSet, LifeCycleEvent::_popPtr, checkBackwardDispersalMatrix(), checkForwardDispersalMatrix(), error(), ParamSet::getMatrix(), Metapop::getPatchNbr(), ParamSet::getValue(), ParamSet::isSet(), setDispMatrix(), and warning().

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

{
  _npatch = _popPtr->getPatchNbr();
  
  _disp_model = (int)_paramSet->getValue("dispersal_model");
  
  _disp_propagule_prob = _paramSet->getValue("dispersal_propagule_prob");
  
  if(_paramSet->isSet("dispersal_matrix")) {
    
    if(_DispMatrix[0] == NULL) _DispMatrix[0] = new TMatrix();
    
    _paramSet->getMatrix("dispersal_matrix",_DispMatrix[0]);
    
    if(_isForward) {
      if(!checkForwardDispersalMatrix(_DispMatrix[0])) return false;
    } else { 
      if(!checkBackwardDispersalMatrix(_DispMatrix[0])) return false;
    }
    
    if(_DispMatrix[1] != NULL) delete _DispMatrix[1];
    
    _DispMatrix[1] = new TMatrix(*_DispMatrix[0]);
    
  } else {
    if(_paramSet->isSet("dispersal_matrix_fem")) {
      
      if(_DispMatrix[0] == NULL) _DispMatrix[0] = new TMatrix();
      
      _paramSet->getMatrix("dispersal_matrix_fem",_DispMatrix[0]);
      
      if(_isForward) {
        if(!checkForwardDispersalMatrix(_DispMatrix[0])) return false;
      } else { 
        if(!checkBackwardDispersalMatrix(_DispMatrix[0])) return false;
      }
    }
    
    if(_paramSet->isSet("dispersal_matrix_mal")) {
      
      if(_DispMatrix[1] == NULL) _DispMatrix[1] = new TMatrix();
      
      _paramSet->getMatrix("dispersal_matrix_mal",_DispMatrix[1]);
      
      if(_isForward) {
        if(!checkForwardDispersalMatrix(_DispMatrix[1])) return false;
      } else {
        if(!checkBackwardDispersalMatrix(_DispMatrix[1])) return false;
      }
    }
  }
  
  if( _paramSet->isSet("dispersal_matrix") || 
     ( _paramSet->isSet("dispersal_matrix_fem") && _paramSet->isSet("dispersal_matrix_mal") )  )
  {
    if(  ( _paramSet->isSet("dispersal_rate") ||
          (_paramSet->isSet("dispersal_rate_fem") &&  _paramSet->isSet("dispersal_rate_mal")) )
       || _paramSet->isSet("dispersal_model") )
      warning("parameter \"dispersal_matrix\" takes precedence over parameters \"dispersal_rate\" and \"dispersal_model\"\n");
    
    _disp_model = 0;
    
  } else {
    
    if(!_paramSet->isSet("dispersal_model")) {
      error("Dispersal model not set!\n");
      return false;
    }
    
    if(_paramSet->isSet("dispersal_rate")) 
      
    {
      _fem_rate = _mal_rate = _paramSet->getValue("dispersal_rate");
      
      if(!setDispMatrix()) return false;
    }
    
    else if(  _paramSet->isSet("dispersal_rate_fem") &&  _paramSet->isSet("dispersal_rate_mal")  ) 
      
    {
      _fem_rate = _paramSet->getValue("dispersal_rate_fem");
      
      _mal_rate = _paramSet->getValue("dispersal_rate_mal");
      
      if(!setDispMatrix()) return false;
    }
    
    else {
      error("Dispersal rate parameters not set!\n");
      return false;
    }
    
  }  
  return true;
}

void LCE_Disperse_base::setPropaguleTargets

(

)

Definition at line 279 of file LCEdisperse.cc.

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

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

{
  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
    
  }
}

bool LCE_Disperse_base::setSteppingStone1DMatrix

(

)

Definition at line 433 of file LCEdisperse.cc.

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

Referenced by setDispMatrix().

{
#ifdef _DEBUG_
  message("setSteppingStone1DMatrix()\n");
#endif
  int border_model = (unsigned int)get_parameter_value("dispersal_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) {
    
    //set migration rates into the absorbing patch:
    fmat->set(0, _npatch, mfem);
    mmat->set(0, _npatch, mmal);
    fmat->set(_npatch -1, _npatch, mfem);
    mmat->set(_npatch -1, _npatch, mmal);
    
    if(!_isForward) { fmat->transpose();  mmat->transpose(); }
    
  } else if (border_model == 2) {
    
    //set migration rates of the two border patches:
    fmat->set(0, 1, 2*mfem);
    mmat->set(0, 1, 2*mmal);
    fmat->set(_npatch -1, _npatch -2, 2*mfem);
    mmat->set(_npatch -1, _npatch -2, 2*mmal);
    
    if(!_isForward) { fmat->transpose();  mmat->transpose(); }
    
  } 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;
}

void LCE_Disperse_base::swapPostDisp

(

)

Definition at line 188 of file LCEdisperse.cc.

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

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

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

bool LCE_Disperse_base::updateDispMatrix

(

)

Definition at line 176 of file LCEdisperse.cc.

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

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

{
  if ( getDispersalModel() == 0) {
    error("cannot update the dispersal matrix provided in input when number of populations changes.\n");
    return false;
  }
  
  return setDispMatrix();
}

---

Friends And Related Function Documentation

friend class LCE_Disperse_ConstDisp [friend]

Definition at line 51 of file LCEdisperse.h.

friend class LCE_Disperse_EvolDisp [friend]

Definition at line 52 of file LCEdisperse.h.

---

Member Data Documentation

int LCE_Disperse_base::_disp_model [private]

Definition at line 42 of file LCEdisperse.h.

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

double LCE_Disperse_base::_disp_propagule_prob [private]

Definition at line 43 of file LCEdisperse.h.

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

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.

Definition at line 49 of file LCEdisperse.h.

Referenced by allocateDispMatrix(), getMigrationPatchBackward(), getMigrationPatchForward(), LCE_Disperse_base(), setBasicLatticeMatrix(), setIsland_MigrantPool_Matrix(), setIsland_PropagulePool_Matrix(), setLatticeAbsorbingMatrix(), setLatticeReflectingMatrix(), setLatticeTorrusMatrix(), setParameters(), setSteppingStone1DMatrix(), and ~LCE_Disperse_base().

double LCE_Disperse_base::_fem_rate [private]

Definition at line 45 of file LCEdisperse.h.

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

bool LCE_Disperse_base::_isForward [private]

Definition at line 46 of file LCEdisperse.h.

Referenced by set_isForward(), setLatticeAbsorbingMatrix(), setLatticeReflectingMatrix(), setParameters(), and setSteppingStone1DMatrix().

double LCE_Disperse_base::_mal_rate [private]

Definition at line 45 of file LCEdisperse.h.

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

unsigned int LCE_Disperse_base::_npatch [protected]

Definition at line 55 of file LCEdisperse.h.

Referenced by LCE_Disperse_EvolDisp::evoldisp(), LCE_Breed_Disperse::execute(), LCE_Disperse_ConstDisp::execute(), LCE_Disperse_EvolDisp::execute(), LCE_Breed_Selection_Disperse::execute(), LCE_Disperse_EvolDisp::fixdisp(), getMigrationPatchBackward(), getMigrationPatchForward(), 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(), reset_counters(), setBasicLatticeMatrix(), setIsland_MigrantPool_Matrix(), setIsland_PropagulePool_Matrix(), setLatticeAbsorbingMatrix(), setLatticeMatrix(), setLatticeReflectingMatrix(), setLatticeTorrusMatrix(), setParameters(), LCE_Disperse_EvolDisp::setParameters(), setSteppingStone1DMatrix(), and swapPostDisp().

vector<unsigned int> LCE_Disperse_base::_PropaguleTargets [private]

Definition at line 44 of file LCEdisperse.h.

Referenced by getPropaguleTarget(), and setPropaguleTargets().

---

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

• LCEdisperse.h
• LCEdisperse.cc