ode_secirvvs/parameters.h

Go to the documentation of this file.

/*
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Wadim Koslow, Daniel Abele, Martin J. Kühn
*
* 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_ODE_SECIRVVS_PARAMETERS_H
#define MIO_ODE_SECIRVVS_PARAMETERS_H
 
#include "memilio/epidemiology/age_group.h"
#include "memilio/epidemiology/dynamic_npis.h"
#include "memilio/epidemiology/simulation_day.h"
#include "memilio/epidemiology/uncertain_matrix.h"
#include "memilio/utils/custom_index_array.h"
#include "memilio/utils/parameter_set.h"
#include "memilio/utils/uncertain_value.h"
 
namespace mio
{
namespace osecirvvs
{
 
template <typename FP>
struct StartDay {
    using Type = FP;
    static Type get_default(AgeGroup)
    {
        return Type(0.0);
    }
    static std::string name()
    {
        return "StartDay";
    }
};
 
template <typename FP>
struct StartDayNewVariant {
    using Type = FP;
    static Type get_default(AgeGroup)
    {
        return std::numeric_limits<FP>::max();
    }
    static std::string name()
    {
        return "StartDayNewVariant";
    }
};
 
template <typename FP>
struct Seasonality {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(0.);
    }
    static std::string name()
    {
        return "Seasonality";
    }
};
 
template <typename FP>
struct ICUCapacity {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(std::numeric_limits<FP>::max());
    }
    static std::string name()
    {
        return "ICUCapacity";
    }
};
 
template <typename FP>
struct TestAndTraceCapacity {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(std::numeric_limits<FP>::max());
    }
    static std::string name()
    {
        return "TestAndTraceCapacity";
    }
};
 
template <typename FP>
struct TestAndTraceCapacityMaxRiskNoSymptoms {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(2.0);
    }
    static std::string name()
    {
        return "TestAndTraceCapacityMaxRiskNoSymptoms";
    }
};
 
template <typename FP>
struct TestAndTraceCapacityMaxRiskSymptoms {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(15.0);
    }
    static std::string name()
    {
        return "TestAndTraceCapacityMaxRiskSymptoms";
    }
};
 
template <typename FP>
struct ContactPatterns {
    using Type = UncertainContactMatrix<FP>;
    static Type get_default(AgeGroup size)
    {
        return Type(1, static_cast<Eigen::Index>((size_t)size));
    }
    static std::string name()
    {
        return "ContactPatterns";
    }
};
 
template <typename FP>
struct DynamicNPIsInfectedSymptoms {
    using Type = DynamicNPIs<FP>;
    static Type get_default(AgeGroup /*size*/)
    {
        return {};
    }
    static std::string name()
    {
        return "DynamicNPIsInfectedSymptoms";
    }
};
 
template <typename FP>
struct TimeExposed {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "TimeExposed";
    }
};
 
template <typename FP>
struct TimeInfectedNoSymptoms {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "TimeInfectedNoSymptoms";
    }
};
 
template <typename FP>
struct TimeInfectedSymptoms {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "TimeInfectedSymptoms";
    }
};
 
template <typename FP>
struct TimeInfectedSevere {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "TimeInfectedSevere";
    }
};
 
template <typename FP>
struct TimeInfectedCritical {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "TimeInfectedCritical";
    }
};
 
template <typename FP>
struct TransmissionProbabilityOnContact {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "TransmissionProbabilityOnContact";
    }
};
 
template <typename FP>
struct RelativeTransmissionNoSymptoms {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "RelativeTransmissionNoSymptoms";
    }
};
 
template <typename FP>
struct RecoveredPerInfectedNoSymptoms {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 0.);
    }
    static std::string name()
    {
        return "RecoveredPerInfectedNoSymptoms";
    }
};
 
template <typename FP>
struct RiskOfInfectionFromSymptomatic {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "RiskOfInfectionFromSymptomatic";
    }
};
 
template <typename FP>
struct MaxRiskOfInfectionFromSymptomatic {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "MaxRiskOfInfectionFromSymptomatic";
    }
};
 
template <typename FP>
struct SeverePerInfectedSymptoms {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 0.);
    }
    static std::string name()
    {
        return "SeverePerInfectedSymptoms";
    }
};
 
template <typename FP>
struct CriticalPerSevere {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 0.);
    }
    static std::string name()
    {
        return "CriticalPerSevere";
    }
};
 
template <typename FP>
struct DeathsPerSevere {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 0.);
    }
    static std::string name()
    {
        return "DeathsPerSevere";
    }
};
 
template <typename FP>
struct DeathsPerCritical {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 0.);
    }
    static std::string name()
    {
        return "DeathsPerCritical";
    }
};
 
template <typename FP>
struct VaccinationGap {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 49.0);
    }
    static std::string name()
    {
        return "VaccinationGap";
    }
};
 
template <typename FP>
struct DaysUntilEffectivePartialImmunity {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 14.0);
    }
    static std::string name()
    {
        return "DaysUntilEffectivePartialImmunity";
    }
};
 
template <typename FP>
struct DaysUntilEffectiveImprovedImmunity {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 7.0);
    }
    static std::string name()
    {
        return "DaysUntilEffectiveImprovedImmunity";
    }
};
 
template <typename FP>
struct DailyPartialVaccinations {
    using Type = CustomIndexArray<FP, AgeGroup, SimulationDay>;
    static Type get_default(AgeGroup size)
    {
        return Type({size, SimulationDay(0)});
    }
    static std::string name()
    {
        return "DailyPartialVaccinations";
    }
};
 
template <typename FP>
struct DailyFullVaccinations {
    using Type = CustomIndexArray<FP, AgeGroup, SimulationDay>;
    static Type get_default(AgeGroup size)
    {
        return Type({size, SimulationDay(0)});
    }
    static std::string name()
    {
        return "DailyFullVaccinations";
    }
};
 
template <typename FP>
struct ReducExposedPartialImmunity {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "ReducExposedPartialImmunity";
    }
};
 
template <typename FP>
struct ReducExposedImprovedImmunity {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "ReducExposedImprovedImmunity";
    }
};
 
template <typename FP>
struct ReducInfectedSymptomsPartialImmunity {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "ReducInfectedSymptomsPartialImmunity";
    }
};
 
template <typename FP>
struct ReducInfectedSymptomsImprovedImmunity {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "ReducInfectedSymptomsImprovedImmunity";
    }
};
 
template <typename FP>
struct ReducInfectedSevereCriticalDeadPartialImmunity {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "ReducInfectedSevereCriticalDeadPartialImmunity";
    }
};
 
template <typename FP>
struct ReducInfectedSevereCriticalDeadImprovedImmunity {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.);
    }
    static std::string name()
    {
        return "ReducInfectedSevereCriticalDeadImprovedImmunity";
    }
};
 
template <typename FP>
struct ReducTimeInfectedMild {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 0.5);
    }
    static std::string name()
    {
        return "ReducTimeInfectedMild";
    }
};
 
template <typename FP>
struct InfectiousnessNewVariant {
    using Type = CustomIndexArray<FP, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.0);
    }
    static std::string name()
    {
        return "InfectiousnessNewVariant";
    }
};
 
template <typename FP>
using ParametersBase = ParameterSet<
    StartDay<FP>, Seasonality<FP>, ICUCapacity<FP>, TestAndTraceCapacity<FP>, TestAndTraceCapacityMaxRiskNoSymptoms<FP>,
    TestAndTraceCapacityMaxRiskSymptoms<FP>, ContactPatterns<FP>, DynamicNPIsInfectedSymptoms<FP>, TimeExposed<FP>,
    TimeInfectedNoSymptoms<FP>, TimeInfectedSymptoms<FP>, TimeInfectedSevere<FP>, TimeInfectedCritical<FP>,
    TransmissionProbabilityOnContact<FP>, RelativeTransmissionNoSymptoms<FP>, RecoveredPerInfectedNoSymptoms<FP>,
    RiskOfInfectionFromSymptomatic<FP>, MaxRiskOfInfectionFromSymptomatic<FP>, SeverePerInfectedSymptoms<FP>,
    CriticalPerSevere<FP>, DeathsPerSevere<FP>, DeathsPerCritical<FP>, VaccinationGap<FP>,
    DaysUntilEffectivePartialImmunity<FP>, DaysUntilEffectiveImprovedImmunity<FP>, DailyFullVaccinations<FP>,
    DailyPartialVaccinations<FP>, ReducExposedPartialImmunity<FP>, ReducExposedImprovedImmunity<FP>,
    ReducInfectedSymptomsPartialImmunity<FP>, ReducInfectedSymptomsImprovedImmunity<FP>,
    ReducInfectedSevereCriticalDeadPartialImmunity<FP>, ReducInfectedSevereCriticalDeadImprovedImmunity<FP>,
    ReducTimeInfectedMild<FP>, InfectiousnessNewVariant<FP>, StartDayNewVariant<FP>>;
 
template <typename FP>
class Parameters : public ParametersBase<FP>
{
public:
    Parameters(AgeGroup num_agegroups)
        : ParametersBase<FP>(num_agegroups)
        , m_num_groups{num_agegroups}
    {
    }
 
    AgeGroup get_num_groups() const
    {
        return m_num_groups;
    }
 
    FP& get_commuter_nondetection()
    {
        return m_commuter_nondetection;
    }
    FP get_commuter_nondetection() const
    {
        return m_commuter_nondetection;
    }
 
    FP& get_start_commuter_detection()
    {
        return m_start_commuter_detection;
    }
 
    FP get_start_commuter_detection() const
    {
        return m_start_commuter_detection;
    }
 
    FP& get_end_commuter_detection()
    {
        return m_end_commuter_detection;
    }
 
    FP get_end_commuter_detection() const
    {
        return m_end_commuter_detection;
    }
 
    bool apply_constraints()
    {
        int corrected = false;
        if (this->template get<Seasonality<FP>>() < 0.0 || this->template get<Seasonality<FP>>() > 0.5) {
            log_warning("Constraint check: Parameter Seasonality changed from {} to {}",
                        this->template get<Seasonality<FP>>(), 0);
            this->template set<Seasonality<FP>>(0);
            corrected = true;
        }
 
        if (this->template get<ICUCapacity<FP>>() < 0.0) {
            log_warning("Constraint check: Parameter ICUCapacity changed from {} to {}",
                        this->template get<ICUCapacity<FP>>(), 0);
            this->template set<ICUCapacity<FP>>(0);
            corrected = true;
        }
 
        if (this->template get<TestAndTraceCapacity<FP>>() < 0.0) {
            log_warning("Constraint check: Parameter TestAndTraceCapacity changed from {} to {}",
                        this->template get<TestAndTraceCapacity<FP>>(), 0);
            this->template set<TestAndTraceCapacity<FP>>(0);
            corrected = true;
        }
 
        if (this->template get<TestAndTraceCapacityMaxRiskSymptoms<FP>>() < 0.0) {
            log_warning("Constraint check: Parameter TestAndTraceCapacityMaxRiskSymptoms changed from {} to {}",
                        this->template get<TestAndTraceCapacityMaxRiskSymptoms<FP>>(), 0);
            this->template set<TestAndTraceCapacityMaxRiskSymptoms<FP>>(0);
            corrected = true;
        }
 
        if (this->template get<TestAndTraceCapacityMaxRiskNoSymptoms<FP>>() < 0.0) {
            log_warning("Constraint check: Parameter TestAndTraceCapacityMaxRiskNoSymptoms changed from {} to {}",
                        this->template get<TestAndTraceCapacityMaxRiskNoSymptoms<FP>>(), 0);
            this->template set<TestAndTraceCapacityMaxRiskNoSymptoms<FP>>(0);
            corrected = true;
        }
 
        const FP tol_times = 1e-1; // accepted tolerance for compartment stays
 
        for (auto i = AgeGroup(0); i < AgeGroup(m_num_groups); ++i) {
            if (this->template get<TimeExposed<FP>>()[i] < tol_times) {
                log_warning("Constraint check: Parameter TimeExposed changed from {} to {}. Please "
                            "note that unreasonably small compartment stays lead to massively increased run time. "
                            "Consider to cancel and reset parameters.",
                            this->template get<TimeExposed<FP>>()[i], tol_times);
                this->template get<TimeExposed<FP>>()[i] = tol_times;
                corrected                                = true;
            }
 
            if (this->template get<TimeInfectedNoSymptoms<FP>>()[i] < tol_times) {
                log_warning("Constraint check: Parameter TimeInfectedNoSymptoms changed from {} to {}. Please "
                            "note that unreasonably small compartment stays lead to massively increased run time. "
                            "Consider to cancel and reset parameters.",
                            this->template get<TimeInfectedNoSymptoms<FP>>()[i], tol_times);
                this->template get<TimeInfectedNoSymptoms<FP>>()[i] = tol_times;
                corrected                                           = true;
            }
 
            if (this->template get<TimeInfectedSymptoms<FP>>()[i] < tol_times) {
                log_warning("Constraint check: Parameter TimeInfectedSymptoms changed from {} to {}. Please "
                            "note that unreasonably small compartment stays lead to massively increased run time. "
                            "Consider to cancel and reset parameters.",
                            this->template get<TimeInfectedSymptoms<FP>>()[i], tol_times);
                this->template get<TimeInfectedSymptoms<FP>>()[i] = tol_times;
                corrected                                         = true;
            }
 
            if (this->template get<TimeInfectedSevere<FP>>()[i] < tol_times) {
                log_warning("Constraint check: Parameter TimeInfectedSevere changed from {} to {}. Please "
                            "note that unreasonably small compartment stays lead to massively increased run time. "
                            "Consider to cancel and reset parameters.",
                            this->template get<TimeInfectedSevere<FP>>()[i], tol_times);
                this->template get<TimeInfectedSevere<FP>>()[i] = tol_times;
                corrected                                       = true;
            }
 
            if (this->template get<TimeInfectedCritical<FP>>()[i] < tol_times) {
                log_warning("Constraint check: Parameter TimeInfectedCritical changed from {} to {}. Please "
                            "note that unreasonably small compartment stays lead to massively increased run time. "
                            "Consider to cancel and reset parameters.",
                            this->template get<TimeInfectedCritical<FP>>()[i], tol_times);
                this->template get<TimeInfectedCritical<FP>>()[i] = tol_times;
                corrected                                         = true;
            }
 
            if (this->template get<TransmissionProbabilityOnContact<FP>>()[i] < 0.0 ||
                this->template get<TransmissionProbabilityOnContact<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter TransmissionProbabilityOnContact changed from {} to {} ",
                            this->template get<TransmissionProbabilityOnContact<FP>>()[i], 0.0);
                this->template get<TransmissionProbabilityOnContact<FP>>()[i] = 0.0;
                corrected                                                     = true;
            }
 
            if (this->template get<RelativeTransmissionNoSymptoms<FP>>()[i] < 0.0) {
                log_warning("Constraint check: Parameter RelativeTransmissionNoSymptoms changed from {} to {} ",
                            this->template get<RelativeTransmissionNoSymptoms<FP>>()[i], 0);
                this->template get<RelativeTransmissionNoSymptoms<FP>>()[i] = 0;
                corrected                                                   = true;
            }
 
            if (this->template get<RecoveredPerInfectedNoSymptoms<FP>>()[i] < 0.0 ||
                this->template get<RecoveredPerInfectedNoSymptoms<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter RecoveredPerInfectedNoSymptoms changed from {} to {} ",
                            this->template get<RecoveredPerInfectedNoSymptoms<FP>>()[i], 0);
                this->template get<RecoveredPerInfectedNoSymptoms<FP>>()[i] = 0;
                corrected                                                   = true;
            }
 
            if (this->template get<RiskOfInfectionFromSymptomatic<FP>>()[i] < 0.0 ||
                this->template get<RiskOfInfectionFromSymptomatic<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter RiskOfInfectionFromSymptomatic changed from {} to {}",
                            this->template get<RiskOfInfectionFromSymptomatic<FP>>()[i], 0);
                this->template get<RiskOfInfectionFromSymptomatic<FP>>()[i] = 0;
                corrected                                                   = true;
            }
 
            if (this->template get<SeverePerInfectedSymptoms<FP>>()[i] < 0.0 ||
                this->template get<SeverePerInfectedSymptoms<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter SeverePerInfectedSymptoms changed from {} to {}",
                            this->template get<SeverePerInfectedSymptoms<FP>>()[i], 0);
                this->template get<SeverePerInfectedSymptoms<FP>>()[i] = 0;
                corrected                                              = true;
            }
 
            if (this->template get<CriticalPerSevere<FP>>()[i] < 0.0 ||
                this->template get<CriticalPerSevere<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter CriticalPerSevere changed from {} to {}",
                            this->template get<CriticalPerSevere<FP>>()[i], 0);
                this->template get<CriticalPerSevere<FP>>()[i] = 0;
                corrected                                      = true;
            }
 
            if (this->template get<DeathsPerSevere<FP>>()[i] < 0.0 ||
                this->template get<DeathsPerSevere<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter DeathsPerSevere changed from {} to {}",
                            this->template get<DeathsPerSevere<FP>>()[i], 0);
                this->template get<DeathsPerSevere<FP>>()[i] = 0;
                corrected                                    = true;
            }
 
            if (this->template get<CriticalPerSevere<FP>>()[i] + this->template get<DeathsPerSevere<FP>>()[i] > 1.0) {
                log_warning("Constraint check: CriticalPerSevere + DeathsPerSevere exceed 1.0 for age group {}. "
                            "DeathsPerSevere changed from {} to 0.",
                            static_cast<size_t>(i), this->template get<DeathsPerSevere<FP>>()[i]);
                this->template get<DeathsPerSevere<FP>>()[i] = 0;
                corrected                                    = true;
            }
 
            if (this->template get<DeathsPerCritical<FP>>()[i] < 0.0 ||
                this->template get<DeathsPerCritical<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter DeathsPerCritical changed from {} to {}",
                            this->template get<DeathsPerCritical<FP>>()[i], 0);
                this->template get<DeathsPerCritical<FP>>()[i] = 0;
                corrected                                      = true;
            }
 
            if (this->template get<DaysUntilEffectivePartialImmunity<FP>>()[i] < 0.0) {
                log_warning("Constraint check: Parameter DaysUntilEffectivePartialImmunity changed from {} to {}",
                            this->template get<DaysUntilEffectivePartialImmunity<FP>>()[i], 0);
                this->template get<DaysUntilEffectivePartialImmunity<FP>>()[i] = 0;
                corrected                                                      = true;
            }
            if (this->template get<DaysUntilEffectiveImprovedImmunity<FP>>()[i] < 0.0) {
                log_warning("Constraint check: Parameter DaysUntilEffectiveImprovedImmunity changed from {} to {}",
                            this->template get<DaysUntilEffectiveImprovedImmunity<FP>>()[i], 0);
                this->template get<DaysUntilEffectiveImprovedImmunity<FP>>()[i] = 0;
                corrected                                                       = true;
            }
 
            if (this->template get<ReducExposedPartialImmunity<FP>>()[i] <= 0.0 ||
                this->template get<ReducExposedPartialImmunity<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter ReducExposedPartialImmunity changed from {} to {}",
                            this->template get<ReducExposedPartialImmunity<FP>>()[i], 1);
                this->template get<ReducExposedPartialImmunity<FP>>()[i] = 1;
                corrected                                                = true;
            }
            if (this->template get<ReducExposedImprovedImmunity<FP>>()[i] <= 0.0 ||
                this->template get<ReducExposedImprovedImmunity<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter ReducExposedImprovedImmunity changed from {} to {}",
                            this->template get<ReducExposedImprovedImmunity<FP>>()[i], 1);
                this->template get<ReducExposedImprovedImmunity<FP>>()[i] = 1;
                corrected                                                 = true;
            }
            if (this->template get<ReducInfectedSymptomsPartialImmunity<FP>>()[i] <= 0.0 ||
                this->template get<ReducInfectedSymptomsPartialImmunity<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter ReducInfectedSymptomsPartialImmunity changed from {} to {}",
                            this->template get<ReducInfectedSymptomsPartialImmunity<FP>>()[i], 1);
                this->template get<ReducInfectedSymptomsPartialImmunity<FP>>()[i] = 1;
                corrected                                                         = true;
            }
            if (this->template get<ReducInfectedSymptomsImprovedImmunity<FP>>()[i] <= 0.0 ||
                this->template get<ReducInfectedSymptomsImprovedImmunity<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter ReducInfectedSymptomsImprovedImmunity changed from {} to {}",
                            this->template get<ReducInfectedSymptomsImprovedImmunity<FP>>()[i], 1.0);
                this->template get<ReducInfectedSymptomsImprovedImmunity<FP>>()[i] = 1.0;
                corrected                                                          = true;
            }
            if (this->template get<ReducInfectedSevereCriticalDeadPartialImmunity<FP>>()[i] <= 0.0 ||
                this->template get<ReducInfectedSevereCriticalDeadPartialImmunity<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter ReducInfectedSevereCriticalDeadPartialImmunity changed from "
                            "{} to {}",
                            this->template get<ReducInfectedSevereCriticalDeadPartialImmunity<FP>>()[i], 1.0);
                this->template get<ReducInfectedSevereCriticalDeadPartialImmunity<FP>>()[i] = 1.0;
                corrected                                                                   = true;
            }
            if (this->template get<ReducInfectedSevereCriticalDeadImprovedImmunity<FP>>()[i] <= 0.0 ||
                this->template get<ReducInfectedSevereCriticalDeadImprovedImmunity<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter ReducInfectedSevereCriticalDeadImprovedImmunity changed from "
                            "{} to {}",
                            this->template get<ReducInfectedSevereCriticalDeadImprovedImmunity<FP>>()[i], 1.0);
                this->template get<ReducInfectedSevereCriticalDeadImprovedImmunity<FP>>()[i] = 1.0;
                corrected                                                                    = true;
            }
            if (this->template get<ReducTimeInfectedMild<FP>>()[i] <= 0.0 ||
                this->template get<ReducTimeInfectedMild<FP>>()[i] > 1.0) {
                log_warning("Constraint check: Parameter ReducTimeInfectedMild changed from {} to {}",
                            this->template get<ReducTimeInfectedMild<FP>>()[i], 1.0);
                this->template get<ReducTimeInfectedMild<FP>>()[i] = 1.0;
                corrected                                          = true;
            }
            if (this->template get<InfectiousnessNewVariant<FP>>()[i] < 0.0) {
                log_warning("Constraint check: Parameter InfectiousnessNewVariant changed from {} to {}",
                            this->template get<InfectiousnessNewVariant<FP>>()[i], 1.0);
                this->template get<InfectiousnessNewVariant<FP>>()[i] = 1.0;
                corrected                                             = true;
            }
            if (this->template get<VaccinationGap<FP>>()[i] < 0.0) {
                log_warning("Constraint check: Parameter VaccinationGap changed from {} to {}",
                            this->template get<VaccinationGap<FP>>()[i], 0);
                this->template get<VaccinationGap<FP>>()[i] = 0;
                corrected                                   = true;
            }
        }
        return corrected;
    }
 
    bool check_constraints() const
    {
        const FP tol_times = 1e-1; // accepted tolerance for compartment stays
        if (this->template get<Seasonality<FP>>() < 0.0 || this->template get<Seasonality<FP>>() > 0.5) {
            log_error("Constraint check: Parameter Seasonality smaller {} or larger {}", 0, 0.5);
            return true;
        }
 
        if (this->template get<ICUCapacity<FP>>() < 0.0) {
            log_error("Constraint check: Parameter ICUCapacity smaller {}", 0);
            return true;
        }
 
        if (this->template get<TestAndTraceCapacity<FP>>() < 0.0) {
            log_error("Constraint check: Parameter TestAndTraceCapacity smaller {}", 0);
            return true;
        }
 
        if (this->template get<TestAndTraceCapacityMaxRiskSymptoms<FP>>() < 0.0) {
            log_error("Constraint check: Parameter TestAndTraceCapacityMaxRiskSymptoms smaller {}", 0);
            return true;
        }
 
        if (this->template get<TestAndTraceCapacityMaxRiskNoSymptoms<FP>>() < 0.0) {
            log_error("Constraint check: Parameter TestAndTraceCapacityMaxRiskNoSymptoms smaller {}", 0);
            return true;
        }
 
        for (auto i = AgeGroup(0); i < AgeGroup(m_num_groups); ++i) {
 
            if (this->template get<TimeExposed<FP>>()[i] < tol_times) {
                log_error("Constraint check: Parameter TimeExposed {} smaller {}. Please "
                          "note that unreasonably small compartment stays lead to massively increased run time. "
                          "Consider to cancel and reset parameters.",
                          this->template get<TimeExposed<FP>>()[i], tol_times);
                return true;
            }
 
            if (this->template get<TimeInfectedNoSymptoms<FP>>()[i] < tol_times) {
                log_error("Constraint check: Parameter TimeInfectedNoSymptoms {} smaller {}. Please "
                          "note that unreasonably small compartment stays lead to massively increased run time. "
                          "Consider to cancel and reset parameters.",
                          this->template get<TimeInfectedNoSymptoms<FP>>()[i], tol_times);
                return true;
            }
 
            if (this->template get<TimeInfectedSymptoms<FP>>()[i] < tol_times) {
                log_error("Constraint check: Parameter TimeInfectedSymptoms {} smaller {}. Please "
                          "note that unreasonably small compartment stays lead to massively increased run time. "
                          "Consider to cancel and reset parameters.",
                          this->template get<TimeInfectedSymptoms<FP>>()[i], tol_times);
                return true;
            }
 
            if (this->template get<TimeInfectedSevere<FP>>()[i] < tol_times) {
                log_error("Constraint check: Parameter TimeInfectedSevere {} smaller {}. Please "
                          "note that unreasonably small compartment stays lead to massively increased run time. "
                          "Consider to cancel and reset parameters.",
                          this->template get<TimeInfectedSevere<FP>>()[i], tol_times);
                return true;
            }
 
            if (this->template get<TimeInfectedCritical<FP>>()[i] < tol_times) {
                log_error("Constraint check: Parameter TimeInfectedCritical {} smaller {}. Please "
                          "note that unreasonably small compartment stays lead to massively increased run time. "
                          "Consider to cancel and reset parameters.",
                          this->template get<TimeInfectedCritical<FP>>()[i], tol_times);
                return true;
            }
 
            if (this->template get<TransmissionProbabilityOnContact<FP>>()[i] < 0.0 ||
                this->template get<TransmissionProbabilityOnContact<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter TransmissionProbabilityOnContact smaller {} or larger {}", 0, 1);
                return true;
            }
 
            if (this->template get<RelativeTransmissionNoSymptoms<FP>>()[i] < 0.0) {
                log_error("Constraint check: Parameter RelativeTransmissionNoSymptoms smaller {}", 0);
                return true;
            }
 
            if (this->template get<RecoveredPerInfectedNoSymptoms<FP>>()[i] < 0.0 ||
                this->template get<RecoveredPerInfectedNoSymptoms<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter RecoveredPerInfectedNoSymptoms smaller {} or larger {}", 0, 1);
                return true;
            }
 
            if (this->template get<RiskOfInfectionFromSymptomatic<FP>>()[i] < 0.0 ||
                this->template get<RiskOfInfectionFromSymptomatic<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter RiskOfInfectionFromSymptomatic smaller {} or larger {}", 0, 1);
                return true;
            }
 
            if (this->template get<SeverePerInfectedSymptoms<FP>>()[i] < 0.0 ||
                this->template get<SeverePerInfectedSymptoms<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter SeverePerInfectedSymptoms smaller {} or larger {}", 0, 1);
                return true;
            }
 
            if (this->template get<CriticalPerSevere<FP>>()[i] < 0.0 ||
                this->template get<CriticalPerSevere<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter CriticalPerSevere smaller {} or larger {}", 0, 1);
                return true;
            }
 
            if (this->template get<DeathsPerSevere<FP>>()[i] < 0.0 ||
                this->template get<DeathsPerSevere<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter DeathsPerSevere smaller {} or larger {}", 0, 1);
                return true;
            }
 
            if (this->template get<CriticalPerSevere<FP>>()[i] + this->template get<DeathsPerSevere<FP>>()[i] > 1.0) {
                log_error("Constraint check: CriticalPerSevere + DeathsPerSevere exceed 1.0 for age group {}.",
                          static_cast<size_t>(i));
                return true;
            }
 
            if (this->template get<DeathsPerCritical<FP>>()[i] < 0.0 ||
                this->template get<DeathsPerCritical<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter DeathsPerCritical smaller {} or larger {}", 0, 1);
                return true;
            }
 
            if (this->template get<VaccinationGap<FP>>()[i] < 1) {
                log_error("Constraint check: Parameter VaccinationGap smaller {}", 1);
                return true;
            }
 
            if (this->template get<DaysUntilEffectivePartialImmunity<FP>>()[i] < 0.0) {
                log_error("Constraint check: Parameter DaysUntilEffectivePartialImmunity smaller {}", 0);
                return true;
            }
            if (this->template get<DaysUntilEffectiveImprovedImmunity<FP>>()[i] < 0.0) {
                log_error("Constraint check: Parameter DaysUntilEffectiveImprovedImmunity smaller {}", 0);
                return true;
            }
 
            if (this->template get<ReducExposedPartialImmunity<FP>>()[i] <= 0.0 ||
                this->template get<ReducExposedPartialImmunity<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter ReducExposedPartialImmunity smaller {} or larger {}", 0, 1);
                return true;
            }
            if (this->template get<ReducExposedImprovedImmunity<FP>>()[i] <= 0.0 ||
                this->template get<ReducExposedImprovedImmunity<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter ReducExposedImprovedImmunity smaller {} or larger {}", 0, 1);
                return true;
            }
            if (this->template get<ReducInfectedSymptomsPartialImmunity<FP>>()[i] <= 0.0 ||
                this->template get<ReducInfectedSymptomsPartialImmunity<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter ReducInfectedSymptomsPartialImmunity smaller {} or larger {}", 0,
                          1);
                return true;
            }
            if (this->template get<ReducInfectedSymptomsImprovedImmunity<FP>>()[i] <= 0.0 ||
                this->template get<ReducInfectedSymptomsImprovedImmunity<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter ReducInfectedSymptomsImprovedImmunity smaller {} or larger {}",
                          0, 1);
                return true;
            }
            if (this->template get<ReducInfectedSevereCriticalDeadPartialImmunity<FP>>()[i] <= 0.0 ||
                this->template get<ReducInfectedSevereCriticalDeadPartialImmunity<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter ReducInfectedSevereCriticalDeadPartialImmunity smaller {} or "
                          "larger {}",
                          0, 1);
                return true;
            }
            if (this->template get<ReducInfectedSevereCriticalDeadImprovedImmunity<FP>>()[i] <= 0.0 ||
                this->template get<ReducInfectedSevereCriticalDeadImprovedImmunity<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter ReducInfectedSevereCriticalDeadImprovedImmunity smaller {} or "
                          "larger {}",
                          0, 1);
                return true;
            }
            if (this->template get<ReducTimeInfectedMild<FP>>()[i] <= 0.0 ||
                this->template get<ReducTimeInfectedMild<FP>>()[i] > 1.0) {
                log_error("Constraint check: Parameter ReducTimeInfectedMild smaller {} or larger {}", 0, 1);
                return true;
            }
            if (this->template get<InfectiousnessNewVariant<FP>>()[i] < 0.0) {
                log_error("Constraint check: Parameter InfectiousnessNewVariant smaller {}", 0);
                return true;
            }
        }
        return false;
    }
 
private:
    Parameters(ParametersBase<FP>&& base)
        : ParametersBase<FP>(std::move(base))
        , m_num_groups(this->template get<ContactPatterns<FP>>().get_cont_freq_mat().get_num_groups())
    {
    }
 
public:
    template <class IOContext>
    static IOResult<Parameters> deserialize(IOContext& io)
    {
        BOOST_OUTCOME_TRY(auto&& base, ParametersBase<FP>::deserialize(io));
        return success(Parameters(std::move(base)));
    }
 
private:
    AgeGroup m_num_groups;
    FP m_commuter_nondetection    = 0.0;
    FP m_start_commuter_detection = 0.0;
    FP m_end_commuter_detection   = 0.0;
};
 
} // namespace osecirvvs
} // namespace mio
 
#endif // MIO_ODE_SECIRVVS_PARAMETERS_H