GameOfLife.hh

Go to the documentation of this file.

#ifndef UTOPIA_MODELS_GAMEOFLIFE_HH
#define UTOPIA_MODELS_GAMEOFLIFE_HH
 
// standard library includes
#include <random>
#include <string>
#include <algorithm>
 
// third-party library includes
 
// Utopia-related includes
#include <utopia/core/model.hh>
#include <utopia/core/cell_manager.hh>
#include <utopia/core/apply.hh>
#include <utopia/core/select.hh>
#include <utopia/data_io/cfg_utils.hh>
 
namespace Utopia::Models::GameOfLife
{
// ++ Type definitions ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
struct CellState
{
    bool living;
 
 
    CellState() : living(false) {};
};
 
 
using CellTraits = Utopia::CellTraits<CellState, Update::manual, true>;
 
using ModelTypes = Utopia::ModelTypes<>;
 
// ++ Model definition ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
class GameOfLife : public Model<GameOfLife, ModelTypes>
{
  public:
    using Base = Model<GameOfLife, ModelTypes>;
 
    using DataGroup = typename Base::DataGroup;
 
    using DataSet = typename Base::DataSet;
 
    using CellManager = Utopia::CellManager<CellTraits, GameOfLife>;
    // NOTE that it requires the model's type as second template argument
 
    using NbLifeRule = std::unordered_set<unsigned short>;
 
 
    using RuleFunc = typename CellManager::RuleFunc;
 
  private:
    // Base members: _time, _name, _cfg, _hdfgrp, _rng, _monitor, _log, _space
    // ... but you should definitely check out the documentation ;)
 
    // -- Members -------------------------------------------------------------
    CellManager _cm;
 
    const std::string _rule;
 
    const NbLifeRule _birth;
 
    const NbLifeRule _survive;
 
    // .. Temporary objects ...................................................
 
    // .. Datasets ............................................................
    std::shared_ptr<DataSet> _dset_living;
 
  public:
    // -- Model Setup ---------------------------------------------------------
 
    template<class ParentModel>
    GameOfLife(const std::string name, ParentModel& parent) :
        // 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);
    }
 
  private:
    // .. Setup functions .....................................................
    NbLifeRule extract_birth_from_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;
    }
 
    NbLifeRule extract_survive_from_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;
    }
 
    // .. Helper functions ....................................................
 
    double calculate_living_cell_density() const
    {
        double sum = 0.;
        for (const auto& cell : _cm.cells()) {
            sum += cell->state.living;
        }
        return sum / _cm.cells().size();
    }
 
    // .. Rule functions ......................................................
    const RuleFunc _life_rule = [this](const auto& cell) {
        // 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;
    };
 
  public:
    // -- Public Interface ----------------------------------------------------
    // .. Simulation Control ..................................................
 
    void perform_step()
    {
        // Apply the rules to all cells, first the interaction, then the update
        apply_rule<Update::sync>(_life_rule, _cm.cells());
    }
 
 
    void monitor()
    {
        this->_monitor.set_entry("living_cell_density",
                                 calculate_living_cell_density());
    }
 
 
    void write_data()
    {
        // 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);
                            });
    }
 
    // .. Getters and setters .................................................
    // Add getters and setters here to interface with other models
};
 
}  // namespace Utopia::Models::GameOfLife
 
#endif  // UTOPIA_MODELS_GAMEOFLIFE_HH