466 add delay in testing and planned migration

cpp/models/abm/analyze_result.h

@@ -195,6 +195,10 @@ std::vector<Model> ensemble_params_percentile(const std::vector<std::vector<Mode
             static auto result = model.parameters.template get<LockdownDate>().days();
             return result;
         });
+        param_percentil(node, [](auto&& model) -> auto& {
+            static auto result = model.parameters.template get<PlanAheadTime>().days();
+            return result;
+        });
     }
 
     return percentile;

cpp/models/abm/parameters.h

@@ -43,7 +43,7 @@ namespace abm
  * @brief Time that a Person is infected but not yet infectious.
  */
 struct IncubationPeriod {
-    using Type = CustomIndexArray< UncertainValue<>, VirusVariant, AgeGroup>;
+    using Type = CustomIndexArray<UncertainValue<>, VirusVariant, AgeGroup>;
     static Type get_default(AgeGroup size)
     {
         return Type({VirusVariant::Count, size}, 1.);
@@ -55,7 +55,7 @@ struct IncubationPeriod {
 };
 
 struct InfectedNoSymptomsToSymptoms {
-    using Type = CustomIndexArray< UncertainValue<>, VirusVariant, AgeGroup>;
+    using Type = CustomIndexArray<UncertainValue<>, VirusVariant, AgeGroup>;
     static Type get_default(AgeGroup size)
     {
         return Type({VirusVariant::Count, size}, 1.);
@@ -67,7 +67,7 @@ struct InfectedNoSymptomsToSymptoms {
 };
 
 struct InfectedNoSymptomsToRecovered {
-    using Type = CustomIndexArray< UncertainValue<>, VirusVariant, AgeGroup>;
+    using Type = CustomIndexArray<UncertainValue<>, VirusVariant, AgeGroup>;
     static Type get_default(AgeGroup size)
     {
         return Type({VirusVariant::Count, size}, 1.);
@@ -79,7 +79,7 @@ struct InfectedNoSymptomsToRecovered {
 };
 
 struct InfectedSymptomsToRecovered {
-    using Type = CustomIndexArray< UncertainValue<>, VirusVariant, AgeGroup>;
+    using Type = CustomIndexArray<UncertainValue<>, VirusVariant, AgeGroup>;
     static Type get_default(AgeGroup size)
     {
         return Type({VirusVariant::Count, size}, 1.);
@@ -91,7 +91,7 @@ struct InfectedSymptomsToRecovered {
 };
 
 struct InfectedSymptomsToSevere {
-    using Type = CustomIndexArray< UncertainValue<>, VirusVariant, AgeGroup>;
+    using Type = CustomIndexArray<UncertainValue<>, VirusVariant, AgeGroup>;
     static Type get_default(AgeGroup size)
     {
         return Type({VirusVariant::Count, size}, 1.);
@@ -103,7 +103,7 @@ struct InfectedSymptomsToSevere {
 };
 
 struct SevereToCritical {
-    using Type = CustomIndexArray< UncertainValue<>, VirusVariant, AgeGroup>;
+    using Type = CustomIndexArray<UncertainValue<>, VirusVariant, AgeGroup>;
     static Type get_default(AgeGroup size)
     {
         return Type({VirusVariant::Count, size}, 1.);
@@ -115,7 +115,7 @@ struct SevereToCritical {
 };
 
 struct SevereToRecovered {
-    using Type = CustomIndexArray< UncertainValue<>, VirusVariant, AgeGroup>;
+    using Type = CustomIndexArray<UncertainValue<>, VirusVariant, AgeGroup>;
     static Type get_default(AgeGroup size)
     {
         return Type({VirusVariant::Count, size}, 1.);
@@ -127,7 +127,7 @@ struct SevereToRecovered {
 };
 
 struct CriticalToRecovered {
-    using Type = CustomIndexArray< UncertainValue<>, VirusVariant, AgeGroup>;
+    using Type = CustomIndexArray<UncertainValue<>, VirusVariant, AgeGroup>;
     static Type get_default(AgeGroup size)
     {
         return Type({VirusVariant::Count, size}, 1.);
@@ -139,7 +139,7 @@ struct CriticalToRecovered {
 };
 
 struct CriticalToDead {
-    using Type = CustomIndexArray< UncertainValue<>, VirusVariant, AgeGroup>;
+    using Type = CustomIndexArray<UncertainValue<>, VirusVariant, AgeGroup>;
     static Type get_default(AgeGroup size)
     {
         return Type({VirusVariant::Count, size}, 1.);
@@ -151,7 +151,7 @@ struct CriticalToDead {
 };
 
 struct RecoveredToSusceptible {
-    using Type = CustomIndexArray< UncertainValue<>, VirusVariant, AgeGroup>;
+    using Type = CustomIndexArray<UncertainValue<>, VirusVariant, AgeGroup>;
     static Type get_default(AgeGroup size)
     {
         return Type({VirusVariant::Count, size}, 1.);
@@ -212,7 +212,7 @@ struct InfectivityDistributions {
  * @brief Probability that an Infection is detected.
  */
 struct DetectInfection {
-    using Type = CustomIndexArray< UncertainValue<>, VirusVariant, AgeGroup>;
+    using Type = CustomIndexArray<UncertainValue<>, VirusVariant, AgeGroup>;
     static Type get_default(AgeGroup size)
     {
         return Type({VirusVariant::Count, size}, 1.);
@@ -227,7 +227,7 @@ struct DetectInfection {
  * @brief Effectiveness of a Mask of a certain MaskType% against an Infection%.
  */
 struct MaskProtection {
-    using Type = CustomIndexArray< UncertainValue<>, MaskType>;
+    using Type = CustomIndexArray<UncertainValue<>, MaskType>;
     static Type get_default(AgeGroup /*size*/)
     {
         return Type({MaskType::Count}, 1.);
@@ -308,19 +308,34 @@ struct HighViralLoadProtectionFactor {
     }
 };
 
+/** 
+ * @brief The index for all the testing types.
+ * Can be used as 0-based index.
+ */
+enum class TestingTypeIndex : std::uint32_t
+{
+    GenericTest = 0,
+    AntigenTest = 1,
+    PCRTest     = 2,
+    Count //last!!
+};
+
 /**
  * @brief Parameters that describe the reliability of a test.
  */
 struct TestParameters {
-     UncertainValue<> sensitivity;
-     UncertainValue<> specificity;
+    UncertainValue<> sensitivity;
+    UncertainValue<> specificity;
+    TimeSpan required_time;
+    TimeSpan validity_period;
+    TestingTypeIndex test_type;
 };
 
 struct GenericTest {
     using Type = TestParameters;
     static Type get_default()
     {
-        return Type{0.9, 0.99};
+        return Type{0.9, 0.99, hours(24), hours(24), TestingTypeIndex::GenericTest};
     }
     static std::string name()
     {
@@ -329,13 +344,13 @@ struct GenericTest {
 };
 
 /**
- * @brief Reliability of an AntigenTest.
+ * @brief Parameters of an AntigenTest.
  */
 struct AntigenTest : public GenericTest {
     using Type = TestParameters;
     static Type get_default()
     {
-        return Type{0.8, 0.88};
+        return Type{0.8, 0.88, minutes(30), hours(24), TestingTypeIndex::AntigenTest};
     }
     static std::string name()
     {
@@ -350,7 +365,7 @@ struct PCRTest : public GenericTest {
     using Type = TestParameters;
     static Type get_default()
     {
-        return Type{0.9, 0.99};
+        return Type{0.9, 0.99, days(1), days(3), TestingTypeIndex::PCRTest};
     }
     static std::string name()
     {
@@ -392,7 +407,7 @@ struct QuarantineDuration {
  * @brief Parameter for the exponential distribution to decide if a Person goes shopping.
  */
 struct BasicShoppingRate {
-    using Type = CustomIndexArray< UncertainValue<>, AgeGroup>;
+    using Type = CustomIndexArray<UncertainValue<>, AgeGroup>;
     static auto get_default(AgeGroup size)
     {
         return Type({size}, 1.0);
@@ -538,14 +553,30 @@ struct AgeGroupGotoWork {
     }
 };
 
+/**
+ * @brief The TimeSpan agents plan forward to take tests.  
+ */
+struct PlanAheadTime {
+    using Type = TimeSpan;
+    static Type get_default(AgeGroup /*size*/)
+    {
+        return TimeSpan(seconds(0));
+    }
+    static std::string name()
+    {
+        return "PlanAheadTime";
+    }
+};
+
 using ParametersBase =
     ParameterSet<IncubationPeriod, InfectedNoSymptomsToSymptoms, InfectedNoSymptomsToRecovered,
                  InfectedSymptomsToRecovered, InfectedSymptomsToSevere, SevereToCritical, SevereToRecovered,
                  CriticalToDead, CriticalToRecovered, RecoveredToSusceptible, ViralLoadDistributions,
                  InfectivityDistributions, DetectInfection, MaskProtection, AerosolTransmissionRates, LockdownDate,
                  QuarantineDuration, SocialEventRate, BasicShoppingRate, WorkRatio, SchoolRatio, GotoWorkTimeMinimum,
                  GotoWorkTimeMaximum, GotoSchoolTimeMinimum, GotoSchoolTimeMaximum, AgeGroupGotoSchool,
-                 AgeGroupGotoWork, InfectionProtectionFactor, SeverityProtectionFactor, HighViralLoadProtectionFactor>;
+                 AgeGroupGotoWork, InfectionProtectionFactor, SeverityProtectionFactor, HighViralLoadProtectionFactor,
+                 PlanAheadTime>;
 
 /**
  * @brief Maximum number of Person%s an infectious Person can infect at the respective Location.
@@ -742,6 +773,11 @@ class Parameters : public ParametersBase
             return true;
         }
 
+        if (this->get<PlanAheadTime>().seconds() < 0.0) {
+            log_error("Constraint check: Parameter PlanAheadTime smaller {:d}", 0);
+            return true;
+        }
+
         return false;
     }
 

cpp/models/abm/person.cpp

@@ -45,6 +45,9 @@ Person::Person(mio::RandomNumberGenerator& rng, Location& location, AgeGroup age
     , m_person_id(person_id)
     , m_cells{0}
     , m_last_transport_mode(TransportMode::Unknown)
+    , m_test_results({TestingTypeIndex::Count}, TestResult())
+    , m_migration_planning()
+    , m_planned_time(TimePoint(-1))
 {
     m_random_workgroup        = UniformDistribution<double>::get_instance()(rng);
     m_random_schoolgroup      = UniformDistribution<double>::get_instance()(rng);
@@ -292,5 +295,38 @@ ScalarType Person::get_protection_factor(TimePoint t, VirusVariant virus, const
         t.days() - latest_protection.second.days());
 }
 
+void Person::add_test_result(TimePoint t, TestingTypeIndex type_index, bool result)
+{
+    TestResult test_result;
+    test_result.time_of_testing = t;
+    test_result.type            = type_index;
+    test_result.result          = result;
+    // Remove outdated test results or replace the old result of the same type
+    m_test_results[{type_index}] = test_result;
+}
+
+const Person::TestResult Person::get_test_result(TestingTypeIndex type_index) const
+{
+    return m_test_results[{type_index}];
+}
+
+void Person::add_migration_plan(TimePoint t, Location& location)
+{
+    std::pair<TimePoint, Location&> new_plan = {t, location};
+    m_migration_planning.push_back(new_plan);
+    m_planned_time = t;
+}
+
+std::vector<std::pair<TimePoint, Location&>> Person::get_migration_plan(TimePoint from_time, TimePoint to_time)
+{
+    std::vector<std::pair<TimePoint, Location&>> result;
+    for (auto plan : m_migration_planning) {
+        if (plan.first >= from_time && plan.first < to_time) {
+            result.push_back(plan);
+        }
+    }
+    return result;
+}
+
 } // namespace abm
 } // namespace mio

cpp/models/abm/person.h

@@ -145,6 +145,15 @@ class Person
         return (m_person_id == other.m_person_id);
     }
 
+    /**
+     * @brief The TestResult of a Person.
+     */
+    struct TestResult {
+        TimePoint time_of_testing; ///< The TimePoint when the Person performs the test.
+        TestingTypeIndex type = TestingTypeIndex::Count; ///< The TestingTypeIndex of the test.
+        bool result; ///< The result of the test.
+    };
+
     /** 
      * @brief Time passes and the Person interacts with the population at its current Location.
      * The Person might become infected.
@@ -473,6 +482,11 @@ class Person
     */
     std::pair<ExposureType, TimePoint> get_latest_protection() const;
 
+    /**
+     * @brief Get the latest #Infection or #Vaccination and its initial TimePoint of the Person. 
+    */
+    bool has_valid_test(TimePoint t) const;
+
     /**
      * serialize this. 
      * @see mio::serialize
@@ -505,6 +519,43 @@ class Person
             loc, age, id);
     }
 
+    /**
+     * @brief Add TestResult to the Person
+     * @param[in] t The TimePoint of the result.
+     * @param[in] type The TestingTypeIndex of the result.
+     * @param[in] result The result of the test.
+    */
+    void add_test_result(TimePoint t, TestingTypeIndex type, bool result);
+
+    /**
+     * @brief Get the most recent TestResult performed from the Person based on the TestType.
+     * @param[in] type The TestingTypeIndex of the result.
+    */
+    const TestResult get_test_result(TestingTypeIndex type) const;
+
+    /**
+     * @brief Get the latest #Infection or #Vaccination and its initial TimePoint of the Person. 
+     * @param[in] t TimePoint of the migration plan.
+     * @param[in] location Location of the destination of the migration plan.
+    */
+    void add_migration_plan(TimePoint t, Location& location);
+
+    /**
+     * @brief Get all the migration plans between a certain time interval.
+     * @param[in] from_time TimePoint of the migration plan.
+     * @param[in] to_time TimePoint of the migration plan.
+     * @return The vector of all the migration plans between mentioned time period.
+    */
+    std::vector<std::pair<TimePoint, Location&>> get_migration_plan(TimePoint from_time, TimePoint to_time);
+
+    /**
+     * @brief Get the agent's lastest TimePoint of its planning.
+     * @return The agent's lastest TimePoint of its planning.
+    */
+    TimePoint get_planned_time() {
+        return m_planned_time;
+    }
+
 private:
     observer_ptr<Location> m_location; ///< Current Location of the Person.
     std::vector<uint32_t> m_assigned_locations; /**! Vector with the indices of the assigned Locations so that the 
@@ -525,7 +576,11 @@ class Person
     uint32_t m_person_id; ///< Id of the Person.
     std::vector<uint32_t> m_cells; ///< Vector with all Cell%s the Person visits at its current Location.
     mio::abm::TransportMode m_last_transport_mode; ///< TransportMode the Person used to get to its current Location.
-    Counter<uint32_t> m_rng_counter{0}; ///< counter for RandomNumberGenerator
+    Counter<uint32_t> m_rng_counter{0}; ///< counter for RandomNumberGenerator.
+    CustomIndexArray<TestResult, TestingTypeIndex> m_test_results; ///< CustomIndexArray for TestResults.
+    std::vector<std::pair<TimePoint, Location&>>
+        m_migration_planning; ///< Vector to store all migration plans (pairs of TimePoint and Location).
+    TimePoint m_planned_time; ///< TimePoint of the last recored planning.
 };
 
 } // namespace abm

cpp/models/abm/testing_strategy.cpp

@@ -172,7 +172,6 @@ bool TestingStrategy::run_strategy(Person::RandomNumberGenerator& rng, Person& p
     if (location.get_type() == mio::abm::LocationType::Home) {
         return true;
     }
-
     //lookup schemes for this specific location as well as the location type
     //lookup in std::vector instead of std::map should be much faster unless for large numbers of schemes
     for (auto loc_key : {LocationId{location.get_index(), location.get_type()},
@@ -185,7 +184,17 @@ bool TestingStrategy::run_strategy(Person::RandomNumberGenerator& rng, Person& p
             //apply all testing schemes that are found
             auto& schemes = iter_schemes->second;
             if (!std::all_of(schemes.begin(), schemes.end(), [&rng, &person, t](TestingScheme& ts) {
-                    return !ts.is_active() || ts.run_scheme(rng, person, t);
+                    auto test_result = person.get_test_result(ts.get_type().get_default().test_type);
+                    // If the agent has a test result valid until now, use the result directly
+                    if ((test_result.type != TestingTypeIndex::Count) &&
+                        (test_result.time_of_testing + ts.get_type().get_default().validity_period >= t)) {
+                        return test_result.result;
+                    }
+                    // If not, perform the test and save result
+                    auto result = !ts.is_active() || ts.run_scheme(rng, person, t);
+                    person.add_test_result(t + ts.get_type().get_default().required_time,
+                                           ts.get_type().get_default().test_type, result);
+                    return result;
                 })) {
                 return false;
             }