Utopia::Models::GameOfLife::GameOfLife Class Reference

The GameOfLife Model. More...

#include <GameOfLife.hh>

Inheritance diagram for Utopia::Models::GameOfLife::GameOfLife:

Collaboration diagram for Utopia::Models::GameOfLife::GameOfLife:

Public Types
using	Base = Model< GameOfLife, ModelTypes >
	The type of the Model base class of this derived class.
using	DataGroup = typename Base::DataGroup
	Data type of the group to write model data to, holding datasets.
using	DataSet = typename Base::DataSet
	Data type for a dataset.
using	CellManager = Utopia::CellManager< CellTraits, GameOfLife >
	Type of the CellManager to use.
using	NbLifeRule = std::unordered_set< unsigned short >
	Type of container to store the number of neighbors for the life rule.
using	RuleFunc = typename CellManager::RuleFunc
	Extract the type of the rule function from the CellManager.
Public Types inherited from Utopia::Model< GameOfLife, ModelTypes >
using	Config = typename ModelTypes::Config
	Data type that holds the configuration.
using	DataManager = DataIO::Default::DefaultDataManager< GameOfLife >
	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 >
	GameOfLife (const std::string name, ParentModel &parent)
	Construct the GameOfLife model.
void	perform_step ()
	Iterate a single step.
void	monitor ()
	Monitor model information.
void	write_data ()
	Write data.
Public Member Functions inherited from Utopia::Model< GameOfLife, ModelTypes >
	Model (const std::string &name, const ParentModel &parent_model, const Config &custom_cfg={}, std::tuple< WriterArgs... > w_args={}, const DataIO::Default::DefaultDecidermap< GameOfLife > &w_deciders=DataIO::Default::default_deciders< GameOfLife >, const DataIO::Default::DefaultTriggermap< GameOfLife > &w_triggers=DataIO::Default::default_triggers< GameOfLife >)
	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
NbLifeRule	extract_birth_from_rule ()
	Extract the number of neighbors required for birth from the rule.
NbLifeRule	extract_survive_from_rule ()
	Extract the number of neighbors required to survive from the rule.
double	calculate_living_cell_density () const
	Calculate the mean of all cells' some_state.

Private Attributes
CellManager	_cm
	The cell manager.
const std::string	_rule
	The rule in Mirek's Cellebration notation.
const NbLifeRule	_birth
	The number of neighbors required to get born.
const NbLifeRule	_survive
	The number of neighbors required to survive.
std::shared_ptr< DataSet >	_dset_living
	A dataset for storing all cells living or dead status.
const RuleFunc	_life_rule
	Implement the general life-like rule.

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

Detailed Description

The GameOfLife Model.

This model implement Conways Game of in the Utopia way.

Member Typedef Documentation

Base

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

The type of the Model base class of this derived class.

CellManager

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

Type of the CellManager to use.

DataGroup

using Utopia::Models::GameOfLife::GameOfLife::DataGroup = typename Base::DataGroup

Data type of the group to write model data to, holding datasets.

DataSet

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

Data type for a dataset.

NbLifeRule

using Utopia::Models::GameOfLife::GameOfLife::NbLifeRule = std::unordered_set<unsigned short>

Type of container to store the number of neighbors for the life rule.

RuleFunc

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

Extract the type of the rule function from the CellManager.

This is a function that receives a reference to a cell and returns the new cell state. For more details, check out Utopia::CellManager

Note

Whether the cell state gets applied directly or requires a synchronous update depends on the update mode specified in the cell traits.

Constructor & Destructor Documentation

GameOfLife()

template<class ParentModel >

Utopia::Models::GameOfLife::GameOfLife::GameOfLife ( const std::string  name, ParentModel &  parent  )

inline

Construct the GameOfLife model.

Parameters

name	Name of this model instance
parent	The parent model this model instance resides in

                                                          :
        // Initialize first via base model
        Base(name, parent),
 
        // Now initialize the cell manager
        _cm(*this),
 
        // Initialize the rule and extract the number of neighbors required
        // for birth and survival
        _rule(get_as<std::string>("rule", this->_cfg)),
        _birth(this->extract_birth_from_rule()),
        _survive(this->extract_survive_from_rule()),
 
        // Datasets
        // For setting up datasets that store CellManager data, you can use the
        // helper functions to take care of setting them up:
        _dset_living(this->create_cm_dset("living", _cm))
    {
        // Select the cells that should be set to living
        const auto living = this->_cm.select_cells(
            get_as<DataIO::Config>("living", this->_cfg));
        for (const auto& living_cell : living) {
            living_cell->state.living = true;
        }
 
        // Initialization should be finished here.
        this->_log->debug("{} model fully set up.", this->_name);
    }

Member Function Documentation

calculate_living_cell_density()

double Utopia::Models::GameOfLife::GameOfLife::calculate_living_cell_density ( ) const

inlineprivate

Calculate the mean of all cells' some_state.

    {
        double sum = 0.;
        for (const auto& cell : _cm.cells()) {
            sum += cell->state.living;
        }
        return sum / _cm.cells().size();
    }

extract_birth_from_rule()

NbLifeRule Utopia::Models::GameOfLife::GameOfLife::extract_birth_from_rule ( )

inlineprivate

Extract the number of neighbors required for birth from the rule.

    {
        const std::string delimiter = "/";
        const std::string birth_s   = _rule.substr(0, _rule.find(delimiter));
 
        NbLifeRule birth;
        for (auto b_char : birth_s) {
            // Subtracting '0' is needed to get from the ASCII number stored as
            // char to the corresponding unsigned short value.
            auto b = static_cast<unsigned short>(b_char - '0');
            birth.emplace(b);
        }
        return birth;
    }

extract_survive_from_rule()

NbLifeRule Utopia::Models::GameOfLife::GameOfLife::extract_survive_from_rule ( )

inlineprivate

Extract the number of neighbors required to survive from the rule.

    {
        // Get the substring specifying `survive` which is the substring that
        // starts after the delimiter and ends with the end of the rule string.
        const std::string delimiter = "/";
        const auto pos_delimiter    = _rule.find(delimiter);
        const std::string survive_s =
            _rule.substr(pos_delimiter + 1, _rule.size() - pos_delimiter);
 
        NbLifeRule survive;
        for (auto b_char : survive_s) {
            // Subtracting '0' is needed to get from the ASCII number stored as
            // char to the corresponding unsigned short value.
            auto b = static_cast<unsigned short>(b_char - '0');
            survive.emplace(b);
        }
        return survive;
    }

monitor()

void Utopia::Models::GameOfLife::GameOfLife::monitor ( )

inline

Monitor model information.

Here, functions and values can be supplied to the monitor that are then available to the frontend. The monitor() function is only called if a certain emit interval has passed; thus, the performance hit is small. With this information, you can then define stop conditions on frontend side, that can stop a simulation once a certain set of conditions is fulfilled.

    {
        this->_monitor.set_entry("living_cell_density",
                                 calculate_living_cell_density());
    }

perform_step()

void Utopia::Models::GameOfLife::GameOfLife::perform_step ( )

inline

Iterate a single step.

    {
        // Apply the rules to all cells, first the interaction, then the update
        apply_rule<Update::sync>(_life_rule, _cm.cells());
    }

write_data()

void Utopia::Models::GameOfLife::GameOfLife::write_data ( )

inline

Write data.

This function is called to write out data. The configuration determines the times at which it is invoked. See Utopia::DataIO::Dataset::write

    {
        // Write out the some_state of all cells
        _dset_living->write(_cm.cells().begin(),
                            _cm.cells().end(),
                            [](const auto& cell) {
                                return static_cast<char>(cell->state.living);
                            });
    }

Member Data Documentation

_birth

const NbLifeRule Utopia::Models::GameOfLife::GameOfLife::_birth

private

The number of neighbors required to get born.

_cm

CellManager Utopia::Models::GameOfLife::GameOfLife::_cm

private

The cell manager.

_dset_living

std::shared_ptr<DataSet> Utopia::Models::GameOfLife::GameOfLife::_dset_living

private

A dataset for storing all cells living or dead status.

_life_rule

const RuleFunc Utopia::Models::GameOfLife::GameOfLife::_life_rule

private

Implement the general life-like rule.

                                                         {
        // Get the current state of the cell
        auto state = cell->state;
 
        // Calculate the number of living neighbors
        auto num_living_nbs {0u};
        for (auto nb : this->_cm.neighbors_of(cell)) {
            if (nb->state.living) {
                ++num_living_nbs;
            }
        }
 
        const bool survive =
            std::find(_survive.begin(), _survive.end(), num_living_nbs) !=
            _survive.end();
        // Die if the number of living neighbors is not in the survival
        // container
        if (not survive) {
            state.living = false;
        }
 
        // Give birth if the number of living neighbors is in the birth
        // container
        const bool birth =
            std::find(_birth.begin(), _birth.end(), num_living_nbs) !=
            _birth.end();
        if (birth) {
            state.living = true;
        }
 
        // Return the new cell state
        return state;
    };

_rule

const std::string Utopia::Models::GameOfLife::GameOfLife::_rule

private

The rule in Mirek's Cellebration notation.

_survive

const NbLifeRule Utopia::Models::GameOfLife::GameOfLife::_survive

private

The number of neighbors required to survive.

---

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

• src/utopia/models/GameOfLife/GameOfLife.hh