466 add delay in testing and planned migration

cpp/examples/abm_history_object.cpp

@@ -125,14 +125,14 @@ int main()
     model.get_location(work).get_infection_parameters().set<mio::abm::MaximumContacts>(10);
 
     // People can get tested at work (and do this with 0.5 probability) from time point 0 to day 30.
-    auto testing_min_time      = mio::abm::days(1);
+    auto validity_period       = mio::abm::days(1);
     auto probability           = 0.5;
     auto start_date            = mio::abm::TimePoint(0);
     auto end_date              = mio::abm::TimePoint(0) + mio::abm::days(30);
     auto test_type             = mio::abm::TestType::Antigen;
     auto test_parameters       = model.parameters.get<mio::abm::TestData>()[test_type];
     auto testing_criteria_work = mio::abm::TestingCriteria();
-    auto testing_scheme_work   = mio::abm::TestingScheme(testing_criteria_work, testing_min_time, start_date, end_date,
+    auto testing_scheme_work   = mio::abm::TestingScheme(testing_criteria_work, validity_period, start_date, end_date,
                                                          test_parameters, probability);
     model.get_testing_strategy().add_testing_scheme(mio::abm::LocationType::Work, testing_scheme_work);
 

cpp/examples/abm_minimal.cpp

@@ -104,14 +104,14 @@ int main()
         .get<mio::abm::ContactRates>()[{age_group_15_to_34, age_group_15_to_34}] = 10.0;
 
     // People can get tested at work (and do this with 0.5 probability) from time point 0 to day 10.
-    auto testing_min_time      = mio::abm::days(1);
+    auto validity_period       = mio::abm::days(1);
     auto probability           = 0.5;
     auto start_date            = mio::abm::TimePoint(0);
     auto end_date              = mio::abm::TimePoint(0) + mio::abm::days(10);
     auto test_type             = mio::abm::TestType::Antigen;
     auto test_parameters       = model.parameters.get<mio::abm::TestData>()[test_type];
     auto testing_criteria_work = mio::abm::TestingCriteria();
-    auto testing_scheme_work   = mio::abm::TestingScheme(testing_criteria_work, testing_min_time, start_date, end_date,
+    auto testing_scheme_work   = mio::abm::TestingScheme(testing_criteria_work, validity_period, start_date, end_date,
                                                          test_parameters, probability);
     model.get_testing_strategy().add_testing_scheme(mio::abm::LocationType::Work, testing_scheme_work);
 

cpp/models/abm/README.md

@@ -98,7 +98,6 @@ add_household_group_to_model(model, twoPersonHousehold_group);
 During the simulation, people can get tested, and we have to specify the scheme for that:
 
 ```cpp
-auto testing_min_time = mio::abm::days(1);
 auto probability      = 0.5;
 auto start_date       = mio::abm::TimePoint(0);
 auto end_date         = mio::abm::TimePoint(0) + mio::abm::days(30);
@@ -107,7 +106,7 @@ auto test_at_work     = std::vector<mio::abm::LocationType>{mio::abm::LocationTy
 auto testing_criteria_work =
     std::vector<mio::abm::TestingCriteria>{mio::abm::TestingCriteria({}, test_at_work, {})};
 auto testing_scheme_work =
-    mio::abm::TestingScheme(testing_criteria_work, testing_min_time, start_date, end_date, test_type, probability);
+    mio::abm::TestingScheme(testing_criteria_work, start_date, end_date, test_type, probability);
 model.get_testing_strategy().add_testing_scheme(testing_scheme_work);
 ```
 

cpp/models/abm/parameters.h

@@ -42,7 +42,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.);
@@ -54,7 +54,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.);
@@ -66,7 +66,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.);
@@ -78,7 +78,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.);
@@ -90,7 +90,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.);
@@ -102,7 +102,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.);
@@ -114,7 +114,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.);
@@ -126,7 +126,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.);
@@ -138,7 +138,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.);
@@ -150,7 +150,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.);
@@ -211,7 +211,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.);
@@ -226,7 +226,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.);
@@ -311,38 +311,40 @@ struct HighViralLoadProtectionFactor {
  * @brief Parameters that describe the reliability of a test.
  */
 struct TestParameters {
-     UncertainValue<> sensitivity;
-     UncertainValue<> specificity;
+    UncertainValue<> sensitivity;
+    UncertainValue<> specificity;
+    TimeSpan required_time;
+    TestType type;
 
-     /**
+    /**
       * serialize this. 
       * @see mio::serialize
       */
-     template <class IOContext>
-     void serialize(IOContext& io) const
-     {
-         auto obj = io.create_object("TestParameters");
-         obj.add_element("Sensitivity", sensitivity);
-         obj.add_element("Specificity", specificity);
-     }
-
-     /**
+    template <class IOContext>
+    void serialize(IOContext& io) const
+    {
+        auto obj = io.create_object("TestParameters");
+        obj.add_element("Sensitivity", sensitivity);
+        obj.add_element("Specificity", specificity);
+    }
+
+    /**
       * deserialize an object of this class.
       * @see mio::deserialize
       */
-     template <class IOContext>
-     static IOResult<TestParameters> deserialize(IOContext& io)
-     {
-         auto obj  = io.expect_object("TestParameters");
-         auto sens = obj.expect_element("Sensitivity", mio::Tag<UncertainValue<>>{});
-         auto spec = obj.expect_element("Specificity", mio::Tag<UncertainValue<>>{});
-         return apply(
-             io,
-             [](auto&& sens_, auto&& spec_) {
-                 return TestParameters{sens_, spec_};
-             },
-             sens, spec);
-     }
+    template <class IOContext>
+    static IOResult<TestParameters> deserialize(IOContext& io)
+    {
+        auto obj  = io.expect_object("TestParameters");
+        auto sens = obj.expect_element("Sensitivity", mio::Tag<UncertainValue<>>{});
+        auto spec = obj.expect_element("Specificity", mio::Tag<UncertainValue<>>{});
+        return apply(
+            io,
+            [](auto&& sens_, auto&& spec_) {
+                return TestParameters{sens_, spec_};
+            },
+            sens, spec);
+    }
 };
 
 /**
@@ -353,9 +355,9 @@ struct TestData {
     static auto get_default(AgeGroup /*size*/)
     {
         Type default_val                 = Type({TestType::Count});
-        default_val[{TestType::Generic}] = TestParameters{0.9, 0.99};
-        default_val[{TestType::Antigen}] = TestParameters{0.8, 0.88};
-        default_val[{TestType::PCR}]     = TestParameters{0.9, 0.99};
+        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()
@@ -398,7 +400,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);

cpp/models/abm/person.cpp

@@ -39,13 +39,13 @@ Person::Person(mio::RandomNumberGenerator& rng, LocationType location_type, Loca
     , m_quarantine_start(TimePoint(-(std::numeric_limits<int>::max() / 2)))
     , m_age(age)
     , m_time_at_location(0)
-    , m_time_of_last_test(TimePoint(-(std::numeric_limits<int>::max() / 2)))
     , m_mask(Mask(MaskType::Community))
     , m_wears_mask(false)
     , m_mask_compliance((uint32_t)LocationType::Count, 0.)
     , m_person_id(person_id)
     , m_cells{0}
     , m_last_transport_mode(TransportMode::Unknown)
+    , m_test_results({TestType::Count}, TestResult())
 {
     m_random_workgroup        = UniformDistribution<double>::get_instance()(rng);
     m_random_schoolgroup      = UniformDistribution<double>::get_instance()(rng);
@@ -154,8 +154,7 @@ void Person::remove_quarantine()
 
 bool Person::get_tested(PersonalRandomNumberGenerator& rng, TimePoint t, const TestParameters& params)
 {
-    ScalarType random   = UniformDistribution<double>::get_instance()(rng);
-    m_time_of_last_test = t;
+    ScalarType random = UniformDistribution<double>::get_instance()(rng);
     if (is_infected(t)) {
         // true positive
         if (random < params.sensitivity) {
@@ -264,5 +263,16 @@ ScalarType Person::get_protection_factor(TimePoint t, VirusVariant virus, const
         t.days() - latest_protection.second.days());
 }
 
+void Person::add_test_result(TimePoint t, TestType type, bool result)
+{
+    // Remove outdated test results or replace the old result of the same type
+    m_test_results[{type}] = {t, result};
+}
+
+TestResult Person::get_test_result(TestType type) const
+{
+    return m_test_results[{type}];
+}
+
 } // namespace abm
 } // namespace mio

cpp/models/abm/person.h

@@ -29,6 +29,7 @@
 #include "abm/person_id.h"
 #include "abm/personal_rng.h"
 #include "abm/time.h"
+#include "abm/test_type.h"
 #include "abm/vaccine.h"
 #include "abm/mask.h"
 #include "abm/mobility_data.h"
@@ -155,15 +156,6 @@ class Person
         m_time_at_location += dt;
     }
 
-    /**
-     * @brief Get the TimePoint of the last negative test.
-     * @return TimePoint since the last test.
-     */
-    TimePoint get_time_of_last_test() const
-    {
-        return m_time_of_last_test;
-    }
-
     /**
      * @brief Set an assigned Location of the Person.
      *
@@ -391,7 +383,7 @@ class Person
     }
 
     /**
-     * @brief Get the latest #Infection or #Vaccination and its initial TimePoint of the Person.
+     * @brief Get the latest #ExposureType and its initial TimePoint of the Person.
      */
     std::pair<ExposureType, TimePoint> get_latest_protection() const;
 
@@ -427,6 +419,22 @@ class Person
             loc, age, id);
     }
 
+    /**
+     * @brief Add TestResult to the Person
+     * @param[in] t The TimePoint of the test.
+     * @param[in] type The TestType of the test.
+     * @param[in] result The result of the test.
+    */
+    void add_test_result(TimePoint t, TestType type, bool result);
+
+    /**
+     * @brief Get the most recent TestResult performed from the Person based on the TestType.
+     * If time_of_testing == TimePoint(std::numeric_limits<int>::min()), there is no previous TestResult.
+     * @param[in] type The TestType of the test.
+     * @return The latest TestResult of the given Type.
+    */
+    TestResult get_test_result(TestType type) const;
+
 private:
     LocationId m_location; ///< Current Location of the Person.
     LocationType m_location_type; ///< Type of the current Location.
@@ -441,14 +449,14 @@ class Person
     double m_random_schoolgroup; ///< Value to determine if the Person goes to school or stays at home during lockdown.
     double m_random_goto_work_hour; ///< Value to determine at what time the Person goes to work.
     double m_random_goto_school_hour; ///< Value to determine at what time the Person goes to school.
-    TimePoint m_time_of_last_test; ///< TimePoint of the last negative test.
     Mask m_mask; ///< The Mask of the Person.
     bool m_wears_mask = false; ///< Whether the Person currently wears a Mask.
     std::vector<ScalarType> m_mask_compliance; ///< Vector of Mask compliance values for all #LocationType%s.
     PersonId 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, TestType> m_test_results; ///< CustomIndexArray for TestResults.
 };
 
 } // namespace abm

cpp/models/abm/test_type.h

@@ -22,7 +22,7 @@
 #define MIO_ABM_TEST_TYPE_H
 
 #include <cstdint>
-
+#include <limits>
 namespace mio
 {
 namespace abm
@@ -40,6 +40,14 @@ enum class TestType : std::uint32_t
     Count
 };
 
+/**
+* @brief The TestResult of a Person.
+*/
+struct TestResult {
+    TimePoint time_of_testing{std::numeric_limits<int>::min()}; ///< The TimePoint when the Person performs the test.
+    bool result{false}; ///< The test result.
+};
+
 } // namespace abm
 } // namespace mio