LCE_Patch_Extinction Class Reference

Randomly removes individuals from the patches according to the extinction rate parameter. More...

#include <LCEmisc.h>

Inheritance diagram for LCE_Patch_Extinction:

Collaboration diagram for LCE_Patch_Extinction:

Public Member Functions
	LCE_Patch_Extinction ()
virtual	~LCE_Patch_Extinction ()
bool	set_matrix_param (TMatrix *mat, string name)
void	do_flush (Patch *patch)
void	do_remove (age_idx AGE, Patch *patch)
unsigned int	get_harvest_size (age_idx AGE, Patch *patch)
virtual bool	setParameters ()
virtual void	execute ()
virtual LifeCycleEvent *	clone ()
virtual void	loadFileServices (FileServices *loader)
virtual void	loadStatServices (StatServices *loader)
virtual bool	resetParameterFromSource (std::string param, SimComponent *cmpt)
virtual age_t	removeAgeClass ()
virtual age_t	addAgeClass ()
virtual age_t	requiredAgeClass ()
Public Member Functions inherited from 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 Member Functions
unsigned int	rand_uniform (double max)
unsigned int	rand_poisson (double mean)
unsigned int	rand_gaussian (double mean)
unsigned int	rand_exp (double mean)
unsigned int	rand_lognormal (double mean)

Private Attributes
TMatrix *	_Xtion_rate
	Patch extinction probability. More...
TMatrix *	_harvest_size
	Number of individual to remove per patch. More...
TMatrix *	_harvest_proportion
	Proportion of the patch size to remove. More...
string	_harvest_distribution
	Name of the distribution to use. More...
bool	_harvest_size_varies
	Flags. More...
bool	_by_size
bool	_by_proportion
double	_harvest_dist_stdev
	Standard deviate to use with the Gaussian dist. More...
double	_harvest_dist_shape
	shape variable to use with the gamma dist. More...
double	_extinction_threshold
	Patch extinction threshold in % of total size of the patch. More...
unsigned int(LCE_Patch_Extinction::*	_rand_size_fct )(double)

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

Randomly removes individuals from the patches according to the extinction rate parameter.

Sets the patches extinction flag accordingly.

Constructor & Destructor Documentation

LCE_Patch_Extinction()

LCE_Patch_Extinction::LCE_Patch_Extinction

(

)

                                            : LifeCycleEvent("extinction",""), _Xtion_rate(0),
_harvest_size(0), _harvest_proportion(0), _harvest_size_varies(0), _by_size(0), 
_by_proportion(0), _harvest_dist_stdev(0), _extinction_threshold(0), _rand_size_fct(0)
{
  ParamUpdater< LCE_Patch_Extinction > * updater =
  new ParamUpdater< LCE_Patch_Extinction > (&LCE_Patch_Extinction::setParameters);
  add_parameter("extinction_rate", DBL, 0, 1, 0, 1, updater);
  add_parameter("extinction_threshold", DBL, 0, 1, 0, 1, updater);
  add_parameter("extinction_size", INT, 0, 0, 0, 0, updater);
  add_parameter("extinction_proportion", DBL, 0, 1, 0, 1, updater);
  add_parameter("extinction_size_distribution", STR, 0, 0, 0, 0, updater);
  add_parameter("extinction_size_dist_stdev", DBL, 0, 0, 0, 0, updater);
  add_parameter("extinction_size_dist_shape", DBL, 0, 0, 0, 0, updater);
}

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

Referenced by clone().

~LCE_Patch_Extinction()

virtual LCE_Patch_Extinction::~LCE_Patch_Extinction ( )

inlinevirtual

  {
    if(_Xtion_rate) delete _Xtion_rate;
    if(_harvest_size) delete _harvest_size; 
    if(_harvest_proportion) delete _harvest_proportion;
  }

References _harvest_proportion, _harvest_size, and _Xtion_rate.

Member Function Documentation

addAgeClass()

virtual age_t LCE_Patch_Extinction::addAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return 0;}

clone()

virtual LifeCycleEvent* LCE_Patch_Extinction::clone ( )

inlinevirtual

Implements LifeCycleEvent.

{return new LCE_Patch_Extinction();}

References LCE_Patch_Extinction().

do_flush()

void LCE_Patch_Extinction::do_flush

(

Patch *

patch

)

{
  patch->flush(_popPtr);
  patch->set_isExtinct(true);
  patch->set_age(0);
}

References LifeCycleEvent::_popPtr, Patch::flush(), Patch::set_age(), and Patch::set_isExtinct().

Referenced by execute().

do_remove()

void LCE_Patch_Extinction::do_remove	(	age_idx	AGE,
		Patch *	patch
	)

{
  unsigned int remove_size;
  sex_t sex;
  
  //check if probability of event is set, and if removal will happen
  if(_Xtion_rate) if( RAND::Uniform() > _Xtion_rate->get(0, patch->getID()) ) return;
  
  if(patch->size(AGE) != 0) {
    
    remove_size = get_harvest_size(AGE, patch);
    
    for(unsigned int i = 0; i < remove_size; ++i) {
      
      sex = (sex_t)RAND::RandBool(); 
      
      if(patch->size(sex, AGE) != 0)
        _popPtr->recycle( patch->remove( sex, AGE, (unsigned int)RAND::Uniform(patch->size(sex, AGE)) ) );
      else //we already know here that the patch is not empty
        _popPtr->recycle( patch->remove( (sex_t)!sex, AGE, (unsigned int)RAND::Uniform(patch->size( (sex_t)!sex, AGE) ) ) );
      
      if(patch->size(AGE) == 0) break;
    }
    //    cout<<"--removed "<<remove_size<<" individuals in age class "<<AGE<<", patch "<< patch->getID()<<" size = "<<patch->size(AGE)<<endl;
  }
}

References LifeCycleEvent::_popPtr, _Xtion_rate, TMatrix::get(), get_harvest_size(), Patch::getID(), RAND::RandBool(), IndFactory::recycle(), Patch::remove(), Patch::size(), and RAND::Uniform().

Referenced by execute().

execute()

void LCE_Patch_Extinction::execute ( )

virtual

Implements LifeCycleEvent.

{
#ifdef _DEBUG_
  message("LCE_Patch_Extinction::execute ");
  unsigned int cnt = 0;
#endif
  Patch *patch;
  for(unsigned int i = 0; i < _popPtr->getPatchNbr(); i++) {
    
    patch = _popPtr->getPatch(i);
    
    if(_by_size || _by_proportion) {
      do_remove(OFFSx, patch);
      do_remove(ADLTx, patch);
    } else if(_Xtion_rate)
      if( RAND::Uniform() < _Xtion_rate->get(0, i) )
        do_flush(patch);
    
    if(_extinction_threshold != -1) {
      if( _extinction_threshold < 1 && (double)patch->size(ALL)/patch->get_K() < _extinction_threshold ) 
        do_flush(patch);
      else if( patch->size(ALL) < _extinction_threshold )
        do_flush(patch);
    }
#ifdef _DEBUG_
    cnt += (patch->get_isExtinct());
#endif
  }
#ifdef _DEBUG_
  message("(%i extinct patches)\n",cnt);
#endif  
}

References _by_proportion, _by_size, _extinction_threshold, LifeCycleEvent::_popPtr, _Xtion_rate, ADLTx, ALL, do_flush(), do_remove(), TMatrix::get(), Patch::get_isExtinct(), Patch::get_K(), Metapop::getPatch(), Metapop::getPatchNbr(), message(), OFFSx, Patch::size(), and RAND::Uniform().

get_harvest_size()

unsigned int LCE_Patch_Extinction::get_harvest_size	(	age_idx	AGE,
		Patch *	patch
	)

{
  
  if( _by_size ) {
    
    if(_harvest_size_varies)  
      return (this->*_rand_size_fct) (_harvest_size->get(0, patch->getID()));
    
    else return (unsigned int)_harvest_size->get(0, patch->getID());
    
  } else if( _by_proportion ) {
    
    return (unsigned int)(_harvest_proportion->get(0, patch->getID()) * patch->size(AGE));
    
  }
  
  return 0;
}

References _by_proportion, _by_size, _harvest_proportion, _harvest_size, _harvest_size_varies, _rand_size_fct, TMatrix::get(), Patch::getID(), and Patch::size().

Referenced by do_remove().

loadFileServices()

virtual void LCE_Patch_Extinction::loadFileServices ( FileServices *  loader )

inlinevirtual

Implements SimComponent.

{}

loadStatServices()

virtual void LCE_Patch_Extinction::loadStatServices ( StatServices *  loader )

inlinevirtual

Implements SimComponent.

{}

rand_exp()

unsigned int LCE_Patch_Extinction::rand_exp ( double  mean )

inlineprivate

{return (unsigned int)(-1.0 * mean * log(1.0-RAND::Uniform()));}

References RAND::Uniform().

Referenced by setParameters().

rand_gaussian()

unsigned int LCE_Patch_Extinction::rand_gaussian ( double  mean )

inlineprivate

{return (unsigned int)abs(mean + RAND::Gaussian(_harvest_dist_stdev));}

References _harvest_dist_stdev, and RAND::Gaussian().

Referenced by setParameters().

rand_lognormal()

unsigned int LCE_Patch_Extinction::rand_lognormal ( double  mean )

inlineprivate

{return (unsigned int)RAND::LogNormal(mean, _harvest_dist_stdev);}

References _harvest_dist_stdev, and RAND::LogNormal().

Referenced by setParameters().

rand_poisson()

unsigned int LCE_Patch_Extinction::rand_poisson ( double  mean )

inlineprivate

{return (unsigned int)RAND::Poisson(mean);}

References RAND::Poisson().

Referenced by setParameters().

rand_uniform()

unsigned int LCE_Patch_Extinction::rand_uniform ( double  max )

inlineprivate

{return RAND::Uniform((unsigned int)max);}

References RAND::Uniform().

Referenced by setParameters().

removeAgeClass()

virtual age_t LCE_Patch_Extinction::removeAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return 0;}

requiredAgeClass()

virtual age_t LCE_Patch_Extinction::requiredAgeClass ( )

inlinevirtual

Implements LifeCycleEvent.

{return 0;}

resetParameterFromSource()

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

inlinevirtual

Implements SimComponent.

{return false;}

set_matrix_param()

bool LCE_Patch_Extinction::set_matrix_param	(	TMatrix *	mat,
		string	name
	)

{
  double value;
  Param* param = get_parameter(name);
  
  if(param->isMatrix()) {
    
    param->getMatrix(mat);
    
    if(mat->getNbRows() > 1) {
      error("The \"%s\" matrix must be a one-dimensional array.\n", name.c_str());
      return false;
    }
    
    if(mat->getNbCols() != _popPtr->getPatchNbr()) {
      error("The length of the \"%s\" array must be equal to the number of patches.\n", name.c_str());
      return false;
    }
    
  } else {
    value = param->getValue();
    mat->reset(1, _popPtr->getPatchNbr());
    mat->assign(value);
  }
  return true; 
}

References LifeCycleEvent::_popPtr, TMatrix::assign(), error(), SimComponent::get_parameter(), Param::getMatrix(), TMatrix::getNbCols(), TMatrix::getNbRows(), Metapop::getPatchNbr(), Param::getValue(), Param::isMatrix(), and TMatrix::reset().

Referenced by setParameters().

setParameters()

bool LCE_Patch_Extinction::setParameters ( )

virtual

Implements SimComponent.

{
  
  if(get_parameter("extinction_rate")->isSet()) {
    
    if(!_Xtion_rate) _Xtion_rate = new TMatrix();
    
    if(!set_matrix_param(_Xtion_rate, "extinction_rate")) return false;
    
  } else {
    if(_Xtion_rate) delete _Xtion_rate;
    _Xtion_rate = 0;
  }
  
  if(get_parameter("extinction_size")->isSet()) {
    
    if(!_harvest_size) _harvest_size = new TMatrix();
    
    if(!set_matrix_param(_harvest_size, "extinction_size")) return false;
    
    _by_size = true;
    
  } else {
    if(_harvest_size) delete _harvest_size;
    _harvest_size = 0;
    _by_size = false;
  }
  
  if(get_parameter("extinction_proportion")->isSet()) {
    if(!_harvest_proportion) _harvest_proportion = new TMatrix();
    
    if(!set_matrix_param(_harvest_proportion, "extinction_proportion")) return false;
    
    _by_proportion = true;
    
  } else {
    if(_harvest_proportion) delete _harvest_proportion;
    _harvest_proportion = 0;
    _by_proportion = false;
  }
  
  _extinction_threshold = get_parameter_value("extinction_threshold");
  
  if( !_Xtion_rate && !_by_size && !_by_proportion) {
    error("Please give one of the following parameter: \"extinction_rate\", \"extinction_size\", or \"extinction_proportion\".\n");
    return false;
  }
  else if(_by_size && _by_proportion) {
    warning("Both \"extinction_size\" and \"extinction_proportion\" are set, using sizes only.\n");
    _by_proportion = false;
  }
  
  if(get_parameter("extinction_size_distribution")->isSet()) {
    
    if(!_by_size) {
      error("\"extinction_size_distribution\" is set but the \"extinction_size\" parameter is not!\n");
      return false;
    }
    
    _harvest_distribution = _paramSet->getArg("extinction_size_distribution");
    _harvest_size_varies = true;
    _harvest_dist_stdev = get_parameter_value("extinction_size_dist_stdev");
    
    if(_harvest_distribution.compare("poisson") == 0)
      
      _rand_size_fct = &LCE_Patch_Extinction::rand_poisson;
    
    else if(_harvest_distribution.compare("uniform") == 0)
      
      _rand_size_fct = &LCE_Patch_Extinction::rand_uniform;
    
    else if(_harvest_distribution.compare("normal") == 0) {
      
      _rand_size_fct = &LCE_Patch_Extinction::rand_gaussian;
      
      if(_harvest_dist_stdev == -1) {
        error("Standard deviation of the normal distribution for the harvesting size distribution is missing!\n");
        return false;
      }
      
    } else if(_harvest_distribution.compare("lognormal") == 0) {
      
      _rand_size_fct = &LCE_Patch_Extinction::rand_lognormal;
      
      if(_harvest_dist_stdev == -1) {
        error("Standard deviation of the lognormal distribution for the harvesting size distribution is missing!\n");
        return false;
      }
      
    } else if(_harvest_distribution.compare("exponential") == 0)
      
      _rand_size_fct = &LCE_Patch_Extinction::rand_exp;
    
    else {
      error("Distribution \"%s\" is not a valid option for \"harvest_size_distribution\"\n",
            _harvest_distribution.c_str());
      return false;
    }
    
  }
  return true;
}

References _by_proportion, _by_size, _extinction_threshold, _harvest_dist_stdev, _harvest_distribution, _harvest_proportion, _harvest_size, _harvest_size_varies, SimComponent::_paramSet, _rand_size_fct, _Xtion_rate, error(), SimComponent::get_parameter(), SimComponent::get_parameter_value(), ParamSet::getArg(), rand_exp(), rand_gaussian(), rand_lognormal(), rand_poisson(), rand_uniform(), set_matrix_param(), and warning().

Referenced by LCE_Patch_Extinction().

Member Data Documentation

_by_proportion

bool LCE_Patch_Extinction::_by_proportion

private

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

_by_size

bool LCE_Patch_Extinction::_by_size

private

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

_extinction_threshold

double LCE_Patch_Extinction::_extinction_threshold

private

Patch extinction threshold in % of total size of the patch.

Referenced by execute(), and setParameters().

_harvest_dist_shape

double LCE_Patch_Extinction::_harvest_dist_shape

private

shape variable to use with the gamma dist.

_harvest_dist_stdev

double LCE_Patch_Extinction::_harvest_dist_stdev

private

Standard deviate to use with the Gaussian dist.

Referenced by rand_gaussian(), rand_lognormal(), and setParameters().

_harvest_distribution

string LCE_Patch_Extinction::_harvest_distribution

private

Name of the distribution to use.

Referenced by setParameters().

_harvest_proportion

TMatrix* LCE_Patch_Extinction::_harvest_proportion

private

Proportion of the patch size to remove.

Referenced by get_harvest_size(), setParameters(), and ~LCE_Patch_Extinction().

_harvest_size

TMatrix* LCE_Patch_Extinction::_harvest_size

private

Number of individual to remove per patch.

Referenced by get_harvest_size(), setParameters(), and ~LCE_Patch_Extinction().

_harvest_size_varies

bool LCE_Patch_Extinction::_harvest_size_varies

private

Flags.

Referenced by get_harvest_size(), and setParameters().

_rand_size_fct

unsigned int(LCE_Patch_Extinction:: * LCE_Patch_Extinction::_rand_size_fct) (double)

private

Referenced by get_harvest_size(), and setParameters().

_Xtion_rate

TMatrix* LCE_Patch_Extinction::_Xtion_rate

private

Patch extinction probability.

Referenced by do_remove(), execute(), setParameters(), and ~LCE_Patch_Extinction().

---

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

• LCEmisc.h
• LCEmisc.cc