abm/parameters.h

Go to the documentation of this file.

/* 
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Daniel Abele, Elisabeth Kluth, Khoa Nguyen, David Kerkmann, Julia Bicker
*
* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MIO_ABM_PARAMETERS_H
#define MIO_ABM_PARAMETERS_H
 
#include "abm/mask_type.h"
#include "abm/time.h"
#include "abm/infection_state.h"
#include "abm/virus_variant.h"
#include "abm/protection_event.h"
#include "abm/protection_event.h"
#include "abm/test_type.h"
#include "memilio/config.h"
#include "memilio/io/default_serialize.h"
#include "memilio/io/io.h"
#include "memilio/math/time_series_functor.h"
#include "memilio/utils/abstract_parameter_distribution.h"
#include "memilio/utils/custom_index_array.h"
#include "memilio/utils/logging.h"
#include "memilio/utils/parameter_distributions.h"
#include "memilio/utils/uncertain_value.h"
#include "memilio/utils/parameter_set.h"
#include "memilio/utils/index_range.h"
#include "memilio/epidemiology/age_group.h"
#include "memilio/epidemiology/damping.h"
#include "memilio/epidemiology/contact_matrix.h"
 
#include <algorithm>
#include <limits>
#include <string>
 
namespace mio
{
namespace abm
{
 
struct TimeExposedToNoSymptoms {
    using Type = CustomIndexArray<AbstractParameterDistribution, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, AbstractParameterDistribution(ParameterDistributionLogNormal(1., 1.)));
    }
    static std::string name()
    {
        return "TimeExposedToNoSymptoms";
    }
};
 
struct TimeInfectedNoSymptomsToSymptoms {
    using Type = CustomIndexArray<AbstractParameterDistribution, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, AbstractParameterDistribution(ParameterDistributionLogNormal(1., 1.)));
    }
    static std::string name()
    {
        return "TimeInfectedNoSymptomsToSymptoms";
    }
};
 
struct TimeInfectedNoSymptomsToRecovered {
    using Type = CustomIndexArray<AbstractParameterDistribution, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, AbstractParameterDistribution(ParameterDistributionLogNormal(1., 1.)));
    }
    static std::string name()
    {
        return "TimeInfectedNoSymptomsToRecovered";
    }
};
 
struct TimeInfectedSymptomsToSevere {
    using Type = CustomIndexArray<AbstractParameterDistribution, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, AbstractParameterDistribution(ParameterDistributionLogNormal(1., 1.)));
    }
    static std::string name()
    {
        return "TimeInfectedSymptomsToSevere";
    }
};
 
struct TimeInfectedSymptomsToRecovered {
    using Type = CustomIndexArray<AbstractParameterDistribution, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, AbstractParameterDistribution(ParameterDistributionLogNormal(1., 1.)));
    }
    static std::string name()
    {
        return "TimeInfectedSymptomsToRecovered";
    }
};
 
struct TimeInfectedSevereToCritical {
    using Type = CustomIndexArray<AbstractParameterDistribution, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, AbstractParameterDistribution(ParameterDistributionLogNormal(1., 1.)));
    }
    static std::string name()
    {
        return "TimeInfectedSevereToCritical";
    }
};
 
struct TimeInfectedSevereToRecovered {
    using Type = CustomIndexArray<AbstractParameterDistribution, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, AbstractParameterDistribution(ParameterDistributionLogNormal(1., 1.)));
    }
    static std::string name()
    {
        return "TimeInfectedSevereToRecovered";
    }
};
 
struct TimeInfectedSevereToDead {
    using Type = CustomIndexArray<AbstractParameterDistribution, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, AbstractParameterDistribution(ParameterDistributionLogNormal(1., 1.)));
    }
    static std::string name()
    {
        return "TimeInfectedSevereToDead";
    }
};
 
struct TimeInfectedCriticalToDead {
    using Type = CustomIndexArray<AbstractParameterDistribution, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, AbstractParameterDistribution(ParameterDistributionLogNormal(1., 1.)));
    }
    static std::string name()
    {
        return "TimeInfectedCriticalToDead";
    }
};
 
struct TimeInfectedCriticalToRecovered {
    using Type = CustomIndexArray<AbstractParameterDistribution, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, AbstractParameterDistribution(ParameterDistributionLogNormal(1., 1.)));
    }
    static std::string name()
    {
        return "TimeInfectedCriticalToRecovered";
    }
};
 
struct SymptomsPerInfectedNoSymptoms {
    using Type = CustomIndexArray<UncertainValue<ScalarType>, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, .5);
    }
    static std::string name()
    {
        return "SymptomaticPerInfectedNoSymptoms";
    }
};
 
struct SeverePerInfectedSymptoms {
    using Type = CustomIndexArray<UncertainValue<ScalarType>, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, .5);
    }
    static std::string name()
    {
        return "SeverePerInfectedSymptoms";
    }
};
 
struct CriticalPerInfectedSevere {
    using Type = CustomIndexArray<UncertainValue<ScalarType>, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, .5);
    }
    static std::string name()
    {
        return "CriticalPerInfectedSevere";
    }
};
 
struct DeathsPerInfectedSevere {
    using Type = CustomIndexArray<UncertainValue<ScalarType>, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, .1);
    }
    static std::string name()
    {
        return "DeathsPerInfectedSevere";
    }
};
 
struct DeathsPerInfectedCritical {
    using Type = CustomIndexArray<UncertainValue<ScalarType>, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({VirusVariant::Count, size}, .5);
    }
    static std::string name()
    {
        return "DeathsPerInfectedCritical";
    }
};
 
struct ViralLoadDistributionsParameters {
    AbstractParameterDistribution viral_load_peak;
    AbstractParameterDistribution viral_load_incline;
    AbstractParameterDistribution viral_load_decline;
 
    auto default_serialize()
    {
        return Members("ViralLoadDistributionsParameters")
            .add("viral_load_peak", viral_load_peak)
            .add("viral_load_incline", viral_load_incline)
            .add("viral_load_decline", viral_load_decline);
    }
};
 
struct ViralLoadDistributions {
    using Type = CustomIndexArray<ViralLoadDistributionsParameters, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        Type default_val(
            {VirusVariant::Count, size},
            ViralLoadDistributionsParameters{AbstractParameterDistribution(ParameterDistributionConstant(8.1)),
                                             AbstractParameterDistribution(ParameterDistributionConstant(2.)),
                                             AbstractParameterDistribution(ParameterDistributionConstant(-0.17))});
        return default_val;
    }
    static std::string name()
    {
        return "ViralLoadDistributions";
    }
};
 
struct ViralShedTuple {
    ScalarType viral_shed_alpha;
    ScalarType viral_shed_beta;
 
    auto default_serialize()
    {
        return Members("ViralShedTuple")
            .add("viral_shed_alpha", viral_shed_alpha)
            .add("viral_shed_beta", viral_shed_beta);
    }
};
 
struct ViralShedParameters {
    using Type = CustomIndexArray<ViralShedTuple, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        Type default_val({VirusVariant::Count, size}, ViralShedTuple{-7., 1.});
        return default_val;
    }
    static std::string name()
    {
        return "ViralShedParameters";
    }
};
 
struct ViralShedFactor {
    using Type = CustomIndexArray<AbstractParameterDistribution, VirusVariant, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        Type default_val({VirusVariant::Count, size},
                         AbstractParameterDistribution(ParameterDistributionUniform(0., 0.28)));
        return default_val;
    }
    static std::string name()
    {
        return "ViralShedFactor";
    }
};
 
struct InfectionRateFromViralShed {
    using Type = CustomIndexArray<ScalarType, VirusVariant>;
    static Type get_default(AgeGroup /*size*/)
    {
        return Type({VirusVariant::Count}, 1.0);
    }
    static std::string name()
    {
        return "InfectionRateFromViralShed";
    }
};
 
struct MaskProtection {
    using Type = CustomIndexArray<UncertainValue<ScalarType>, MaskType>;
    static Type get_default(AgeGroup /*size*/)
    {
        Type defaut_value = Type(MaskType::Count, 0.0);
        // Initial values according to http://dx.doi.org/10.15585/mmwr.mm7106e1
        defaut_value[MaskType::FFP2]      = 0.83;
        defaut_value[MaskType::Surgical]  = 0.66;
        defaut_value[MaskType::Community] = 0.56;
        return defaut_value;
    }
    static std::string name()
    {
        return "MaskProtection";
    }
};
 
struct AerosolTransmissionRates {
    using Type = CustomIndexArray<ScalarType, VirusVariant>;
    static Type get_default(AgeGroup /*size*/)
    {
        return Type({VirusVariant::Count}, 1.0);
    }
    static std::string name()
    {
        return "AerosolTransmissionRates";
    }
};
 
struct InfectionProtectionFactor {
    using Type = CustomIndexArray<TimeSeriesFunctor<ScalarType>, ProtectionType, AgeGroup, VirusVariant>;
    static auto get_default(AgeGroup size)
    {
        return Type({ProtectionType::Count, size, VirusVariant::Count}, TimeSeriesFunctor<ScalarType>());
    }
    static std::string name()
    {
        return "InfectionProtectionFactor";
    }
};
 
struct SeverityProtectionFactor {
    using Type = CustomIndexArray<TimeSeriesFunctor<ScalarType>, ProtectionType, AgeGroup, VirusVariant>;
    static auto get_default(AgeGroup size)
    {
        return Type({ProtectionType::Count, size, VirusVariant::Count}, TimeSeriesFunctor<ScalarType>());
    }
    static std::string name()
    {
        return "SeverityProtectionFactor";
    }
};
 
struct HighViralLoadProtectionFactor {
    using Type = CustomIndexArray<TimeSeriesFunctor<ScalarType>, ProtectionType, AgeGroup, VirusVariant>;
    static auto get_default(AgeGroup size)
    {
        return Type({ProtectionType::Count, size, VirusVariant::Count}, TimeSeriesFunctor<ScalarType>());
    }
    static std::string name()
    {
        return "HighViralLoadProtectionFactor";
    }
};
 
struct TestParameters {
    UncertainValue<ScalarType> sensitivity;
    UncertainValue<ScalarType> specificity;
    TimeSpan required_time;
    TestType type;
 
    auto default_serialize()
    {
        return Members("TestParameters")
            .add("sensitivity", sensitivity)
            .add("specificity", specificity)
            .add("required_time", required_time)
            .add("test_type", type);
    }
};
 
struct TestData {
    using Type = CustomIndexArray<TestParameters, TestType>;
    static auto get_default(AgeGroup /*size*/)
    {
        Type default_val                 = Type({TestType::Count});
        default_val[{TestType::Generic}] = TestParameters{0.9, 0.99, hours(48), TestType::Generic};
        default_val[{TestType::Antigen}] = TestParameters{0.8, 0.88, minutes(30), TestType::Antigen};
        default_val[{TestType::PCR}]     = TestParameters{0.9, 0.99, hours(48), TestType::PCR};
        return default_val;
    }
    static std::string name()
    {
        return "TestData";
    }
};
 
struct LockdownDate {
    using Type = TimePoint;
    static auto get_default(AgeGroup /*size*/)
    {
        return TimePoint(std::numeric_limits<int>::max());
    }
    static std::string name()
    {
        return "LockdownDate";
    }
};
 
struct QuarantineDuration {
    using Type = TimeSpan;
    static auto get_default(AgeGroup /*size*/)
    {
        return days(10);
    }
    static std::string name()
    {
        return "QuarantineDuration";
    }
};
 
struct QuarantineEffectiveness {
    using Type = ScalarType;
    static auto get_default(AgeGroup /*size*/)
    {
        return 0.0;
    }
    static std::string name()
    {
        return "QuarantineEffectivness";
    }
};
 
struct BasicShoppingRate {
    using Type = CustomIndexArray<UncertainValue<ScalarType>, AgeGroup>;
    static auto get_default(AgeGroup size)
    {
        return Type({size}, 1.0);
    }
    static std::string name()
    {
        return "BasicShoppingRate";
    }
};
 
struct WorkRatio {
    using Type =
        DampingMatrixExpression<ScalarType, Dampings<ScalarType, Damping<ScalarType, ColumnVectorShape<ScalarType>>>>;
    static auto get_default(AgeGroup /*size*/)
    {
        return Type(Eigen::VectorX<ScalarType>::Constant(1, 1.0));
    }
    static std::string name()
    {
        return "WorkRatio";
    }
};
 
struct SchoolRatio {
    using Type =
        DampingMatrixExpression<ScalarType, Dampings<ScalarType, Damping<ScalarType, ColumnVectorShape<ScalarType>>>>;
    static auto get_default(AgeGroup /*size*/)
    {
        return Type(Eigen::VectorX<ScalarType>::Constant(1, 1.0));
    }
    static std::string name()
    {
        return "SchoolRatio";
    }
};
 
struct SocialEventRate {
    using Type =
        DampingMatrixExpression<ScalarType, Dampings<ScalarType, Damping<ScalarType, ColumnVectorShape<ScalarType>>>>;
    static auto get_default(AgeGroup size)
    {
        return Type(Eigen::VectorX<ScalarType>::Constant((size_t)size, 1.0));
    }
    static std::string name()
    {
        return "SocialEventRate";
    }
};
 
struct GotoWorkTimeMinimum {
    using Type = CustomIndexArray<TimeSpan, AgeGroup>;
    static auto get_default(AgeGroup size)
    {
        return CustomIndexArray<TimeSpan, AgeGroup>(size, hours(6));
    }
    static std::string name()
    {
        return "GotoWorkTimeMinimum";
    }
};
 
struct GotoWorkTimeMaximum {
    using Type = CustomIndexArray<TimeSpan, AgeGroup>;
    static auto get_default(AgeGroup size)
    {
        return CustomIndexArray<TimeSpan, AgeGroup>(size, hours(9));
    }
    static std::string name()
    {
        return "GotoWorkTimeMaximum";
    }
};
 
struct GotoSchoolTimeMinimum {
    using Type = CustomIndexArray<TimeSpan, AgeGroup>;
    static auto get_default(AgeGroup size)
    {
        return CustomIndexArray<TimeSpan, AgeGroup>(size, hours(6));
    }
    static std::string name()
    {
        return "GotoSchoolTimeMinimum";
    }
};
 
struct GotoSchoolTimeMaximum {
    using Type = CustomIndexArray<TimeSpan, AgeGroup>;
    static auto get_default(AgeGroup size)
    {
        return CustomIndexArray<TimeSpan, AgeGroup>(size, hours(9));
    }
    static std::string name()
    {
        return "GotoSchoolTimeMaximum";
    }
};
 
struct AgeGroupGotoSchool {
    using Type = CustomIndexArray<bool, AgeGroup>;
    static Type get_default(AgeGroup num_agegroups)
    {
        return Type(num_agegroups, false);
    }
    static std::string name()
    {
        return "AgeGroupGotoSchool";
    }
};
 
struct AgeGroupGotoWork {
    using Type = CustomIndexArray<bool, AgeGroup>;
    static Type get_default(AgeGroup num_agegroups)
    {
        return Type(num_agegroups, false);
    }
    static std::string name()
    {
        return "AgeGroupGotoWork";
    }
};
 
using ParametersBase =
    ParameterSet<TimeExposedToNoSymptoms, TimeInfectedNoSymptomsToSymptoms, TimeInfectedNoSymptomsToRecovered,
                 TimeInfectedSymptomsToSevere, TimeInfectedSymptomsToRecovered, TimeInfectedSevereToCritical,
                 TimeInfectedSevereToRecovered, TimeInfectedSevereToDead, TimeInfectedCriticalToDead,
                 TimeInfectedCriticalToRecovered, SymptomsPerInfectedNoSymptoms, SeverePerInfectedSymptoms,
                 CriticalPerInfectedSevere, DeathsPerInfectedSevere, DeathsPerInfectedCritical, ViralLoadDistributions,
                 ViralShedParameters, ViralShedFactor, InfectionRateFromViralShed, MaskProtection,
                 AerosolTransmissionRates, LockdownDate, QuarantineDuration, QuarantineEffectiveness, SocialEventRate,
                 BasicShoppingRate, WorkRatio, SchoolRatio, GotoWorkTimeMinimum, GotoWorkTimeMaximum,
                 GotoSchoolTimeMinimum, GotoSchoolTimeMaximum, AgeGroupGotoSchool, AgeGroupGotoWork,
                 InfectionProtectionFactor, SeverityProtectionFactor, HighViralLoadProtectionFactor, TestData>;
 
struct MaximumContacts {
    using Type = ScalarType;
    static Type get_default(AgeGroup /*size*/)
    {
        return std::numeric_limits<ScalarType>::max();
    }
    static std::string name()
    {
        return "MaximumContacts";
    }
};
 
struct ContactRates {
    using Type = CustomIndexArray<ScalarType, AgeGroup, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type({size, size},
                    1.0); // amount of contacts from AgeGroup a to AgeGroup b per day
    }
    static std::string name()
    {
        return "ContactRates";
    }
};
 
// If true, consider the capacity of the Cell%s of this Location for the computation of relative transmission risk.
struct UseLocationCapacityForTransmissions {
    using Type = bool;
    static Type get_default(AgeGroup /*size*/)
    {
        return false;
    }
    static std::string name()
    {
        return "UseLocationCapacityForTransmissions";
    }
};
 
using LocalInfectionParameters = ParameterSet<MaximumContacts, ContactRates, UseLocationCapacityForTransmissions>;
 
class Parameters : public ParametersBase
{
public:
    Parameters(size_t num_agegroups)
        : ParametersBase(AgeGroup(num_agegroups))
        , m_num_groups(num_agegroups)
    {
    }
 
private:
    Parameters(ParametersBase&& base)
        : ParametersBase(std::move(base))
        , m_num_groups(this->get<AgeGroupGotoWork>().size<AgeGroup>().get())
    {
    }
 
public:
    size_t get_num_groups() const
    {
        return m_num_groups;
    }
 
    bool check_constraints() const
    {
        for (auto i = AgeGroup(0); i < AgeGroup(m_num_groups); ++i) {
            for (auto&& v : enum_members<VirusVariant>()) {
 
                if (this->get<TimeExposedToNoSymptoms>()[{v, i}].params()[0] < 0) {
                    log_error("Constraint check: Mean of parameter TimeExposedToNoSymptoms of virus variant {} and "
                              "age group {} smaller "
                              "than {}",
                              (uint32_t)v, (size_t)i, 0);
                    return true;
                }
 
                if (this->get<TimeInfectedNoSymptomsToSymptoms>()[{v, i}].params()[0] < 0.0) {
                    log_error("Constraint check: Mean of parameter TimeInfectedNoSymptomsToSymptoms "
                              "of virus variant "
                              "{} and age group {} smaller "
                              "than {}",
                              (uint32_t)v, (size_t)i, 0);
                    return true;
                }
 
                if (this->get<TimeInfectedNoSymptomsToRecovered>()[{v, i}].params()[0] < 0.0) {
                    log_error("Constraint check: Mean of parameter TimeInfectedNoSymptomsToRecovered of "
                              "virus variant "
                              "{} and age group {} smaller "
                              "than {}",
                              (uint32_t)v, (size_t)i, 0);
                    return true;
                }
 
                if (this->get<TimeInfectedSymptomsToSevere>()[{v, i}].params()[0] < 0.0) {
                    log_error("Constraint check: Mean of parameter TimeInfectedSymptomsToSevere of virus "
                              "variant {} "
                              "and age group {} smaller "
                              "than {}",
                              (uint32_t)v, (size_t)i, 0);
                    return true;
                }
 
                if (this->get<TimeInfectedSymptomsToRecovered>()[{v, i}].params()[0] < 0.0) {
                    log_error("Constraint check: Mean of parameter TimeInfectedSymptomsToRecovered of virus "
                              "variant {} "
                              "and age group {} smaller "
                              "than {}",
                              (uint32_t)v, (size_t)i, 0);
                    return true;
                }
 
                if (this->get<TimeInfectedSevereToCritical>()[{v, i}].params()[0] < 0.0) {
                    log_error("Constraint check: Mean of parameter TimeInfectedSevereToCritical of virus "
                              "variant {} "
                              "and age group {} smaller "
                              "than {}",
                              (uint32_t)v, (size_t)i, 0);
                    return true;
                }
 
                if (this->get<TimeInfectedSevereToRecovered>()[{v, i}].params()[0] < 0.0) {
                    log_error("Constraint check: Mean of parameter TimeInfectedSevereToRecovered of virus "
                              "variant {} "
                              "and age group {} smaller "
                              "than {}",
                              (uint32_t)v, (size_t)i, 0);
                    return true;
                }
 
                if (this->get<TimeInfectedSevereToDead>()[{v, i}].params()[0] < 0.0) {
                    log_error("Constraint check: Mean of parameter TimeInfectedSevereToDead of virus "
                              "variant {} "
                              "and age group {} smaller "
                              "than {}",
                              (uint32_t)v, (size_t)i, 0);
                    return true;
                }
 
                if (this->get<TimeInfectedCriticalToDead>()[{v, i}].params()[0] < 0.0) {
                    log_error("Constraint check: Mean of parameter TimeInfectedCriticalToDead of virus variant {} "
                              "and age group {} smaller "
                              "than {}",
                              (uint32_t)v, (size_t)i, 0);
                    return true;
                }
 
                if (this->get<TimeInfectedCriticalToRecovered>()[{v, i}].params()[0] < 0.0) {
                    log_error("Constraint check: Mean of parameter TimeInfectedCriticalToRecovered of virus "
                              "variant {} "
                              "and age group {} smaller "
                              "than {}",
                              (uint32_t)v, (size_t)i, 0);
                    return true;
                }
 
                if (this->get<SymptomsPerInfectedNoSymptoms>()[{v, i}] < 0.0 ||
                    this->get<SymptomsPerInfectedNoSymptoms>()[{v, i}] > 1.0) {
                    log_error("Constraint check: Parameter SymptomsPerInfectedNoSymptoms of virus variant {} and age "
                              "group {} smaller than {} or larger than {}",
                              (uint32_t)v, (size_t)i, 0, 1);
                    return true;
                }
 
                if (this->get<SeverePerInfectedSymptoms>()[{v, i}] < 0.0 ||
                    this->get<SeverePerInfectedSymptoms>()[{v, i}] > 1.0) {
                    log_error("Constraint check: Parameter SeverePerInfectedSymptoms of virus variant {} and age group "
                              "{} smaller than {} or larger than {}",
                              (uint32_t)v, (size_t)i, 0, 1);
                    return true;
                }
 
                if (this->get<CriticalPerInfectedSevere>()[{v, i}] < 0.0 ||
                    this->get<CriticalPerInfectedSevere>()[{v, i}] > 1.0) {
                    log_error("Constraint check: Parameter CriticalPerInfectedSevere of virus variant {} and age group "
                              "{} smaller than {} or larger than {}",
                              (uint32_t)v, (size_t)i, 0, 1);
                    return true;
                }
 
                if (this->get<DeathsPerInfectedSevere>()[{v, i}] < 0.0 ||
                    this->get<DeathsPerInfectedSevere>()[{v, i}] > 1.0) {
                    log_error("Constraint check: Parameter DeathsPerInfectedSevere of age group {} smaller than "
                              "{} or larger than {}",
                              (uint32_t)v, (size_t)i, 0, 1);
                    return true;
                }
 
                if ((this->get<DeathsPerInfectedSevere>()[{v, i}] + this->get<CriticalPerInfectedSevere>()[{v, i}]) >
                    1.0) {
                    log_error("Constraint check: Sum of parameters DeathsPerInfectedSevere and "
                              "CriticalPerInfectedSevere of age group {} larger than "
                              "{}",
                              (uint32_t)v, (size_t)i, 1);
                    return true;
                }
 
                if (this->get<DeathsPerInfectedCritical>()[{v, i}] < 0.0 ||
                    this->get<DeathsPerInfectedCritical>()[{v, i}] > 1.0) {
                    log_error("Constraint check: Parameter DeathsPerInfectedCritical of age group {} smaller than "
                              "{} or larger than {}",
                              (uint32_t)v, (size_t)i, 0, 1);
                    return true;
                }
 
                if (this->get<ViralShedFactor>()[{v, i}].params()[0] < 0.0) {
                    log_error("Constraint check: Mean of parameter ViralShedFactor of virus "
                              "variant {} "
                              "and age group {:.0f} smaller "
                              "than {:d}",
                              (uint32_t)v, (size_t)i, 0);
                    return true;
                }
            }
 
            if (this->get<GotoWorkTimeMinimum>()[i].seconds() < 0.0 ||
                this->get<GotoWorkTimeMinimum>()[i].seconds() > this->get<GotoWorkTimeMaximum>()[i].seconds()) {
                log_error("Constraint check: Parameter GotoWorkTimeMinimum of age group {} smaller {} or "
                          "larger {}",
                          (size_t)i, 0, this->get<GotoWorkTimeMaximum>()[i].seconds());
                return true;
            }
 
            if (this->get<GotoWorkTimeMaximum>()[i].seconds() < this->get<GotoWorkTimeMinimum>()[i].seconds() ||
                this->get<GotoWorkTimeMaximum>()[i] > days(1)) {
                log_error("Constraint check: Parameter GotoWorkTimeMaximum of age group {} smaller {} or larger "
                          "than one day time span",
                          (size_t)i, this->get<GotoWorkTimeMinimum>()[i].seconds());
                return true;
            }
 
            if (this->get<GotoSchoolTimeMinimum>()[i].seconds() < 0.0 ||
                this->get<GotoSchoolTimeMinimum>()[i].seconds() > this->get<GotoSchoolTimeMaximum>()[i].seconds()) {
                log_error("Constraint check: Parameter GotoSchoolTimeMinimum of age group {} smaller {} or "
                          "larger {}",
                          (size_t)i, 0, this->get<GotoWorkTimeMaximum>()[i].seconds());
                return true;
            }
 
            if (this->get<GotoSchoolTimeMaximum>()[i].seconds() < this->get<GotoSchoolTimeMinimum>()[i].seconds() ||
                this->get<GotoSchoolTimeMaximum>()[i] > days(1)) {
                log_error("Constraint check: Parameter GotoWorkTimeMaximum of age group {} smaller {} or larger "
                          "than one day time span",
                          (size_t)i, this->get<GotoSchoolTimeMinimum>()[i].seconds());
                return true;
            }
        }
 
        for (auto&& v : enum_members<VirusVariant>()) {
            if (this->get<InfectionRateFromViralShed>()[v] < 0.0) {
                log_error("Constraint check: Parameter InfectionRateFromViralShed of virus "
                          "variant {} is smaller than {:d}",
                          (uint32_t)v, 0);
                return true;
            }
        }
 
        if (this->get<MaskProtection>()[MaskType::Community] < 0.0 ||
            this->get<MaskProtection>()[MaskType::Community] > 1.0) {
            log_error("Constraint check: Parameter MaskProtection for MaskType Community is smaller {} or larger {}", 0,
                      1);
            return true;
        }
 
        if (this->get<MaskProtection>()[MaskType::FFP2] < 0.0 || this->get<MaskProtection>()[MaskType::FFP2] > 1.0) {
            log_error("Constraint check: Parameter MaskProtection for MaskType FFP2 is smaller {} or larger {}", 0, 1);
            return true;
        }
 
        if (this->get<MaskProtection>()[MaskType::Surgical] < 0.0 ||
            this->get<MaskProtection>()[MaskType::Surgical] > 1.0) {
            log_error("Constraint check: Parameter MaskProtection for MaskType Surgical smaller {} or larger {}", 0, 1);
            return true;
        }
 
        if (this->get<LockdownDate>().seconds() < 0.0) {
            log_error("Constraint check: Parameter LockdownDate smaller {}", 0);
            return true;
        }
 
        if (this->get<QuarantineEffectiveness>() < 0.0 || this->get<QuarantineEffectiveness>() > 1.0) {
            log_error("Constraint check: Parameter QuarantineEffectiveness not between {:d,:d}", 0, 1);
            return true;
        }
 
        return false;
    }
 
    template <class IOContext>
    static IOResult<Parameters> deserialize(IOContext& io)
    {
        BOOST_OUTCOME_TRY(auto&& base, ParametersBase::deserialize(io));
        return success(Parameters(std::move(base)));
    }
 
private:
    size_t m_num_groups;
};
 
} // namespace abm
} // namespace mio
#endif