Utopia::Models::ContDisease::InfectionContParams Struct Reference

Parameters specifying the infection control. More...

#include <params.hh>

Public Types
using	TimesQueue = std::queue< std::size_t >
	Type of the times queue.
using	TimesValuesQueue = std::queue< std::pair< std::size_t, double > >
	The type of the change p_infection pairs.

Public Member Functions
	InfectionContParams (const DataIO::Config &cfg)
	Configuration constructor.

Public Attributes
const bool	enabled
	Whether infection control is enabled.
const std::size_t	num_additional_infections
	The number of infections added to the default p_infect.
TimesQueue	at_times
	Add additional infections at these time steps.
TimesValuesQueue	change_p_infect
	Change p_infect to new value at given times.

Detailed Description

Parameters specifying the infection control.

Member Typedef Documentation

TimesQueue

using Utopia::Models::ContDisease::InfectionContParams::TimesQueue = std::queue<std::size_t>

Type of the times queue.

TimesValuesQueue

using Utopia::Models::ContDisease::InfectionContParams::TimesValuesQueue = std::queue<std::pair<std::size_t, double> >

The type of the change p_infection pairs.

Constructor & Destructor Documentation

InfectionContParams()

Utopia::Models::ContDisease::InfectionContParams::InfectionContParams ( const DataIO::Config &  cfg )

inline

Configuration constructor.

Construct an InfectionContParams object with required parameters being extracted from a configuration node with the same parameter names.

    :
    enabled(get_as<bool>("enabled", cfg)),
    num_additional_infections{get_as<std::size_t>(
        "num_additional_infections", cfg, 0)},
    at_times{[&](){
        auto cont = get_as<std::vector<std::size_t>>("at_times", cfg, {});
 
        std::sort(cont.begin(), cont.end());
 
        // Copy elements into the queue
        TimesQueue q{};
        for (const auto& v : cont){
            q.push(v);
        }
 
        return q;
    }()},
    change_p_infect{[&](){
        // Check the parameter
        // For the default case, an empty list, a empty queue is returned.
        if(cfg["change_p_infect"].IsSequence() and cfg["change_p_infect"].size() == 0){
            // Key was empty; return empty queue.
            return TimesValuesQueue{};
        }
        // Check if given Parameter is a Sequence
        else if(not cfg["change_p_infect"].IsSequence()){
            // Inform about bad type of the given configuration entry
            throw std::invalid_argument("Parameter change_p_infect need be "
                "a sequence of pairs, but was not a sequence! Given infection "
                "control parameters:\n" + DataIO::to_string(cfg));
        }
        // Check if it is a sequence that it contains only pairs. 
        else{ 
            bool pairs_only = true;
            for(const auto pair: cfg["change_p_infect"]){
                pairs_only &= pair.size() == 2;
            }
            if(not pairs_only){
                throw std::invalid_argument("Parameter change_p_infect need be "
                    "a sequence of pairs, but contained something which was not "
                    "a pair! Given infection control parameters:\n" 
                    + DataIO::to_string(cfg));
            }
        }
        // Getting the parameters
        std::vector<std::pair<std::size_t, double>> cont = [&cfg](){
            std::vector<std::pair<int, double>> val = 
                get_as<std::vector<std::pair<int, double>>>
                ("change_p_infect", cfg);
 
            for_each(val.begin(), val.end(), 
                [&cfg](auto& pair){
                // Check for negative timesteps
                if(pair.first < 0){
                    throw std::invalid_argument("Timesteps from parameter "
                    "change_p_infect needs to be larger zero. Given infection "
                    "control parameters:\n" + DataIO::to_string(cfg));
                }
                // Check for probabilites outside [0, 1]
                if(pair.second < 0 or pair.second > 1){
                    throw std::invalid_argument("Infection chance from parameter "
                    "change_p_infect needs to be withhin [0, 1]. Given infection "
                    "control parameters:\n" + DataIO::to_string(cfg));
                }
            });
            return get_as<std::vector<std::pair<std::size_t, double>>>
                ("change_p_infect", cfg);
        }();
        
        // Sort such that times low times are in the beginning of the queue
        std::sort(cont.begin(), cont.end(),
            [](const auto& a, const auto& b){
                return a.first < b.first;
            }
        );
        
        // Copy elements into the queue
        TimesValuesQueue q{};
        for (const auto& v : cont){
            q.push(v);
        }
 
        return q;
    }()}
    {};

Member Data Documentation

at_times

TimesQueue Utopia::Models::ContDisease::InfectionContParams::at_times

mutable

Add additional infections at these time steps.

change_p_infect

TimesValuesQueue Utopia::Models::ContDisease::InfectionContParams::change_p_infect

mutable

Change p_infect to new value at given times.

Each element of this container provides a pair of [time, new_value]. If the iteration step (time) of the simulation is reached p_infect is set to new_value

enabled

const bool Utopia::Models::ContDisease::InfectionContParams::enabled

Whether infection control is enabled.

num_additional_infections

const std::size_t Utopia::Models::ContDisease::InfectionContParams::num_additional_infections

The number of infections added to the default p_infect.

---

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

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