Environment.hh

Go to the documentation of this file.

#ifndef UTOPIA_MODELS_ENVIRONMENT_HH
#define UTOPIA_MODELS_ENVIRONMENT_HH
 
// standard library includes
#include <random>
#include <unordered_map>
 
// third-party library includes
 
// Utopia-related includes
#include <utopia/core/model.hh>
#include <utopia/core/apply.hh>
#include <utopia/core/types.hh>
#include <utopia/core/cell_manager.hh>
 
// FuncBundle classes
#include "func_bundle.hh"
 
// Collections of environment functions
#include "env_param_func_collection.hh"
#include "env_state_func_collection.hh"
 
 
namespace Utopia {
namespace Models {
namespace Environment {
 
using namespace ParameterFunctionCollection;
using namespace StateFunctionCollection;
 
// ++ Type definitions ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
struct BaseEnvParam {
    virtual ~BaseEnvParam() = default;
 
    virtual double get_env(const std::string&) const = 0;
 
    virtual void set_env(const std::string&, const double&) = 0;
};
 
 
struct DummyEnvParam : BaseEnvParam
{
    DummyEnvParam(const DataIO::Config&) { }
 
    ~DummyEnvParam() = default;
 
    double get_env(const std::string&) const override {
        throw std::invalid_argument("Accessing getter of the dummy type of "
                                    "EnvParam!");
    }
 
    void set_env(const std::string&, const double&) override {
        throw std::invalid_argument("Accessing setter of the dummy type of "
                                    "EnvParam!");
    }
};
 
 
struct BaseEnvCellState {
    using SpaceVec = SpaceVecType<2>;
 
    SpaceVec position;
 
    virtual ~BaseEnvCellState() = default;
 
    virtual double get_env(const std::string&) const = 0;
 
    virtual void set_env(const std::string&, const double&) = 0;
};
 
 
struct DummyEnvCellState : BaseEnvCellState
{
    DummyEnvCellState(const DataIO::Config&) { }
 
    ~DummyEnvCellState() = default;
 
    double get_env(const std::string&) const override {
        throw std::invalid_argument("Accessing getter of the dummy type of "
                                    "EnvCellState!");
    }
 
    void set_env(const std::string&, const double&) override {
        throw std::invalid_argument("Accessing setter of the dummy type of "
                                    "EnvCellState!");
    }
};
 
 
using ModelTypes = Utopia::ModelTypes<>;
 
 
// ++ Model definition ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
template<typename EnvParam=DummyEnvParam,
         typename EnvCellState=DummyEnvCellState,
         bool standalone=false>
class Environment:
    public Model<Environment<EnvParam, EnvCellState, standalone>, ModelTypes>
{
public:
    using Self = Environment<EnvParam, EnvCellState, standalone>;
 
    using Base = Model<Self, ModelTypes>;
 
    using DataGroup = typename Base::DataGroup;
 
    using DataSet = typename Base::DataSet;
 
    using CellTraits = Utopia::CellTraits<EnvCellState, Update::manual>;
 
    using CellManager = Utopia::CellManager<CellTraits, Self>;
 
    using EnvCellContainer = CellContainer<typename CellManager::Cell>;
 
    using Time = typename Base::Time;
 
    using EnvParamFunc = typename std::function<double()>;
 
    using EnvParamFuncBundle = FuncBundle::ParamFuncBundle<EnvParamFunc, Time>;
 
    using EnvStateFunc = typename CellManager::RuleFunc;
 
    using EnvStateFuncBundle = FuncBundle::RuleFuncBundle<EnvStateFunc, Time,
                                                          EnvCellContainer>;
 
    using Config = DataIO::Config;
 
private:
    struct DummyCellManager {
        DataIO::Config cfg() const {
            return {};
        }
    };
 
    // -- Members -------------------------------------------------------------
    // Base members: _time, _name, _cfg, _hdfgrp, _rng, _monitor, _space
 
    CellManager _cm;
 
    EnvParam _params;
 
 
    std::vector<EnvParamFuncBundle> _env_param_funcs;
 
 
    std::vector<EnvStateFuncBundle> _init_env_state_funcs;
 
 
    std::vector<EnvStateFuncBundle> _env_state_funcs;
 
    // .. Datasets ............................................................
    std::unordered_map<std::string, std::shared_ptr<DataSet>> _dsets_state;
 
    std::unordered_map<std::string, std::shared_ptr<DataSet>> _dsets_param;
 
 
public:
    // -- Model Setup ---------------------------------------------------------
 
    template<class ParentModel, class CellManager>
    Environment (
        const std::string& name,
        ParentModel& parent_model,
        CellManager&& associate_cm,
        const DataIO::Config& custom_cfg = {}
    )
    :
        // Initialize first via base model
        Base(name, parent_model, custom_cfg),
 
        // Set up the internal CellManager
        _cm(*this, associate_cm.cfg()),
        // NOTE If called from the standalone constructor, the .cfg() call
        //      always returns an empty configuration which leads to this
        //      internal CellManager being set up from _cfg["cell_manager"]
 
        //set up the environment params
        _params(this->_cfg),
 
        // Set up environment function bundle containers empty
        _env_param_funcs{},
        _init_env_state_funcs{},
        _env_state_funcs{},
 
        // Map of datasets; empty until states are set to be tracked
        _dsets_state{},
        _dsets_param{}
    {
        // Associate the CellManager's cells with each other
        if constexpr (not std::is_same<CellManager, DummyCellManager>()) {
            for (std::size_t i=0; i < _cm.cells().size(); i++) {
                associate_cm.cells()[i]->custom_links().env = _cm.cells()[i];
            }
 
            this->_log->info(
                "Associated '{}' cells with those of the parent model '{}'.",
                this->_name, parent_model.get_name()
            );
        }
        else if constexpr (not standalone) {
            // Only allow coupled models without coupled cellmanagers when
            // a EnvCellState is the dummy type
            static_assert(std::is_same<EnvCellState, DummyEnvCellState>(),
                          "The cm for association of environment cells cannot "
                          "be the DummyCellManager! \n"
                          "Setup the model with type DummyEnvCellState for "
                          "standalone model or pass a cell manager for "
                          "associated model.");
 
            this->_log->info("Setting up '{}' as coupled model without "
                             "associated cell manager.", this->_name);
        }
        else {
            this->_log->info("Setting up '{}' as standalone model ...",
                             this->_name);
        }
 
        // Check inheritance of EnvCellState; needed for position cache
        static_assert(std::is_base_of<BaseEnvCellState, EnvCellState>::value,
                      "The model's EnvCellState must derive from "
                      "Utopia::Models::Environment::BaseEnvCellState!");
 
        // Check inheritance of EnvParam; needed for getters and setters
        static_assert(std::is_base_of<BaseEnvParam, EnvParam>::value,
                      "The model's EnvParam must derive from "
                      "Utopia::Models::Environment::BaseEnvParam!");
 
        // Store positions
        apply_rule<Update::sync>(
            [this](const auto& cell){
                auto& state = cell->state;
                state.position = this->_cm.barycenter_of(cell);
                return state;
            },
            this->_cm.cells()
        );
        this->_log->debug("Cell barycenters cached.");
 
 
        // Now set up the actual environment parameter functions
        if (this->_cfg["env_param_funcs"]) {
            setup_env_param_funcs(this->_cfg["env_param_funcs"]);
        }
 
        // Apply the env_param_funcs for initialization
        this->_log->debug("Applying {} initial environment param function{} ...",
                         _env_param_funcs.size(),
                         _env_param_funcs.size() != 1 ? "s" : "");
        for (auto& epfb : _env_param_funcs) {
            if (epfb.invoke_at_initialization) {
                apply_env_param_func(epfb, true);
            }
        }
 
        // Now set up the actual environment state functions
        if (this->_cfg["init_env_state_funcs"]) {
            setup_env_state_funcs<true>(this->_cfg["init_env_state_funcs"]);
        }
        if (this->_cfg["env_state_funcs"]) {
            setup_env_state_funcs<false>(this->_cfg["env_state_funcs"]);
        }
 
        // Apply the env_state_funcs for initialization
        this->_log->info("Applying {} initial environment state function{} ...",
                         _init_env_state_funcs.size(),
                         _init_env_state_funcs.size() != 1 ? "s" : "");
        for (auto& esfb : _init_env_state_funcs) {
            apply_env_state_func(esfb);
        }
 
        this->_log->info("{} set up.", this->_name);
    }
 
 
    template <typename ParentModel>
    Environment (const std::string name, ParentModel& parent)
    :
        // Use existing constructor, passing a _DummyCellManager instance that
        // ensures that no configuration is carried over.
        Environment(name, parent, DummyCellManager())
    { }
 
 
    // -- Public Interface ----------------------------------------------------
    // .. Simulation Control ..................................................
 
    void perform_step () {
        for (auto& epfb : _env_param_funcs) {
            apply_env_param_func(epfb);
        }
        for (auto& esfb : _env_state_funcs) {
            apply_env_state_func(esfb);
        }
    }
 
 
    void monitor () {
    }
 
 
 
    void write_data () {
        // write parameters
        for (auto& [key, dset] : _dsets_param) {
            dset->write(_params.get_env(key));
        }
 
        // write states
        for (auto& param_dset_pair : _dsets_state) {
            const auto key = std::get<0>(param_dset_pair);
            auto& dset = std::get<1>(param_dset_pair);
 
            dset->write(_cm.cells().begin(), _cm.cells().end(),
                [key](const auto& cell) {
                    return cell->state.get_env(key);
                }
            );
        }
    }
 
 
    // Getters and setters ....................................................
    double get_parameter(const std::string& param_name) const {
        return this->_params.get_env(param_name);
    }
 
    void set_parameter(const std::string& param_name, double value) {
        this->_params.set_env(param_name, value);
    }
 
    const auto& cm() const {
        return this->_cm;
    }
 
    // .. Environment Function Bundle Handling ................................
 
    template<class EPFB>
    void add_env_param_func(EPFB&& epfb) {
        _env_param_funcs.push_back(epfb);
        this->_log->debug("Added environment param function '{}'.", epfb.name);
    }
 
 
    void add_env_param_func(const std::string& name, const EnvParamFunc& epf,
            const std::string& param_name,
            std::tuple<bool, bool, std::set<Time>> times_tuple)
    {
        add_env_param_func(
            EnvParamFuncBundle(name, epf, param_name, times_tuple)
        );
    }
 
 
    void add_env_param_func_from_cfg(const std::string& name,
            const EnvParamFunc& epf, const std::string& param_name,
            const Config& cfg = {})
    {
        auto invoke_times_tuple = extract_times_and_initialization<Time>(cfg);
        add_env_param_func(name, epf, param_name, invoke_times_tuple);
    }
 
 
    template<bool add_to_initial=false, class ESFB>
    void add_env_state_func(ESFB&& esfb) {
        if constexpr (add_to_initial) {
            _init_env_state_funcs.push_back(esfb);
        }
        else {
            _env_state_funcs.push_back(esfb);
        }
        this->_log->debug("Added {}environment function '{}'.",
                          add_to_initial ? "initial " : "", esfb.name);
    }
 
 
    template<bool add_to_initial=false>
    void add_env_state_func(const std::string& name,
            const EnvStateFunc& esf, const Update& update = Update::sync,
            std::pair<bool, std::set<Time>> times_pair = {true, {}},
            Config select_cfg = {})
    {
        // resolve select option
        bool fix_selection;
        EnvCellContainer cell_selection = {};
        if (not select_cfg.IsNull()) {
            std::string generate = get_as<std::string>("generate", select_cfg);
            if (generate == "once") {
                fix_selection = true;
            }
            else if (generate == "always") {
                fix_selection = false;
            }
            else {
                throw std::invalid_argument("Key 'generate' in 'select' "
                        "feature of environment state function '"
                        + name + "' must be 'once' to fix selection or "
                        "'always' to generate it on the fly, but was '"
                        + generate + "'!");
            }
 
            if (fix_selection) {
                this->_log->debug("Generating a selection of cells and fixing "
                                  "it for the rule '{}'.", name);
                cell_selection = _cm.select_cells(select_cfg);
            }
        }
        else {
            fix_selection = false;
        }
 
        add_env_state_func<add_to_initial>(
            EnvStateFuncBundle(name, esf, update, add_to_initial, times_pair,
                               {fix_selection, cell_selection, select_cfg})
        );
    }
 
 
    template<bool add_to_initial=false>
    void add_env_state_func_from_cfg(
        const std::string& name,
        const EnvStateFunc& esf,
        const Update& update = Update::sync,
        const Config& cfg = {})
    {
        auto times_pair = extract_times<Time>(cfg);
        Config select_cfg = {};
        if (cfg.IsMap()) {
            select_cfg = get_as<Config>("select", cfg, {});
        }
 
        add_env_state_func<add_to_initial>(name, esf, update, times_pair,
                                           select_cfg);
    }
 
    void track_parameter(const std::string& key) {
        if (_dsets_param.find(key) != _dsets_param.end()) {
            throw std::invalid_argument("Parameter '" + key + "' is already "
                                        "being tracked!");
        }
        _dsets_param.insert({key, this->create_dset(key, {})});
    }
 
 
    void track_parameters(const std::vector<std::string>& keys) {
        for (const auto& key : keys) {
            track_parameter(key);
        }
    }
 
    void track_state(const std::string& key) {
        if (_dsets_state.find(key) != _dsets_state.end()) {
            throw std::invalid_argument("State '" + key + "' is already "
                                        "being tracked!");
        }
        _dsets_state.insert({key, this->create_cm_dset(key, _cm)});
    }
 
 
    void track_states(const std::vector<std::string>& keys) {
        for (const auto& key : keys) {
            track_state(key);
        }
    }
 
private:
    void setup_env_param_funcs(const Config& cfg) {
        this->_log->info("Setting up environment param function sequence "
                         "from {} configuration entr{} ...",
                         cfg.size(), cfg.size() != 1 ? "ies" : "y");
 
        // For zombie or empty configurations, return empty container
        if (not cfg or not cfg.size()) {
            return;
        }
        // Otherwise, require a sequence
        if (not cfg.IsSequence()) {
            throw std::invalid_argument("The config for initializing the "
                "environment functions must be a sequence!");
        }
 
        // Iterate over the sequence of mappings
        for (const auto& epfs : cfg) {
            // epfs.IsMap() == true
            // The top `epfs` keys are now the names of the desired environment
            // functions. Iterate over those ...
            for (const auto& epf_pair : epfs) {
                // epf_pair is a pair of (key node, value node)
                // Find out the name of the rule function
                const auto epf_name = epf_pair.first.as<std::string>();
 
                this->_log->trace("  Function name:  {}", epf_name);
 
                // Now iterate over the (param name, param cfg) pairs
                for (const auto& kv_pair : epf_pair.second) {
                    // Get the parameter name and configuration
                    const auto param_name = kv_pair.first.as<std::string>();
                    const auto& epf_cfg = kv_pair.second;
 
                    // Distinguish by name of rule function
                    if (epf_name == "increment") {
                        auto epf = epf_increment(*this, param_name, epf_cfg);
                        add_env_param_func_from_cfg(
                            epf_name+"."+param_name, epf, param_name, epf_cfg
                        );
                    }
                    else if (epf_name == "random") {
                        auto epf = epf_random(*this, param_name, epf_cfg);
                        add_env_param_func_from_cfg(
                            epf_name+"."+param_name, epf, param_name, epf_cfg
                        );
                    }
                    else if (epf_name == "rectangular") {
                        auto epf = epf_rectangular(*this, epf_cfg);
                        add_env_param_func_from_cfg(
                            epf_name+"."+param_name, epf, param_name, epf_cfg
                        );
                    }
                    else if (epf_name == "set") {
                        auto epf = epf_set(*this, epf_cfg);
                        add_env_param_func_from_cfg(
                            epf_name+"."+param_name, epf, param_name, epf_cfg
                        );
                    }
                    else if (epf_name == "sinusoidal") {
                        auto epf = epf_sinusoidal(*this, epf_cfg);
                        add_env_param_func_from_cfg(
                            epf_name+"."+param_name, epf, param_name, epf_cfg
                        );
                    }
                    // .. can add more rule functions here (alphabetic order).
                    //    Add also in invalid_argument message below ..
                    else if (epf_name != "void") {
                        throw std::invalid_argument("No environment parameter "
                            "function '" + epf_name + "' available to "
                            "construct! Choose from: increment, random, "
                            "rectangular, set, sinusoidal.");
                    }
 
                    this->_log->debug("Added '{}' environment parameter "
                        "function for parameter '{}'.", epf_name, param_name);
                }
            }
        }
    };
 
    template<bool add_to_initial=false>
    void setup_env_state_funcs(const Config& cfg) {
        this->_log->info("Setting up {}environment state function sequence "
                         "from {} configuration entr{} ...",
                         add_to_initial ? "initial " : "",
                         cfg.size(), cfg.size() != 1 ? "ies" : "y");
 
        // For zombie or empty configurations, return empty container
        if (not cfg or not cfg.size()) {
            return;
        }
        // Otherwise, require a sequence
        if (not cfg.IsSequence()) {
            throw std::invalid_argument("The config for initializing the "
                "environment state functions must be a sequence!");
        }
 
        // Iterate over the sequence of mappings
        for (const auto& esfs : cfg) {
            // esfs.IsMap() == true
            // The top `esfs` keys are now the names of the desired environment
            // functions. Iterate over those ...
            for (const auto& esf_pair : esfs) {
                // esf_pair is a pair of (key node, value node)
                // Find out the name of the rule function
                const auto esf_name = esf_pair.first.as<std::string>();
 
                this->_log->trace("  Function name:  {}", esf_name);
 
                // Now iterate over the (param name, param cfg) pairs
                for (const auto& kv_pair : esf_pair.second) {
                    // Get the parameter name and configuration
                    const auto param_name = kv_pair.first.as<std::string>();
                    const auto& esf_cfg = kv_pair.second;
 
                    // Distinguish by name of rule function
                    if (esf_name == "noise") {
                        auto esf_update_pair = esf_noise(*this, param_name,
                                                         esf_cfg);
                        add_env_state_func_from_cfg<add_to_initial>(
                            "noise."+param_name, esf_update_pair.first,
                            esf_update_pair.second, esf_cfg
                        );
                    }
                    else if (esf_name == "slope") {
                        auto esf_update_pair = esf_slope(*this, param_name,
                                                         esf_cfg,
                                                         _cm.space()->extent);
                        add_env_state_func_from_cfg<add_to_initial>(
                            "slope."+param_name, esf_update_pair.first,
                            esf_update_pair.second, esf_cfg
                        );
                    }
                    else if (esf_name == "steps") {
                        auto esf_update_pair = esf_steps(*this, param_name,
                                                         esf_cfg);
                        add_env_state_func_from_cfg<add_to_initial>(
                            "steps."+param_name, esf_update_pair.first,
                            esf_update_pair.second, esf_cfg
                        );
                    }
                    else if (esf_name == "uniform") {
                        auto esf_update_pair = esf_uniform(*this, param_name,
                                                           esf_cfg);
                        add_env_state_func_from_cfg<add_to_initial>(
                            "uniform."+param_name, esf_update_pair.first,
                            esf_update_pair.second, esf_cfg
                        );
                    }
                    // .. can add more rule functions here ..
                    else if (esf_name != "void") {
                        throw std::invalid_argument("No environment state "
                            "function '" + esf_name + "' available to "
                            "construct! Choose from: noise, slope, steps, "
                            "uniform.");
                    }
 
                    this->_log->trace("Added '{}' environment state"
                        "function for parameter '{}'.", esf_name, param_name);
                }
            }
        }
    };
 
 
 
    template<class EPFB>
    void apply_env_param_func(EPFB&& epfb, bool initialization = false) {
        // Check whether to invoke
        if (initialization) {
            if (not epfb.invoke_at_initialization) {
                this->_log->trace("Not invoking environment function '{}' at "
                                  "initialization.", epfb.name);
                return;
            }
        }
        else if (not epfb.invoke_always) {
            // Compare to first element of the times set
            // NOTE This approach has a low and constant complexity as no tree
            //      traversal in the set takes place. This, however, relies on
            //      the ordering of the set and that the first element is
            //      never smaller than (current time + 1), which would lead to
            //      clogging of the erasure ...
            if (    epfb.times.size()
                and *epfb.times.begin() == (this->_time + 1))
            {
                // Invoke at this time; pop element corresponding to this time
                epfb.times.erase(epfb.times.begin());
            }
            else {
                this->_log->trace("Not invoking environment function '{}' in "
                                  "this iteration.", epfb.name);
                return;
            }
        }
 
        this->_log->debug("Applying environment parameter function '{}' ...",
                          epfb.name);
        this->_params.set_env(epfb.param_name, epfb.func());
    }
 
 
    template<class ESFB>
    void apply_env_state_func(ESFB&& esfb) {
        // Check whether to invoke
        if (not esfb.invoke_always) {
            // Compare to first element of the times set
            // NOTE This approach has a low and constant complexity as no tree
            //      traversal in the set takes place. This, however, relies on
            //      the ordering of the set and that the first element is
            //      never smaller than (current time + 1), which would lead to
            //      clogging of the erasure ...
            if (    esfb.times.size()
                and *esfb.times.begin() == (this->_time + 1))
            {
                // Invoke at this time; pop element corresponding to this time
                esfb.times.erase(esfb.times.begin());
            }
            else {
                this->_log->trace("Not invoking environment function '{}' in "
                                  "this iteration.", esfb.name);
                return;
            }
        }
 
        this->_log->debug("Applying environment state function '{}' ...",
                          esfb.name);
 
        // get EnvCellContainer over which to apply the function
        EnvCellContainer cell_selection = {};
        if (esfb.fix_selection) {
            cell_selection = esfb.cell_selection;
        }
        else if (not esfb.select_cfg.IsNull()) {
            this->_log->debug("Generating a new selection of cells for "
                              "environment state function '{}' ...", esfb.name);
            cell_selection = _cm.select_cells(esfb.select_cfg);
        }
        else {
            cell_selection = _cm.cells();
        }
 
        this->_log->debug("Applying to {} cells ...",
                          (cell_selection.size() == _cm.cells().size() ?
                           "all" : std::to_string(cell_selection.size())));
 
        // Need to distinguish by update mode
        if (esfb.update == Update::sync) {
            apply_rule<Update::sync>(esfb.func, cell_selection);
        }
        else if (esfb.update == Update::async) {
            apply_rule<Update::async>(esfb.func, cell_selection, *this->_rng);
        }
        else {
            // Throw in case the Update enum gets extended and an unexpected
            // value is passed ...
            throw std::invalid_argument("Unsupported `update` argument!");
        }
    }
 
    // .. Helper functions ....................................................
};
 
// End group Environment
} // namespace Environment
} // namespace Models
} // namespace Utopia
 
#endif // UTOPIA_MODELS_ENVIRONMENT_HH