1081 rework ABM state transitions

cpp/examples/abm_history_object.cpp

@@ -22,7 +22,9 @@
 #include "abm/simulation.h"
 #include "abm/model.h"
 #include "abm/location_type.h"
+#include "memilio/utils/parameter_distribution_wrapper.h"
 #include "memilio/io/history.h"
+#include "memilio/utils/parameter_distributions.h"
 
 #include <fstream>
 #include <string>
@@ -68,9 +70,9 @@ int main()
 
     // Create the model with 4 age groups.
     auto model = mio::abm::Model(num_age_groups);
-
-    // Set same infection parameter for all age groups. For example, the incubation period is 4 days.
-    model.parameters.get<mio::abm::IncubationPeriod>() = 4.;
+    mio::ParameterDistributionLogNormal log_norm(4., 1.);
+    // Set same infection parameter for all age groups. For example, the incubation period is log normally distributed with parameters 4 and 1.
+    model.parameters.get<mio::abm::IncubationPeriod>() = mio::ParameterDistributionWrapper(log_norm);
 
     // Set the age group the can go to school is AgeGroup(1) (i.e. 5-14)
     model.parameters.get<mio::abm::AgeGroupGotoSchool>()[age_group_5_to_14] = true;

cpp/examples/abm_minimal.cpp

@@ -21,6 +21,7 @@
 #include "abm/lockdown_rules.h"
 #include "abm/model.h"
 #include "abm/common_abm_loggers.h"
+#include "memilio/utils/parameter_distribution_wrapper.h"
 
 #include <fstream>
 
@@ -36,9 +37,9 @@ int main()
 
     // Create the model with 4 age groups.
     auto model = mio::abm::Model(num_age_groups);
-
-    // Set same infection parameter for all age groups. For example, the incubation period is 4 days.
-    model.parameters.get<mio::abm::IncubationPeriod>() = 4.;
+    mio::ParameterDistributionLogNormal log_norm(4., 1.);
+    // Set same infection parameter for all age groups. For example, the incubation period is log normally distributed with parameters 4 and 1.
+    model.parameters.get<mio::abm::IncubationPeriod>() = mio::ParameterDistributionWrapper(log_norm);
 
     // Set the age group the can go to school is AgeGroup(1) (i.e. 5-14)
     model.parameters.get<mio::abm::AgeGroupGotoSchool>()                    = false;

cpp/examples/ode_secir_parameter_sampling.cpp

@@ -18,6 +18,7 @@
 * limitations under the License.
 */
 #include "memilio/utils/parameter_distributions.h"
+#include "memilio/utils/random_number_generator.h"
 #include "ode_secir/parameter_space.h"
 #include "ode_secir/model.h"
 
@@ -41,7 +42,7 @@ int main()
     printf("\n N(%.0f,%.0f)-distribution with sampling only in [%.0f,%.0f]", mean, stddev, min, max);
     int counter[10] = {0};
     for (int i = 0; i < 1000; i++) {
-        int rounded = (int)(some_parameter.get_sample() - 1);
+        int rounded = (int)(some_parameter.get_sample(mio::thread_local_rng()) - 1);
         if (rounded >= 0 && rounded < 10) {
             counter[rounded]++;
         }
@@ -59,7 +60,7 @@ int main()
 
     double counter_unif[10] = {0};
     for (int i = 0; i < 1000; i++) {
-        int rounded = (int)(some_other_parameter.get_sample() - 1);
+        int rounded = (int)(some_other_parameter.get_sample(mio::thread_local_rng()) - 1);
         if (rounded >= 0 && rounded < 10) {
             counter_unif[rounded]++;
         }

cpp/memilio/CMakeLists.txt

@@ -78,6 +78,7 @@ add_library(memilio
     utils/custom_index_array.h
     utils/memory.h
     utils/parameter_distributions.h
+    utils/parameter_distribution_wrapper.h
     utils/time_series.h
     utils/time_series.cpp
     utils/span.h

cpp/memilio/epidemiology/damping_sampling.h

@@ -21,6 +21,7 @@
 #define EPI_SECIR_DAMPING_SAMPLING_H
 
 #include "memilio/epidemiology/damping.h"
+#include "memilio/utils/random_number_generator.h"
 #include "memilio/utils/uncertain_value.h"
 #include <memory>
 

cpp/memilio/utils/parameter_distribution_wrapper.h

@@ -0,0 +1,139 @@
+/* 
+* Copyright (C) 2020-2024 MEmilio
+*
+* Authors: Julia Bicker
+*
+* Contact: Martin J. Kuehn <[email protected]>
+*
+* 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 PARAMETER_DISTRIBUTION_WRAPPER_H
+#define PARAMETER_DISTRIBUTION_WRAPPER_H
+
+#include "memilio/io/io.h"
+#include "memilio/utils/compiler_diagnostics.h"
+#include "parameter_distributions.h"
+
+namespace mio
+{
+
+class ParameterDistributionWrapper
+{
+public:
+    ParameterDistributionWrapper()
+        : m_dist(nullptr)
+    {
+    }
+
+    ParameterDistributionWrapper(ParameterDistribution& dist)
+        : m_dist(std::unique_ptr<ParameterDistribution>(dist.clone()))
+    {
+    }
+
+    ParameterDistributionWrapper(const ParameterDistributionWrapper& other)
+    {
+        m_dist = (other.m_dist == nullptr) ? nullptr : std::unique_ptr<ParameterDistribution>(other.m_dist->clone());
+    }
+
+    ParameterDistributionWrapper(ParameterDistributionWrapper&& other)
+    {
+        m_dist = (other.m_dist == nullptr) ? nullptr : std::unique_ptr<ParameterDistribution>(other.m_dist->clone());
+    }
+
+    ParameterDistributionWrapper& operator=(ParameterDistributionWrapper const& other)
+    {
+        m_dist = (other.m_dist == nullptr) ? nullptr : std::unique_ptr<ParameterDistribution>(other.m_dist->clone());
+        return *this;
+    }
+
+    ParameterDistributionWrapper& operator=(ParameterDistributionWrapper&& other)
+    {
+        m_dist = (other.m_dist == nullptr) ? nullptr : std::unique_ptr<ParameterDistribution>(other.m_dist->clone());
+        return *this;
+    };
+
+    ~ParameterDistributionWrapper() = default;
+
+    std::vector<double> params() const
+    {
+        if (m_dist == nullptr) {
+            log_error("Distribution is not defined. Parameters cannot be deduced.");
+        }
+        return m_dist->params();
+    }
+
+    template <class RNG>
+    double get(RNG& rng)
+    {
+        if (m_dist == nullptr) {
+            log_error("Distribution is not defined. Value cannot be sampled.");
+        }
+        return m_dist->get_sample(rng);
+    }
+
+    /**
+     * serialize this.
+     * @see mio::serialize
+     */
+    template <class IOContext>
+    void serialize(IOContext& io) const
+    {
+        m_dist->serialize(io);
+    }
+
+private:
+    std::unique_ptr<ParameterDistribution> m_dist;
+};
+
+/**
+ * deserialize a ParameterDistributionWrapper.
+ * @see mio::deserialize
+ */
+template <class IOContext>
+IOResult<ParameterDistributionWrapper> deserialize_internal(IOContext& io, Tag<ParameterDistributionWrapper>)
+{
+
+    auto obj  = io.expect_object("ParameterDistribution");
+    auto type = obj.expect_element("Type", Tag<std::string>{});
+    if (type) {
+        if (type.value() == "Uniform") {
+            BOOST_OUTCOME_TRY(auto&& r, ParameterDistributionUniform::deserialize_elements(io, obj));
+            return ParameterDistributionWrapper(r);
+        }
+        else if (type.value() == "Normal") {
+            BOOST_OUTCOME_TRY(auto&& r, ParameterDistributionNormal::deserialize_elements(io, obj));
+            return ParameterDistributionWrapper(r);
+        }
+        else if (type.value() == "LogNormal") {
+            BOOST_OUTCOME_TRY(auto&& r, ParameterDistributionLogNormal::deserialize_elements(io, obj));
+            return ParameterDistributionWrapper(r);
+        }
+        else if (type.value() == "Exponential") {
+            BOOST_OUTCOME_TRY(auto&& r, ParameterDistributionExponential::deserialize_elements(io, obj));
+            return ParameterDistributionWrapper(r);
+        }
+        else if (type.value() == "Constant") {
+            BOOST_OUTCOME_TRY(auto&& r, ParameterDistributionConstant::deserialize_elements(io, obj));
+            return ParameterDistributionWrapper(r);
+        }
+        else {
+            return failure(StatusCode::InvalidValue, "Type of ParameterDistribution in ParameterDistributionWrapper" +
+                                                         type.value() + " not valid.");
+        }
+    }
+    return failure(type.error());
+}
+
+} // namespace mio
+
+#endif //PARAMETER_DISTRIBUTION_WRAPPER_H