The full cell struct for the SEIRD model. More...

#include <state.hh>

Public Member Functions
template<class RNG >
	State (const DataIO::Config &cfg, const std::shared_ptr< RNG > &rng)
	Construct the cell state from a configuration and an RNG.

Static Public Member Functions
template<typename RNG >
static double	initialize_p_transmit (const DataIO::Config &cfg, const std::shared_ptr< RNG > &rng)
	Initialize p_transmit from a configuration node.

Public Attributes
Kind	kind
	The cell state.

bool	immune
	Whether the agent is immune.

double	p_transmit

unsigned	exposed_time
	The time passed since first being exposed.

unsigned	age
	The age of the cell.

unsigned	num_recoveries
	The number of recoveries.

unsigned int	cluster_id
	An ID denoting to which cluster this cell belongs.

Detailed Description

The full cell struct for the SEIRD model.

Constructor & Destructor Documentation

◆ State()

template<class RNG >

Utopia::Models::SEIRD::State::State	(	const DataIO::Config &	cfg,
		const std::shared_ptr< RNG > &	rng
	)

inline

Construct the cell state from a configuration and an RNG.

    :
        kind(Kind::empty),
        immune(false),
        p_transmit(1),
        exposed_time(0),
        age(0),
        num_recoveries(0),
        cluster_id(0)
    {
        // Check if p_susceptible is available to set up cell state
        if (cfg["p_susceptible"]) {
            const auto init_density = get_as<double>("p_susceptible", cfg);
 
            if (init_density < 0. or init_density > 1.) {
                throw std::invalid_argument("p_susceptible needs to be in "
                                            "interval [0., 1.], but was " +
                                            std::to_string(init_density) + "!");
            }
 
            // With this probability, the cell state is a susceptible
            if (std::uniform_real_distribution<double>(0., 1.)(*rng) <
                init_density) {
                kind = Kind::susceptible;
            }
 
            // If cells are susceptible check whether they are immune
            // Check if p_immune is available to set up cell state
            if (cfg["p_immune"]) {
                const auto init_density = get_as<double>("p_immune", cfg);
 
                if (init_density < 0. or init_density > 1.) {
                    throw std::invalid_argument("p_immune needs to be in "
                                                "interval [0., 1.], but was " +
                                                std::to_string(init_density) +
                                                "!");
                }
 
                // With this probability, the cell state is immune
                if (std::uniform_real_distribution<double>(0., 1.)(*rng) <
                    init_density) {
                    immune = true;
                }
                else {
                    immune = false;
                }
            }
        }
        // Check if p_transmit is available to set up cell state
        if (cfg["p_transmit"]) {
            p_transmit = initialize_p_transmit(cfg["p_transmit"], rng);
        }
    }

Member Function Documentation

◆ initialize_p_transmit()

template<typename RNG >

static double Utopia::Models::SEIRD::State::initialize_p_transmit	(	const DataIO::Config &	cfg,
		const std::shared_ptr< RNG > &	rng
	)

inlinestatic

Initialize p_transmit from a configuration node.

    {
        const auto mode = get_as<std::string>("mode", cfg);
 
        if (mode == "value") {
            // Return the default value
            return get_as<double>("default",
                                  get_as<DataIO::Config>("value", cfg));
        }
        else if (mode == "uniform") {
            const auto range = get_as<std::pair<double, double>>(
                "range",
                get_as<DataIO::Config>("uniform", cfg));
 
            // Create a uniform real distribution from the specified range
            std::uniform_real_distribution<double> distr(range.first,
                                                         range.second);
 
            // Draw a random number from the range and return it
            return distr(*rng);
        }
        else {
            throw std::invalid_argument(fmt::format(
                "Invalid mode! Need be either 'value' or 'uniform', was '{}'!",
                mode)
            );
        }
    };

Member Data Documentation

◆ age

unsigned Utopia::Models::SEIRD::State::age

The age of the cell.

◆ cluster_id

unsigned int Utopia::Models::SEIRD::State::cluster_id

An ID denoting to which cluster this cell belongs.

◆ exposed_time

unsigned Utopia::Models::SEIRD::State::exposed_time

The time passed since first being exposed.

◆ immune

bool Utopia::Models::SEIRD::State::immune

Whether the agent is immune.

◆ kind

Kind Utopia::Models::SEIRD::State::kind

The cell state.

◆ num_recoveries

unsigned Utopia::Models::SEIRD::State::num_recoveries

The number of recoveries.

◆ p_transmit

double Utopia::Models::SEIRD::State::p_transmit

The probability to transmit the infection to others if exposed or infected

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

src/utopia/models/SEIRD/state.hh

Public Member Functions

Static Public Member Functions

Public Attributes