Parameters specifying the transmit control. More...

#include <params.hh>

Public Types
using	TimesQueue = std::queue< std::size_t >
	Type of the times queue.

using	TimesValuesQueue = std::queue< std::tuple< std::size_t, unsigned, Kind, double > >
	The type of the change p_transmit tuples.

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

Public Attributes
const bool	enabled
	Whether immunity control is enabled.

TimesValuesQueue	change_p_transmit
	Change p_transmit to new value at given times.

Detailed Description

Parameters specifying the transmit control.

Member Typedef Documentation

◆ TimesQueue

using Utopia::Models::SEIRD::TransmitContParams::TimesQueue = std::queue<std::size_t>

Type of the times queue.

◆ TimesValuesQueue

using Utopia::Models::SEIRD::TransmitContParams::TimesValuesQueue = std::queue<std::tuple<std::size_t, unsigned, Kind, double> >

The type of the change p_transmit tuples.

Constructor & Destructor Documentation

◆ TransmitContParams()

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

inline

Configuration constructor.

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

                                                :
        enabled(get_as<bool>("enabled", cfg)), change_p_transmit {[&]() {
            // Check the parameter
            if (not cfg["change_p_transmit"] or
                not cfg["change_p_transmit"].size()) {
                // Key did not exist or was empty; return empty queue.
                return TimesValuesQueue {};
            }
            else if (not cfg["change_p_transmit"].IsSequence()) {
                // Inform about bad type of the given configuration entry
                throw std::invalid_argument(
                    "Parameter change_p_transmit need be "
                    "a sequence of tuples, but was not! Given transmit control "
                    "parameters:\n" +
                    DataIO::to_string(cfg));
            }
 
            // Create the container with Kind as type in the third place
            // and fill it up with the
            std::vector<std::tuple<std::size_t, unsigned, Kind, double>> cont;
            for (const auto& cfg_item :
                 get_as<DataIO::Config>("change_p_transmit", cfg)) {
                const auto time      = get_as<std::size_t>("time", cfg_item);
                const auto num_cells = get_as<unsigned>("num_cells", cfg_item);
                const auto cell_kind =
                    kind_from_string.at(get_as<std::string>("cell_kind", cfg_item));
                const auto p_transmit = get_as<double>("p_transmit", cfg_item);
 
                cont.emplace_back(time, num_cells, cell_kind, p_transmit);
            }
 
            // Sort such that low times are in the beginning of the queue
            std::sort(cont.begin(),
                      cont.end(),
                      [](const auto& a, const auto& b) {
                          return std::get<0>(a) < std::get<0>(b);
                      });
 
            // Copy elements into the queue
            TimesValuesQueue q {};
            for (const auto& v : cont) {
                q.push(v);
            }
 
            return q;
        }()} {};

Member Data Documentation

◆ change_p_transmit

TimesValuesQueue Utopia::Models::SEIRD::TransmitContParams::change_p_transmit

mutable

Change p_transmit to new value at given times.

Each element of this container provides a tuple of [time, num_cells, cell_kind, p_transmit]. If the iteration step (time) of the simulation is reached p_transmit is set to p_transmit for a subset of num_cells randomly drawn cells of kind cell_kind.

◆ enabled

const bool Utopia::Models::SEIRD::TransmitContParams::enabled

Whether immunity control is enabled.

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

src/utopia/models/SEIRD/params.hh

Public Types

Public Member Functions

Public Attributes