Improvements according to review --- IGNORE ---

DavidKerkmann · DavidKerkmann · commit 6bc0825c27a1 · 2025-11-03T13:09:35.000+01:00
diff --git a/cpp/models/abm/analyze_result.h b/cpp/models/abm/analyze_result.h
@@ -169,10 +169,6 @@ std::vector<Model> ensemble_params_percentile(const std::vector<std::vector<Mode
                     return model.parameters.template get<DeathsPerInfectedCritical>()[{virus_variant, age_group}];
                 });
 
-                param_percentile(node, [age_group, virus_variant](auto&& model) -> auto& {
-                    return model.parameters.template get<DetectInfection>()[{virus_variant, age_group}];
-                });
-
                 param_percentile(node, [virus_variant](auto&& model) -> auto& {
                     return model.parameters.template get<AerosolTransmissionRates>()[{virus_variant}];
                 });
@@ -187,9 +183,9 @@ std::vector<Model> ensemble_params_percentile(const std::vector<std::vector<Mode
                         return dist1.viral_load_peak < dist2.viral_load_peak;
                     });
                 param_percentile_dist(
-                    node, std::vector<ViralShedParameters>(num_runs),
+                    node, std::vector<ViralShedTuple>(num_runs),
                     [age_group, virus_variant](auto&& model) -> auto& {
-                        return model.parameters.template get<ViralShedDistribution>()[{virus_variant, age_group}];
+                        return model.parameters.template get<ViralShedParameters>()[{virus_variant, age_group}];
                     },
                     [](auto& dist1, auto& dist2) {
                         return dist1.virus_shed_alpha < dist2.virus_shed_alpha;
diff --git a/cpp/models/abm/infection.cpp b/cpp/models/abm/infection.cpp
@@ -31,7 +31,7 @@ namespace abm
 void Infection::initialize_viral_load(PersonalRandomNumberGenerator& rng, VirusVariant virus, AgeGroup age,
                                       const Parameters& params, TimePoint init_date, ProtectionEvent latest_protection)
 {
-    auto vl_params                    = params.get<ViralLoadDistributions>()[{virus, age}];
+    auto& vl_params                   = params.get<ViralLoadDistributions>()[{virus, age}];
     ScalarType high_viral_load_factor = 1;
 
     if (latest_protection.type != ProtectionType::NoProtection) {
@@ -49,7 +49,7 @@ void Infection::initialize_viral_load(PersonalRandomNumberGenerator& rng, VirusV
 void Infection::initialize_viral_shed(PersonalRandomNumberGenerator& rng, VirusVariant virus, AgeGroup age,
                                       const Parameters& params)
 {
-    auto viral_shed_params = params.get<ViralShedDistribution>()[{virus, age}];
+    auto viral_shed_params = params.get<ViralShedParameters>()[{virus, age}];
     m_log_norm_alpha       = viral_shed_params.viral_shed_alpha;
     m_log_norm_beta        = viral_shed_params.viral_shed_beta;
 
@@ -349,8 +349,8 @@ TimePoint Infection::draw_infection_course_forward(PersonalRandomNumberGenerator
 {
     TimePoint start_of_init_state = init_date; // since there is no state transition from Recovered or Dead
     bool init                     = true; // the random start time of the first state cannot be drawn
-    auto& uniform_dist =
-        UniformDistribution<double>::get_instance(); // thus, just use the init_date as the start for this
+    // thus, just use the init_date as the start for this
+    auto& init_state_dist = params.get<InitialInfectionStateDistributions>()[{m_virus_variant, age, start_state}];
 
     TimePoint current_time       = init_date;
     InfectionState current_state = start_state;
@@ -360,7 +360,7 @@ TimePoint Infection::draw_infection_course_forward(PersonalRandomNumberGenerator
         StateTransition transition =
             get_forward_transition(rng, age, params, current_state, current_time, latest_protection);
         if (init && current_state != InfectionState::Susceptible) { // random init within first time period
-            ScalarType p = uniform_dist(rng);
+            ScalarType p = init_state_dist.get(rng);
             start_of_init_state -= transition.duration.multiply(1 - p);
             transition.duration = transition.duration.multiply(p);
             init                = false;
diff --git a/cpp/models/abm/parameters.h b/cpp/models/abm/parameters.h
@@ -22,6 +22,7 @@
 
 #include "abm/mask_type.h"
 #include "abm/time.h"
+#include "abm/infection_state.h"
 #include "abm/virus_variant.h"
 #include "abm/protection_event.h"
 #include "abm/protection_event.h"
@@ -276,6 +277,23 @@ struct DeathsPerInfectedCritical {
     }
 };
 
+/**
+ * @brief Distributions of the time that people have been in their initial infection state at the beginning of the simulation.
+ * This makes it possible to draw from a user-defined distribution instead of drawing from a uniform distribution.
+ */
+struct InitialInfectionStateDistributions {
+    using Type = CustomIndexArray<AbstractParameterDistribution, VirusVariant, AgeGroup, InfectionState>;
+    static Type get_default(AgeGroup size)
+    {
+        return Type({VirusVariant::Count, size, InfectionState::Count},
+                    AbstractParameterDistribution(ParameterDistributionUniform(0., 1.)));
+    }
+    static std::string name()
+    {
+        return "InitialInfectionStateDistributions";
+    }
+};
+
 /**
  * @brief Parameters for the ViralLoad course. Default values taken as constant values from the average from
  * https://github.com/VirologyCharite/SARS-CoV-2-VL-paper/tree/main
@@ -317,29 +335,29 @@ struct ViralLoadDistributions {
  * @brief Parameters for the viral shed. Default values taken as constant values that match the graph 2C from
  * https://github.com/VirologyCharite/SARS-CoV-2-VL-paper/tree/main
 */
-struct ViralShedParameters {
+struct ViralShedTuple {
     ScalarType viral_shed_alpha;
     ScalarType viral_shed_beta;
 
     /// This method is used by the default serialization feature.
     auto default_serialize()
     {
-        return Members("ViralShedParameters")
+        return Members("ViralShedTuple")
             .add("viral_shed_alpha", viral_shed_alpha)
             .add("viral_shed_beta", viral_shed_beta);
     }
 };
 
-struct ViralShedDistribution {
-    using Type = CustomIndexArray<ViralShedParameters, VirusVariant, AgeGroup>;
+struct ViralShedParameters {
+    using Type = CustomIndexArray<ViralShedTuple, VirusVariant, AgeGroup>;
     static Type get_default(AgeGroup size)
     {
-        Type default_val({VirusVariant::Count, size}, ViralShedParameters{-7., 1.});
+        Type default_val({VirusVariant::Count, size}, ViralShedTuple{-7., 1.});
         return default_val;
     }
     static std::string name()
     {
-        return "ViralShedDistribution";
+        return "ViralShedParameters";
     }
 };
 
@@ -375,21 +393,6 @@ struct InfectionRateFromViralShed {
     }
 };
 
-/**
- * @brief Probability that an Infection is detected.
- */
-struct DetectInfection {
-    using Type = CustomIndexArray<UncertainValue<ScalarType>, VirusVariant, AgeGroup>;
-    static Type get_default(AgeGroup size)
-    {
-        return Type({VirusVariant::Count, size}, 1.);
-    }
-    static std::string name()
-    {
-        return "DetectInfection";
-    }
-};
-
 /**
  * @brief Effectiveness of a Mask of a certain MaskType% against an Infection%.
  */
@@ -715,12 +718,13 @@ using ParametersBase =
                  TimeInfectedSymptomsToSevere, TimeInfectedSymptomsToRecovered, TimeInfectedSevereToCritical,
                  TimeInfectedSevereToRecovered, TimeInfectedSevereToDead, TimeInfectedCriticalToDead,
                  TimeInfectedCriticalToRecovered, SymptomsPerInfectedNoSymptoms, SeverePerInfectedSymptoms,
-                 CriticalPerInfectedSevere, DeathsPerInfectedSevere, DeathsPerInfectedCritical, ViralLoadDistributions,
-                 ViralShedDistribution, ViralShedFactor, InfectionRateFromViralShed, DetectInfection, MaskProtection, AerosolTransmissionRates,
-                 LockdownDate, QuarantineDuration, QuarantineEffectiveness, SocialEventRate, BasicShoppingRate,
-                 WorkRatio, SchoolRatio, GotoWorkTimeMinimum, GotoWorkTimeMaximum, GotoSchoolTimeMinimum,
-                 GotoSchoolTimeMaximum, AgeGroupGotoSchool, AgeGroupGotoWork, InfectionProtectionFactor,
-                 SeverityProtectionFactor, HighViralLoadProtectionFactor, TestData>;
+                 CriticalPerInfectedSevere, DeathsPerInfectedSevere, DeathsPerInfectedCritical,
+                 InitialInfectionStateDistributions, ViralLoadDistributions, ViralShedParameters, ViralShedFactor,
+                 InfectionRateFromViralShed, MaskProtection, AerosolTransmissionRates, LockdownDate, QuarantineDuration,
+                 QuarantineEffectiveness, SocialEventRate, BasicShoppingRate, WorkRatio, SchoolRatio,
+                 GotoWorkTimeMinimum, GotoWorkTimeMaximum, GotoSchoolTimeMinimum, GotoSchoolTimeMaximum,
+                 AgeGroupGotoSchool, AgeGroupGotoWork, InfectionProtectionFactor, SeverityProtectionFactor,
+                 HighViralLoadProtectionFactor, TestData>;
 
 /**
  * @brief Maximum number of Person%s an infectious Person can infect at the respective Location.
@@ -954,14 +958,6 @@ class Parameters : public ParametersBase
                               (uint32_t)v, (size_t)i, 0);
                     return true;
                 }
-
-                if (this->get<DetectInfection>()[{v, i}] < 0.0 || this->get<DetectInfection>()[{v, i}] > 1.0) {
-                    log_error("Constraint check: Parameter DetectInfection of virus variant {} and age group {:.0f} "
-                              "smaller than {:d} or "
-                              "larger than {:d}",
-                              (uint32_t)v, (size_t)i, 0, 1);
-                    return true;
-                }
             }
 
             if (this->get<GotoWorkTimeMinimum>()[i].seconds() < 0.0 ||
diff --git a/cpp/models/abm/person.cpp b/cpp/models/abm/person.cpp
@@ -233,8 +233,8 @@ ProtectionEvent Person::get_latest_protection(TimePoint t) const
     // Use reverse iterators to start from the most recent infection
     for (auto it = m_infections.rbegin(); it != m_infections.rend(); ++it) {
         if (it->get_start_date() <= t) {
-            latest_exposure_type = ExposureType::NaturalInfection;
-            latest_time          = it->get_start_date();
+            latest_protection_type = ProtectionType::NaturalInfection;
+            latest_time            = it->get_start_date();
             break; // Stop once we find the latest infection before time t
         }
     }
@@ -243,8 +243,8 @@ ProtectionEvent Person::get_latest_protection(TimePoint t) const
     for (auto it = m_vaccinations.rbegin(); it != m_vaccinations.rend(); ++it) {
         if (it->time <= t) {
             if (it->time > latest_time) {
-                latest_exposure_type = it->exposure_type;
-                latest_time          = it->time;
+                latest_protection_type = it->type;
+                latest_time            = it->time;
             }
         }
         else {
diff --git a/cpp/tests/test_abm_location.cpp b/cpp/tests/test_abm_location.cpp
@@ -92,9 +92,9 @@ TEST_F(TestLocation, interact)
     params.get<mio::abm::ViralLoadDistributions>()[{variant, age}] = {mio::ParameterDistributionConstant(1.),
                                                                       mio::ParameterDistributionConstant(0.0001),
                                                                       mio::ParameterDistributionConstant(-0.0001)};
-    params.set_default<mio::abm::ViralShedDistribution>(num_age_groups);
-    params.get<mio::abm::ViralShedDistribution>()[{variant, age}] = {mio::ParameterDistributionConstant(1.),
-                                                                     mio::ParameterDistributionConstant(1.)};
+    params.set_default<mio::abm::ViralShedParameters>(num_age_groups);
+    params.get<mio::abm::ViralShedParameters>()[{variant, age}] = {mio::ParameterDistributionConstant(1.),
+                                                                   mio::ParameterDistributionConstant(1.)};
 
     // Set incubtion period to two days so that the newly infected person is still exposed
     ScopedMockDistribution<testing::StrictMock<MockDistribution<mio::LogNormalDistribution<double>>>> mock_logNorm_dist;
diff --git a/cpp/tests/test_abm_model.cpp b/cpp/tests/test_abm_model.cpp
@@ -674,7 +674,6 @@ TEST_F(TestModel, checkParameterConstraints)
     params.get<mio::abm::CriticalPerInfectedSevere>()[{mio::abm::VirusVariant::Wildtype, age_group_0_to_4}]     = 0.05;
     params.get<mio::abm::DeathsPerInfectedSevere>()[{mio::abm::VirusVariant::Wildtype, age_group_0_to_4}]       = 0.001;
     params.get<mio::abm::DeathsPerInfectedCritical>()[{mio::abm::VirusVariant::Wildtype, age_group_0_to_4}]     = 0.1;
-    params.get<mio::abm::DetectInfection>()[{mio::abm::VirusVariant::Wildtype, age_group_0_to_4}]               = 0.3;
     params.get<mio::abm::GotoWorkTimeMinimum>()[age_group_35_to_59]       = mio::abm::hours(4);
     params.get<mio::abm::GotoWorkTimeMaximum>()[age_group_35_to_59]       = mio::abm::hours(8);
     params.get<mio::abm::GotoSchoolTimeMinimum>()[age_group_0_to_4]       = mio::abm::hours(3);
@@ -737,10 +736,6 @@ TEST_F(TestModel, checkParameterConstraints)
     ASSERT_EQ(params.check_constraints(), true);
     params.get<mio::abm::TimeInfectedCriticalToRecovered>()[{mio::abm::VirusVariant::Wildtype, age_group_0_to_4}] =
         mio::ParameterDistributionLogNormal(9., 0.5);
-    params.get<mio::abm::DetectInfection>()[{mio::abm::VirusVariant::Wildtype, age_group_0_to_4}] = 1.1;
-    ASSERT_EQ(params.check_constraints(), true);
-    params.get<mio::abm::DetectInfection>()[{mio::abm::VirusVariant::Wildtype, age_group_0_to_4}] = 0.3;
-
     params.get<mio::abm::SymptomsPerInfectedNoSymptoms>()[{mio::abm::VirusVariant::Wildtype, age_group_0_to_4}] = -0.1;
     ASSERT_EQ(params.check_constraints(), true);
     params.get<mio::abm::SymptomsPerInfectedNoSymptoms>()[{mio::abm::VirusVariant::Wildtype, age_group_0_to_4}] = 0.2;

Original file line number	Diff line number	Diff line change
`@@ -233,8 +233,8 @@ ProtectionEvent Person::get_latest_protection(TimePoint t) const`
`233`	`233`	`// Use reverse iterators to start from the most recent infection`
`234`	`234`	`for (auto it = m_infections.rbegin(); it != m_infections.rend(); ++it) {`
`235`	`235`	`if (it->get_start_date() <= t) {`
`236`		`- latest_exposure_type = ExposureType::NaturalInfection;`
`237`		`- latest_time = it->get_start_date();`
	`236`	`+ latest_protection_type = ProtectionType::NaturalInfection;`
	`237`	`+ latest_time = it->get_start_date();`
`238`	`238`	`break; // Stop once we find the latest infection before time t`
`239`	`239`	`}`
`240`	`240`	`}`
`@@ -243,8 +243,8 @@ ProtectionEvent Person::get_latest_protection(TimePoint t) const`
`243`	`243`	`for (auto it = m_vaccinations.rbegin(); it != m_vaccinations.rend(); ++it) {`
`244`	`244`	`if (it->time <= t) {`
`245`	`245`	`if (it->time > latest_time) {`
`246`		`- latest_exposure_type = it->exposure_type;`
`247`		`- latest_time = it->time;`
	`246`	`+ latest_protection_type = it->type;`
	`247`	`+ latest_time = it->time;`
`248`	`248`	`}`
`249`	`249`	`}`
`250`	`250`	`else {`