1315 support io without age groups

cpp/memilio/geography/regions.h

@@ -77,6 +77,8 @@ DECL_TYPESAFE(int, CountyId);
 
 DECL_TYPESAFE(int, DistrictId);
 
+DECL_TYPESAFE(int, ProvinciaId);
+
 /**
          * get the id of the state that the specified county is in. 
          * @param[in, out] county a county id.

cpp/memilio/io/epi_data.cpp

@@ -27,10 +27,10 @@ namespace mio
 
 std::vector<const char*> ConfirmedCasesDataEntry::age_group_names = {"A00-A04", "A05-A14", "A15-A34",
                                                                      "A35-A59", "A60-A79", "A80+"};
-
-std::vector<const char*> PopulationDataEntry::age_group_names = {
+std::vector<const char*> PopulationDataEntry::age_group_names     = {
     "<3 years",    "3-5 years",   "6-14 years",  "15-17 years", "18-24 years", "25-29 years",
     "30-39 years", "40-49 years", "50-64 years", "65-74 years", ">74 years"};
+std::vector<const char*> PopulationDataEntrySpain::age_group_names = {"Population"};
 
 std::vector<const char*> VaccinationDataEntry::age_group_names = {"0-4", "5-14", "15-34", "35-59", "60-79", "80-99"};
 
@@ -49,11 +49,14 @@ IOResult<std::vector<int>> get_node_ids(const std::string& path, bool is_node_fo
             }
         }
         else {
-            if (entry.district_id) {
+            if (entry.state_id) {
+                id.push_back(entry.state_id->get());
+            }
+            else if (entry.district_id) {
                 id.push_back(entry.district_id->get());
             }
             else {
-                return failure(StatusCode::InvalidValue, "Population data file is missing district ids.");
+                return failure(StatusCode::InvalidValue, "Population data file is missing district and state ids.");
             }
         }
     }
@@ -62,6 +65,13 @@ IOResult<std::vector<int>> get_node_ids(const std::string& path, bool is_node_fo
     id.erase(std::unique(id.begin(), id.end()), id.end());
     return success(id);
 }
+
+IOResult<std::vector<int>> get_country_id(const std::string& /*path*/, bool /*is_node_for_county*/,
+                                          bool /*rki_age_groups*/)
+{
+    std::vector<int> id = {0};
+    return success(id);
+}
 } // namespace mio
 
 #endif //MEMILIO_HAS_JSONCPP

cpp/memilio/io/epi_data.h

@@ -77,6 +77,9 @@ class ConfirmedCasesNoAgeEntry
     double num_recovered;
     double num_deaths;
     Date date;
+    boost::optional<regions::StateId> state_id;
+    boost::optional<regions::CountyId> county_id;
+    boost::optional<regions::DistrictId> district_id;
 
     template <class IOContext>
     static IOResult<ConfirmedCasesNoAgeEntry> deserialize(IOContext& io)
@@ -86,12 +89,15 @@ class ConfirmedCasesNoAgeEntry
         auto num_recovered = obj.expect_element("Recovered", Tag<double>{});
         auto num_deaths    = obj.expect_element("Deaths", Tag<double>{});
         auto date          = obj.expect_element("Date", Tag<StringDate>{});
+        auto state_id      = obj.expect_optional("ID_State", Tag<regions::StateId>{});
+        auto county_id     = obj.expect_optional("ID_County", Tag<regions::CountyId>{});
+        auto district_id   = obj.expect_optional("ID_District", Tag<regions::DistrictId>{});
         return apply(
             io,
-            [](auto&& nc, auto&& nr, auto&& nd, auto&& d) {
-                return ConfirmedCasesNoAgeEntry{nc, nr, nd, d};
+            [](auto&& nc, auto&& nr, auto&& nd, auto&& d, auto&& sid, auto&& cid, auto&& did) {
+                return ConfirmedCasesNoAgeEntry{nc, nr, nd, d, sid, cid, did};
             },
-            num_confirmed, num_recovered, num_deaths, date);
+            num_confirmed, num_recovered, num_deaths, date, state_id, county_id, district_id);
     }
 };
 
@@ -142,29 +148,42 @@ class ConfirmedCasesDataEntry
     {
         auto obj           = io.expect_object("ConfirmedCasesDataEntry");
         auto num_confirmed = obj.expect_element("Confirmed", Tag<double>{});
-        auto num_recovered = obj.expect_element("Recovered", Tag<double>{});
-        auto num_deaths    = obj.expect_element("Deaths", Tag<double>{});
+        auto num_recovered = obj.expect_optional("Recovered", Tag<double>{});
+        auto num_deaths    = obj.expect_optional("Deaths", Tag<double>{});
         auto date          = obj.expect_element("Date", Tag<StringDate>{});
-        auto age_group_str = obj.expect_element("Age_RKI", Tag<std::string>{});
+        auto age_group_str = obj.expect_optional("Age_RKI", Tag<std::string>{});
         auto state_id      = obj.expect_optional("ID_State", Tag<regions::StateId>{});
         auto county_id     = obj.expect_optional("ID_County", Tag<regions::CountyId>{});
         auto district_id   = obj.expect_optional("ID_District", Tag<regions::DistrictId>{});
         return apply(
             io,
-            [](auto&& nc, auto&& nr, auto&& nd, auto&& d, auto&& a_str, auto&& sid, auto&& cid,
+            [](auto&& nc, auto&& nr, auto&& nd, auto&& d, auto&& a_str_opt, auto&& sid, auto&& cid,
                auto&& did) -> IOResult<ConfirmedCasesDataEntry> {
-                auto a  = AgeGroup(0);
-                auto it = std::find(age_group_names.begin(), age_group_names.end(), a_str);
-                if (it != age_group_names.end()) {
-                    a = AgeGroup(size_t(it - age_group_names.begin()));
-                }
-                else if (a_str == "unknown") {
-                    a = AgeGroup(age_group_names.size());
+                auto a = AgeGroup(0); // default if Age_RKI missing
+
+                // if no age group is given, use "total" as name
+                if (!a_str_opt) {
+                    if (age_group_names.size() != 1) {
+                        age_group_names.clear();
+                        age_group_names.push_back("total");
+                    }
                 }
                 else {
-                    return failure(StatusCode::InvalidValue, "Invalid confirmed cases data age group.");
+                    const auto& a_str = *a_str_opt;
+                    auto it           = std::find(age_group_names.begin(), age_group_names.end(), a_str);
+                    if (it != age_group_names.end()) {
+                        a = AgeGroup(size_t(it - age_group_names.begin()));
+                    }
+                    else if (a_str == "unknown") {
+                        a = AgeGroup(age_group_names.size());
+                    }
+                    else {
+                        return failure(StatusCode::InvalidValue, "Invalid confirmed cases data age group.");
+                    }
                 }
-                return success(ConfirmedCasesDataEntry{nc, nr, nd, d, a, sid, cid, did});
+                double nrec  = nr ? *nr : 0.0;
+                double ndead = nd ? *nd : 0.0;
+                return success(ConfirmedCasesDataEntry{nc, nrec, ndead, d, a, sid, cid, did});
             },
             num_confirmed, num_recovered, num_deaths, date, age_group_str, state_id, county_id, district_id);
     }
@@ -331,6 +350,35 @@ class PopulationDataEntry
     }
 };
 
+class PopulationDataEntrySpain
+{
+public:
+    static std::vector<const char*> age_group_names;
+
+    CustomIndexArray<double, AgeGroup> population;
+    boost::optional<regions::ProvinciaId> provincia_id;
+
+    template <class IoContext>
+    static IOResult<PopulationDataEntrySpain> deserialize(IoContext& io)
+    {
+        auto obj       = io.expect_object("PopulationDataEntrySpain");
+        auto provincia = obj.expect_optional("ID_Provincia", Tag<regions::ProvinciaId>{});
+        std::vector<IOResult<double>> age_groups;
+        age_groups.reserve(age_group_names.size());
+        std::transform(age_group_names.begin(), age_group_names.end(), std::back_inserter(age_groups),
+                       [&obj](auto&& age_name) {
+                           return obj.expect_element(age_name, Tag<double>{});
+                       });
+        return apply(
+            io,
+            [](auto&& ag, auto&& pid) {
+                return PopulationDataEntrySpain{
+                    CustomIndexArray<double, AgeGroup>(AgeGroup(ag.size()), ag.begin(), ag.end()), pid};
+            },
+            details::unpack_all(age_groups), provincia);
+    }
+};
+
 namespace details
 {
 inline void get_rki_age_interpolation_coefficients(const std::vector<double>& age_ranges,
@@ -435,6 +483,19 @@ inline IOResult<std::vector<PopulationDataEntry>> deserialize_population_data(co
     }
 }
 
+/**
+ * Deserialize population data from a JSON value.
+ * Age groups are interpolated to RKI age groups.
+ * @param jsvalue JSON value that contains the population data.
+ * @param rki_age_groups Specifies whether population data should be interpolated to rki age groups.
+ * @return list of population data.
+ */
+inline IOResult<std::vector<PopulationDataEntrySpain>> deserialize_population_data_spain(const Json::Value& jsvalue)
+{
+    BOOST_OUTCOME_TRY(auto&& population_data, deserialize_json(jsvalue, Tag<std::vector<PopulationDataEntrySpain>>{}));
+    return success(population_data);
+}
+
 /**
  * Deserialize population data from a JSON file.
  * Age groups are interpolated to RKI age groups.
@@ -448,6 +509,18 @@ inline IOResult<std::vector<PopulationDataEntry>> read_population_data(const std
     return deserialize_population_data(jsvalue, rki_age_group);
 }
 
+/**
+ * Deserialize population data from a JSON file.
+ * Age groups are interpolated to RKI age groups.
+ * @param filename JSON file that contains the population data.
+ * @return list of population data.
+ */
+inline IOResult<std::vector<PopulationDataEntrySpain>> read_population_data_spain(const std::string& filename)
+{
+    BOOST_OUTCOME_TRY(auto&& jsvalue, read_json(filename));
+    return deserialize_population_data_spain(jsvalue);
+}
+
 /**
  * @brief Sets the age groups' names for the ConfirmedCasesDataEntry%s.
  * @param[in] names age group names
@@ -474,6 +547,8 @@ IOResult<void> set_vaccination_data_age_group_names(std::vector<const char*> nam
  * @return list of node ids.
  */
 IOResult<std::vector<int>> get_node_ids(const std::string& path, bool is_node_for_county, bool rki_age_groups = true);
+IOResult<std::vector<int>> get_country_id(const std::string& /*path*/, bool /*is_node_for_county*/,
+                                          bool /*rki_age_groups*/ = true);
 
 /**
  * Represents an entry in a vaccination data file.

cpp/memilio/io/parameters_io.cpp

@@ -62,11 +62,43 @@ IOResult<std::vector<std::vector<double>>> read_population_data(const std::vecto
     return success(vnum_population);
 }
 
+IOResult<std::vector<std::vector<double>>>
+read_population_data_spain(const std::vector<PopulationDataEntrySpain>& population_data,
+                           const std::vector<int>& vregion)
+{
+    std::vector<std::vector<double>> vnum_population(vregion.size(), std::vector<double>(1, 0.0));
+
+    for (auto&& provincia_entry : population_data) {
+        if (provincia_entry.provincia_id) {
+            for (size_t idx = 0; idx < vregion.size(); ++idx) {
+                if (vregion[idx] == provincia_entry.provincia_id->get()) {
+                    vnum_population[idx][0] += provincia_entry.population[AgeGroup(0)];
+                }
+            }
+        }
+        // id 0 means the whole country
+        for (size_t idx = 0; idx < vregion.size(); ++idx) {
+            if (vregion[idx] == 0) {
+                vnum_population[idx][0] += provincia_entry.population[AgeGroup(0)];
+            }
+        }
+    }
+
+    return success(vnum_population);
+}
+
 IOResult<std::vector<std::vector<double>>> read_population_data(const std::string& path,
                                                                 const std::vector<int>& vregion)
 {
     BOOST_OUTCOME_TRY(auto&& population_data, mio::read_population_data(path));
     return read_population_data(population_data, vregion);
 }
+
+IOResult<std::vector<std::vector<double>>> read_population_data_spain(const std::string& path,
+                                                                      const std::vector<int>& vregion)
+{
+    BOOST_OUTCOME_TRY(auto&& population_data, mio::read_population_data_spain(path));
+    return read_population_data_spain(population_data, vregion);
+}
 } // namespace mio
 #endif //MEMILIO_HAS_JSONCPP

cpp/memilio/io/parameters_io.h

@@ -136,6 +136,24 @@ IOResult<std::vector<std::vector<double>>> read_population_data(const std::vecto
 IOResult<std::vector<std::vector<double>>> read_population_data(const std::string& path,
                                                                 const std::vector<int>& vregion);
 
+/**
+ * @brief Reads (Spain) population data from a vector of Spain population data entries.
+ * Uses provincias IDs and a single aggregated age group.
+ * @param[in] population_data Vector of Spain population data entries.
+ * @param[in] vregion Vector of keys representing the provincias (or country = 0) of interest.
+ */
+IOResult<std::vector<std::vector<double>>>
+read_population_data_spain(const std::vector<PopulationDataEntrySpain>& population_data,
+                           const std::vector<int>& vregion);
+
+/**
+ * @brief Reads (Spain) population data from census data file with provincias.
+ * @param[in] path Path to the provincias population data file.
+ * @param[in] vregion Vector of keys representing the provincias (or country = 0) of interest.
+ */
+IOResult<std::vector<std::vector<double>>> read_population_data_spain(const std::string& path,
+                                                                      const std::vector<int>& vregion);
+
 } // namespace mio
 
 #endif //MEMILIO_HAS_JSONCPP

cpp/memilio/mobility/graph.h

@@ -307,15 +307,15 @@ IOResult<void> set_nodes(const Parameters& params, Date start_date, Date end_dat
             });
 
         //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 * double(compartment_value) + 0.9 * double(compartment_value)));
-                compartment_value.set_distribution(mio::ParameterDistributionUniform(0.9 * double(compartment_value),
-                                                                                     1.1 * double(compartment_value)));
-            }
-        }
+        // 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 * double(compartment_value) + 0.9 * double(compartment_value)));
+        //         compartment_value.set_distribution(mio::ParameterDistributionUniform(0.9 * double(compartment_value),
+        //                                                                              1.1 * double(compartment_value)));
+        //     }
+        // }
 
         params_graph.add_node(node_ids[node_idx], nodes[node_idx]);
     }
@@ -368,7 +368,7 @@ IOResult<void> set_edges(const fs::path& mobility_data_file, Graph<Model, Mobili
             for (auto age = AgeGroup(0); age < populations.template size<mio::AgeGroup>(); ++age) {
                 for (auto compartment : mobile_compartments) {
                     auto coeff_index = populations.get_flat_index({age, compartment});
-                    mobility_coeffs[size_t(ContactLocation::Work)].get_baseline()[coeff_index] =
+                    mobility_coeffs[size_t(ContactLocation::Home)].get_baseline()[coeff_index] =
                         commuter_coeff_ij * commuting_weights[size_t(age)];
                 }
             }