model.hh

Go to the documentation of this file.

#ifndef UTOPIA_CORE_MODEL_HH
#define UTOPIA_CORE_MODEL_HH
 
#include <algorithm>
 
#include "exceptions.hh"
#include "signal.hh"
#include "ostream.hh"
#include "logging.hh"
#include "space.hh"
#include "parallel.hh"
 
#include "../data_io/hdffile.hh"
#include "../data_io/hdfgroup.hh"
#include "../data_io/cfg_utils.hh"
#include "../data_io/monitor.hh"
#include "../data_io/data_manager/data_manager.hh"
#include "../data_io/data_manager/factory.hh"
 
 
namespace Utopia {
 
enum class WriteMode {
 
    basic,
 
 
    managed,
 
 
    manual,
 
    off
};
 
constexpr WriteMode DefaultWriteMode = WriteMode::basic;
 
 
 
template<
    typename RNGType=DefaultRNG,
    WriteMode data_write_mode=DefaultWriteMode,
    typename SpaceType=DefaultSpace,
    typename ConfigType=Utopia::DataIO::Config,
    typename DataGroupType=Utopia::DataIO::HDFGroup,
    typename DataSetType=Utopia::DataIO::HDFDataset,
    typename TimeType=std::size_t,
    typename MonitorType=Utopia::DataIO::Monitor,
    typename MonitorManagerType=Utopia::DataIO::MonitorManager
    >
struct ModelTypes {
    using RNG = RNGType;
    static constexpr WriteMode write_mode = data_write_mode;
    using Space = SpaceType;
    using Config = ConfigType;
    using DataGroup = DataGroupType;
    using DataSet = DataSetType;
    using Time = TimeType;
    using Monitor = MonitorType;
    using MonitorManager = MonitorManagerType;
    using Level = std::size_t;
};
 
 
 
template<class Derived, typename ModelTypes>
class Model
{
public:
    // -- Data types uses throughout the model class --------------------------
    using Config = typename ModelTypes::Config;
 
    using DataManager = DataIO::Default::DefaultDataManager<Derived>;
 
    using DataGroup = typename ModelTypes::DataGroup;
 
    using DataSet = typename ModelTypes::DataSet;
 
    using RNG = typename ModelTypes::RNG;
 
    using Space = typename ModelTypes::Space;
 
    using Time = typename ModelTypes::Time;
 
    using Monitor = typename ModelTypes::Monitor;
 
    using MonitorManager = typename ModelTypes::MonitorManager;
 
    using Level = typename ModelTypes::Level;
 
 
protected:
    // -- Member declarations -------------------------------------------------
    const std::string _name;
 
    const std::string _full_name;
 
    const Level _level;
 
    const Config _cfg;
 
    const std::shared_ptr<RNG> _rng;
 
    const std::shared_ptr<spdlog::logger> _log;
 
    std::shared_ptr<Space> _space;
 
    Time _time;
 
    const Time _time_max;
 
    const std::shared_ptr<DataGroup> _hdfgrp;
 
    static constexpr WriteMode _write_mode = ModelTypes::write_mode;
 
    const Time _write_start;
 
    const Time _write_every;
 
    Monitor _monitor;
 
 
    DataManager _datamanager;
 
private:
    // .. Construction helpers ................................................
 
 
    template<class Parent>
    auto setup_logger(const Parent& parent_model) const {
        auto log = spdlog::stdout_color_mt(
            parent_model.get_logger()->name() + "." + _name
        );
 
        // Set this model instance's log level
        if (_cfg["log_level"]) {
            // Via value given in configuration
            const auto lvl = get_as<std::string>("log_level", _cfg);
            log->debug("Setting log level to '{}' ...", lvl);
            log->set_level(spdlog::level::from_str(lvl));
        }
        else {
            // No config value given; use the level of the parent's logger
            log->set_level(parent_model.get_logger()->level());
        }
 
        log->info("Model logger initialized.");
        return log;
    }
 
    auto setup_space() const {
        if (_cfg["space"]) {
            auto space = std::make_shared<Space>(_cfg["space"]);
            _log->info(
                "Using {}periodic space with extent {}.",
                space->periodic ? "" : "non-", Utils::str(space->extent)
            );
            return space;
        }
        else {
            _log->debug(
                "No model-level space configured; using default space."
            );
            return std::make_shared<Space>();
        }
    }
 
 
public:
    // -- Constructor ---------------------------------------------------------
 
 
    template < class ParentModel, class... WriterArgs >
    Model(
        const std::string& name,
        const ParentModel& parent_model,
        const Config& custom_cfg = {},
        std::tuple< WriterArgs... > w_args = {},
        const DataIO::Default::DefaultDecidermap< Derived >&
            w_deciders = DataIO::Default::default_deciders< Derived >,
        const DataIO::Default::DefaultTriggermap< Derived >&
            w_triggers = DataIO::Default::default_triggers< Derived >
        )
    :
        // First thing: setup name and position within model hierarchy
        _name(name),
        _full_name(parent_model.get_full_name() + "." + name),
        _level(parent_model.get_level() + 1),
 
        // Retrieve the appropriate configuration entry from the parent model
        _cfg(custom_cfg.size() ? custom_cfg
             : get_as<Config>(_name, parent_model.get_cfg())),
 
        // Construct infrastructure objects using information from parent
        _rng(parent_model.get_rng()),
        _log(setup_logger(parent_model)),
 
        // Determine space and time
        _space(setup_space()),
        _time(0),
        _time_max(_level == 1 ? parent_model.get_time_max()
                  : get_as<Time>("num_steps", _cfg,
                                 std::numeric_limits<Time>::max())),
 
        // Extract the other information from the parent model object
        _hdfgrp(parent_model.get_hdfgrp()->open_group(_name)),
        _write_start(get_as<Time>("write_start", _cfg,
                                  parent_model.get_write_start())),
        _write_every(get_as<Time>("write_every", _cfg,
                                  parent_model.get_write_every())),
 
        // Set up the monitor, using the parent model's monitor to place it in
        // a hierarchy equivalent to the model hierarchy
        _monitor(_name, parent_model.get_monitor()),
 
        // Default-construct the data maanger; only used if needed, see below.
        _datamanager()
    {
        // Provide some information, also depending on write mode
        _log->info("Model base constructor for '{}' finished.", _name);
        _log->info("  full_name:   {}", _full_name);
        _log->info("  level:       {}", _level);
        _log->info("  time_max:    {:7d}", _time_max);
 
        if constexpr (_write_mode == WriteMode::basic) {
            _log->info("  write_mode:  {:>7s}", "basic");
            _log->info("  write_start: {:7d}", _write_start);
            _log->info("  write_every: {:7d}", _write_every);
            _log->info("  #writes:     {:7d}", get_remaining_num_writes());
 
            // Store relevant info in base group attributes
            _hdfgrp->add_attribute("write_mode", "basic");
            _hdfgrp->add_attribute("write_start", _write_start);
            _hdfgrp->add_attribute("write_every", _write_every);
            _hdfgrp->add_attribute("time_max",    _time_max);
        }
        else if constexpr (_write_mode == WriteMode::manual) {
            _log->info("  write_mode:  {:>7s}", "manual");
            _hdfgrp->add_attribute("write_mode", "manual");
        }
        else if constexpr (_write_mode == WriteMode::off) {
            _log->info("  write_mode:  {:>7s}", "off");
            _hdfgrp->add_attribute("write_mode", "off");
        }
        else if constexpr (_write_mode == WriteMode::managed) {
            static_assert(sizeof...(WriterArgs) > 0,
                          "No arguments to construct write_tasks given!");
 
            _log->info("  write_mode:  {:>7s}", "managed");
 
            // Store relevant info in base group attributes
            _hdfgrp->add_attribute("write_mode", "managed");
 
            // Some convenience key checks for nicer error messages.
            if (not _cfg["data_manager"]) {
                throw KeyError("data_manager", _cfg,
                               "Cannot set up DataManager!");
            }
            const auto dm_cfg = _cfg["data_manager"];
 
            if (not dm_cfg["tasks"]) {
                throw KeyError("tasks", dm_cfg,
                               "Cannot set up DataManager tasks!");
            }
            if (not dm_cfg["deciders"]) {
                throw KeyError("deciders", dm_cfg,
                               "Cannot set up DataManager deciders!");
            }
            if (not dm_cfg["triggers"]) {
                throw KeyError("triggers", dm_cfg,
                               "Cannot set up DataManager triggers!");
            }
 
            _log->info("Invoking DataManager task factory ...");
 
            _datamanager = DataIO::DataManagerFactory<Derived>()(
                dm_cfg, w_args, w_deciders, w_triggers
            );
 
            _log->info("DataManager set up with {} task(s), {} decider(s), "
                       "and {} trigger(s).", _datamanager.get_tasks().size(),
                       _datamanager.get_deciders().size(),
                       _datamanager.get_triggers().size());
        }
    }
 
 
 
    // -- Getters -------------------------------------------------------------
 
    const std::shared_ptr<Space>& get_space() const {
        return _space;
    }
 
    Time get_time() const {
        return _time;
    }
 
 
    Time get_time_max() const {
        if (_time_max == std::numeric_limits<Time>::max()) {
            this->_log->warn("Accessing the `time_max` of (sub-)model {} with "
                "unlimited value!", this->get_full_name());
        }
        return _time_max;
    }
 
    Config get_cfg() const {
        return _cfg;
    }
 
    std::string get_name() const {
        return _name;
    }
 
    std::string get_full_name() const {
        return _full_name;
    }
 
    std::shared_ptr<DataGroup> get_hdfgrp() const {
        return _hdfgrp;
    }
 
    Time get_write_start() const {
        return _write_start;
    }
 
    Time get_write_every() const {
        return _write_every;
    }
 
    DataManager get_datamanager() const {
        return _datamanager;
    }
 
 
    hsize_t get_remaining_num_writes() const {
        static_assert(
            _write_mode == WriteMode::basic or
            _write_mode == WriteMode::manual or
            _write_mode == WriteMode::off or
            _write_mode == WriteMode::managed
        );
 
        if constexpr (_write_mode == WriteMode::basic) {
            if (_time_max == std::numeric_limits<hsize_t>::max()) {
                return std::numeric_limits<hsize_t>::max();
            }
            return (  (_time_max - std::max(_time, _write_start))
                    / _write_every) + 1;
        }
        else if constexpr (_write_mode == WriteMode::manual) {
            if (_time_max - _time == std::numeric_limits<hsize_t>::max()) {
                return std::numeric_limits<hsize_t>::max();
            }
            return _time_max - _time + 1;
        }
        else {
            return 0;
        }
 
    }
 
    std::shared_ptr<RNG> get_rng() const {
        return _rng;
    }
 
    std::shared_ptr<spdlog::logger> get_logger() const {
        return _log;
    }
 
    Monitor get_monitor() const {
        return _monitor;
    }
 
    std::shared_ptr<MonitorManager> get_monitor_manager() const {
        return _monitor.get_monitor_manager();
    }
 
    Level get_level() const {
        return _level;
    }
 
 
    // -- Simulation control --------------------------------------------------
 
    virtual void prolog () {
        __prolog();
    }
 
 
    virtual void epilog () {
        __epilog();
    }
 
 
    void iterate () {
        // -- Perform the simulation step
        __perform_step();
        increment_time();
 
        // -- Monitoring
        /* If the model is at the first hierarchical level, check whether the
         * monitor entries should be collected and emitted. This leads to a
         * flag being set in the monitor manager, such that the submodels do
         * not have to do the check against the timer as well and that all
         * collected data stems from the same time step.
         */
        if (_level == 1) {
            _monitor.get_monitor_manager()->check_timer();
            __monitor();
 
            // If enabled for this step, perform the emission of monitor data
            // NOTE At this point, we can be sure that all submodels have
            //      already run, because their iterate functions were called
            //      in the perform_step of the level 1 model.
            _monitor.get_monitor_manager()->emit_if_enabled();
        }
        else {
            __monitor();
        }
 
        // -- Data output
        if constexpr (_write_mode == WriteMode::basic) {
            if (    (_time >= _write_start)
                and (_time - _write_start) % _write_every == 0) {
                __write_data();
            }
        }
        else if constexpr (_write_mode == WriteMode::manual) {
            __write_data();
        }
        else if constexpr (_write_mode == WriteMode::managed) {
            _datamanager(static_cast<Derived&>(*this));
        }
 
        if (_level == 1) {
            _log->debug("Finished iteration: {:7d} / {:d}", _time, _time_max);
        }
        else {
            _log->debug("Finished iteration: {:7d}", _time);
        }
    }
 
 
    void run () {
        if (_level > 1 and get_time_max() == std::numeric_limits<Time>::max()) {
            throw std::runtime_error(fmt::format("Cannot perform run on "
                "(sub-)model {} with unlimited `time_max`. You need to provide "
                "`num_steps` to the model's configuration in order to use the "
                "`run` method. See the nested models guide for further "
                "information!", get_full_name()));
        }
 
        // First, attach the signal handler, such that the while loop below can
        // be left upon receiving of a signal.
        __attach_sig_handlers();
 
        // call the prolog of the model
        prolog();
 
        // Now, let's go repeatedly iterate the model ...
        _log->info("Running from current time  {}  to  {}  ...",
                   _time, _time_max);
 
        while (_time < _time_max) {
            iterate();
 
            if (stop_now.load()) {
                const auto signum = received_signum.load();
 
                if (signum == SIGUSR1) {
                    _log->warn("The stop condition for this run is fulfilled. "
                               "Not iterating further ...");
                }
                else {
                    _log->warn("Was told to stop. Not iterating further ...");
                }
 
                _log->info("Invoking epilog ...");
                epilog();
 
                throw GotSignal(received_signum.load());
            }
        }
 
        _log->info("Run finished. Current time:  {}", _time);
 
        // call the epilog of the model
        epilog();
    }
 
 
protected:
    // -- Functions requiring/allowing user-defined implementations -----------
 
    void __perform_step () {
        impl().perform_step();
    }
 
    /* The child implementation of this function will only be called if the
     * monitor manager has determined that an emission will occur, because it
     * only makes sense to collect data if it will be emitted in this step.
     */
    void __monitor () {
        if (_monitor.get_monitor_manager()->emit_enabled()) {
            // Perform actions that should only happen once by the monitor at
            // the highest level of the model hierarchy.
            if (_level == 1){
                // Supply the global time. When reaching this point, all sub-
                // models will also have reached this time.
                _monitor.get_monitor_manager()->set_time_entries(_time,
                                                                 _time_max);
                // This method also sets the other top level entries
            }
 
            // Call the child's implementation of the monitor functions.
            impl().monitor();
        }
    }
 
    void __write_data () {
        _log->trace("Calling write_data ...");
        impl().write_data();
    }
 
    void __write_initial_state () {
        // Select the required WriteMode
        // Decide on whether the initial state needs to be written
        if constexpr (_write_mode == WriteMode::basic) {
            if (_write_start == _time) {
                _log->info("Writing initial state ...");
                __write_data();
            }
        }
        else if constexpr (_write_mode == WriteMode::manual) {
            __write_data();
        }
        else if constexpr (_write_mode == WriteMode::managed) {
            _datamanager(static_cast<Derived&>(*this));
        }
 
    }
 
 
    void increment_time (const Time dt=1) {
        _time += dt;
    }
 
 
    void __prolog () {
        __write_initial_state();
 
        this->_log->debug("Prolog finished.");
    }
 
 
    void __epilog () {
        this->_log->debug("Epilog finished.");
    }
 
 
    // -- CRTP ----------------------------------------------------------------
    Derived& impl () {
        return static_cast<Derived&>(*this);
    }
 
    const Derived& impl () const {
        return static_cast<const Derived&>(*this);
    }
 
 
public:
    // -- Convenience functions -----------------------------------------------
 
    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={})
    {
        _log->debug("Creating dataset '{}' in group '{}' ...",
                    name, hdfgrp->get_path());
 
        // Calculate the number of time steps to be written
        const hsize_t num_write_ops = get_remaining_num_writes();
 
        // Calculate the shape of the dataset
        add_write_shape.insert(add_write_shape.begin(), num_write_ops);
        auto capacity = add_write_shape;
 
        // Create the dataset and return it.
        const auto dset = hdfgrp->open_dataset(name, capacity,
                                               chunksize, compression_level);
        _log->debug("Successfully created dataset '{}'.", name);
 
        // Write further attributes, if not specifically suppressed
        if (get_as<bool>("write_dim_labels_and_coords", _cfg, true)) {
            // We know that dimension 0 is the time dimension. Add the
            // attributes that specify dimension names and coordinates:
            dset->add_attribute("dim_name__0", "time");
            dset->add_attribute("coords_mode__time", "start_and_step");
            dset->add_attribute("coords__time",
                                std::vector<std::size_t>{_write_start,
                                                         _write_every});
            _log->debug("Added time dimension labels and coordinates to "
                        "dataset '{}'.", name);
        }
 
        return dset;
    }
 
    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={})
    {
        // Forward to the main create_dset function
        return create_dset(name,
                           _hdfgrp, // The base group for this model
                           add_write_shape, compression_level, chunksize);
    }
 
    template<class CellManager>
    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={})
    {
        // Forward to the main create_dset function
        const auto dset = create_dset(
            name,
            _hdfgrp,
            {cm.cells().size()}, // -> 2D dataset
            compression_level,
            chunksize
        );
 
        // Set attributes to mark this dataset as containing grid data
        dset->add_attribute("content", "grid");
 
        // Need further attributes to denote the grid structure, size, etc.
        const auto grid_structure = cm.grid()->structure_name();
        dset->add_attribute("grid_structure", grid_structure);
        dset->add_attribute("grid_shape", cm.grid()->shape());
        dset->add_attribute("space_extent", cm.grid()->space()->extent);
        dset->add_attribute("periodic_space", cm.grid()->space()->periodic);
 
        if (grid_structure == "hexagonal") {
            // ... some additional info is needed, which is dependent on the
            // way the HexagonalGrid maps cells
            dset->add_attribute("coordinate_mode", "offset");
            dset->add_attribute("offset_mode", "even");
            dset->add_attribute("pointy_top", true);
        }
 
        // The CellManager uses "column-style" index ordering, also called
        // "Fortran-style". This is relevant for assigning the correct IDs.
        dset->add_attribute("index_order", "F");
 
        _log->debug("Added attributes to dataset '{}' to mark it as storing "
                    "grid data.", name);
 
        // Write additional attributes, if not specifically suppressed.
        if (get_as<bool>("write_dim_labels_and_coords", _cfg, true)) {
            // We know that the dimensions here refer to (time, cell ids).
            // The time information is already added in create_dset; only need
            // to add the ID information here
            dset->add_attribute("dim_name__1", "ids");
 
            // For ids, the dimensions are trivial
            dset->add_attribute("coords_mode__ids", "range");
            dset->add_attribute("coords__ids",
                                std::vector<std::size_t>{cm.cells().size()});
 
            _log->debug("Added cell ID dimension labels and coordinates to "
                        "dataset '{}'.", name);
        }
 
        return dset;
    }
    
    
    template<class AgentManager>
    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 = {})    
    {
        // Forward to the main create_dset function
        const auto dset = create_dset(
            name,
            _hdfgrp,
            {am.agents().size()},  // --> 2D: time, agents
            compression_level,
            chunksize
        );
 
        // Set attribute to store the agent managers' extent of space
        dset->add_attribute("space_extent", am.space()->extent);
        _log->debug("Added attribute to dataset '{}' to store space extent",
                    name);
        
        // Write additional attributes, if not specifically suppressed.
        if (get_as<bool>("write_dim_labels_and_coords", _cfg, true)) {
            // We know that the dimensions here refer to (time, agent ids). The
            // time information is already added in create_dset; add only ID
            // information here. Note that this assumes trivial and constant
            // agent IDs!
            dset->add_attribute("dim_name__1", "ids");
 
            // For ids, the dimensions are trivial
            dset->add_attribute("coords_mode__ids", "trivial");
                                 
           _log->debug("Added agent index dimension labels and coordinates "
                       "to dataset '{}'.", name);
        }
 
        return dset;
    }
 
 
private:
    // -- Private Helper Methods ----------------------------------------------
 
 
    void __attach_sig_handlers() const {
        _log->debug("Attaching signal handlers for SIGINT and SIGTERM ...");
 
        attach_signal_handler(SIGINT);
        attach_signal_handler(SIGTERM);
 
        _log->debug("Attaching signal handler for stop conditions, triggered "
                    "by SIGUSR1 ({:d}) ...", SIGUSR1);
        attach_signal_handler(SIGUSR1);
 
        _log->debug("Signal handlers attached.");
    }
};
 
 
 
 
template<typename RNG=DefaultRNG>
class PseudoParent
{
protected:
    using Config = Utopia::DataIO::Config;
 
    using HDFFile = Utopia::DataIO::HDFFile;
    using HDFGroup = Utopia::DataIO::HDFGroup;
 
    using MonitorManager = Utopia::DataIO::MonitorManager;
    using Monitor = Utopia::DataIO::Monitor;
 
    using Time = std::size_t;
    using Level = std::size_t;
 
    const Level _level;
 
    const Config _cfg;
 
    const std::shared_ptr<HDFFile> _hdffile;
 
    const std::shared_ptr<RNG> _rng;
 
 
    const std::shared_ptr<spdlog::logger> _log;
 
    const std::shared_ptr<MonitorManager> _monitor_mgr;
 
    Monitor _monitor;
 
public:
 
    PseudoParent (const std::string cfg_path)
    :
    // The hierarchical level is 0
    _level(0),
    // Initialize the config node from the path to the config file
    _cfg(YAML::LoadFile(cfg_path)),
    // Create a file at the specified output path and store the shared pointer
    _hdffile(std::make_shared<HDFFile>(
        get_as<std::string>("output_path", _cfg),
        get_as<std::string>("output_file_mode", _cfg, "w")
    )),
    // Initialize the RNG from a seed
    _rng(std::make_shared<RNG>(get_as<int>("seed", _cfg))),
    // And initialize the root logger at warning level
    _log(Utopia::init_logger("root", spdlog::level::warn, false)),
    // Create a monitor manager and a root monitor
    _monitor_mgr(std::make_shared<MonitorManager>(
        get_as<double>("monitor_emit_interval", _cfg))
    ),
    _monitor(_monitor_mgr)
    {
        setup_loggers(); // global loggers
        set_log_level(); // this log level
        ParallelExecution::init(_cfg);
 
        _log->info("Initialized PseudoParent from config file");
        _log->debug("cfg_path:       {}", cfg_path);
        _log->debug("output_path:    {}", get_as<std::string>("output_path",
                                                              _cfg));
        _log->debug("RNG seed:       {}", get_as<int>("seed", _cfg));
        _log->debug("emit_interval:  {}s",
                    get_as<double>("monitor_emit_interval", _cfg));
    }
 
 
 
    PseudoParent (const std::string cfg_path,
                  const std::string output_path,
                  const int seed=42,
                  const std::string output_file_mode="w",
                  const double emit_interval=5.)
    :
    // The hierarchical level is 0
    _level(0),
    // Initialize the config node from the path to the config file
    _cfg(YAML::LoadFile(cfg_path)),
    // Create a file at the specified output path
    _hdffile(std::make_shared<HDFFile>(output_path, output_file_mode)),
    // Initialize the RNG from a seed
    _rng(std::make_shared<RNG>(seed)),
    // And initialize the root logger at warning level
    _log(Utopia::init_logger("root", spdlog::level::warn, false)),
    // Create a monitor manager and a "root" monitor
    _monitor_mgr(std::make_shared<MonitorManager>(emit_interval)),
    _monitor(_monitor_mgr)
    {
        setup_loggers(); // global loggers
        set_log_level(); // this log level
        ParallelExecution::init(_cfg);
 
        _log->info("Initialized PseudoParent from parameters");
        _log->debug("cfg_path:      {}", cfg_path);
        _log->debug("output_path:   {}  (mode: {})",
                    output_path, output_file_mode);
        _log->debug("RNG seed:      {}", seed);
        _log->debug("emit_interval: {}", emit_interval);
    }
 
 
 
    // -- Getters -- //
 
    Level get_level() const {
        return _level;
    }
 
    std::string get_full_name() const {
        return "";
    }
 
    Config get_cfg() const {
        return _cfg;
    }
 
    std::shared_ptr<HDFFile> get_hdffile() const {
        return _hdffile;
    }
 
    std::shared_ptr<HDFGroup> get_hdfgrp() const {
        return _hdffile->get_basegroup();
    }
 
    Time get_write_start() const {
        return get_as<Time>("write_start", _cfg, 0);
    }
 
    Time get_write_every() const {
        return get_as<Time>("write_every", _cfg, 1);
    }
 
    std::shared_ptr<RNG> get_rng() const {
        return _rng;
    }
 
    std::shared_ptr<spdlog::logger> get_logger() const {
        return _log;
    }
 
 
    Time get_time_max() const {
        return get_as<Time>("num_steps", _cfg);
    }
 
    std::shared_ptr<MonitorManager> get_monitor_manager() const {
        return _monitor_mgr;
    }
 
    const Monitor& get_monitor() const {
        return _monitor;
    }
 
 
private:
 
 
    void setup_loggers () const {
        Utopia::setup_loggers(
            spdlog::level::from_str(
                get_as<std::string>("core", _cfg["log_levels"])
            ),
            spdlog::level::from_str(
                get_as<std::string>("data_io", _cfg["log_levels"])
            ),
            spdlog::level::from_str(
                get_as<std::string>("data_mngr", _cfg["log_levels"], "warn")
            ),
            get_as<std::string>("log_pattern", _cfg, "")
        );
    }
 
    void set_log_level () const {
        _log->set_level(
            spdlog::level::from_str(get_as<std::string>("model",
                                                        _cfg["log_levels"]))
        );
    }
};
 
 
// end group Model
} // namespace Utopia
 
#endif // UTOPIA_CORE_MODEL_HH