Utopia::Models::SEIRD::SEIRD Class Reference

SEIRD model on a grid. More...

#include <SEIRD.hh>

Inheritance diagram for Utopia::Models::SEIRD::SEIRD:

Collaboration diagram for Utopia::Models::SEIRD::SEIRD:

Public Types
using	Base = Model< SEIRD, CDTypes >
	The base model type.
using	DataGroup = typename Base::DataGroup
	Data type for a data group.
using	DataSet = typename Base::DataSet
	Data type for a dataset.
using	CellManager = Utopia::CellManager< CDCellTraits, SEIRD >
	Type of the CellManager to use.
using	Cell = typename CellManager::Cell
	Type of a cell.
using	CellContainer = Utopia::CellContainer< Cell >
	Type of a container of shared pointers to cells.
using	RuleFunc = typename CellManager::RuleFunc
	Rule function type.
Public Types inherited from Utopia::Model< SEIRD, CDTypes >
using	Config = typename ModelTypes::Config
	Data type that holds the configuration.
using	DataManager = DataIO::Default::DefaultDataManager< SEIRD >
	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 >
	SEIRD (const std::string &name, ParentModel &parent_model, const DataIO::Config &custom_cfg={})
	Construct the SEIRD model.
void	perform_step ()
	Iterate a single time step.
void	monitor ()
	Monitor model information.
void	write_data ()
	Write data.
Public Member Functions inherited from Utopia::Model< SEIRD, CDTypes >
	Model (const std::string &name, const ParentModel &parent_model, const Config &custom_cfg={}, std::tuple< WriterArgs... > w_args={}, const DataIO::Default::DefaultDecidermap< SEIRD > &w_deciders=DataIO::Default::default_deciders< SEIRD >, const DataIO::Default::DefaultTriggermap< SEIRD > &w_triggers=DataIO::Default::default_triggers< SEIRD >)
	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.

Protected Member Functions
void	update_densities ()
	Update the densities array.
void	identify_clusters ()
	Identify clusters.
void	exposure_control ()
	Apply exposure control.
void	immunity_control ()
	Apply immunity control.
void	transmission_control ()
	Apply transmission control.
Protected Member Functions inherited from Utopia::Model< SEIRD, CDTypes >
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.
SEIRD &	impl ()
	cast to the derived class
const SEIRD &	impl () const
	const cast to the derived interface

Protected Attributes
RuleFunc	_update
	Define the update rule.
RuleFunc	_identify_cluster
	Identify each cluster of susceptibles.
RuleFunc	_move_away_from_infected
	Move the agent on the cell away from an infected neighboring cell.
RuleFunc	_move_randomly
	Move randomly to a neighboring cell if that cell is empty.
Protected Attributes inherited from Utopia::Model< SEIRD, CDTypes >
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.

Private Attributes
CellManager	_cm
	The cell manager.
const Params	_params
	Model parameters.
std::uniform_real_distribution< double >	_prob_distr
	The range [0, 1] distribution to use for probability checks.
unsigned int	_cluster_id_cnt
	The incremental cluster tag.
std::vector< std::shared_ptr< CellManager::Cell > >	_cluster_members
	A temporary container for use in cluster identification.
std::array< double, static_cast< char >(Kind::COUNT)>	_densities
	Densities for all states.
Counters< std::size_t >	_counts
	Cumulative counters for state transitions and other events
const int	_compression
	The compression level used for all datasets.
bool	_write_ca_data
	If false, writes only the non-spatial densities and counts data.
std::shared_ptr< DataSet >	_dset_densities
	2D dataset (densities array and time) of density values
std::shared_ptr< DataSet >	_dset_counts
	2D dataset (counts array and time) of cumulative state counters
std::shared_ptr< DataSet >	_dset_kind
	2D dataset (cell ID and time) of cell kinds
std::shared_ptr< DataSet >	_dset_immune
	2D dataset (cell ID and time) of cell's immunity
std::shared_ptr< DataSet >	_dset_num_recoveries
	2D dataset (cell ID and time) of cell's number of recoveries
std::shared_ptr< DataSet >	_dset_age
	2D dataset (cell ID and time) of cell's age
std::shared_ptr< DataSet >	_dset_cluster_id
	The dataset for storing the cluster ID associated with each cell.

Additional Inherited Members
Static Protected Attributes inherited from Utopia::Model< SEIRD, CDTypes >
static constexpr WriteMode	_write_mode
	Which data-writing mode the base model should use.

Detailed Description

SEIRD model on a grid.

In this model, we model the spread of a disease using a SEIRD (susceptible-exposed-infected-recovered-deceased) model on a 2D grid.

Member Typedef Documentation

Base

using Utopia::Models::SEIRD::SEIRD::Base = Model<SEIRD, CDTypes>

The base model type.

Cell

using Utopia::Models::SEIRD::SEIRD::Cell = typename CellManager::Cell

Type of a cell.

CellContainer

using Utopia::Models::SEIRD::SEIRD::CellContainer = Utopia::CellContainer<Cell>

Type of a container of shared pointers to cells.

CellManager

using Utopia::Models::SEIRD::SEIRD::CellManager = Utopia::CellManager<CDCellTraits, SEIRD>

Type of the CellManager to use.

DataGroup

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

Data type for a data group.

DataSet

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

Data type for a dataset.

RuleFunc

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

Rule function type.

Constructor & Destructor Documentation

SEIRD()

template<class ParentModel >

Utopia::Models::SEIRD::SEIRD::SEIRD ( const std::string &  name, ParentModel &  parent_model, const DataIO::Config &  custom_cfg = {}  )

inline

Construct the SEIRD model.

Parameters

name	Name of this model instance; is used to extract the configuration from the parent model and set up a HDFGroup for this instance
parent_model	The parent model this model instance resides in
custom_cfg	A custom configuration to use instead of the one extracted from the parent model using the instance name

                                           {})
    :
        // Initialize first via base model
        Base(name, parent_model, custom_cfg),
 
        // Initialize the cell manager, binding it to this model
        _cm(*this),
 
        // Carry over Parameters
        _params(this->_cfg),
 
        // Initialize remaining members
        _prob_distr(0., 1.),
        _cluster_id_cnt(),
        _cluster_members(),
        _densities{},  // undefined here, will be set in constructor body
        _counts{},
 
        // Data output . . . . . . . . . . . . . . . . . . . . . . . . . . . .
        // Get output-related parameters
        _compression(get_as<int>("compression", this->_cfg)),
        _write_ca_data(get_as<bool>("write_ca_data", this->_cfg)),
 
        // Create the dataset for the densities and counts; shape is known
        _dset_densities(
            this->create_dset("densities", {static_cast<char>(Kind::COUNT)},
                              _compression)
        ),
        _dset_counts(
            this->create_dset("counts", {_counts.size}, _compression)
        ),
 
        // Create CellManager-based datasets
        _dset_kind(
            this->create_cm_dset("kind", _cm, _compression)),
        _dset_immune(
            this->create_cm_dset("immune", _cm, _compression)),
        _dset_num_recoveries(
            this->create_cm_dset("num_recoveries", _cm, _compression)),
        _dset_age(
            this->create_cm_dset("age", _cm, _compression)),
        _dset_cluster_id(
            this->create_cm_dset("cluster_id", _cm, _compression))
    {
        // Make sure the densities are not undefined
        _densities.fill(std::numeric_limits<double>::quiet_NaN());
 
        // Cells are already set up by the CellManager.
        // Remaining initialization steps regard only macroscopic quantities,
        // e.g. the setup of heterogeneities: Inert cells and infection source.
 
        // Inert
        if (_cfg["inert_cells"] and
            get_as<bool>("enabled", _cfg["inert_cells"]))
        {
            this->_log->info("Setting cells to be inert ...");
 
            // Get the container
            auto make_inert = _cm.select_cells(_cfg["inert_cells"]);
 
            // Apply a rule to all cells of that container: turn to an inert cell
            apply_rule<Update::async, Shuffle::off>(
                [](const auto& cell) {
                    auto& state = cell->state;
                    state.kind  = Kind::inert;
                    return state;
                },
                make_inert);
 
            this->_log->info("Set {} cells to be inert using selection mode "
                             "'{}'.",
                             make_inert.size(),
                             get_as<std::string>("mode", _cfg["inert_cells"]));
        }
 
        // Ignite some cells permanently: infection sources
        if (_cfg["infection_source"] and
            get_as<bool>("enabled", _cfg["infection_source"]))
        {
            this->_log->info("Setting cells to be infection sources ...");
            auto source_cells = _cm.select_cells(_cfg["infection_source"]);
 
            apply_rule<Update::async, Shuffle::off>(
                [](const auto& cell) {
                    auto& state = cell->state;
                    state.kind  = Kind::source;
                    return state;
                },
                source_cells);
 
            this->_log->info(
                "Set {} cells to be infection sources using "
                "selection mode '{}'.",
                source_cells.size(),
                get_as<std::string>("mode", _cfg["infection_source"]));
        }
 
        // Store the kind names (see state.hh) in the dataset attributes.
        _dset_kind->add_attribute("kind_names", kind_names);
        this->_log->debug("Stored metadata in 'kind' dataset.");
 
        // Add coordinate attributes to density and counts datasets
        _dset_densities->add_attribute("dim_name__1", "kind");
        _dset_densities->add_attribute("coords_mode__kind", "values");
        _dset_densities->add_attribute("coords__kind", kind_names);
 
        _dset_counts->add_attribute("dim_name__1", "label");
        _dset_counts->add_attribute("coords_mode__label", "values");
        _dset_counts->add_attribute("coords__label", _counts.labels());
 
        this->_log->debug("Added coordinate labels to 'densities' and "
                          "'counts' datasets.");
 
        // Initialization should be finished here. Provide some info
        this->_log->info("{} model fully set up.", this->_name);
        this->_log->info("  Writing CA data?    {}",
                         _write_ca_data ? "Yes" : "No");
        this->_log->info("  Compression level:  {}", _compression);
    }

Member Function Documentation

exposure_control()

void Utopia::Models::SEIRD::SEIRD::exposure_control ( )

inlineprotected

Apply exposure control.

Add exposures if the iteration step matches the ones specified in the configuration. There are two available modes of exposure control that are applied, if provided, in this order:

1. At specified times (parameter: at_times) a number of additional exposures is added (parameter: num_additional_exposures)
2. The parameter p_exposed is changed to a new value at given times. This can happen multiple times. Parameter: change_p_exposed

    {
        // Check that time matches the first element of the sorted queue of
        // time steps at which to apply the given number of exposures.
        if (not _params.exposure_control.at_times.empty()) {
            // Check whether time has come for exposures
            if (this->_time == _params.exposure_control.at_times.front()) {
                // Select cells that are susceptibles
                // (not empty, inert, infected, or source)
                const auto cells_pool =
                    _cm.select_cells<SelectionMode::condition>(
                        [&](const auto& cell) {
                            return (cell->state.kind == Kind::susceptible);
                        });
 
                // Sample cells from the pool and ...
                CellContainer sample {};
                std::sample(cells_pool.begin(),
                            cells_pool.end(),
                            std::back_inserter(sample),
                            _params.exposure_control.num_additional_exposures,
                            *this->_rng);
 
                // ... and expose the sampled cells
                for (const auto& cell : sample) {
                    cell->state.kind = Kind::exposed;
                    _counts.increment_susceptible_to_exposed_controlled();
                }
 
                // Done. Can now remove first element of the queue.
                _params.exposure_control.at_times.pop();
            }
        }
 
        // Change p_exposed if the iteration step matches the ones
        // specified in the configuration. This leads to constant time lookup.
        if (not _params.exposure_control.change_p_exposed.empty()) {
            const auto change_p_exposed =
                _params.exposure_control.change_p_exposed.front();
 
            if (this->_time == change_p_exposed.first) {
                _params.p_exposed = change_p_exposed.second;
 
                // Done. Can now remove the element from the queue.
                _params.exposure_control.change_p_exposed.pop();
            }
        }
    }

identify_clusters()

void Utopia::Models::SEIRD::SEIRD::identify_clusters ( )

inlineprotected

Identify clusters.

This function identifies clusters and updates the cell specific cluster_id as well as the member variable cluster_id_cnt that counts the number of ids

    {
        // reset cluster counter
        _cluster_id_cnt = 0;
        apply_rule<Update::async, Shuffle::off>(_identify_cluster, _cm.cells());
    }

immunity_control()

void Utopia::Models::SEIRD::SEIRD::immunity_control ( )

inlineprotected

Apply immunity control.

Add cell immunities if the iteration step matches the ones specified in the configuration. There are two available modes of immunity control that are applied, if provided, in this order:

1. At specified times (parameter: at_times) a number of additional immmunities is added (parameter: num_additional_immmunities)
2. The parameter immune is changed to a new value at given times. This can happen multiple times. Parameter: change_immune

    {
        // Check that time matches the first element of the sorted queue of
        // time steps at which to apply the given number of immmunities.
        if (not _params.immunity_control.at_times.empty()) {
            // Check whether time has come for immmunities
            if (this->_time == _params.immunity_control.at_times.front()) {
                // Select cells that are susceptibles
                // (not empty, exposed, infected, inert, infected, or source)
                const auto cells_pool =
                    _cm.select_cells<SelectionMode::condition>(
                        [&](const auto& cell) {
                            return (cell->state.kind == Kind::susceptible);
                        });
 
                // Sample cells from the pool and ...
                CellContainer sample {};
                std::sample(cells_pool.begin(),
                            cells_pool.end(),
                            std::back_inserter(sample),
                            _params.immunity_control.num_additional_immunities,
                            *this->_rng);
 
                // ... and add immunity to the sampled cells
                for (const auto& cell : sample) {
                    cell->state.immune = true;
                }
 
                // Done. Can now remove first element of the queue.
                _params.immunity_control.at_times.pop();
            }
        }
 
        // Change immune if the iteration step matches the ones
        // specified in the configuration. This leads to constant time lookup.
        if (not _params.immunity_control.change_p_immune.empty()) {
            const auto change_p_immune =
                _params.immunity_control.change_p_immune.front();
 
            if (this->_time == change_p_immune.first) {
                _params.p_immune = change_p_immune.second;
 
                // Done. Can now remove the element from the queue.
                _params.immunity_control.change_p_immune.pop();
            }
        }
    }

monitor()

void Utopia::Models::SEIRD::SEIRD::monitor ( )

inline

Monitor model information.

Supplies the densities and counts arrays to the monitor.

    {
        update_densities();
        this->_monitor.set_entry("densities", _densities);
        this->_monitor.set_entry("counts", _counts.counts());
    }

perform_step()

void Utopia::Models::SEIRD::SEIRD::perform_step ( )

inline

Iterate a single time step.

This updates all cells (synchronously) according to the _update rule. For specifics, see there.

If exposure control is activated, the cells are first modified according to the specific exposure control parameters.

    {
        // Apply exposure control if enabled
        if (_params.exposure_control.enabled) {
            exposure_control();
        }
 
        // Apply immunity control if enabled
        if (_params.immunity_control.enabled) {
            immunity_control();
        }
 
        // Apply transmit control if enabled
        if (_params.transmission_control.enabled) {
            transmission_control();
        }
 
        // Apply the update rule to all cells.
        apply_rule<Update::sync>(_update, _cm.cells());
        // NOTE The cell state is updated synchronously, i.e.: only after
        // all cells have been visited and know their state for the next step
 
        // Move cells randomly with probability p_move_randomly
        apply_rule<Update::async, Shuffle::on>(_move_randomly,
                                               _cm.cells(),
                                               *this->_rng);
 
        // Move the agents living on cells randomly
        if (_params.move_away_from_infected) {
            apply_rule<Update::async, Shuffle::on>(_move_away_from_infected,
                                                   _cm.cells(),
                                                   *this->_rng);
        }
    }

transmission_control()

void Utopia::Models::SEIRD::SEIRD::transmission_control ( )

inlineprotected

Apply transmission control.

Change the transmitting probability p_transmit for a subset of cells of a specified kind if the iteration step matches the ones specified in the configuration. The parameter p_transmit is changed to a new value at given times for a number of randomly chosen cells of specified kins. This can happen multiple times. Parameter: change_p_transmit

    {
        // Change p_transmit if the iteration step matches the ones
        // specified in the configuration. This leads to constant time
        // lookup.
        if (not _params.transmission_control.change_p_transmit.empty()) {
            // Extract parameters
            const auto change_p_transmit =
                _params.transmission_control.change_p_transmit.front();
 
            const auto iteration_step = std::get<0>(change_p_transmit);
            const auto num_cells      = std::get<1>(change_p_transmit);
            const auto cell_kind      = std::get<2>(change_p_transmit);
            const auto p_transmit     = std::get<3>(change_p_transmit);
 
            if (this->_time == iteration_step) {
                // Select cells that are of desired kind
                const auto cells_pool =
                    _cm.select_cells<SelectionMode::condition>(
                        [&](const auto& cell) {
                            return (cell->state.kind == cell_kind);
                        });
 
                // Sample cells from the pool and ...
                CellContainer sample {};
                std::sample(cells_pool.begin(),
                            cells_pool.end(),
                            std::back_inserter(sample),
                            num_cells,
                            *this->_rng);
 
                // ... and change p_transmit for the sampled cells
                for (const auto& cell : sample) {
                    cell->state.p_transmit = p_transmit;
                }
 
                // Done. Can now remove the element from the queue.
                _params.transmission_control.change_p_transmit.pop();
            }
        }
    }

update_densities()

void Utopia::Models::SEIRD::SEIRD::update_densities ( )

inlineprotected

Update the densities array.

Each density is calculated by counting the number of state occurrences and afterwards dividing by the total number of cells.

Attention

It is possible that rounding errors occur due to the division, thus, it is not guaranteed that the densities exactly add up to 1. The errors should be negligible.

    {
        // Temporarily overwrite every entry in the densities with zeroes
        _densities.fill(0);
 
        // Count the occurrence of each possible state. Use the _densities
        // member for that in order to not create a new array.
        for (const auto& cell : this->_cm.cells()) {
            // Cast enum to integer to arrive at the corresponding index
            ++_densities[static_cast<char>(cell->state.kind)];
        }
        // The _densities array now contains the counts.
 
        // Calculate the actual densities by dividing the counts by the total
        // number of cells.
        for (auto&& d : _densities) {
            d /= static_cast<double>(this->_cm.cells().size());
        }
    };

write_data()

void Utopia::Models::SEIRD::SEIRD::write_data ( )

inline

Write data.

    {
        // Update densities and write them
        update_densities();
        _dset_densities->write(_densities);
 
        // Store the counts
        _dset_counts->write(_counts.counts());
 
        // If CA data is not to be written, can return here
        if (not _write_ca_data) {
            return;
        }
 
        // Write the cell state
        _dset_kind->write(_cm.cells().begin(),
                          _cm.cells().end(),
                          [](const auto& cell) {
                              return static_cast<char>(cell->state.kind);
                          });
 
        // Write the immune state
        _dset_immune->write(_cm.cells().begin(),
                            _cm.cells().end(),
                            [](const auto& cell) {
                                return static_cast<char>(cell->state.immune);
                            });
 
        // Write the number of recoveries state
        _dset_num_recoveries->write(_cm.cells().begin(),
                                    _cm.cells().end(),
                                    [](const auto& cell) {
                                        return static_cast<unsigned short>(
                                            cell->state.num_recoveries);
                                    });
 
        // Write the susceptible ages
        _dset_age->write(_cm.cells().begin(),
                         _cm.cells().end(),
                         [](const auto& cell) {
                             return cell->state.age;
                         });
 
        // Identify clusters and write them out
        identify_clusters();
        _dset_cluster_id->write(_cm.cells().begin(),
                                _cm.cells().end(),
                                [](const auto& cell) {
                                    return cell->state.cluster_id;
                                });
    }

Member Data Documentation

_cluster_id_cnt

unsigned int Utopia::Models::SEIRD::SEIRD::_cluster_id_cnt

private

The incremental cluster tag.

_cluster_members

std::vector<std::shared_ptr<CellManager::Cell> > Utopia::Models::SEIRD::SEIRD::_cluster_members

private

A temporary container for use in cluster identification.

_cm

CellManager Utopia::Models::SEIRD::SEIRD::_cm

private

The cell manager.

_compression

const int Utopia::Models::SEIRD::SEIRD::_compression

private

The compression level used for all datasets.

_counts

Counters<std::size_t> Utopia::Models::SEIRD::SEIRD::_counts

private

Cumulative counters for state transitions and other events

_densities

std::array<double, static_cast<char>(Kind::COUNT)> Utopia::Models::SEIRD::SEIRD::_densities

private

Densities for all states.

Array indices are linked to Utopia::Models::SEIRD::Kind

Warning

This array is used for temporary storage; it is not automatically updated but only upon write operations.

_dset_age

std::shared_ptr<DataSet> Utopia::Models::SEIRD::SEIRD::_dset_age

private

2D dataset (cell ID and time) of cell's age

_dset_cluster_id

std::shared_ptr<DataSet> Utopia::Models::SEIRD::SEIRD::_dset_cluster_id

private

The dataset for storing the cluster ID associated with each cell.

_dset_counts

std::shared_ptr<DataSet> Utopia::Models::SEIRD::SEIRD::_dset_counts

private

2D dataset (counts array and time) of cumulative state counters

_dset_densities

std::shared_ptr<DataSet> Utopia::Models::SEIRD::SEIRD::_dset_densities

private

2D dataset (densities array and time) of density values

_dset_immune

std::shared_ptr<DataSet> Utopia::Models::SEIRD::SEIRD::_dset_immune

private

2D dataset (cell ID and time) of cell's immunity

_dset_kind

std::shared_ptr<DataSet> Utopia::Models::SEIRD::SEIRD::_dset_kind

private

2D dataset (cell ID and time) of cell kinds

_dset_num_recoveries

std::shared_ptr<DataSet> Utopia::Models::SEIRD::SEIRD::_dset_num_recoveries

private

2D dataset (cell ID and time) of cell's number of recoveries

_identify_cluster

RuleFunc Utopia::Models::SEIRD::SEIRD::_identify_cluster

protected

Identify each cluster of susceptibles.

                                                          {
        if (cell->state.cluster_id != 0 or
            cell->state.kind != Kind::susceptible)
        {
            // already labelled, nothing to do. Return current state
            return cell->state;
        }
        // else: need to label this cell
 
        // Increment the cluster ID counter and label the given cell
        _cluster_id_cnt++;
        cell->state.cluster_id = _cluster_id_cnt;
 
        // Use existing cluster member container, clear it, add current cell
        auto& cluster = _cluster_members;
        cluster.clear();
        cluster.push_back(cell);
 
        // Perform the percolation
        for (unsigned int i = 0; i < cluster.size(); ++i) {
            // Iterate over all potential cluster members nb, i.e. all
            // neighbors of cell cluster[i] that is already in the cluster
            for (const auto& nb : this->_cm.neighbors_of(cluster[i])) {
                // If it is susceptible and not yet in the cluster, add it.
                if (nb->state.cluster_id == 0 and
                    nb->state.kind == Kind::susceptible)
                {
                    nb->state.cluster_id = _cluster_id_cnt;
                    cluster.push_back(nb);
                    // This extends the outer for-loop...
                }
            }
        }
 
        return cell->state;
    };

_move_away_from_infected

RuleFunc Utopia::Models::SEIRD::SEIRD::_move_away_from_infected

protected

Initial value:

= [this](const auto& cell) {
        
        auto& state = cell->state;
 
        auto neighbors = _cm.neighbors_of(cell);
 
        for (const auto& nb : neighbors) {
            if (nb->state.kind == Kind::infected) {
                
                std::shuffle(neighbors.begin(), neighbors.end(), *this->_rng);
                
                
                for (const auto& _nb : neighbors) {
                    if (_nb->state.kind == Kind::empty) {
                        
                        std::swap(state, _nb->state);
                        _counts.increment_move_away_from_infected();
                        break;
                    }
                }
                
                
                
                
                break;
            }
        }
 
        return state;
    }

Move the agent on the cell away from an infected neighboring cell.

Check whether there is an infected cell in the neighborhood. If there is an empty cell in the neighborhood, move to it. If there is no empty spot in the neighborhood do nothing.

                                                                 {
        // Get the reference to the state because it is directly manipulated
        auto& state = cell->state;
 
        auto neighbors = _cm.neighbors_of(cell);
 
        for (const auto& nb : neighbors) {
            if (nb->state.kind == Kind::infected) {
                // Shuffle the neighbors container ...
                std::shuffle(neighbors.begin(), neighbors.end(), *this->_rng);
                // ... go through it, and move to the first appearing empty
                // cell
                for (const auto& _nb : neighbors) {
                    if (_nb->state.kind == Kind::empty) {
                        // Swap the states and leave the loop
                        std::swap(state, _nb->state);
                        _counts.increment_move_away_from_infected();
                        break;
                    }
                }
                // NOTE It is important to leave the outer loop because the
                //      neighbors container over which it is iterated was
                //      shuffled. This could result in undefined behavior and
                //      breaking code
                break;
            }
        }
 
        return state;
    };

_move_randomly

RuleFunc Utopia::Models::SEIRD::SEIRD::_move_randomly

protected

Move randomly to a neighboring cell if that cell is empty.

If the cell is not empty, an inert cell, or a source: move to neighboring empty location with probability p_move_randomly. If no neighboring cell is empty, do nothing.

                                                       {
        // Get the state reference to directly manipulate the state
        auto& state = cell->state;
 
        // Directly return the state if the cell is of kind empty, source,
        // or inert.
        if ((state.kind == Kind::empty) or
            (state.kind == Kind::source) or
            (state.kind == Kind::inert))
        {
            return state;
        }
 
        if (_prob_distr(*this->_rng) < _params.p_move_randomly) {
            auto neighbors = _cm.neighbors_of(cell);
 
            // Shuffle the neighbors container ...
            std::shuffle(neighbors.begin(), neighbors.end(), *this->_rng);
            // ... go through it, and move to the first appearing empty cell
            for (const auto& _nb : neighbors) {
                if (_nb->state.kind == Kind::empty) {
                    // Swap the states and leave the loop
                    std::swap(state, _nb->state);
                    _counts.increment_move_randomly();
                    break;
                }
            }
        }
 
        return state;
    };

_params

const Params Utopia::Models::SEIRD::SEIRD::_params

private

Model parameters.

_prob_distr

std::uniform_real_distribution<double> Utopia::Models::SEIRD::SEIRD::_prob_distr

private

The range [0, 1] distribution to use for probability checks.

_update

RuleFunc Utopia::Models::SEIRD::SEIRD::_update

protected

Define the update rule.

Update the given cell according to the following rules:

• Empty cells grow susceptible cells with probability p_susceptible.
• Cells in neighborhood of an infected cell do not get exposed with the probability p_random_immunity.
• Exposed cells become infected cells after a certain incubation period.
• Infected cells die with probability p_deceased and become an empty cell or they become recovered cells with 1-p_deceased.

                                                {
        // Get the current state of the cell and reset its cluster ID
        auto state       = cell->state;
        state.cluster_id = 0;
 
        // With probability p_empty transition any kind of cell to be empty
        // Note that this allows for empty cells to become susceptible directly
        // in the same update step. Having it at the end would, however, create
        // a similar issue with just appearing agents.
        // Be explicit in the kinds to assure that inert and sources do not
        // convert to empty cells
        // Note that this could probably be made more efficient through
        // sampling if more performance is needed.
        if ((state.kind == Kind::susceptible) or
            (state.kind == Kind::exposed) or
            (state.kind == Kind::infected) or
            (state.kind == Kind::recovered))
        {
            if (_prob_distr(*this->_rng) < _params.p_empty) {
                state.kind           = Kind::empty;
                state.num_recoveries = 0;
                state.immune         = false;
                _counts.increment_living_to_empty();
            }
        }
 
        // Distinguish by current state
        if (state.kind == Kind::empty) {
            // With a probability of p_susceptible, set the cell's state to
            // susceptible
            if (_prob_distr(*this->_rng) < _params.p_susceptible) {
                state.kind = Kind::susceptible;
                _counts.increment_empty_to_susceptible();
 
                // If a new susceptible cell appears it is immune with the
                // probability p_immune.
                if (_prob_distr(*this->_rng) < _params.p_immune) {
                    state.immune = true;
                }
                else {
                    state.immune = false;
                }
 
                // Initialize the probability p_transmit of the cell from
                // the configuration node
                state.p_transmit = State::initialize_p_transmit(
                    get_as<DataIO::Config>("p_transmit", this->_cfg),
                    this->_rng);
 
                // The new susceptible cell does not yet have recoveries
                state.num_recoveries = 0;
 
                return state;
            }
        }
        else if (state.kind == Kind::susceptible) {
            // Increase the age of the susceptible cell
            ++state.age;
 
            // If the cell is immune nothing happens :)
            // It can neither be infected through point infection nor through
            // contact with exposed or infected cells
            if (state.immune) {
                return state;
            }
            else {
                // Susceptible cell can be exposed by neighbor
                // or by random-point-infection.
 
                // Determine whether there will be a point infection resulting
                // in an exposed agent.
                if (_prob_distr(*this->_rng) < _params.p_exposed) {
                    // Yes, point infection occurred.
                    state.kind = Kind::exposed;
                    _counts.increment_susceptible_to_exposed_random();
                    return state;
                }
                else {
                    // Go through neighbor cells (according to Neighborhood
                    // type) and check if they are infected
                    // (or an infection source).
                    // If yes, expose the cell with the probability p_transmit
                    // given by the neighbor's cell state if no random immunity
                    // given by p_random_immunity occurs.
                    for (const auto& nb : this->_cm.neighbors_of(cell)) {
                        // Get the neighbor cell's state
                        const auto& nb_state = nb->state;
 
                        if (nb_state.kind == Kind::infected or
                            nb_state.kind == Kind::exposed or
                            nb_state.kind == Kind::source)
                        {
                            // With the probability given by the neighbors cell
                            // p_transmit become exposed if no random immunity
                            // occurs
                            if (_prob_distr(*this->_rng) <
                                ((1. - _params.p_random_immunity) *
                                 nb_state.p_transmit))
                            {
                                state.kind = Kind::exposed;
                                _counts.increment_susceptible_to_exposed_contact();
                                return state;
                            }
                        }
                    }
                }
            }
        }
        else if (state.kind == Kind::exposed) {
            // Increase the age of the exposed cell
            ++state.age;
 
            // Transition from the exposed state to infected with probability
            // p_infected
            if (_prob_distr(*this->_rng) < _params.p_infected) {
                state.kind = Kind::infected;
                _counts.increment_exposed_to_infected();
                return state;
            }
 
            return state;
        }
        else if (state.kind == Kind::infected) {
            // Increase the age of the infected cell
            ++state.age;
 
            // Increment the exposed time because if the cell is infected
            // the infected time adds to the total exposed time.
            ++state.exposed_time;
 
            if (_prob_distr(*this->_rng) < _params.p_recovered) {
                state.kind   = Kind::recovered;
                state.immune = true;
                ++state.num_recoveries;
                _counts.increment_infected_to_recovered();
            }
            else if (_prob_distr(*this->_rng) < _params.p_deceased) {
                state.kind = Kind::deceased;
                _counts.increment_infected_to_deceased();
                // Do not reset the cell states here to keep them for
                // write out and analysis. Resetting happens in the deceased
                // case below.
            }
            // else nothing happens and the cell stays infected the next time
 
            return state;
        }
        else if (state.kind == Kind::recovered) {
            // Increase the age of the recovered cell
            ++state.age;
 
            // Cells can lose their immunity and get susceptible again
            if (_prob_distr(*this->_rng) < _params.p_lose_immunity) {
                state.immune = false;
                state.kind   = Kind::susceptible;
                _counts.increment_recovered_to_susceptible();
            }
 
            return state;
        }
        else if (state.kind == Kind::deceased) {
            // A former deceased cell gets empty
            state.kind           = Kind::empty;
            state.immune         = false;
            state.num_recoveries = 0;
 
            // Reset the age for the next susceptible cell
            state.age = 0;
 
            return state;
        }
        // else: other cell states need no update
 
        // Return the (potentially changed) cell state for the next round
        return state;
    };

_write_ca_data

bool Utopia::Models::SEIRD::SEIRD::_write_ca_data

private

If false, writes only the non-spatial densities and counts data.

---

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

• src/utopia/models/SEIRD/SEIRD.hh