Utopia::PseudoParent< RNG > Class Template Reference

A class to use at the top level of the model hierarchy as a mock parent. More...

#include <model.hh>

Collaboration diagram for Utopia::PseudoParent< RNG >:

Public Member Functions
	PseudoParent (const std::string cfg_path)
	Constructor that only requires path to a config file.
	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.)
	Constructor that allows granular control over config parameters.
Level	get_level () const
	Return the hierarchical level within the model hierarchy.
std::string	get_full_name () const
	Return the full name of the PseudoParent: an empty string.
Config	get_cfg () const
	Return the config node of the Pseudo model, i.e. the root node.
std::shared_ptr< HDFFile >	get_hdffile () const
	Return a pointer to the HDF data file.
std::shared_ptr< HDFGroup >	get_hdfgrp () const
	Return a pointer to the HDF group, which is the base group of the file.
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.
std::shared_ptr< RNG >	get_rng () const
	Return a pointer to the RNG.
std::shared_ptr< spdlog::logger >	get_logger () const
	Return a pointer to the logger of this model.
Time	get_time_max () const
	The maximum time value as it can be found in the config.
std::shared_ptr< MonitorManager >	get_monitor_manager () const
	Return the monitor manager of this model.
const Monitor &	get_monitor () const
	Return the monitor of this model.

Protected Types
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

Protected Attributes
const Level	_level
	The hierarchical level.
const Config	_cfg
	The config node.
const std::shared_ptr< HDFFile >	_hdffile
	Pointer to the HDF5 file where data is written to.
const std::shared_ptr< RNG >	_rng
	Pointer to a RNG that can be shared between models.
const std::shared_ptr< spdlog::logger >	_log
	Pointer to the logger of this (pseudo) model.
const std::shared_ptr< MonitorManager >	_monitor_mgr
	The monitor manager.
Monitor	_monitor
	The monitor instance of this root model.

Private Member Functions
void	setup_loggers () const
	Set up the global loggers with levels specified in the config file.
void	set_log_level () const
	Set the log level for the pseudo parent from the base_cfg.

Detailed Description

template<typename RNG = DefaultRNG>
class Utopia::PseudoParent< RNG >

A class to use at the top level of the model hierarchy as a mock parent.

It is especially useful when initializing a top-level model as the the model constructor that expects a Model-class-like object can be used. This class also takes care to load and hold a configuration file, to create a HDFFile for output, and to initialize a shared RNG. A template parameter exists that allows customization of the RNG class.

Template Parameters

RNG	The RNG type to use

Member Typedef Documentation

Config

template<typename RNG = DefaultRNG>

using Utopia::PseudoParent< RNG >::Config = Utopia::DataIO::Config

protected

HDFFile

template<typename RNG = DefaultRNG>

using Utopia::PseudoParent< RNG >::HDFFile = Utopia::DataIO::HDFFile

protected

HDFGroup

template<typename RNG = DefaultRNG>

using Utopia::PseudoParent< RNG >::HDFGroup = Utopia::DataIO::HDFGroup

protected

Level

template<typename RNG = DefaultRNG>

using Utopia::PseudoParent< RNG >::Level = std::size_t

protected

Monitor

template<typename RNG = DefaultRNG>

using Utopia::PseudoParent< RNG >::Monitor = Utopia::DataIO::Monitor

protected

MonitorManager

template<typename RNG = DefaultRNG>

using Utopia::PseudoParent< RNG >::MonitorManager = Utopia::DataIO::MonitorManager

protected

Time

template<typename RNG = DefaultRNG>

using Utopia::PseudoParent< RNG >::Time = std::size_t

protected

Constructor & Destructor Documentation

PseudoParent() [1/2]

template<typename RNG = DefaultRNG>

Utopia::PseudoParent< RNG >::PseudoParent ( const std::string  cfg_path )

inline

Constructor that only requires path to a config file.

From the config file, all necessary information is extracted, i.e.: the path to the output file ('output_path') and the seed of the shared RNG ('seed'). These keys have to be located at the top level of the configuration file.

Parameters

cfg_path

The path to the YAML-formatted configuration file

    :
    // 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() [2/2]

template<typename RNG = DefaultRNG>

Utopia::PseudoParent< RNG >::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.  )

inline

Constructor that allows granular control over config parameters.

Parameters

cfg_path	The path to the YAML-formatted configuration file
output_path	Where the HDF5 file is to be located
seed	The seed the RNG is initialized with (default: 42)
output_file_mode	The access mode of the HDF5 file (default: w)
emit_interval	The monitor emit interval (in seconds)

    :
    // 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);
    }

Member Function Documentation

get_cfg()

template<typename RNG = DefaultRNG>

Config Utopia::PseudoParent< RNG >::get_cfg ( ) const

inline

Return the config node of the Pseudo model, i.e. the root node.

                           {
        return _cfg;
    }

get_full_name()

template<typename RNG = DefaultRNG>

std::string Utopia::PseudoParent< RNG >::get_full_name ( ) const

inline

Return the full name of the PseudoParent: an empty string.

                                    {
        return "";
    }

get_hdffile()

template<typename RNG = DefaultRNG>

std::shared_ptr< HDFFile > Utopia::PseudoParent< RNG >::get_hdffile ( ) const

inline

Return a pointer to the HDF data file.

                                               {
        return _hdffile;
    }

get_hdfgrp()

template<typename RNG = DefaultRNG>

std::shared_ptr< HDFGroup > Utopia::PseudoParent< RNG >::get_hdfgrp ( ) const

inline

Return a pointer to the HDF group, which is the base group of the file.

                                               {
        return _hdffile->get_basegroup();
    }

get_level()

template<typename RNG = DefaultRNG>

Level Utopia::PseudoParent< RNG >::get_level ( ) const

inline

Return the hierarchical level within the model hierarchy.

                            {
        return _level;
    }

get_logger()

template<typename RNG = DefaultRNG>

std::shared_ptr< spdlog::logger > Utopia::PseudoParent< RNG >::get_logger ( ) const

inline

Return a pointer to the logger of this model.

                                                   {
        return _log;
    }

get_monitor()

template<typename RNG = DefaultRNG>

const Monitor & Utopia::PseudoParent< RNG >::get_monitor ( ) const

inline

Return the monitor of this model.

                                       {
        return _monitor;
    }

get_monitor_manager()

template<typename RNG = DefaultRNG>

std::shared_ptr< MonitorManager > Utopia::PseudoParent< RNG >::get_monitor_manager ( ) const

inline

Return the monitor manager of this model.

                                                              {
        return _monitor_mgr;
    }

get_rng()

template<typename RNG = DefaultRNG>

std::shared_ptr< RNG > Utopia::PseudoParent< RNG >::get_rng ( ) const

inline

Return a pointer to the RNG.

                                       {
        return _rng;
    }

get_time_max()

template<typename RNG = DefaultRNG>

Time Utopia::PseudoParent< RNG >::get_time_max ( ) const

inline

The maximum time value as it can be found in the config.

Currently, this reads the num_steps key, but this might be changed in the future to allow continuous time steps.

                              {
        return get_as<Time>("num_steps", _cfg);
    }

get_write_every()

template<typename RNG = DefaultRNG>

Time Utopia::PseudoParent< RNG >::get_write_every ( ) const

inline

Return the parameter that controls how often write_data is called.

                                 {
        return get_as<Time>("write_every", _cfg, 1);
    }

get_write_start()

template<typename RNG = DefaultRNG>

Time Utopia::PseudoParent< RNG >::get_write_start ( ) const

inline

Return the parameter that controls when write_data is called first.

                                 {
        return get_as<Time>("write_start", _cfg, 0);
    }

set_log_level()

template<typename RNG = DefaultRNG>

void Utopia::PseudoParent< RNG >::set_log_level ( ) const

inlineprivate

Set the log level for the pseudo parent from the base_cfg.

                                {
        _log->set_level(
            spdlog::level::from_str(get_as<std::string>("model",
                                                        _cfg["log_levels"]))
        );
    }

setup_loggers()

template<typename RNG = DefaultRNG>

void Utopia::PseudoParent< RNG >::setup_loggers ( ) const

inlineprivate

Set up the global loggers with levels specified in the config file.

Extract the following keys from the _cfg member:

- ``log_levels.core``:      the Core module log level; required
- ``log_levels.data_io``:   the DataIO module log level; required
- ``log_levels.data_mngr``: the DataIO::DataManager log level;
                            optional, defaults to ``warn``
- ``log_pattern``:          the global log pattern

                                {
        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, "")
        );
    }

Member Data Documentation

_cfg

template<typename RNG = DefaultRNG>

const Config Utopia::PseudoParent< RNG >::_cfg

protected

The config node.

_hdffile

template<typename RNG = DefaultRNG>

const std::shared_ptr<HDFFile> Utopia::PseudoParent< RNG >::_hdffile

protected

Pointer to the HDF5 file where data is written to.

_level

template<typename RNG = DefaultRNG>

const Level Utopia::PseudoParent< RNG >::_level

protected

The hierarchical level.

_log

template<typename RNG = DefaultRNG>

const std::shared_ptr<spdlog::logger> Utopia::PseudoParent< RNG >::_log

protected

Pointer to the logger of this (pseudo) model.

Required for passing on the logging level if unspecified for the respective model

_monitor

template<typename RNG = DefaultRNG>

Monitor Utopia::PseudoParent< RNG >::_monitor

protected

The monitor instance of this root model.

_monitor_mgr

template<typename RNG = DefaultRNG>

const std::shared_ptr<MonitorManager> Utopia::PseudoParent< RNG >::_monitor_mgr

protected

The monitor manager.

_rng

template<typename RNG = DefaultRNG>

const std::shared_ptr<RNG> Utopia::PseudoParent< RNG >::_rng

protected

Pointer to a RNG that can be shared between models.

---

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

• include/utopia/core/model.hh