LCE_Resize Class Reference

A class to change the size of the population/patches during a simulation. More...

#include <LCEmisc.h>

Inheritance diagram for LCE_Resize:

Collaboration diagram for LCE_Resize:

Public Member Functions
	LCE_Resize ()
virtual	~LCE_Resize ()
void	buildNewPatchArrayNoBackup ()
void	buildNewPatchArrayWithBackup ()
void	removeDesignatedPatch (bool do_backup)
void	updatePatchCapacities ()
void	fillPop (void(LCE_Resize::*fillFuncPtr)(unsigned int p, age_idx age))
void	fillPatchNoBackup (unsigned int p, age_idx age)
void	fillPatchWithBackup (unsigned int p, age_idx age)
void	regulate (void(LCE_Resize::*regFuncPtr)(Patch *patch, age_idx age))
void	regulateAgeClassWithBackup (Patch *patch, age_idx age)
void	regulateAgeClassNoBackup (Patch *patch, age_idx age)
virtual bool	setParameters ()
bool	updateParameters ()
virtual void	execute ()
virtual LifeCycleEvent *	clone ()
virtual void	loadFileServices (FileServices *loader)
virtual void	loadStatServices (StatServices *loader)
virtual bool	resetParameterFromSource (std::string param, SimComponent *cmpt)
virtual age_t	removeAgeClass ()
virtual age_t	addAgeClass ()
virtual age_t	requiredAgeClass ()
Public Member Functions inherited from LifeCycleEvent
	LifeCycleEvent (const char *name, const char *trait_link)
	Cstor. More...
virtual	~LifeCycleEvent ()
virtual void	init (Metapop *popPtr)
	Sets the pointer to the current Metapop and the trait link if applicable. More...
virtual bool	attach_trait (string trait)
virtual void	set_paramset (std::string name, bool required, SimComponent *owner)
virtual void	set_event_name (std::string &name)
	Set the name of the event (name of the ParamSet) and add the corresponding parameter to the set. More...
virtual void	set_event_name (const char *name)
virtual string &	get_event_name ()
	Accessor to the LCE's name. More...
virtual int	get_rank ()
	Accessor to the LCE rank in the life cycle. More...
virtual void	set_pop_ptr (Metapop *popPtr)
	Accessors for the population pointer. More...
virtual Metapop *	get_pop_ptr ()
Public Member Functions inherited from SimComponent
	SimComponent ()
virtual	~SimComponent ()
virtual void	loadUpdaters (UpdaterServices *loader)
	Loads the parameters and component updater onto the updater manager. More...
virtual void	set_paramset (ParamSet *paramset)
	Sets the ParamSet member. More...
virtual void	set_paramsetFromCopy (const ParamSet &PSet)
	Reset the set of parameters from a another set. More...
virtual ParamSet *	get_paramset ()
	ParamSet accessor. More...
virtual void	add_parameter (Param *param)
	Interface to add a parameter to the set. More...
virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd)
	Interface to add a parameter to the set. More...
virtual void	add_parameter (std::string Name, param_t Type, bool isRequired, bool isBounded, double low_bnd, double up_bnd, ParamUpdaterBase *updater)
	Interface to add a parameter and its updater to the set. More...
virtual Param *	get_parameter (std::string name)
	Param getter. More...
virtual double	get_parameter_value (std::string name)
	Param value getter. More...
virtual string	get_name ()
	Returnd the name of the ParamSet, i.e. More...
virtual bool	has_parameter (std::string name)
	Param getter. More...

Private Attributes
list< int >::const_iterator	_genITER
int	_atGeneration
list< int >	_generations
bool	_do_flush
bool	_do_fill
bool	_do_regulate
TMatrix	_patch2keep
age_t	_setAge
Patch *	_patchBackup

Additional Inherited Members
Protected Attributes inherited from LifeCycleEvent
std::string	_event_name
	The param name to be read in the init file. More...
Metapop *	_popPtr
	The ptr to the current Metapop. More...
std::string	_LCELinkedTraitType
	The name of the linked trait. More...
int	_LCELinkedTraitIndex
	The index in the individual's trait table of the linked trait. More...
Protected Attributes inherited from SimComponent
ParamSet *	_paramSet
	The parameters container. More...

Detailed Description

A class to change the size of the population/patches during a simulation.

Constructor & Destructor Documentation

LCE_Resize()

LCE_Resize::LCE_Resize

(

)

                       : LifeCycleEvent("resize",""), _atGeneration(0),
_do_flush(0), _do_fill(0), _do_regulate(0), _setAge(0), _patchBackup(0)
{
  ParamUpdater< LCE_Resize > * updater = new ParamUpdater< LCE_Resize > (&LCE_Resize::setParameters);
  add_parameter("resize_at_generation", INT, 1, 0, 0, 0, updater);
  updater = new ParamUpdater< LCE_Resize > (&LCE_Resize::updateParameters);
  add_parameter("resize_patch_number", INT, 0, 0, 0, 0, updater);
  add_parameter("resize_patch_capacity", INT, 0, 0, 0, 0, updater);
  add_parameter("resize_female_capacity", INT, 0, 0, 0, 0, updater);
  add_parameter("resize_male_capacity", INT, 0, 0, 0, 0, updater);
  add_parameter("resize_age_class", STR, 0, 0, 0, 0, updater);
  add_parameter("resize_do_flush", BOOL, 0, 0, 0, 0, updater);
  add_parameter("resize_do_regulate", BOOL, 0, 0, 0, 0, updater);
  add_parameter("resize_do_fill", BOOL, 0, 0, 0, 0, updater);
  add_parameter("resize_keep_patch", MAT, 0, 0, 0, 0, updater);
}

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

Referenced by clone().

~LCE_Resize()

virtual LCE_Resize::~LCE_Resize ( )

inlinevirtual

{ if(_patchBackup) delete _patchBackup;}

References _patchBackup.

Member Function Documentation

addAgeClass()

virtual age_t LCE_Resize::addAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return 0;}

buildNewPatchArrayNoBackup()

void LCE_Resize::buildNewPatchArrayNoBackup

(

)

{
  if(_patch2keep.getNbCols() != 0)  removeDesignatedPatch(false);
  
  //
  //add or remove patches until the array size matches Metapop::_patchNbr
  //up to this point, the number of patches to keep could not be != from that nbre
  _popPtr->updatePatchArray();
  
}

References _patch2keep, LifeCycleEvent::_popPtr, TMatrix::getNbCols(), removeDesignatedPatch(), and Metapop::updatePatchArray().

Referenced by execute().

buildNewPatchArrayWithBackup()

void LCE_Resize::buildNewPatchArrayWithBackup

(

)

{
  unsigned int patchNbr =  _popPtr->getPatchNbr();
  
  if(_patch2keep.getNbCols() != 0)  removeDesignatedPatch(true);
  
  //reset the right number of patches to match new parameters
  if(_popPtr->getPatchArraySize() > patchNbr) {
    
    while(_popPtr->getPatchArraySize() > patchNbr) {
      _popPtr->getPatchPtr(0)->copy2patch(_patchBackup);
      _popPtr->getPatchPtr(0)->clear();
      _popPtr->removePatch(0);
    }
  } else while(_popPtr->getPatchArraySize() < patchNbr) _popPtr->addPatch(new Patch());
  //set the patch ID and Ks:
  _popPtr->updatePatchState();
  //regulate the patches, backup the supernumerary individuals, will be used in empty patches
  if(_do_fill) regulate( &LCE_Resize::regulateAgeClassWithBackup );
}

References _do_fill, _patch2keep, _patchBackup, LifeCycleEvent::_popPtr, Metapop::addPatch(), Patch::clear(), Patch::copy2patch(), TMatrix::getNbCols(), Metapop::getPatchArraySize(), Metapop::getPatchNbr(), Metapop::getPatchPtr(), regulate(), regulateAgeClassWithBackup(), removeDesignatedPatch(), Metapop::removePatch(), and Metapop::updatePatchState().

Referenced by execute().

clone()

virtual LifeCycleEvent* LCE_Resize::clone ( )

inlinevirtual

Implements LifeCycleEvent.

{return new LCE_Resize();}

References LCE_Resize().

execute()

void LCE_Resize::execute ( )

virtual

Implements LifeCycleEvent.

{
 
  if(_atGeneration > 0)
    if(_popPtr->getCurrentGeneration() != (unsigned)_atGeneration) return;
  
  if(++_genITER != _generations.end())
    _atGeneration = (*_genITER);
  else {
    _genITER = _generations.begin();
    _atGeneration = (*_genITER);
  }
  
  // if(_everyGeneration > 0)
  //    if(_atGeneration > 0) {
  //      //in this case, the _atGeneration value is taken as the starting point
  //      if( _popPtr->getCurrentGeneration() < (unsigned)_atGeneration ||
  //         (_popPtr->getCurrentGeneration() - _atGeneration) % _everyGeneration ) return;
  //    } else if(_popPtr->getCurrentGeneration() % _everyGeneration) return;
  
#ifdef _DEBUG_
  message("\nLCE_Resize::execute at %i (Patch nb: %i offsprg nb: %i adlt nb: %i)"
          ,_popPtr->getCurrentGeneration(),_popPtr->getPatchArraySize(),_popPtr->size( OFFSPRG ),_popPtr->size( ADULTS ));
#endif
  
  if( !(_popPtr->getCurrentAge() & _setAge) || _popPtr->getCurrentAge() == NONE ) {
    warning("LCE_Resize::execute:: required aged class not present in population, exiting.\n");
    return;
  }
  //first reset the metapop size parameters:
  ParamSet *originalPSet = _popPtr->get_paramset();
  //make a backup copy of the initial parameters state to restore them later:
  ParamSet *pSet = new ParamSet(*originalPSet);
  
  if( get_parameter("resize_patch_number")->isSet() )
    pSet->set_param("patch_number", _paramSet->getArg("resize_patch_number"));
  
  if( get_parameter("resize_keep_patch")->isSet() ) {
    if(_patch2keep.getNbCols() <= _popPtr->getPatchNbr()) {
      pSet->set_param("patch_number", tstring::int2str(_patch2keep.getNbCols()));
    } else if(_patch2keep.getNbCols() > _popPtr->getPatchNbr() && 
              _popPtr->getCurrentGeneration() == (unsigned)_atGeneration)
      //this is a problem if one want to resize AND reorder... unless temporal arg used in pop params
      fatal("LCE_Resize::execute:: more patches to keep than present in the population!\n");
  }
  
  if( get_parameter("resize_patch_capacity")->isSet() )
    pSet->set_param("patch_capacity", _paramSet->getArg("resize_patch_capacity"));
  
  if( get_parameter("resize_female_capacity")->isSet() )
    pSet->set_param("patch_nbfem", _paramSet->getArg("resize_female_capacity"));
  
  if( get_parameter("resize_male_capacity")->isSet() )
    pSet->set_param("patch_nbmal", _paramSet->getArg("resize_male_capacity"));
  
  _popPtr->set_paramset(pSet);
  //just reset the patch number and patch capacities, doesn't touch the patch structure yet
  _popPtr->setPopulationParameters();
  
  //now restore the original param set from the backup, will be needed to start the next replicate:
  _popPtr->set_paramset(originalPSet);
  
  delete pSet;
  
  if(_do_flush) {
    
    //new populations will be empty and supernumerary patches are flushed and deleted
    buildNewPatchArrayNoBackup();
    
  } else {
    
    if(_patchBackup) {
      _patchBackup->clear();
      delete _patchBackup;
    }
    _patchBackup = new Patch();
    
    _patchBackup->init(_popPtr->getPatchKFem(), _popPtr->getPatchKMal(), 0);
    
    //should be used when existing patches are merged together (fusion) or split (fission)
    buildNewPatchArrayWithBackup();
    
  }
  
  // updatePatchCapacities();
  
  if(_do_regulate) {
    if(_do_flush)  regulate( &LCE_Resize::regulateAgeClassNoBackup );
    else           regulate( &LCE_Resize::regulateAgeClassWithBackup );
  }
  
  if(_do_fill){
    if(_do_flush) fillPop( &LCE_Resize::fillPatchNoBackup );
    else          fillPop( &LCE_Resize::fillPatchWithBackup );
  }
#ifdef _DEBUG_
  message(" ---> (Patch nb: %i offsprg nb: %i adlt nb: %i, do_fill %i, do_flush %i)\n"
          ,_popPtr->getPatchNbr(),_popPtr->size( OFFSPRG ),_popPtr->size( ADULTS ), _do_fill, _do_flush);
#endif
}

References _atGeneration, _do_fill, _do_flush, _do_regulate, _generations, _genITER, SimComponent::_paramSet, _patch2keep, _patchBackup, LifeCycleEvent::_popPtr, _setAge, ADULTS, buildNewPatchArrayNoBackup(), buildNewPatchArrayWithBackup(), Patch::clear(), fatal(), fillPatchNoBackup(), fillPatchWithBackup(), fillPop(), SimComponent::get_parameter(), SimComponent::get_paramset(), ParamSet::getArg(), Metapop::getCurrentAge(), Metapop::getCurrentGeneration(), TMatrix::getNbCols(), Metapop::getPatchArraySize(), Metapop::getPatchKFem(), Metapop::getPatchKMal(), Metapop::getPatchNbr(), Patch::init(), tstring::int2str(), message(), NONE, OFFSPRG, regulate(), regulateAgeClassNoBackup(), regulateAgeClassWithBackup(), ParamSet::set_param(), SimComponent::set_paramset(), Metapop::setPopulationParameters(), Metapop::size(), and warning().

fillPatchNoBackup()

void LCE_Resize::fillPatchNoBackup	(	unsigned int	p,
		age_idx	age
	)

{
  Patch *patch = _popPtr->getPatchPtr(p);
  while (patch->size(FEM, age) != patch->get_KFem()) {
    patch->add(FEM, age, _popPtr->makeNewIndividual(NULL, NULL, FEM, patch->getID()));
  }
  while (patch->size(MAL, age) != patch->get_KMal()) {
    patch->add(MAL, age, _popPtr->makeNewIndividual(NULL, NULL, MAL, patch->getID()));
  }
}

References LifeCycleEvent::_popPtr, Patch::add(), FEM, Patch::get_KFem(), Patch::get_KMal(), Patch::getID(), Metapop::getPatchPtr(), IndFactory::makeNewIndividual(), MAL, and Patch::size().

Referenced by execute().

fillPatchWithBackup()

void LCE_Resize::fillPatchWithBackup	(	unsigned int	p,
		age_idx	age
	)

{
  Patch *patch = _popPtr->getPatchPtr(p);
  while (patch->size(FEM, age) != patch->get_KFem() && _patchBackup->size(FEM, age) != 0) {
    patch->add(FEM, age, _patchBackup->get(FEM, age, 0));
    _patchBackup->remove(FEM, age, 0);
  }
  while (patch->size(MAL, age) != patch->get_KMal() && _patchBackup->size(MAL, age) != 0) {
    patch->add(MAL, age, _patchBackup->get(MAL, age, 0));
    _patchBackup->remove(MAL, age, 0);
  }
}

References _patchBackup, LifeCycleEvent::_popPtr, Patch::add(), FEM, Patch::get(), Patch::get_KFem(), Patch::get_KMal(), Metapop::getPatchPtr(), MAL, Patch::remove(), and Patch::size().

Referenced by execute().

fillPop()

void LCE_Resize::fillPop

(

void(LCE_Resize::*)(unsigned int p, age_idx age)

fillFuncPtr

)

{
  age_t active_age = (_popPtr->getCurrentAge() & _setAge);
  
  if(active_age & OFFSPRG) { 
    for(unsigned int i=0; i < _popPtr->getPatchNbr(); ++i) 
      (this->*fillFuncPtr)(i, OFFSx); 
  }
  
  if(active_age & ADULTS) {
    for(unsigned int i=0; i < _popPtr->getPatchNbr(); ++i) 
      (this->*fillFuncPtr)(i, ADLTx); 
  }
}

References LifeCycleEvent::_popPtr, _setAge, ADLTx, ADULTS, Metapop::getCurrentAge(), Metapop::getPatchNbr(), OFFSPRG, and OFFSx.

Referenced by execute().

loadFileServices()

virtual void LCE_Resize::loadFileServices ( FileServices *  loader )

inlinevirtual

Implements SimComponent.

{}

loadStatServices()

virtual void LCE_Resize::loadStatServices ( StatServices *  loader )

inlinevirtual

Implements SimComponent.

{}

regulate()

void LCE_Resize::regulate

(

void(LCE_Resize::*)(Patch *patch, age_idx age)

regFuncPtr

)

{
  Patch *patch;
  for(unsigned int i = 0; i < _popPtr->getPatchNbr(); i++) {
    patch = _popPtr->getPatchPtr(i);
    (this->*regFuncPtr)(patch, OFFSx);
    (this->*regFuncPtr)(patch, ADLTx);
  }
}

References LifeCycleEvent::_popPtr, ADLTx, Metapop::getPatchNbr(), Metapop::getPatchPtr(), and OFFSx.

Referenced by buildNewPatchArrayWithBackup(), and execute().

regulateAgeClassNoBackup()

void LCE_Resize::regulateAgeClassNoBackup	(	Patch *	patch,
		age_idx	age
	)

{
  unsigned int ind;
  
  while(patch->size(FEM, age) > patch->get_KFem()) {
    ind = RAND::Uniform( patch->size(FEM, age) ) ;
    _popPtr->recycle( patch->get(FEM, age, ind) );
    patch->remove(FEM, age, ind);
  }
  
  while(patch->size(MAL, age) > patch->get_KMal()) {
    ind = RAND::Uniform( patch->size(MAL, age) ) ;
    _popPtr->recycle( patch->get(MAL, age, ind) );
    patch->remove(MAL, age, ind);
  }
  
}

References LifeCycleEvent::_popPtr, FEM, Patch::get(), Patch::get_KFem(), Patch::get_KMal(), MAL, IndFactory::recycle(), Patch::remove(), Patch::size(), and RAND::Uniform().

Referenced by execute().

regulateAgeClassWithBackup()

void LCE_Resize::regulateAgeClassWithBackup	(	Patch *	patch,
		age_idx	age
	)

{
  unsigned int ind;
  
  while(patch->size(FEM, age) > patch->get_KFem()) {
    ind = RAND::Uniform( patch->size(FEM, age) ) ;
    _patchBackup->add(FEM, age, patch->get(FEM, age, ind));
    patch->remove(FEM, age, ind);
  }
  
  while(patch->size(MAL, age) > patch->get_KMal()) {
    ind = RAND::Uniform( patch->size(MAL, age) ) ;
    _patchBackup->add(MAL, age, patch->get(MAL, age, ind));
    patch->remove(MAL, age, ind);
  }
  
}

References _patchBackup, Patch::add(), FEM, Patch::get(), Patch::get_KFem(), Patch::get_KMal(), MAL, Patch::remove(), Patch::size(), and RAND::Uniform().

Referenced by buildNewPatchArrayWithBackup(), and execute().

removeAgeClass()

virtual age_t LCE_Resize::removeAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return 0;}

removeDesignatedPatch()

void LCE_Resize::removeDesignatedPatch

(

bool

do_backup

)

{
  deque< Patch* > to_keep;
  Patch* patch;
  unsigned int patchNbr = _popPtr->getPatchArraySize() ;
  unsigned int i, nKeep = _patch2keep.getNbCols();
  unsigned int id;
  
  if(patchNbr < nKeep) fatal("LCE_Resize::more patches to keep than available in the population\n");
  
  for(i = 0; i < nKeep; i++)
    to_keep.push_back( _popPtr->getPatchPtr((unsigned int)_patch2keep.get(0, i)-1 ) );
  
  //remove the patches we want to keep from the patch array, without touching the contents
  for(i = 0; i < nKeep; i++) {
    id = to_keep[i]->getID();
    for(unsigned int j = 0; j < _popPtr->getPatchArraySize(); ++j)
      if(_popPtr->getPatchPtr(j)->getID() == id){ _popPtr->removePatch(j); break;}
  }
  //delete the patches we don't want to keep, remove the individuals and backup them if needed
  for(i = 0; i < _popPtr->getPatchArraySize(); i++) {
    
    patch = _popPtr->getPatchPtr(i);
    
    if(do_backup) { patch->copy2patch(_patchBackup); patch->clear(); }
    
    _popPtr->deletePatch(i); //this deletes the patch and the individuals it contains
    
  }
  //rebuild the patch array with the patches we want, in the right order
  for(i = 0; i < nKeep; i++)
    _popPtr->addPatch(to_keep[i]);
  
  
}

References _patch2keep, _patchBackup, LifeCycleEvent::_popPtr, Metapop::addPatch(), Patch::clear(), Patch::copy2patch(), Metapop::deletePatch(), fatal(), TMatrix::get(), Patch::getID(), TMatrix::getNbCols(), Metapop::getPatchArraySize(), Metapop::getPatchPtr(), and Metapop::removePatch().

Referenced by buildNewPatchArrayNoBackup(), and buildNewPatchArrayWithBackup().

requiredAgeClass()

virtual age_t LCE_Resize::requiredAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return 0;}

resetParameterFromSource()

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

inlinevirtual

Implements SimComponent.

{return false;}

setParameters()

bool LCE_Resize::setParameters ( )

virtual

Implements SimComponent.

{
  
  _generations.clear();
  
  if(_paramSet->isMatrix("resize_at_generation") ) {
    
    TMatrix tmp;
    
    _paramSet->getMatrix("resize_at_generation", &tmp);
    
    for(unsigned int i = 0; i < tmp.getNbCols(); i++)
      _generations.push_back((int)tmp.get(0, i));
    
  } else
    _generations.push_back((int)get_parameter_value("resize_at_generation"));
  
  _genITER = _generations.begin();
  _atGeneration =  (*_genITER);
  
  return updateParameters();
}

References _atGeneration, _generations, _genITER, SimComponent::_paramSet, TMatrix::get(), SimComponent::get_parameter_value(), ParamSet::getMatrix(), TMatrix::getNbCols(), ParamSet::isMatrix(), and updateParameters().

Referenced by LCE_Resize().

updateParameters()

bool LCE_Resize::updateParameters

(

)

{
  string option = _paramSet->getArg("resize_age_class");
  
  if(option.length() == 0) _setAge = ALL;
  else if(option.compare("OFFSPRG") == 0 || option.compare("offspring") == 0 ||
          option.compare("0") == 0){
    _setAge = OFFSPRG;
  } else if(option.compare("ADULTS") == 0 || option.compare("adults") == 0 ||
            option.compare("1") == 0) {
    _setAge = ADULTS;
  } else if(option.compare("ALL") == 0 || option.compare("all") == 0) {
    _setAge = ALL;
  } else {
    warning("\"%s\" is not a valid option for parameter \"resize_age_class\".\n",option.c_str());
    _setAge = ALL;
  }
  
  if( !get_parameter("resize_patch_number")->isSet() &&
     !get_parameter("resize_patch_capacity")->isSet() &&
     !get_parameter("resize_female_capacity")->isSet() &&
     !get_parameter("resize_male_capacity")->isSet() &&
     !get_parameter("resize_keep_patch")->isSet()) {
    error("LCE_Resize:: at least one of the population size parameters must be specified.\n");
    return false;
  }
  
  _do_regulate = get_parameter("resize_do_regulate")->isSet();
  _do_flush = get_parameter("resize_do_flush")->isSet();
  _do_fill = get_parameter("resize_do_fill")->isSet();
  
  if(get_parameter("resize_keep_patch")->isSet()) {
    _paramSet->getMatrix("resize_keep_patch", &_patch2keep);
    if(_patch2keep.getNbCols() > _popPtr->getPatchNbr() && 
       _popPtr->getCurrentGeneration() == (unsigned)_atGeneration) {
      error("LCE_Resize:: more patches to keep than existing patches in the population!\n");
      return false;
    }
  } else
    _patch2keep.reset();
  return true;
}

References _atGeneration, _do_fill, _do_flush, _do_regulate, SimComponent::_paramSet, _patch2keep, LifeCycleEvent::_popPtr, _setAge, ADULTS, ALL, error(), SimComponent::get_parameter(), ParamSet::getArg(), Metapop::getCurrentGeneration(), ParamSet::getMatrix(), TMatrix::getNbCols(), Metapop::getPatchNbr(), Param::isSet(), OFFSPRG, TMatrix::reset(), and warning().

Referenced by LCE_Resize(), and setParameters().

updatePatchCapacities()

void LCE_Resize::updatePatchCapacities

(

)

{
  TMatrix *cap = _popPtr->getPatchCapacities();
  
  if(cap->getNbCols() != _popPtr->getPatchNbr())
    fatal("LCE_Resize:: more patch capacities than patches in the population!\n");
  
  for (unsigned int i = 0; i < _popPtr->getPatchNbr(); i++) {
    _popPtr->getPatchPtr(i)->set_KFem((unsigned int)cap->get(FEM, i));
    _popPtr->getPatchPtr(i)->set_KMal((unsigned int)cap->get(MAL, i));
  }
}

References LifeCycleEvent::_popPtr, fatal(), FEM, TMatrix::get(), TMatrix::getNbCols(), Metapop::getPatchCapacities(), Metapop::getPatchNbr(), Metapop::getPatchPtr(), MAL, Patch::set_KFem(), and Patch::set_KMal().

Member Data Documentation

_atGeneration

int LCE_Resize::_atGeneration

private

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

_do_fill

bool LCE_Resize::_do_fill

private

Referenced by buildNewPatchArrayWithBackup(), execute(), and updateParameters().

_do_flush

bool LCE_Resize::_do_flush

private

Referenced by execute(), and updateParameters().

_do_regulate

bool LCE_Resize::_do_regulate

private

Referenced by execute(), and updateParameters().

_generations

list< int > LCE_Resize::_generations

private

Referenced by execute(), and setParameters().

_genITER

list< int >::const_iterator LCE_Resize::_genITER

private

Referenced by execute(), and setParameters().

_patch2keep

TMatrix LCE_Resize::_patch2keep

private

Referenced by buildNewPatchArrayNoBackup(), buildNewPatchArrayWithBackup(), execute(), removeDesignatedPatch(), and updateParameters().

_patchBackup

Patch* LCE_Resize::_patchBackup

private

Referenced by buildNewPatchArrayWithBackup(), execute(), fillPatchWithBackup(), regulateAgeClassWithBackup(), removeDesignatedPatch(), and ~LCE_Resize().

_setAge

age_t LCE_Resize::_setAge

private

Referenced by execute(), fillPop(), and updateParameters().

---

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

• LCEmisc.h
• LCEmisc.cc