Line data    Source code

       1             : /*
       2             : * Copyright (C) 2020-2024 MEmilio
       3             : *
       4             : * Authors: Ralf Hannemann-Tamas
       5             : *
       6             : * Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
       7             : *
       8             : * Licensed under the Apache License, Version 2.0 (the "License");
       9             : * you may not use this file except in compliance with the License.
      10             : * You may obtain a copy of the License at
      11             : *
      12             : *     http://www.apache.org/licenses/LICENSE-2.0
      13             : *
      14             : * Unless required by applicable law or agreed to in writing, software
      15             : * distributed under the License is distributed on an "AS IS" BASIS,
      16             : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      17             : * See the License for the specific language governing permissions and
      18             : * limitations under the License.
      19             : */
      20             : 
      21             : #ifndef ODESEAIR_PARAMETERS_H
      22             : #define ODESEAIR_PARAMETERS_H
      23             : 
      24             : #include "memilio/utils/parameter_set.h"
      25             : #include "memilio/utils/logging.h"
      26             : 
      27             : namespace mio
      28             : {
      29             : namespace oseair
      30             : {
      31             : 
      32             : /****************************************
      33             :  * Define Parameters of the SEAIR model *
      34             :  ****************************************/
      35             : 
      36             : /**
      37             :  * @brief Social distancing.
      38             :  */
      39             : template <typename FP = double>
      40             : struct SocialDistancing {
      41             :     using Type = FP;
      42          56 :     static Type get_default()
      43             :     {
      44          56 :         return Type(0.2);
      45             :     }
      46             :     static std::string name()
      47             :     {
      48             :         return "SocialDistancing";
      49             :     }
      50             : };
      51             : 
      52             : /**
      53             :  * @brief Quarantining.
      54             :  */
      55             : template <typename FP = double>
      56             : struct Quarantined {
      57             :     using Type = FP;
      58          56 :     static Type get_default()
      59             :     {
      60          56 :         return Type(0.2);
      61             :     }
      62             :     static std::string name()
      63             :     {
      64             :         return "Quarantined";
      65             :     }
      66             : };
      67             : 
      68             : /**
      69             :  * @brief Rate of testing.
      70             :  */
      71             : template <typename FP = double>
      72             : struct TestingRate {
      73             :     using Type = FP;
      74          56 :     static Type get_default()
      75             :     {
      76          56 :         return Type(0.2);
      77             :     }
      78             :     static std::string name()
      79             :     {
      80             :         return "TestingRate";
      81             :     }
      82             : };
      83             : 
      84             : /**
      85             :  * @brief Recovery rate.
      86             :  */
      87             : template <typename FP = double>
      88             : struct RecoveryRate {
      89             :     using Type = FP;
      90          56 :     static Type get_default()
      91             :     {
      92          56 :         return Type(0.0067);
      93             :     }
      94             :     static std::string name()
      95             :     {
      96             :         return "RecoveryRate";
      97             :     }
      98             : };
      99             : 
     100             : /**
     101             :  * @brief Death Rate.
     102             :  */
     103             : template <typename FP = double>
     104             : struct DeathRate {
     105             :     using Type = FP;
     106          56 :     static Type get_default()
     107             :     {
     108          56 :         return Type(0.0041);
     109             :     }
     110             :     static std::string name()
     111             :     {
     112             :         return "DeathRate";
     113             :     }
     114             : };
     115             : 
     116             : /**
     117             :  * @brief Inverse of the latent period of the virus.
     118             :  */
     119             : template <typename FP = double>
     120             : struct TimeExposed {
     121             :     using Type = FP;
     122          56 :     static Type get_default()
     123             :     {
     124          56 :         return Type(0.5);
     125             :     }
     126             :     static std::string name()
     127             :     {
     128             :         return "TimeExposed";
     129             :     }
     130             : };
     131             : 
     132             : /**
     133             :  * @brief Infectious period for unconfirmed infected people.
     134             :  */
     135             : template <typename FP = double>
     136             : struct RecoveryRateFromAsymptomatic {
     137             :     using Type = FP;
     138          56 :     static Type get_default()
     139             :     {
     140          56 :         return Type(0.1);
     141             :     }
     142             :     static std::string name()
     143             :     {
     144             :         return "RecoveryRateFromAsymptomatic";
     145             :     }
     146             : };
     147             : 
     148             : /**
     149             :  * @brief Rate recovered people become susceptible again.
     150             :  */
     151             : template <typename FP = double>
     152             : struct TimeRecoveredInv {
     153             :     using Type = FP;
     154          56 :     static Type get_default()
     155             :     {
     156          56 :         return Type(0.0);
     157             :     }
     158             :     static std::string name()
     159             :     {
     160             :         return "TimeRecoveredInv";
     161             :     }
     162             : };
     163             : 
     164             : template <typename FP = double>
     165             : using ParametersBase =
     166             :     ParameterSet<SocialDistancing<FP>, Quarantined<FP>, TestingRate<FP>, RecoveryRate<FP>, DeathRate<FP>,
     167             :                  TimeExposed<FP>, RecoveryRateFromAsymptomatic<FP>, TimeRecoveredInv<FP>>;
     168             : 
     169             : /**
     170             :  * @brief Parameters of an SEAIR model.
     171             :  */
     172             : template <typename FP = double>
     173             : class Parameters : public ParametersBase<FP>
     174             : {
     175             : public:
     176          56 :     Parameters()
     177          56 :         : ParametersBase<FP>()
     178             :     {
     179          56 :     }
     180             : 
     181             :     /**
     182             :      * @brief Checks whether all Parameters satisfy their corresponding constraints and logs an error 
     183             :      * if constraints are not satisfied.
     184             :      * @return Returns true if one constraint is not satisfied, otherwise false. 
     185             :      */
     186         137 :     bool check_constraints() const
     187             :     {
     188         137 :         if (this->template get<SocialDistancing<FP>>() < 0.0) {
     189          18 :             log_error("Constraint check: Parameter SocialDistancing smaller {:d}", 0);
     190           9 :             return true;
     191             :         }
     192             : 
     193         128 :         if (this->template get<Quarantined<FP>>() < 0.0) {
     194          18 :             log_error("Constraint check: Parameter Quarantined smaller {:d}", 0);
     195           9 :             return true;
     196             :         }
     197             : 
     198         119 :         const double tol_times = 1e-1; // accepted tolerance for compartment stays
     199         119 :         if (this->template get<TimeExposed<FP>>() < tol_times) {
     200          18 :             log_error("Constraint check: Parameter TimeExposed {:.4f} smaller {:.4f}. Please "
     201             :                       "note that unreasonably small compartment stays lead to massively increased run time. "
     202             :                       "Consider to cancel and reset parameters.",
     203           9 :                       this->template get<TimeExposed<FP>>(), tol_times);
     204           9 :             return true;
     205             :         }
     206             : 
     207         110 :         if (this->template get<RecoveryRateFromAsymptomatic<FP>>() < 0.0) {
     208          18 :             log_error("Constraint check: Parameter RecoveryRateFromAsymptomatic smaller {:d}", 0);
     209           9 :             return true;
     210             :         }
     211             : 
     212         101 :         if (this->template get<TestingRate<FP>>() < 0.0) {
     213          18 :             log_error("Constraint check: Parameter TestingRate smaller {:d}", 0);
     214           9 :             return true;
     215             :         }
     216             : 
     217          92 :         if (this->template get<RecoveryRate<FP>>() < 0.0) {
     218          18 :             log_error("Constraint check: Parameter RecoveryRate smaller {:d}", 0);
     219           9 :             return true;
     220             :         }
     221             : 
     222          83 :         if (this->template get<DeathRate<FP>>() < 0.0) {
     223          18 :             log_error("Constraint check: Parameter DeathRate smaller {:d}", 0);
     224           9 :             return true;
     225             :         }
     226             : 
     227          74 :         if (this->template get<TimeRecoveredInv<FP>>() < 0.0) {
     228          18 :             log_error("Constraint check: Parameter TimeRecoveredInv smaller {:d}", 0);
     229           9 :             return true;
     230             :         }
     231             : 
     232          65 :         return false;
     233             :     }
     234             : 
     235             : private:
     236             :     Parameters(ParametersBase<FP>&& base)
     237             :         : ParametersBase<FP>(std::move(base))
     238             :     {
     239             :     }
     240             : 
     241             : public:
     242             :     /**
     243             :      * deserialize an object of this class.
     244             :      * @see mio::deserialize
     245             :      */
     246             :     template <class IOContext>
     247             :     static IOResult<Parameters> deserialize(IOContext& io)
     248             :     {
     249             :         BOOST_OUTCOME_TRY(auto&& base, ParametersBase<FP>::deserialize(io));
     250             :         return success(Parameters(std::move(base)));
     251             :     }
     252             : };
     253             : 
     254             : } // namespace oseair
     255             : } // namespace mio
     256             : 
     257             : #endif // ODESEAIR_PARAMETERS_H