Utopia::Models::SEIRD::Params Struct Reference

Parameters of the SEIRD. More...

#include <params.hh>

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

Public Member Functions
	Params (const DataIO::Config &cfg)
	Construct the parameters from the given configuration node.

Public Attributes
const double	p_susceptible
	Probability per site and time step to go from state empty to susceptible.
double	p_immune
	Probability per transition to susceptible via p_susceptible to be immune.
const double	p_random_immunity
double	p_exposed
double	p_infected
double	p_recovered
	Probability for a cell to recover.
double	p_deceased
	Probability for a cell to desease.
double	p_empty
	Probability for a cell to become empty.
double	p_lose_immunity
	The probability to loose immunity if a cell is recovered.
bool	move_away_from_infected
	Whether to globally allow moving away from infected neighboring cells.
double	p_move_randomly
	Probability to move randomly if the neighboring cell is empty.
const ExposureContParams	exposure_control
	Exposure control parameters.
const ImmunityContParams	immunity_control
	Immunity control parameters.
const TransmitContParams	transmission_control
	Transmit control parameters.

Detailed Description

Parameters of the SEIRD.

Constructor & Destructor Documentation

Params()

Utopia::Models::SEIRD::Params::Params ( const DataIO::Config &  cfg )

inline

Construct the parameters from the given configuration node.

                                    :
        p_susceptible(get_as<double>("p_susceptible", cfg)),
        p_immune(get_as<double>("p_immune", cfg)),
        p_random_immunity(get_as<double>("p_random_immunity", cfg)),
        p_exposed(get_as<double>("p_exposed", cfg)),
        p_infected(get_as<double>("p_infected", cfg)),
        p_recovered(get_as<double>("p_recovered", cfg)),
        p_deceased(get_as<double>("p_deceased", cfg)),
        p_empty(get_as<double>("p_empty", cfg)),
        p_lose_immunity(get_as<double>("p_lose_immunity", cfg)),
        move_away_from_infected(get_as<bool>("move_away_from_infected", cfg)),
        p_move_randomly(get_as<double>("p_move_randomly", cfg)),
        exposure_control(get_as<DataIO::Config>("exposure_control", cfg)),
        immunity_control(get_as<DataIO::Config>("immunity_control", cfg)),
        transmission_control(get_as<DataIO::Config>("transmission_control", cfg))
    {
        if ((p_susceptible > 1) or (p_susceptible < 0)) {
            throw std::invalid_argument(
                "Invalid p_susceptible! Need be a value "
                "in range [0, 1] and specify the probability per time step "
                "and cell with which an empty cell turns into a susceptible "
                "one. Was: " +
                std::to_string(p_susceptible));
        }
        if ((p_immune > 1) or (p_immune < 0)) {
            throw std::invalid_argument(
                "Invalid p_immune! Need be a value "
                "in range [0, 1] and specify the probability per time step "
                "and cell with which an empty cell turns into a susceptible "
                "one. Was: " +
                std::to_string(p_immune));
        }
        if ((p_random_immunity > 1) or (p_random_immunity < 0)) {
            throw std::invalid_argument(
                "Invalid p_random_immunity! Need be in range "
                "[0, 1], was " +
                std::to_string(p_random_immunity));
        }
        if ((p_exposed > 1) or (p_exposed < 0)) {
            throw std::invalid_argument("Invalid p_exposed! Need be a value "
                                        "in range [0, 1], was " +
                                        std::to_string(p_exposed));
        }
        if ((p_infected > 1) or (p_infected < 0)) {
            throw std::invalid_argument("Invalid p_infected! Need be a value "
                                        "in range [0, 1], was " +
                                        std::to_string(p_infected));
        }
        if ((p_recovered > 1) or (p_recovered < 0)) {
            throw std::invalid_argument("Invalid p_recovered! Need be a value "
                                        "in range [0, 1], was " +
                                        std::to_string(p_recovered));
        }
        if ((p_deceased > 1) or (p_deceased < 0)) {
            throw std::invalid_argument("Invalid p_deceased! Need be a value "
                                        "in range [0, 1], was " +
                                        std::to_string(p_deceased));
        }
        if (((p_deceased + p_recovered) > 1)) {
            throw std::invalid_argument(
                "Invalid p_deceased and p_recovered! The sum needs to be a value "
                "smaller than 1, was " +
                std::to_string(p_deceased + p_recovered));
        }
        if ((p_empty > 1) or (p_empty < 0)) {
            throw std::invalid_argument("Invalid p_empty! Need be a value "
                                        "in range [0, 1], was " +
                                        std::to_string(p_empty));
        }
        if ((p_lose_immunity > 1) or (p_lose_immunity < 0)) {
            throw std::invalid_argument(
                "Invalid p_lose_immunity! Need be a value "
                "in range [0, 1], was " +
                std::to_string(p_lose_immunity));
        }
        if ((p_move_randomly > 1) or (p_move_randomly < 0)) {
            throw std::invalid_argument(
                "Invalid p_move_randomly! Need be a value "
                "in range [0, 1], was " +
                std::to_string(p_move_randomly));
        }
    }

Member Data Documentation

exposure_control

const ExposureContParams Utopia::Models::SEIRD::Params::exposure_control

Exposure control parameters.

immunity_control

const ImmunityContParams Utopia::Models::SEIRD::Params::immunity_control

Immunity control parameters.

move_away_from_infected

bool Utopia::Models::SEIRD::Params::move_away_from_infected

Whether to globally allow moving away from infected neighboring cells.

p_deceased

double Utopia::Models::SEIRD::Params::p_deceased

Probability for a cell to desease.

p_empty

double Utopia::Models::SEIRD::Params::p_empty

Probability for a cell to become empty.

p_exposed

double Utopia::Models::SEIRD::Params::p_exposed

mutable

Probability per susceptible cell and time step to transition to exposed state

p_immune

double Utopia::Models::SEIRD::Params::p_immune

mutable

Probability per transition to susceptible via p_susceptible to be immune.

p_infected

double Utopia::Models::SEIRD::Params::p_infected

mutable

Probability per exposed cell and time step to transition to infected state This probability will define the typical incubation period of the desease.

p_lose_immunity

double Utopia::Models::SEIRD::Params::p_lose_immunity

The probability to loose immunity if a cell is recovered.

p_move_randomly

double Utopia::Models::SEIRD::Params::p_move_randomly

Probability to move randomly if the neighboring cell is empty.

p_random_immunity

const double Utopia::Models::SEIRD::Params::p_random_immunity

Probability per site and time step for a susceptible cell to not become exposed if an exposed or infected cell is in the neighborhood.

p_recovered

double Utopia::Models::SEIRD::Params::p_recovered

Probability for a cell to recover.

p_susceptible

const double Utopia::Models::SEIRD::Params::p_susceptible

Probability per site and time step to go from state empty to susceptible.

transmission_control

const TransmitContParams Utopia::Models::SEIRD::Params::transmission_control

Transmit control parameters.

---

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

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