ode_seirv/parameters.h

Go to the documentation of this file.

/*
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Henrik Zunker
*
* 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 SEIRV_PARAMETERS_H
#define SEIRV_PARAMETERS_H
 
#include "memilio/config.h"
#include "memilio/epidemiology/age_group.h"
#include "memilio/epidemiology/uncertain_matrix.h"
#include "memilio/utils/custom_index_array.h"
#include "memilio/utils/uncertain_value.h"
#include "memilio/utils/parameter_set.h"
 
namespace mio
{
namespace oseirv
{
 
template <class FP>
struct BaselineTransmissibility {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(1.0);
    }
    static std::string name()
    {
        return "BaselineTransmissibility";
    }
};
 
template <class FP>
struct TimeExposed {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(2.0);
    }
    static std::string name()
    {
        return "TimeExposed";
    }
};
 
template <class FP>
struct TimeInfected {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(2.0);
    }
    static std::string name()
    {
        return "TimeInfected";
    }
};
 
template <class FP>
struct SeasonalityAmplitude {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(0.0);
    }
    static std::string name()
    {
        return "SeasonalityAmplitude";
    }
};
 
template <class FP>
struct SeasonalityShiftPerSubtype {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(0.0);
    }
    static std::string name()
    {
        return "SeasonalityShiftPerSubtype";
    }
};
 
template <class FP>
struct SeasonalityShiftPerSeason {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(0.0);
    }
    static std::string name()
    {
        return "SeasonalityShiftPerSeason";
    }
};
 
template <class FP>
struct OutsideFoI {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(0.0);
    }
    static std::string name()
    {
        return "OutsideFoI";
    }
};
 
template <class FP>
struct ClusteringExponent {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(1.0);
    }
    static std::string name()
    {
        return "ClusteringExponent";
    }
};
 
template <class FP>
struct SickMixing {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(1.0);
    }
    static std::string name()
    {
        return "SickMixing";
    }
};
 
template <class FP>
struct ContactPatternsHealthy {
    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 "ContactPatternsHealthy";
    }
};
 
template <class FP>
struct ContactPatternsSick {
    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 "ContactPatternsSick";
    }
};
 
template <class FP>
struct SusceptibilityByAge {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 1.0);
    }
    static std::string name()
    {
        return "SusceptibilityByAge";
    }
};
 
template <class FP>
struct VaccineCoverage {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 0.0);
    }
    static std::string name()
    {
        return "VaccineCoverage";
    }
};
 
template <class FP>
struct VaccineEffectiveness {
    using Type = CustomIndexArray<UncertainValue<FP>, AgeGroup>;
    static Type get_default(AgeGroup size)
    {
        return Type(size, 0.0);
    }
    static std::string name()
    {
        return "VaccineEffectiveness";
    }
};
 
template <class FP>
struct SusceptibleFraction {
    using Type = UncertainValue<FP>;
    static Type get_default(AgeGroup)
    {
        return Type(1.0);
    }
    static std::string name()
    {
        return "SusceptibleFraction";
    }
};
 
template <class FP>
using ParametersBase =
    ParameterSet<BaselineTransmissibility<FP>, TimeExposed<FP>, TimeInfected<FP>, SeasonalityAmplitude<FP>,
                 SeasonalityShiftPerSubtype<FP>, SeasonalityShiftPerSeason<FP>, OutsideFoI<FP>, ClusteringExponent<FP>,
                 SickMixing<FP>, ContactPatternsHealthy<FP>, ContactPatternsSick<FP>, SusceptibilityByAge<FP>,
                 VaccineCoverage<FP>, VaccineEffectiveness<FP>, SusceptibleFraction<FP>>;
 
template <class FP>
class Parameters : public ParametersBase<FP>
{
public:
    Parameters(AgeGroup ng)
        : ParametersBase<FP>(ng)
        , m_num_groups{ng}
    {
    }
 
    AgeGroup get_num_groups() const
    {
        return m_num_groups;
    }
 
    bool apply_constraints()
    {
        const FP tol_times = 1e-1;
 
        bool corrected = false;
        if (this->template get<TimeExposed<FP>>() < 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>>(), tol_times);
            this->template get<TimeExposed<FP>>() = tol_times;
            corrected                             = true;
        }
        if (this->template get<TimeInfected<FP>>() < tol_times) {
            log_warning("Constraint check: Parameter TimeInfected 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<TimeInfected<FP>>(), tol_times);
            this->template get<TimeInfected<FP>>() = tol_times;
            corrected                              = true;
        }
        if (this->template get<ClusteringExponent<FP>>() <= 0.0) {
            log_warning("Constraint check: Parameter ClusteringExponent changed from {} to {}", //
                        this->template get<ClusteringExponent<FP>>(), 1.0);
            this->template get<ClusteringExponent<FP>>() = 1.0;
            corrected                                    = true;
        }
        if (this->template get<BaselineTransmissibility<FP>>() < 0.0) {
            log_warning("Constraint check: Parameter BaselineTransmissibility changed from {} to {}", //
                        this->template get<BaselineTransmissibility<FP>>(), 0.0);
            this->template get<BaselineTransmissibility<FP>>() = 0.0;
            corrected                                          = true;
        }
        if (this->template get<OutsideFoI<FP>>() < 0.0) {
            log_warning("Constraint check: Parameter OutsideFoI changed from {} to {}", //
                        this->template get<OutsideFoI<FP>>(), 0.0);
            this->template get<OutsideFoI<FP>>() = 0.0;
            corrected                            = true;
        }
        return corrected;
    }
 
    bool check_constraints() const
    {
        const FP tol_times = 1e-1;
 
        if (this->template get<TimeExposed<FP>>() < tol_times) {
            log_warning("Constraint check: Parameter TimeExposed {} smaller or equal {}. Please note that "
                        "unreasonably small compartment stays lead to massively increased run time. Consider to cancel "
                        "and reset parameters.",
                        this->template get<TimeExposed<FP>>(), tol_times);
            return true;
        }
        if (this->template get<TimeInfected<FP>>() < tol_times) {
            log_warning("Constraint check: Parameter TimeInfected {} smaller or equal {}. Please note that "
                        "unreasonably small compartment stays lead to massively increased run time. Consider to cancel "
                        "and reset parameters.",
                        this->template get<TimeInfected<FP>>(), tol_times);
            return true;
        }
        if (this->template get<ClusteringExponent<FP>>() <= 0.0) {
            log_error("Constraint check: Parameter ClusteringExponent {} smaller or equal {}", //
                      this->template get<ClusteringExponent<FP>>(), 0.0);
            return true;
        }
        if (this->template get<BaselineTransmissibility<FP>>() < 0.0) {
            log_error("Constraint check: Parameter BaselineTransmissibility {} smaller {}", //
                      this->template get<BaselineTransmissibility<FP>>(), 0.0);
            return true;
        }
        if (this->template get<OutsideFoI<FP>>() < 0.0) {
            log_error("Constraint check: Parameter OutsideFoI {} smaller {}", //
                      this->template get<OutsideFoI<FP>>(), 0.0);
            return true;
        }
        return false;
    }
 
private:
    AgeGroup m_num_groups;
};
 
} // namespace oseirv
} // namespace mio
#endif