Utopia::Models::Vegetation::Vegetation Class Reference

A very simple vegetation model. More...

#include <Vegetation.hh>

Inheritance diagram for Utopia::Models::Vegetation::Vegetation:

Collaboration diagram for Utopia::Models::Vegetation::Vegetation:

Public Types
using	Base = Model< Vegetation, VegetationTypes >
	Type of the base class.
using	Config = typename Base::Config
	Type of the config tree.
using	DataSet = typename Base::DataSet
	Type of a data set.
using	CellManager = Utopia::CellManager< CellTraits, Vegetation >
	Type of the cell manager used.
using	RuleFunc = typename CellManager::RuleFunc
	Type of the update rule.
Public Types inherited from Utopia::Model< Vegetation, VegetationTypes >
using	Config = typename ModelTypes::Config
	Data type that holds the configuration.
using	DataManager = DataIO::Default::DefaultDataManager< Vegetation >
	The data manager to use, specialized with the derived model.
using	DataGroup = typename ModelTypes::DataGroup
	Data type that is used for storing datasets.
using	DataSet = typename ModelTypes::DataSet
	Data type that is used for storing data.
using	RNG = typename ModelTypes::RNG
	Data type of the shared RNG.
using	Space = typename ModelTypes::Space
	Data type of the space this model resides in.
using	Time = typename ModelTypes::Time
	Data type for the model time.
using	Monitor = typename ModelTypes::Monitor
	Data type for the monitor.
using	MonitorManager = typename ModelTypes::MonitorManager
	Data type for the monitor manager.
using	Level = typename ModelTypes::Level
	Data type for the hierarchical level.

Public Member Functions
template<class ParentModel >
	Vegetation (const std::string &name, const ParentModel &parent_model, const DataIO::Config &custom_cfg={})
	Construct the Vegetation model.
void	perform_step ()
	Iterate a single step.
void	write_data ()
	Write the cell states (aka plant bio-mass)
void	monitor ()
	Monitor the current model state; supplies the mean plant mass.
Public Member Functions inherited from Utopia::Model< Vegetation, VegetationTypes >
	Model (const std::string &name, const ParentModel &parent_model, const Config &custom_cfg={}, std::tuple< WriterArgs... > w_args={}, const DataIO::Default::DefaultDecidermap< Vegetation > &w_deciders=DataIO::Default::default_deciders< Vegetation >, const DataIO::Default::DefaultTriggermap< Vegetation > &w_triggers=DataIO::Default::default_triggers< Vegetation >)
	Constructs a Model instance.
const std::shared_ptr< Space > &	get_space () const
	Return the space this model resides in.
Time	get_time () const
	Return the current time of this model.
Time	get_time_max () const
	Return the maximum time possible for this model.
Config	get_cfg () const
	Return the config node of this model.
std::string	get_name () const
	Return the name of this model instance.
std::string	get_full_name () const
	Return the full name of this model within the model hierarchy.
std::shared_ptr< DataGroup >	get_hdfgrp () const
	Return a pointer to the HDF group this model stores data in.
Time	get_write_start () const
	Return the parameter that controls when write_data is called first.
Time	get_write_every () const
	Return the parameter that controls how often write_data is called.
DataManager	get_datamanager () const
	return the datamanager
hsize_t	get_remaining_num_writes () const
	Return the number of remaining write_data calls this model will make.
std::shared_ptr< RNG >	get_rng () const
	Return a pointer to the shared RNG.
std::shared_ptr< spdlog::logger >	get_logger () const
	Return a pointer to the logger of this model.
Monitor	get_monitor () const
	Return the monitor of this model.
std::shared_ptr< MonitorManager >	get_monitor_manager () const
	Get the monitor manager of the root model.
Level	get_level () const
	Return the hierarchical level within the model hierarchy.
virtual void	prolog ()
	A function that is called before starting model iteration.
virtual void	epilog ()
	A function that is called after the last iteration of a model.
void	iterate ()
	Iterate one (time) step of this model.
void	run ()
	Run the model from the current time to the maximum time.
std::shared_ptr< DataSet >	create_dset (const std::string name, const std::shared_ptr< DataGroup > &hdfgrp, std::vector< hsize_t > add_write_shape, const std::size_t compression_level=1, const std::vector< hsize_t > chunksize={})
	Create a new dataset within the given group.
std::shared_ptr< DataSet >	create_dset (const std::string name, const std::vector< hsize_t > add_write_shape, const std::size_t compression_level=1, const std::vector< hsize_t > chunksize={})
	Create a new dataset within the model's base data group.
std::shared_ptr< DataSet >	create_cm_dset (const std::string name, const CellManager &cm, const std::size_t compression_level=1, const std::vector< hsize_t > chunksize={})
	Create a dataset storing data from a CellManager.
std::shared_ptr< DataSet >	create_am_dset (const std::string name, const AgentManager &am, const std::size_t compression_level=1, const std::vector< hsize_t > chunksize={})
	Create a dataset storing data from a AgentManager.

Private Member Functions
double	calc_mean_mass () const
	Calculate the mean plant mass.

Private Attributes
CellManager	_cm
	The grid manager.
std::normal_distribution< double >	_rain_dist
	Normal distribution for drawing random rain values.
double	_growth_rate
	The growth rate (logistic growth model)
double	_seeding_rate
	The seeding rate.
std::shared_ptr< DataSet >	_dset_plant_mass
	Plant mass dataset.
RuleFunc	_growth_seeding
	Apply logistic growth and seeding.

Additional Inherited Members
Protected Member Functions inherited from Utopia::Model< Vegetation, VegetationTypes >
void	__perform_step ()
	Perform the computation of a step.
void	__monitor ()
	Monitor information in the terminal.
void	__write_data ()
	Write data; calls the implementation's write_data method.
void	__write_initial_state ()
	Write the initial state.
void	increment_time (const Time dt=1)
	Increment time.
void	__prolog ()
	The default prolog of a model.
void	__epilog ()
	The default epilog of a model.
Vegetation &	impl ()
	cast to the derived class
const Vegetation &	impl () const
	const cast to the derived interface
Protected Attributes inherited from Utopia::Model< Vegetation, VegetationTypes >
const std::string	_name
	Name of the model instance.
const std::string	_full_name
	The full name within the model hierarchy.
const Level	_level
	The level within the model hierarchy.
const Config	_cfg
	Config node belonging to this model instance.
const std::shared_ptr< RNG >	_rng
	The RNG shared between models.
const std::shared_ptr< spdlog::logger >	_log
	The (model) logger.
std::shared_ptr< Space >	_space
	The space this model resides in.
Time	_time
	Model-internal current time stamp.
const Time	_time_max
	Model-internal maximum time stamp.
const std::shared_ptr< DataGroup >	_hdfgrp
	The HDF group this model instance should write its data to.
const Time	_write_start
	First time at which write_data is called.
const Time	_write_every
	How often to call write_data from iterate.
Monitor	_monitor
	The monitor.
DataManager	_datamanager
	Manager object for handling data output; see DataManager.
Static Protected Attributes inherited from Utopia::Model< Vegetation, VegetationTypes >
static constexpr WriteMode	_write_mode
	Which data-writing mode the base model should use.

Detailed Description

A very simple vegetation model.

Member Typedef Documentation

Base

using Utopia::Models::Vegetation::Vegetation::Base = Model<Vegetation, VegetationTypes>

Type of the base class.

CellManager

using Utopia::Models::Vegetation::Vegetation::CellManager = Utopia::CellManager<CellTraits, Vegetation>

Type of the cell manager used.

Config

using Utopia::Models::Vegetation::Vegetation::Config = typename Base::Config

Type of the config tree.

DataSet

using Utopia::Models::Vegetation::Vegetation::DataSet = typename Base::DataSet

Type of a data set.

RuleFunc

using Utopia::Models::Vegetation::Vegetation::RuleFunc = typename CellManager::RuleFunc

Type of the update rule.

Constructor & Destructor Documentation

Vegetation()

template<class ParentModel >

Utopia::Models::Vegetation::Vegetation::Vegetation ( const std::string &  name, const ParentModel &  parent_model, const DataIO::Config &  custom_cfg = {}  )

inline

Construct the Vegetation model.

Parameters

name	Name of this model instance; is used to extract the configuration from the parent model and set up a HDFGroup for this instance
parent_model	The parent model this model instance resides in
custom_cfg	A custom configuration to use instead of the one extracted from the parent model using the instance name

                                         {}
    )
    :
        // Construct the base class
        Base(name, parent_model, custom_cfg),
 
        // Initialize the manager, setting the initial state
        _cm(*this, CellState({0.0})),
 
        // Initialize the rain distribution
        _rain_dist{get_as<double>("rain_mean", this->_cfg),
                   get_as<double>("rain_std", this->_cfg)},
 
        // Initialize model parameters from config file
        _growth_rate(get_as<double>("growth_rate", this->_cfg)),
        _seeding_rate(get_as<double>("seeding_rate", this->_cfg)),
 
        // Open dataset for output of cell states
        _dset_plant_mass(this->create_cm_dset("plant_mass", _cm))
    {
        this->_log->info("'{}' model fully set up.", name);
    }

Member Function Documentation

calc_mean_mass()

double Utopia::Models::Vegetation::Vegetation::calc_mean_mass ( ) const

inlineprivate

Calculate the mean plant mass.

                                   {
        return std::accumulate(_cm.cells().begin(),
                               _cm.cells().end(),
                               0.,
                               [](double sum, const auto& cell) {
                                   return sum + cell->state().plant_mass;
                               }) / _cm.cells().size();
    }

monitor()

void Utopia::Models::Vegetation::Vegetation::monitor ( )

inline

Monitor the current model state; supplies the mean plant mass.

                    {
        this->_monitor.set_entry("mean_mass", calc_mean_mass());
    }

perform_step()

void Utopia::Models::Vegetation::Vegetation::perform_step ( )

inline

Iterate a single step.

    {
        apply_rule(_growth_seeding, _cm.cells());
    }

write_data()

void Utopia::Models::Vegetation::Vegetation::write_data ( )

inline

Write the cell states (aka plant bio-mass)

    {
        _dset_plant_mass->write(_cm.cells().begin(),
                                _cm.cells().end(),
                                [](auto& cell) {
                                    return cell->state().plant_mass; }
                                );
    }

Member Data Documentation

_cm

CellManager Utopia::Models::Vegetation::Vegetation::_cm

private

The grid manager.

_dset_plant_mass

std::shared_ptr<DataSet> Utopia::Models::Vegetation::Vegetation::_dset_plant_mass

private

Plant mass dataset.

_growth_rate

double Utopia::Models::Vegetation::Vegetation::_growth_rate

private

The growth rate (logistic growth model)

_growth_seeding

RuleFunc Utopia::Models::Vegetation::Vegetation::_growth_seeding

private

Initial value:

= [this](const auto& cell){
        auto state = cell->state();
        auto rain = _rain_dist(*(this->_rng));
        auto mass = state.plant_mass;
 
        if (rain < 1e-16) {
            rain = 0.;
        }
 
        
        
        
        if (not (mass < 1e-16)) {
            
            
            state.plant_mass = ((_growth_rate + 1.) * mass)/(1. + (mass * (_growth_rate))/rain);
        }
        else {
            
            state.plant_mass = _seeding_rate * rain;
        }
 
        return state;
    }

Apply logistic growth and seeding.

For each cell, a random gauss-distributed number is drawn that represents the rainfall onto that cell. If the plant bio-mass at that cell is already non-zero, it is increased according to a logistic growth model, modelled by the Beverton-Holt discretisation of the logistic function. If it is zero, then the plant bio-mass is set proportional to the seeding rate and the amount of rain.

                                                       {
        auto state = cell->state();
        auto rain = _rain_dist(*(this->_rng));
        auto mass = state.plant_mass;
 
        if (rain < 1e-16) {
            rain = 0.;
        }
 
        // Distinguish by mass whether to grow or to seed
        // If negative or smaller than machine epsilon at 1.0 for doubles,
        // consider invalid and reseed
        if (not (mass < 1e-16)) {
            // Logistic Growth
            /* Use Beverton-Holt to approximate discretized logistic growth.
             * Be careful that when using the Wikipedia version
             *   [https://en.wikipedia.org/wiki/Beverton–Holt_model], the R0
             * parameter therein is >= 1 -> proliferation rate!
             * This means that, as given therein, we have:
             *   n_{t+1} = (r*n_t)/(1 + (n_t*(r-1)/K))
             *  with r >= 1, which has to be turned into
             *   n_{t+1} =((r+1.)*n_t)/(1 +(n_t*r)/K)
             * when r is given as a growth rate proper.
             */
            state.plant_mass = ((_growth_rate + 1.) * mass)/(1. + (mass * (_growth_rate))/rain);
        }
        else {
            // Seeding
            state.plant_mass = _seeding_rate * rain;
        }
 
        return state;
    };

_rain_dist

std::normal_distribution<double> Utopia::Models::Vegetation::Vegetation::_rain_dist

private

Normal distribution for drawing random rain values.

_seeding_rate

double Utopia::Models::Vegetation::Vegetation::_seeding_rate

private

The seeding rate.

---

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

• src/utopia/models/Vegetation/Vegetation.hh