params.hh

Go to the documentation of this file.

#ifndef UTOPIA_MODELS_CONTDISEASE_PARAMS_HH
#define UTOPIA_MODELS_CONTDISEASE_PARAMS_HH
 
#include <queue>
 
#include <utopia/core/types.hh>
#include <utopia/data_io/cfg_utils.hh>
 
namespace Utopia::Models::ContDisease
{
 
 
struct InfectionContParams {
    // -- Type definitions ----------------------------------------------------
    using TimesQueue = std::queue<std::size_t>;
 
    using TimesValuesQueue = std::queue<std::pair<std::size_t, double>>;
 
    // -- Parameters ----------------------------------------------------
    const bool enabled;
 
    const std::size_t num_additional_infections;
 
    mutable TimesQueue at_times;
 
 
    mutable TimesValuesQueue change_p_infect;
 
 
    InfectionContParams(const DataIO::Config& cfg)
    :
    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;
    }()}
    {};
};
 
 
struct Params {
    const double p_growth;
 
    const double p_immunity;
 
    mutable double p_infect;
 
    const InfectionContParams infection_control;
 
    Params(const DataIO::Config& cfg)
    :
        p_growth(get_as<double>("p_growth", cfg)),
        p_immunity(get_as<double>("p_immunity", cfg)),
        p_infect(get_as<double>("p_infect", cfg)),
        infection_control(get_as<DataIO::Config>("infection_control", cfg))
    {}
};
 
} // namespace Utopia::Models::ContDisease
 
#endif // UTOPIA_MODELS_CONTDISEASE_PARAMS_HH