data setter redesign

Author: MaxBetzDLR

cpp/memilio/geography/regions.h

@@ -103,7 +103,59 @@ get_holidays(StateId state);
 Range<std::pair<std::vector<std::pair<Date, Date>>::const_iterator, std::vector<std::pair<Date, Date>>::const_iterator>>
 get_holidays(StateId state, Date start_date, Date end_date);
 
+namespace de
+{
+    struct EpidataFilenames
+    {
+        private:
+
+        EpidataFilenames(std::string& pydata) :
+            population_data_path(mio::path_join(pydata, "county_current_population.json"))
+        {
+        }
+        
+        static EpidataFilenames county(std::string& pydata)
+        {
+            EpidataFilenames s(pydata);
+
+            s.case_data_path = mio::path_join(pydata, "cases_all_county_age_ma7.json");
+            s.divi_data_path = mio::path_join(pydata, "county_divi_ma7.json");
+            s.vaccination_data_path = mio::path_join(pydata, "vacc_county_ageinf_ma7.json");
+
+            return s;
+        }
+
+        static EpidataFilenames states(std::string& pydata)
+        {
+            EpidataFilenames s(pydata);
+
+            s.case_data_path = mio::path_join(pydata, "cases_all_state_age_ma7.json");
+            s.divi_data_path = mio::path_join(pydata, "state_divi_ma7.json");
+            s.vaccination_data_path = mio::path_join(pydata, "vacc_state_ageinf_ma7.json");
+            
+            return s;
+        }
+
+        static EpidataFilenames country(std::string& pydata)
+        {
+            EpidataFilenames s(pydata);
+
+            s.case_data_path = mio::path_join(pydata, "cases_all_age_ma7.json");
+            s.divi_data_path = mio::path_join(pydata, "germany_divi_ma7.json");
+            s.vaccination_data_path = mio::path_join(pydata, "vacc_ageinf_ma7.json");
+            
+            return s;
+        }
+
+        std::string population_data_path;
+        std::string case_data_path;
+        std::string divi_data_path;
+        std::string vaccination_data_path;
+    };
+} // namespace de
+
 } // namespace regions
+
 } // namespace mio
 
 #endif //MIO_EPI_REGIONS_H

cpp/memilio/io/parameters_io.h

@@ -92,7 +92,7 @@ IOResult<std::vector<ScalarType>> read_divi_data(const std::string& path, const
  * @return An IOResult indicating success or failure.
  */
 template <typename FP, class Model>
-IOResult<void> set_divi_data(std::vector<Model>& model, const std::vector<double>& num_icu, const std::vector<int>& vregion,
+IOResult<void> set_divi_data(mio::VectorRange<Model>& model, const std::vector<double>& num_icu, const std::vector<int>& vregion,
                              Date date, FP scaling_factor_icu)
 {
     std::vector<FP> sum_mu_I_U(vregion.size(), 0);
@@ -127,7 +127,7 @@ IOResult<void> set_divi_data(std::vector<Model>& model, const std::vector<double
  * @param[in] scaling_factor_icu factor by which to scale the icu cases of divi data
  */
 template <class Model>
-IOResult<void> set_divi_data(std::vector<Model>& model, const std::string& path, const std::vector<int>& vregion,
+IOResult<void> set_divi_data(mio::VectorRange<Model>& model, const std::string& path, const std::vector<int>& vregion,
                              Date date, double scaling_factor_icu)
 {
     // DIVI dataset will no longer be updated from CW29 2024 on.
@@ -138,7 +138,7 @@ IOResult<void> set_divi_data(std::vector<Model>& model, const std::string& path,
         return success();
     }
     BOOST_OUTCOME_TRY(auto&& num_icu, read_divi_data(path, vregion, date));
-    BOOST_OUTCOME_TRY(set_divi_data(model, num_icu, rki_data, vregion, date, scaling_factor_icu));
+    BOOST_OUTCOME_TRY(set_divi_data(model, num_icu, vregion, date, scaling_factor_icu));
     return success();
 }
 

cpp/memilio/mobility/graph.h

@@ -152,6 +152,21 @@ class Graph
     using NodeProperty = NodePropertyT;
     using EdgeProperty = EdgePropertyT;
 
+    Graph(std::vector<NodePropertyT> nodes, std::vector<EdgePropertyT> edges)
+        : m_nodes(nodes)
+        , m_edges(edges)
+    {
+    }
+
+    template <class... Args>
+    Graph(std::vector<int>& node_ids, Args&&... args)
+    {
+        for (int id : node_ids) {
+            add_node(id, std::forward<Args>(args)...);
+        }
+    }
+
+
     /**
      * @brief add a node to the graph. property of the node is constructed from arguments.
      */
@@ -240,6 +255,75 @@ class Graph
     std::vector<Edge<EdgePropertyT>> m_edges;
 }; // namespace mio
 
+template <class FP, class Model, class ContactPattern>
+void set_german_holidays(Model& node, const int node_id,
+                  const mio::Date& start_date, const mio::Date& end_date)
+{
+    auto state_id        = regions::get_state_id(node_id);
+    auto holiday_periods = regions::get_holidays(state_id, start_date, end_date);
+
+    auto& contacts       = node.parameters.template get<ContactPattern>();
+    contacts.get_school_holidays() =
+        std::vector<std::pair<mio::SimulationTime<FP>, mio::SimulationTime<FP>>>(holiday_periods.size());
+    std::transform(
+        holiday_periods.begin(), holiday_periods.end(), contacts.get_school_holidays().begin(), [=](auto& period) {
+            return std::make_pair(mio::SimulationTime<FP>(mio::get_offset_in_days(period.first, start_date)),
+                                    mio::SimulationTime<FP>(mio::get_offset_in_days(period.second, start_date)));
+        });
+}
+
+/**
+ * @brief Sets the graph nodes for counties or districts.
+ * Reads the node ids which could refer to districts or counties and the epidemiological
+ * data from json files and creates one node for each id. Every node contains a model.
+ * @param[in] params Model Parameters that are used for every node.
+ * @param[in] start_date Start date for which the data should be read.
+ * @param[in] end_data End date for which the data should be read.
+ * @param[in] data_dir Directory that contains the data files.
+ * @param[in, out] params_graph Graph whose nodes are set by the function.
+ * @param[in] read_func Function that reads input data for german counties and sets Model compartments.
+ * @param[in] node_func Function that returns the county ids.
+ * @param[in] scaling_factor_inf Factor of confirmed cases to account for undetected cases in each county.
+ * @param[in] scaling_factor_icu Factor of ICU cases to account for underreporting.
+ * @param[in] tnt_capacity_factor Factor for test and trace capacity.
+ */
+template <typename FP, class ContactPattern, class Model, class MobilityParams, class Parameters,
+          class ReadFunction>
+IOResult<void> set_nodes(const Parameters& params, Date start_date, Date end_date, const fs::path& data_dir,
+                         Graph<Model, MobilityParams>& params_graph, ReadFunction&& read_func,
+                         const std::vector<int>& node_ids, const std::vector<FP>& scaling_factor_inf, FP scaling_factor_icu,
+                         bool add_uncertainty_to_population = true)
+
+{
+    std::vector<Model> nodes(node_ids.size(), Model(int(size_t(params.get_num_groups()))));
+    for (auto& node : nodes) {
+        node.parameters = params;
+    }
+
+    BOOST_OUTCOME_TRY(read_func(nodes, start_date, node_ids, scaling_factor_inf, scaling_factor_icu, data_dir.string()));
+
+    for (size_t node_idx = 0; node_idx < nodes.size(); ++node_idx) {
+
+        set_german_holidays<FP, Model, ContactPattern>(nodes[node_idx], node_ids[node_idx], start_date, end_date);
+        if (add_uncertainty_to_population)
+        {
+            //uncertainty in populations
+            for (auto i = mio::AgeGroup(0); i < params.get_num_groups(); i++) {
+                for (auto j = Index<typename Model::Compartments>(0); j < Model::Compartments::Count; ++j) {
+                    auto& compartment_value = nodes[node_idx].populations[{i, j}];
+                    compartment_value =
+                        UncertainValue<FP>(compartment_value.value());
+                    compartment_value.set_distribution(mio::ParameterDistributionUniform(0.9 * compartment_value.value(),
+                                                                                        1.1 * compartment_value.value()));
+                }
+            }
+        }
+
+        params_graph.add_node(node_ids[node_idx], nodes[node_idx]);
+    }
+    return success();
+}
+
 /**
  * @brief Sets the graph nodes for counties or districts.
  * Reads the node ids which could refer to districts or counties and the epidemiological
@@ -248,72 +332,49 @@ class Graph
  * @param[in] start_date Start date for which the data should be read.
  * @param[in] end_data End date for which the data should be read.
  * @param[in] data_dir Directory that contains the data files.
- * @param[in] population_data_path Path to json file containing the population data.
- * @param[in] is_node_for_county Specifies whether the node ids should be county ids (true) or district ids (false).
  * @param[in, out] params_graph Graph whose nodes are set by the function.
  * @param[in] read_func Function that reads input data for german counties and sets Model compartments.
  * @param[in] node_func Function that returns the county ids.
  * @param[in] scaling_factor_inf Factor of confirmed cases to account for undetected cases in each county.
  * @param[in] scaling_factor_icu Factor of ICU cases to account for underreporting.
  * @param[in] tnt_capacity_factor Factor for test and trace capacity.
- * @param[in] num_days Number of days to be simulated; required to load data for vaccinations during the simulation.
- * @param[in] export_time_series If true, reads data for each day of simulation and writes it in the same directory as the input files.
- * @param[in] rki_age_groups Specifies whether rki-age_groups should be used.
  */
 template <typename FP, class TestAndTrace, class ContactPattern, class Model, class MobilityParams, class Parameters,
-          class ReadFunction, class NodeIdFunction>
+          class ReadFunction>
 IOResult<void> set_nodes(const Parameters& params, Date start_date, Date end_date, const fs::path& data_dir,
-                         const std::string& population_data_path, bool is_node_for_county,
                          Graph<Model, MobilityParams>& params_graph, ReadFunction&& read_func,
-                         NodeIdFunction&& node_func, const std::vector<FP>& scaling_factor_inf, FP scaling_factor_icu,
-                         FP tnt_capacity_factor, int num_days = 0, bool export_time_series = false,
-                         bool rki_age_groups = true)
+                         const std::vector<int>& node_ids, const std::vector<FP>& scaling_factor_inf, FP scaling_factor_icu,
+                         FP tnt_capacity_factor, bool add_uncertainty_to_population = true)
 
 {
-    BOOST_OUTCOME_TRY(auto&& node_ids, node_func(population_data_path, is_node_for_county, rki_age_groups));
     std::vector<Model> nodes(node_ids.size(), Model(int(size_t(params.get_num_groups()))));
     for (auto& node : nodes) {
         node.parameters = params;
     }
 
-    BOOST_OUTCOME_TRY(read_func(nodes, start_date, node_ids, scaling_factor_inf, scaling_factor_icu, data_dir.string(),
-                                num_days, export_time_series));
+    BOOST_OUTCOME_TRY(read_func(nodes, start_date, node_ids, scaling_factor_inf, scaling_factor_icu, data_dir.string()));
 
     for (size_t node_idx = 0; node_idx < nodes.size(); ++node_idx) {
 
         auto tnt_capacity = nodes[node_idx].populations.get_total() * tnt_capacity_factor;
 
-        //local parameters
+        // local parameters
         auto& tnt_value = nodes[node_idx].parameters.template get<TestAndTrace>();
-        tnt_value       = UncertainValue<FP>(0.5 * (1.2 * tnt_capacity + 0.8 * tnt_capacity));
+        tnt_value       = UncertainValue<FP>(tnt_capacity);
         tnt_value.set_distribution(mio::ParameterDistributionUniform(0.8 * tnt_capacity, 1.2 * tnt_capacity));
 
-        auto id = 0;
-        if (is_node_for_county) {
-            id = int(regions::CountyId(node_ids[node_idx]));
-        }
-        else {
-            id = int(regions::DistrictId(node_ids[node_idx]));
-        }
-        //holiday periods
-        auto holiday_periods = regions::get_holidays(regions::get_state_id(id), start_date, end_date);
-        auto& contacts       = nodes[node_idx].parameters.template get<ContactPattern>();
-        contacts.get_school_holidays() =
-            std::vector<std::pair<mio::SimulationTime<FP>, mio::SimulationTime<FP>>>(holiday_periods.size());
-        std::transform(
-            holiday_periods.begin(), holiday_periods.end(), contacts.get_school_holidays().begin(), [=](auto& period) {
-                return std::make_pair(mio::SimulationTime<FP>(mio::get_offset_in_days(period.first, start_date)),
-                                      mio::SimulationTime<FP>(mio::get_offset_in_days(period.second, start_date)));
-            });
-
-        //uncertainty in populations
-        for (auto i = mio::AgeGroup(0); i < params.get_num_groups(); i++) {
-            for (auto j = Index<typename Model::Compartments>(0); j < Model::Compartments::Count; ++j) {
-                auto& compartment_value = nodes[node_idx].populations[{i, j}];
-                compartment_value =
-                    UncertainValue<FP>(0.5 * (1.1 * compartment_value.value() + 0.9 * compartment_value.value()));
-                compartment_value.set_distribution(mio::ParameterDistributionUniform(0.9 * compartment_value.value(),
-                                                                                     1.1 * compartment_value.value()));
+        set_german_holidays<FP, Model, ContactPattern>(nodes[node_idx], node_ids[node_idx], start_date, end_date);
+        if (add_uncertainty_to_population)
+        {
+            //uncertainty in populations
+            for (auto i = mio::AgeGroup(0); i < params.get_num_groups(); i++) {
+                for (auto j = Index<typename Model::Compartments>(0); j < Model::Compartments::Count; ++j) {
+                    auto& compartment_value = nodes[node_idx].populations[{i, j}];
+                    compartment_value =
+                        UncertainValue<FP>(compartment_value.value());
+                    compartment_value.set_distribution(mio::ParameterDistributionUniform(0.9 * compartment_value.value(),
+                                                                                        1.1 * compartment_value.value()));
+                }
             }
         }
 

cpp/memilio/utils/stl_util.h

@@ -315,6 +315,12 @@ constexpr std::array<T, size_t(T::Count)> enum_members()
     return enum_members;
 }
 
+template<class T>
+using VectorRange = mio::Range<std::pair<typename std::vector<T>::iterator, typename std::vector<T>::iterator>>;
+
+template<class T>
+using ConstVectorRange = mio::Range<std::pair<typename std::vector<T>::const_iterator, typename std::vector<T>::const_iterator>>;
+
 } // namespace mio
 
 #endif //STL_UTIL_H