Utopia::Models::PredatorPrey::PredatorPrey Class Reference

PredatorPrey Model on grid cells. More...

#include <PredatorPrey.hh>

Inheritance diagram for Utopia::Models::PredatorPrey::PredatorPrey:

Collaboration diagram for Utopia::Models::PredatorPrey::PredatorPrey:

Public Types
using	Base = Model< PredatorPrey, ModelTypes >
	The base model.
using	DataSet = typename Base::DataSet
	Data type for a dataset.
using	CellManager = Utopia::CellManager< CellTraits, PredatorPrey >
	The type of the cell manager.
using	Cell = typename CellManager::Cell
	The type of a cell.
using	Rule = typename CellManager::RuleFunc
	Type of the update rules.
Public Types inherited from Utopia::Model< PredatorPrey, ModelTypes >
using	Config = typename ModelTypes::Config
	Data type that holds the configuration.
using	DataManager = DataIO::Default::DefaultDataManager< PredatorPrey >
	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 >
	PredatorPrey (const std::string &name, ParentModel &parent_model, const DataIO::Config &custom_cfg={})
	Construct the PredatorPrey model.
void	perform_step ()
	Perform an iteration step.
void	monitor ()
	Monitor model information.
void	write_data ()
	Write data.
Public Member Functions inherited from Utopia::Model< PredatorPrey, ModelTypes >
	Model (const std::string &name, const ParentModel &parent_model, const Config &custom_cfg={}, std::tuple< WriterArgs... > w_args={}, const DataIO::Default::DefaultDecidermap< PredatorPrey > &w_deciders=DataIO::Default::default_deciders< PredatorPrey >, const DataIO::Default::DefaultTriggermap< PredatorPrey > &w_triggers=DataIO::Default::default_triggers< PredatorPrey >)
	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
void	move_predator_to_nb_cell (const std::shared_ptr< Cell > &cell, const std::shared_ptr< Cell > &nb_cell)
	Move a predator to a neighboring cell.
void	move_prey_to_nb_cell (const std::shared_ptr< Cell > &cell, const std::shared_ptr< Cell > &nb_cell)
	Move a prey to a neighboring cell.

Private Attributes
CellManager	_cm
	The cell manager.
SpeciesParams	_params
	Predator-specific model parameters.
CellContainer< Cell >	_prey_cell
	A container to temporarily accumulate the prey neighbour cells.
CellContainer< Cell >	_empty_cell
	A container to temporarily accumulate empty neighbour cells.
CellContainer< Cell >	_repro_cell
	A container to temporarily accumulate neighbour cells for reproduction.
std::uniform_real_distribution< double >	_prob_distr
const std::shared_ptr< DataSet >	_dset_prey
	Dataset of Prey locations on the grid.
const std::shared_ptr< DataSet >	_dset_predator
	Dataset of Predator locations on the grid.
const std::shared_ptr< DataSet >	_dset_resource_prey
	Dataset of Prey resources on the grid.
const std::shared_ptr< DataSet >	_dset_resource_predator
	Dataset of Predator resources on the grid.
Rule	_cost_of_living
	Cost of Living.
Rule	_move_predator
	Define the movement rule of predator.
Rule	_flee_prey
	Define the movement rule of prey.
Rule	_eat
	Define the eating rule.
Rule	_repro
	Define the reproduction rule.
Rule	_reset_predator_movement
	Resets the movement flag of predators to "false" for next turn.

Additional Inherited Members
Protected Member Functions inherited from Utopia::Model< PredatorPrey, ModelTypes >
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.
PredatorPrey &	impl ()
	cast to the derived class
const PredatorPrey &	impl () const
	const cast to the derived interface
Protected Attributes inherited from Utopia::Model< PredatorPrey, ModelTypes >
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< PredatorPrey, ModelTypes >
static constexpr WriteMode	_write_mode
	Which data-writing mode the base model should use.

Detailed Description

PredatorPrey Model on grid cells.

Predators and prey correspond to the Population state of each cell, either empty, prey, predator or both. Cells are updated based on the following interactions: 1) resource levels are reduced by a cost_of_living for both species and individuals are removed if resource <= 0 2) predators move to neighbouring cells if there is a no prey on their own cell. Prey flees with a certain probability, if there is a predator on the same cell 3) predators eat prey if on the same cell, else if there is only a prey it takes up resources 4) both predators and prey reproduce if resources are sufficient and if there is a cell in their neighbourhood not already occupied by the same species

Member Typedef Documentation

Base

using Utopia::Models::PredatorPrey::PredatorPrey::Base = Model<PredatorPrey, ModelTypes>

The base model.

Cell

using Utopia::Models::PredatorPrey::PredatorPrey::Cell = typename CellManager::Cell

The type of a cell.

CellManager

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

The type of the cell manager.

DataSet

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

Data type for a dataset.

Rule

using Utopia::Models::PredatorPrey::PredatorPrey::Rule = typename CellManager::RuleFunc

Type of the update rules.

Constructor & Destructor Documentation

PredatorPrey()

template<class ParentModel >

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

inline

Construct the PredatorPrey 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

                                         {}
    )
    :
        Base(name, parent_model, custom_cfg),
        // Initialize the cell manager, binding it to this model
        _cm(*this),
 
        // Extract model parameters
        _params(this->_cfg),
 
        // Temporary cell containers
        _prey_cell(),
        _empty_cell(),
        _repro_cell(),
 
        // Initialize distributions
        _prob_distr(0., 1.),
 
        // Create datasets
        _dset_prey(this->create_cm_dset("prey", _cm)),
        _dset_predator(this->create_cm_dset("predator", _cm)),
        _dset_resource_prey(this->create_cm_dset("resource_prey", _cm)),
        _dset_resource_predator(this->create_cm_dset("resource_predator", _cm))
    {
        // Load the cell state from a file, overwriting the current state
        if (this->_cfg["cell_states_from_file"]) {
            const auto& cs_cfg = this->_cfg["cell_states_from_file"];
            const auto hdf5_file = get_as<std::string>("hdf5_file", cs_cfg);
            const auto predator_init_resources = get_as<double>("init_resources", 
                this->_cfg["cell_manager"]["cell_params"]["predator"]);
            const auto prey_init_resources = get_as<double>("init_resources", 
                this->_cfg["cell_manager"]["cell_params"]["prey"]);
            if (get_as<bool>("load_predator", cs_cfg)) {
                this->_log->info("Loading predator positions from file ...");
 
                // Use the CellManager to set the cell state from the data
                // given by the `predator` dataset. Load as int to be able to
                // detect that a user supplied invalid values (better than
                // failing silently, which would happen with booleans).
                _cm.set_cell_states<int>(hdf5_file, "predator",
                    [predator_init_resources](auto& cell, const int on_cell){
                        if (on_cell == 0 or on_cell == 1) {
                            cell->state.predator.on_cell = on_cell;
                            if(on_cell == 1){
                                cell->state.predator.resources = 
                                    predator_init_resources;
                            }
                            else{
                                cell->state.predator.resources = 0;
                            }
                            return;
                        }
                        throw std::invalid_argument("While setting predator "
                            "positions, encountered an invalid value: "
                            + std::to_string(on_cell) + ". Allowed: 0 or 1.");
                    }
                );
 
                this->_log->info("Predator positions loaded.");
            }
 
            if (get_as<bool>("load_prey", cs_cfg)) {
                this->_log->info("Loading prey positions from file ...");
 
                _cm.set_cell_states<int>(hdf5_file, "prey",
                    [prey_init_resources](auto& cell, const int on_cell){
                        if (on_cell == 0 or on_cell == 1) {
                            cell->state.prey.on_cell = on_cell;
                            if(on_cell == 1){
                                cell->state.prey.resources = 
                                    prey_init_resources;
                            }
                            else{
                                cell->state.prey.resources = 0;
                            }
                            return;
                        }
                        throw std::invalid_argument("While setting prey "
                            "positions, encountered an invalid value: "
                            + std::to_string(on_cell) + ". Allowed: 0 or 1.");
                    }
                );
 
                this->_log->info("Prey positions loaded.");
            }
        }
 
        // Reserve memory in the size of the neighborhood for the temp. vectors
        const auto nb_size = _cm.nb_size();
        _prey_cell.reserve(nb_size);
        _empty_cell.reserve(nb_size);
        _repro_cell.reserve(nb_size);
 
        // Initialization finished
        this->_log->info("{} model fully set up.", this->_name);
    }

Member Function Documentation

monitor()

void Utopia::Models::PredatorPrey::PredatorPrey::monitor ( )

inline

Monitor model information.

Calculate the densities for both species

                    {
        auto [pred_density, prey_density] = [this](){
            double predator_sum = 0.;
            double prey_sum = 0.;
            double num_cells = this->_cm.cells().size();
 
            for (const auto& cell : this->_cm.cells()) {
                auto state = cell->state;
 
                if (state.prey.on_cell) {
                    prey_sum++;
                }
 
                if (state.predator.on_cell) {
                    predator_sum++;
                }
            }
            return std::pair{predator_sum / num_cells, prey_sum / num_cells};
        }();
 
        this->_monitor.set_entry("predator_density", pred_density);
        this->_monitor.set_entry("prey_density", prey_density);
    }

move_predator_to_nb_cell()

void Utopia::Models::PredatorPrey::PredatorPrey::move_predator_to_nb_cell ( const std::shared_ptr< Cell > &  cell, const std::shared_ptr< Cell > &  nb_cell  )

inlineprivate

Move a predator to a neighboring cell.

This function resets the states predator state and updates the neighboring predator state.

                                                                      {
        auto& state = cell->state;
        auto& nb_state = nb_cell->state;
 
        nb_state.predator.on_cell = true;
        nb_state.predator.resources = state.predator.resources;
 
        state.predator.on_cell = false;
        state.predator.resources = 0.;
    }

move_prey_to_nb_cell()

void Utopia::Models::PredatorPrey::PredatorPrey::move_prey_to_nb_cell ( const std::shared_ptr< Cell > &  cell, const std::shared_ptr< Cell > &  nb_cell  )

inlineprivate

Move a prey to a neighboring cell.

This function resets the states prey state and updates the neighboring prey state.

                                                                  {
        auto& state = cell->state;
        auto& nb_state = nb_cell->state;
 
        nb_state.prey.on_cell = true;
        nb_state.prey.resources = state.prey.resources;
 
        state.prey.on_cell = false;
        state.prey.resources = 0.;
    }

perform_step()

void Utopia::Models::PredatorPrey::PredatorPrey::perform_step ( )

inline

Perform an iteration step.

An iteration step consists of:

1. Subtracting costs of living
2. Let predator and prey move to neighboring cells
3. Lunch time: Prey eats grass and predator eats prey if on the same cell
4. Reproduction: Create offspring

                        {
        apply_rule<Update::async, Shuffle::off>
            (_cost_of_living, _cm.cells());
        
        apply_rule<Update::async, Shuffle::on>
            (_move_predator, _cm.cells(), *this->_rng);
 
        apply_rule<Update::async, Shuffle::on>
            (_flee_prey, _cm.cells(), *this->_rng);
 
        apply_rule<Update::async, Shuffle::off>
            (_eat, _cm.cells());
 
        apply_rule<Update::async, Shuffle::on>
            (_repro, _cm.cells(), *this->_rng);
 
        apply_rule<Update::sync>
            (_reset_predator_movement, _cm.cells());
    }

write_data()

void Utopia::Models::PredatorPrey::PredatorPrey::write_data ( )

inline

Write data.

When invoked, stores cell positions and resources of both prey and predators.

Note

Positions are cast to char and therefore stored as such. This is because C has no native boolean type, and the HDF5 library thus cannot store it directly. With 8 bit width, char is the smallest data type available; short int is already 16 bit.

                      {
        // Predator
        _dset_predator->write(_cm.cells().begin(), _cm.cells().end(),
            [](const auto& cell) {
                return static_cast<char>(cell->state.predator.on_cell);
            }
        );
 
        // Prey
        _dset_prey->write(_cm.cells().begin(), _cm.cells().end(),
            [](const auto& cell) {
                return static_cast<char>(cell->state.prey.on_cell);
            }
        );
 
        // resource of predator
        _dset_resource_predator->write(_cm.cells().begin(), _cm.cells().end(),
            [](const auto& cell) {
                return cell->state.predator.resources;
            }
        );
 
        // resource of prey
        _dset_resource_prey->write(_cm.cells().begin(), _cm.cells().end(),
            [](const auto& cell) {
                return cell->state.prey.resources;
            }
        );
    }

Member Data Documentation

_cm

CellManager Utopia::Models::PredatorPrey::PredatorPrey::_cm

private

The cell manager.

_cost_of_living

Rule Utopia::Models::PredatorPrey::PredatorPrey::_cost_of_living

private

Initial value:

= [this](const auto& cell) {
        
        auto& state = cell->state;
 
        
        
        
        state.predator.resources =
            std::clamp(  state.predator.resources
                       - _params.predator.cost_of_living,
                       0., _params.predator.resource_max);
        state.prey.resources =
            std::clamp(  state.prey.resources
                       - _params.prey.cost_of_living,
                       0., _params.prey.resource_max);
 
        
        if (state.predator.on_cell and state.predator.resources <= 0.) {
            state.predator.on_cell = false;
        }
 
        
        if (state.prey.on_cell and state.prey.resources <= 0.) {
            state.prey.on_cell = false;
        }
 
        return state;
    }

Cost of Living.

subtract the cost of living from the resources of an individual and map the values below zero back to zero, then remove all individuals that do not have sufficient resources

                                                    {
        // Get the state of the cell
        auto& state = cell->state;
 
        // Subtract the cost of living and clamp the resources to the limits:
        // If the resources exceed the maximal resources they are equal to
        // the maximal resources and if they go below 0 they are mapped to 0.
        state.predator.resources =
            std::clamp(  state.predator.resources
                       - _params.predator.cost_of_living,
                       0., _params.predator.resource_max);
        state.prey.resources =
            std::clamp(  state.prey.resources
                       - _params.prey.cost_of_living,
                       0., _params.prey.resource_max);
 
        // Remove predators that have no resources.
        if (state.predator.on_cell and state.predator.resources <= 0.) {
            state.predator.on_cell = false;
        }
 
        // Remove prey that have no resources.
        if (state.prey.on_cell and state.prey.resources <= 0.) {
            state.prey.on_cell = false;
        }
 
        return state;
    };

_dset_predator

const std::shared_ptr<DataSet> Utopia::Models::PredatorPrey::PredatorPrey::_dset_predator

private

Dataset of Predator locations on the grid.

_dset_prey

const std::shared_ptr<DataSet> Utopia::Models::PredatorPrey::PredatorPrey::_dset_prey

private

Dataset of Prey locations on the grid.

_dset_resource_predator

const std::shared_ptr<DataSet> Utopia::Models::PredatorPrey::PredatorPrey::_dset_resource_predator

private

Dataset of Predator resources on the grid.

_dset_resource_prey

const std::shared_ptr<DataSet> Utopia::Models::PredatorPrey::PredatorPrey::_dset_resource_prey

private

Dataset of Prey resources on the grid.

_eat

Rule Utopia::Models::PredatorPrey::PredatorPrey::_eat

private

Define the eating rule.

Update procedure is as follows:

• prey is consumed by a predator if they are on the same cell. The predator increases its resources.
• prey eats grass which increases its resources

                                         {
        // Get the state of the cell
        auto& state = cell->state;
 
        // Predator eats prey
        if (state.predator.on_cell and state.prey.on_cell) {
            // Increase the predator's resources and assure that the resource
            // maximum is not exceeded by clamping into the correct interval.
            state.predator.resources = std::clamp(
                                        state.predator.resources
                                            + _params.predator.resource_intake,
                                        0.,
                                        _params.predator.resource_max);
 
            // Remove the prey from the cell
            state.prey.on_cell = false;
            state.prey.resources = 0.;
        }
 
        // Prey eats grass
        else if (state.prey.on_cell == true) {
            // Increase the resources and clamp to the allowed range
            // [0, resource_max]
            state.prey.resources = std::clamp(
                                    state.prey.resources
                                        + _params.prey.resource_intake,
                                    0.,
                                    _params.prey.resource_max);
        }
        return state;
    };

_empty_cell

CellContainer<Cell> Utopia::Models::PredatorPrey::PredatorPrey::_empty_cell

private

A container to temporarily accumulate empty neighbour cells.

_flee_prey

Rule Utopia::Models::PredatorPrey::PredatorPrey::_flee_prey

private

Define the movement rule of prey.

If a prey is on the same cell as a predator, determine whether it may flee and where to.

                                               {
        auto& state = cell->state;
 
        if (state.prey.on_cell and state.predator.on_cell) {
            // Flee, if possible, with a given flee probability
            if (this->_prob_distr(*this->_rng) < _params.prey.p_flee){
                // Collect empty neighboring cells to which the prey could flee
                _empty_cell.clear();
                for (const auto& nb : this->_cm.neighbors_of(cell)) {
                    if (    (not nb->state.prey.on_cell)
                        and (not nb->state.predator.on_cell)) {
                        _empty_cell.push_back(nb);
                    }
                }
 
                // If there is an empty cell, move there
                if (_empty_cell.size() > 0) {
                    // Choose a random cell to move to
                    std::uniform_int_distribution<>
                        dist(0, _empty_cell.size() - 1);
 
                    auto nb_cell = _empty_cell[dist(*this->_rng)];
                    move_prey_to_nb_cell(cell, nb_cell);
                }
            }
        }
        return state;
        // NOTE Should the case be added that the neighboring cell has a predator?
        //      In case that there are no empty cells.
        //      Then the prey has again a small probability to flee in the next
        //      round.
    };

_move_predator

Rule Utopia::Models::PredatorPrey::PredatorPrey::_move_predator

private

Define the movement rule of predator.

If a predator is on the given cell, it moves random to a neighbour cell with prey on it. If no prey is available on neighbour cells, it moves randomly to an empty cell, if there is on. Otherwise it stays on its current cell.

                                                   {
        // Get the state of the Cell
        auto& state = cell->state;
 
        // Case: only a predator is on the cell
        if ((state.predator.on_cell) and (not state.moved_predator)) {
            // checking neighbouring cells for prey and moving to that cell
 
            // clear the containers for cells that contain prey or empty cells
            // in the neighbourhood
            _prey_cell.clear();
            _empty_cell.clear();
 
            for (const auto& nb : this->_cm.neighbors_of(cell)) {
                auto& nb_state = nb->state;
 
                if ((nb_state.prey.on_cell) and (not nb_state.predator.on_cell)) {
                    _prey_cell.push_back(nb);
                }
                // if neither a prey nor a predator is on the cell, then
                // it is empty
                else if (not nb_state.predator.on_cell) {
                    _empty_cell.push_back(nb);
                }
            }
 
            // if there is prey in the vicinity move the predator to a random
            // prey cell
            if (_prey_cell.size() > 0) {
                // distribution to choose a random cell for the movement if
                // there is more than one
                std::uniform_int_distribution<>
                    dist_prey(0, _prey_cell.size() - 1);
 
                // Select a random neighbor cell and move the predator to it
                auto nb_cell = _prey_cell[dist_prey(*this->_rng)];
                // Mark target cell as cell with moved predator
                nb_cell->state.moved_predator=true; 
                move_predator_to_nb_cell(cell, nb_cell);
            }
 
            // if there is no prey the predator makes a random move
            else if (_empty_cell.size() > 0) {
                // distribution to choose a random cell for the movement if
                // there is more than one
                std::uniform_int_distribution<>
                    dist_empty(0, _empty_cell.size() - 1);
 
                // Select a random empty neighbor cell and move the predator
                // to it
                auto nb_cell = _empty_cell[dist_empty(*this->_rng)];
                // Mark target cell as cell with moved predator
                nb_cell->state.moved_predator=true; 
                move_predator_to_nb_cell(cell, nb_cell);
            }
        }
        return state;
    };

_params

SpeciesParams Utopia::Models::PredatorPrey::PredatorPrey::_params

private

Predator-specific model parameters.

_prey_cell

CellContainer<Cell> Utopia::Models::PredatorPrey::PredatorPrey::_prey_cell

private

A container to temporarily accumulate the prey neighbour cells.

_prob_distr

std::uniform_real_distribution<double> Utopia::Models::PredatorPrey::PredatorPrey::_prob_distr

private

_repro

Rule Utopia::Models::PredatorPrey::PredatorPrey::_repro

private

Define the reproduction rule.

If space is available reproduce with reproduction probabilities of predator and prey respectively.

                                           {
        // Get the state of the cell
        auto& state = cell->state;
 
        // Reproduce predators
        if (    state.predator.on_cell
            and (this->_prob_distr(*this->_rng) < _params.predator.repro_prob)
            and (state.predator.resources >= _params.predator.repro_resource_requ))
        {
            // Collect available neighboring spots without predators
            _repro_cell.clear();
            for (const auto& nb : this->_cm.neighbors_of(cell)) {
                if (not nb->state.predator.on_cell) {
                    _repro_cell.push_back(nb);
                }
            }
 
            // Choose an available neighboring cell to put an offspring on
            if (_repro_cell.size() > 0) {
                // choose a random cell for the offspring to be placed on
                std::uniform_int_distribution<> dist(0, _repro_cell.size()-1);
                const auto& nb_cell = _repro_cell[dist(*this->_rng)];
                auto& nb_state = nb_cell->state;
 
                // neighboring cell has now a predator.
                // Congratulations to your new baby! :)
                nb_state.predator.on_cell = true;
 
                // transfer resources from parent to offspring
                nb_state.predator.resources = _params.predator.repro_cost;
                state.predator.resources -= _params.predator.repro_cost;
            }
        }
 
        // Reproduce prey
        if (    state.prey.on_cell
            and this->_prob_distr(*this->_rng) < _params.prey.repro_prob
            and state.prey.resources >= _params.prey.repro_resource_requ)
        {
            _repro_cell.clear();
 
            for (const auto& nb : this->_cm.neighbors_of(cell)) {
                if (not nb->state.prey.on_cell) {
                    _repro_cell.push_back(nb);
                }
            }
 
            if (_repro_cell.size() > 0) {
                // choose a random cell for the offspring to be placed on
                std::uniform_int_distribution<> dist(0, _repro_cell.size() - 1);
                // TODO Use std::sample
 
                auto nb_cell = _repro_cell[dist(*this->_rng)];
 
                // neighboring cell has now a prey.
                // Congratulations to your new baby! :)
                nb_cell->state.prey.on_cell = true;
 
                // transfer energy from parent to offspring
                nb_cell->state.prey.resources = _params.prey.repro_cost;
                state.prey.resources -= _params.prey.repro_cost;
 
                // NOTE Should there be some dissipation of resources during
                //      reproduction?
            }
        }
        return state;
    };

_repro_cell

CellContainer<Cell> Utopia::Models::PredatorPrey::PredatorPrey::_repro_cell

private

A container to temporarily accumulate neighbour cells for reproduction.

_reset_predator_movement

Rule Utopia::Models::PredatorPrey::PredatorPrey::_reset_predator_movement

private

Initial value:

= [](const auto& cell) {
        auto& state = cell->state;
        state.moved_predator = false;
        return state;
    }

Resets the movement flag of predators to "false" for next turn.

                                                         {
        auto& state = cell->state;
        state.moved_predator = false;
        return state;
    };

---

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

• src/utopia/models/PredatorPrey/PredatorPrey.hh