646 use graph model with ABMs v3

cpp/CMakeLists.txt

@@ -162,6 +162,7 @@ if(MEMILIO_BUILD_MODELS)
     add_subdirectory(models/sde_sir)
     add_subdirectory(models/sde_sirs)
     add_subdirectory(models/sde_seirvv)
+    add_subdirectory(models/graph_abm)
 endif()
 
 if(MEMILIO_BUILD_EXAMPLES)

cpp/benchmarks/abm.cpp

@@ -2,7 +2,7 @@
 
 #include "benchmark/benchmark.h"
 
-mio::abm::Simulation make_simulation(size_t num_persons, std::initializer_list<uint32_t> seeds)
+mio::abm::Simulation<> make_simulation(size_t num_persons, std::initializer_list<uint32_t> seeds)
 {
     auto rng = mio::RandomNumberGenerator();
     rng.seed(seeds);
@@ -26,7 +26,7 @@ mio::abm::Simulation make_simulation(size_t num_persons, std::initializer_list<u
         auto age    = mio::AgeGroup(mio::UniformIntDistribution<size_t>::get_instance()(
             model.get_rng(), size_t(0), model.parameters.get_num_groups() - 1));
         auto person = model.add_person(home, age);
-        model.assign_location(person, home);
+        model.assign_location(uint32_t(i), home);
         home_size++;
     }
 
@@ -40,10 +40,10 @@ mio::abm::Simulation make_simulation(size_t num_persons, std::initializer_list<u
         std::generate(locs.begin(), locs.end(), [&] {
             return model.add_location(loc_type);
         });
-        for (auto& person : model.get_persons()) {
+        for (size_t p = 0; p < num_persons; ++p) {
             auto loc_idx =
                 mio::UniformIntDistribution<size_t>::get_instance()(model.get_rng(), size_t(0), num_locs - 1);
-            model.assign_location(person.get_id(), locs[loc_idx]);
+            model.assign_location(uint32_t(p), locs[loc_idx]);
         }
     }
 

cpp/examples/CMakeLists.txt

@@ -128,6 +128,10 @@ add_executable(history_example history.cpp)
 target_link_libraries(history_example PRIVATE memilio)
 target_compile_options(history_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 
+add_executable(graph_abm_example graph_abm.cpp)
+target_link_libraries(graph_abm_example PRIVATE memilio graph_abm abm)
+target_compile_options(graph_abm_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
+
 if(MEMILIO_HAS_JSONCPP)
     add_executable(ode_secir_read_graph_example ode_secir_read_graph.cpp)
     target_link_libraries(ode_secir_read_graph_example PRIVATE memilio ode_secir)
@@ -164,7 +168,7 @@ if(MEMILIO_HAS_HDF5)
 endif()
 
 if(MEMILIO_HAS_JSONCPP)
-  add_executable(ide_initialization_example ide_initialization.cpp)
-  target_link_libraries(ide_initialization_example PRIVATE memilio ide_secir)
-  target_compile_options(ide_initialization_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
+    add_executable(ide_initialization_example ide_initialization.cpp)
+    target_link_libraries(ide_initialization_example PRIVATE memilio ide_secir)
+    target_compile_options(ide_initialization_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 endif()

cpp/examples/abm_history_object.cpp

@@ -150,7 +150,7 @@ int main()
 
     // Assign locations to the people
     for (auto& person : model.get_persons()) {
-        const auto pid = person.get_id();
+        const auto pid = person.get_index();
         //assign shop and event
         model.assign_location(pid, event);
         model.assign_location(pid, shop);
@@ -176,14 +176,14 @@ int main()
 
     struct LogTimePoint : mio::LogAlways {
         using Type = double;
-        static Type log(const mio::abm::Simulation& sim)
+        static Type log(const mio::abm::Simulation<>& sim)
         {
             return sim.get_time().hours();
         }
     };
     struct LogLocationIds : mio::LogOnce {
         using Type = std::vector<std::tuple<mio::abm::LocationType, uint32_t>>;
-        static Type log(const mio::abm::Simulation& sim)
+        static Type log(const mio::abm::Simulation<>& sim)
         {
             Type location_ids{};
             for (auto& location : sim.get_model().get_locations()) {

cpp/examples/abm_minimal.cpp

@@ -55,7 +55,7 @@ int main()
     // For more than 1 family households we need families. These are parents and children and randoms (which are distributed like the data we have for these households).
     auto child = mio::abm::HouseholdMember(num_age_groups); // A child is 50/50% 0-4 or 5-14.
     child.set_age_weight(age_group_0_to_4, 1);
-    child.set_age_weight(age_group_0_to_4, 1);
+    child.set_age_weight(age_group_5_to_14, 1);
 
     auto parent = mio::abm::HouseholdMember(num_age_groups); // A parent is 50/50% 15-34 or 35-59.
     parent.set_age_weight(age_group_15_to_34, 1);
@@ -130,15 +130,15 @@ int main()
 
     // Assign locations to the people
     for (auto& person : model.get_persons()) {
-        const auto id = person.get_id();
+        const auto id = person.get_index();
         //assign shop and event
         model.assign_location(id, event);
         model.assign_location(id, shop);
         //assign hospital and ICU
         model.assign_location(id, hospital);
         model.assign_location(id, icu);
         //assign work/school to people depending on their age
-        if (person.get_age() == age_group_0_to_4) {
+        if (person.get_age() == age_group_5_to_14) {
             model.assign_location(id, school);
         }
         if (person.get_age() == age_group_15_to_34 || person.get_age() == age_group_35_to_59) {

cpp/examples/graph_abm.cpp

@@ -0,0 +1,268 @@
+/* 
+* 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.
+*/
+
+#include "abm/household.h"
+#include "abm/model.h"
+#include "abm/infection_state.h"
+#include "abm/location_type.h"
+#include "abm/time.h"
+#include "abm/person_id.h"
+#include "graph_abm/graph_abm_mobility.h"
+#include "graph_abm/graph_abmodel.h"
+#include "memilio/io/history.h"
+#include "memilio/mobility/graph.h"
+#include <cstddef>
+#include <cstdint>
+#include <map>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+//Logger
+struct Logger : mio::LogAlways {
+    /**
+    * A vector of tuples with the Location information i.e. each tuple contains the following information:
+    * - The LocationId (including the model id)
+    * - The total number of Persons at the location
+    * - A map containing the number of Persons per InfectionState at the location
+    */
+    using Type = std::vector<std::tuple<int, mio::abm::LocationType, mio::abm::LocationId, size_t,
+                                        std::map<mio::abm::InfectionState, size_t>>>;
+    static Type log(const mio::abm::Simulation<mio::GraphABModel>& sim)
+    {
+        Type location_information{};
+        location_information.reserve(size_t(mio::abm::LocationType::Count));
+        auto t = sim.get_time();
+        for (auto&& loc : sim.get_model().get_locations()) {
+            std::map<mio::abm::InfectionState, size_t> persons_per_infection_state;
+            for (size_t i = 0; i < static_cast<size_t>(mio::abm::InfectionState::Count); ++i) {
+                auto inf_state = mio::abm::InfectionState(i);
+                persons_per_infection_state.insert(
+                    {inf_state, sim.get_model().get_subpopulation(loc.get_id(), t, inf_state)});
+            }
+            location_information.push_back(std::make_tuple(loc.get_model_id(), loc.get_type(), loc.get_id(),
+                                                           sim.get_model().get_number_persons(loc.get_id()),
+                                                           persons_per_infection_state));
+        }
+        return location_information;
+    }
+};
+
+int main()
+{
+    // This is an example with three age groups representing children, adults and seniors.
+    size_t num_age_groups         = 3;
+    const auto age_group_children = mio::AgeGroup(0);
+    const auto age_group_adults   = mio::AgeGroup(1);
+    const auto age_group_seniors  = mio::AgeGroup(2);
+
+    auto model1 = mio::GraphABModel(num_age_groups, 0);
+
+    //Set infection parameters
+    model1.parameters.get<mio::abm::IncubationPeriod>()              = 4.;
+    model1.parameters.get<mio::abm::InfectedNoSymptomsToSymptoms>()  = 2.;
+    model1.parameters.get<mio::abm::InfectedNoSymptomsToRecovered>() = 4.;
+    model1.parameters.get<mio::abm::InfectedSymptomsToRecovered>()   = 5.;
+    model1.parameters.get<mio::abm::InfectedSymptomsToSevere>()      = 6.;
+    model1.parameters.get<mio::abm::SevereToRecovered>()             = 8.;
+    model1.parameters.get<mio::abm::SevereToCritical>()              = 7.;
+    model1.parameters.get<mio::abm::CriticalToRecovered>()           = 10.;
+    model1.parameters.get<mio::abm::CriticalToDead>()                = 11.;
+
+    //Age group 0 goes to school and age group 1 goes to work
+    model1.parameters.get<mio::abm::AgeGroupGotoSchool>()[age_group_children] = true;
+    model1.parameters.get<mio::abm::AgeGroupGotoWork>()[age_group_adults]     = true;
+
+    //Household members can be child, parent or senior
+    auto child = mio::abm::HouseholdMember(num_age_groups);
+    child.set_age_weight(age_group_children, 1);
+    auto parent = mio::abm::HouseholdMember(num_age_groups);
+    parent.set_age_weight(age_group_adults, 1);
+    auto adult = mio::abm::HouseholdMember(num_age_groups);
+    adult.set_age_weight(age_group_adults, 1);
+    adult.set_age_weight(age_group_seniors, 1);
+
+    //Single-Person households
+    auto single_hh = mio::abm::Household();
+    single_hh.add_members(adult, 1);
+
+    //Two-Adult household
+    auto two_adult_hh = mio::abm::Household();
+    two_adult_hh.add_members(adult, 2);
+
+    //Single-Parent household
+    auto single_parent_hh = mio::abm::Household();
+    single_parent_hh.add_members(child, 1);
+    single_parent_hh.add_members(parent, 1);
+
+    //Family household
+    auto family_hh = mio::abm::Household();
+    family_hh.add_members(child, 1);
+    family_hh.add_members(parent, 2);
+
+    //Household groups for model 1
+    auto single_hh_group_m1 = mio::abm::HouseholdGroup();
+    single_hh_group_m1.add_households(single_hh, 5);
+    auto two_adult_hh_group_m1 = mio::abm::HouseholdGroup();
+    two_adult_hh_group_m1.add_households(two_adult_hh, 3);
+    auto single_parent_hh_group_m1 = mio::abm::HouseholdGroup();
+    single_parent_hh_group_m1.add_households(single_parent_hh, 5);
+    auto family_hh_group_m1 = mio::abm::HouseholdGroup();
+    family_hh_group_m1.add_households(family_hh, 10);
+    add_household_group_to_model(model1, single_hh_group_m1);
+    add_household_group_to_model(model1, two_adult_hh_group_m1);
+    add_household_group_to_model(model1, single_hh_group_m1);
+    add_household_group_to_model(model1, family_hh_group_m1);
+
+    auto model2 = mio::GraphABModel(num_age_groups, 1);
+
+    //Set infection parameters
+    model2.parameters.get<mio::abm::IncubationPeriod>()              = 4.;
+    model2.parameters.get<mio::abm::InfectedNoSymptomsToSymptoms>()  = 2.;
+    model2.parameters.get<mio::abm::InfectedNoSymptomsToRecovered>() = 4.;
+    model2.parameters.get<mio::abm::InfectedSymptomsToRecovered>()   = 5.;
+    model2.parameters.get<mio::abm::InfectedSymptomsToSevere>()      = 6.;
+    model2.parameters.get<mio::abm::SevereToRecovered>()             = 8.;
+    model2.parameters.get<mio::abm::SevereToCritical>()              = 7.;
+    model2.parameters.get<mio::abm::CriticalToRecovered>()           = 10.;
+    model2.parameters.get<mio::abm::CriticalToDead>()                = 11.;
+
+    //Age group 0 goes to school and age group 1 goes to work
+    model2.parameters.get<mio::abm::AgeGroupGotoSchool>()[age_group_children] = true;
+    model2.parameters.get<mio::abm::AgeGroupGotoWork>()[age_group_adults]     = true;
+
+    //Household groups for model 2
+    auto single_hh_group_m2 = mio::abm::HouseholdGroup();
+    single_hh_group_m2.add_households(single_hh, 6);
+    auto two_adult_hh_group_m2 = mio::abm::HouseholdGroup();
+    two_adult_hh_group_m2.add_households(two_adult_hh, 2);
+    auto single_parent_hh_group_m2 = mio::abm::HouseholdGroup();
+    single_parent_hh_group_m2.add_households(single_parent_hh, 10);
+    auto family_hh_group_m2 = mio::abm::HouseholdGroup();
+    family_hh_group_m2.add_households(family_hh, 11);
+    add_household_group_to_model(model2, single_hh_group_m2);
+    add_household_group_to_model(model2, two_adult_hh_group_m2);
+    add_household_group_to_model(model2, single_hh_group_m2);
+    add_household_group_to_model(model2, family_hh_group_m2);
+
+    //Create locations for both models
+    //model 1
+    auto event_m1 = model1.add_location(mio::abm::LocationType::SocialEvent);
+    model1.get_location(event_m1).get_infection_parameters().set<mio::abm::MaximumContacts>(10);
+    auto hospital_m1 = model1.add_location(mio::abm::LocationType::Hospital);
+    model1.get_location(hospital_m1).get_infection_parameters().set<mio::abm::MaximumContacts>(10);
+    auto icu_m1 = model1.add_location(mio::abm::LocationType::ICU);
+    model1.get_location(icu_m1).get_infection_parameters().set<mio::abm::MaximumContacts>(5);
+    auto shop_m1 = model1.add_location(mio::abm::LocationType::BasicsShop);
+    model1.get_location(shop_m1).get_infection_parameters().set<mio::abm::MaximumContacts>(20);
+    auto school_m1 = model1.add_location(mio::abm::LocationType::School);
+    model1.get_location(school_m1).get_infection_parameters().set<mio::abm::MaximumContacts>(20);
+    auto work_m1 = model1.add_location(mio::abm::LocationType::Work);
+    model1.get_location(work_m1).get_infection_parameters().set<mio::abm::MaximumContacts>(10);
+    //model 2
+    auto event_m2 = model2.add_location(mio::abm::LocationType::SocialEvent);
+    model2.get_location(event_m2).get_infection_parameters().set<mio::abm::MaximumContacts>(10);
+    auto hospital_m2 = model2.add_location(mio::abm::LocationType::Hospital);
+    model2.get_location(hospital_m2).get_infection_parameters().set<mio::abm::MaximumContacts>(10);
+    auto icu_m2 = model2.add_location(mio::abm::LocationType::ICU);
+    model2.get_location(icu_m2).get_infection_parameters().set<mio::abm::MaximumContacts>(5);
+    auto shop_m2 = model2.add_location(mio::abm::LocationType::BasicsShop);
+    model2.get_location(shop_m2).get_infection_parameters().set<mio::abm::MaximumContacts>(20);
+    auto school_m2 = model2.add_location(mio::abm::LocationType::School);
+    model2.get_location(school_m2).get_infection_parameters().set<mio::abm::MaximumContacts>(20);
+    auto work_m2 = model2.add_location(mio::abm::LocationType::Work);
+    model2.get_location(work_m2).get_infection_parameters().set<mio::abm::MaximumContacts>(10);
+
+    auto start_date = mio::abm::TimePoint(0);
+    auto end_date   = mio::abm::TimePoint(0) + mio::abm::days(30);
+
+    //Assign infection states and locations to persons from model 1
+    std::vector<double> infection_distribution_m1{0.5, 0.3, 0.05, 0.05, 0.05, 0.05, 0.0, 0.0};
+    for (auto& person : model1.get_persons()) {
+        mio::abm::InfectionState infection_state = mio::abm::InfectionState(
+            mio::DiscreteDistribution<size_t>::get_instance()(model1.get_rng(), infection_distribution_m1));
+        auto rng = mio::abm::PersonalRandomNumberGenerator(model1.get_rng(), person);
+        if (infection_state != mio::abm::InfectionState::Susceptible) {
+            person.add_new_infection(mio::abm::Infection(rng, mio::abm::VirusVariant::Wildtype, person.get_age(),
+                                                         model1.parameters, start_date, infection_state));
+        }
+        person.set_assigned_location(mio::abm::LocationType::SocialEvent, event_m1, model1.get_id());
+        person.set_assigned_location(mio::abm::LocationType::BasicsShop, shop_m1, model1.get_id());
+        person.set_assigned_location(mio::abm::LocationType::Hospital, hospital_m1, model1.get_id());
+        person.set_assigned_location(mio::abm::LocationType::ICU, icu_m1, model1.get_id());
+        if (person.get_age() == age_group_children) {
+            person.set_assigned_location(mio::abm::LocationType::School, school_m1, model1.get_id());
+        }
+        if (person.get_age() == age_group_adults) {
+            //10% of adults in model 1 work in model 2
+            size_t work_model = mio::DiscreteDistribution<size_t>::get_instance()(mio::thread_local_rng(),
+                                                                                  std::vector<double>{0.9, 0.1});
+            if (work_model == 1) { //person works in other model
+                person.set_assigned_location(mio::abm::LocationType::Work, work_m2, model2.get_id());
+            }
+            else { //person works in same model
+                person.set_assigned_location(mio::abm::LocationType::Work, work_m1, model1.get_id());
+            }
+        }
+    }
+
+    //Assign infection states and locations to persons from model 2
+    std::vector<double> infection_distribution_m2{0.7, 0.1, 0.05, 0.05, 0.1, 0.0, 0.0, 0.0};
+    for (auto& person : model2.get_persons()) {
+        mio::abm::InfectionState infection_state = mio::abm::InfectionState(
+            mio::DiscreteDistribution<size_t>::get_instance()(model2.get_rng(), infection_distribution_m2));
+        auto rng = mio::abm::PersonalRandomNumberGenerator(model2.get_rng(), person);
+        if (infection_state != mio::abm::InfectionState::Susceptible) {
+            person.add_new_infection(mio::abm::Infection(rng, mio::abm::VirusVariant::Wildtype, person.get_age(),
+                                                         model2.parameters, start_date, infection_state));
+        }
+        person.set_assigned_location(mio::abm::LocationType::SocialEvent, event_m2, model2.get_id());
+        person.set_assigned_location(mio::abm::LocationType::BasicsShop, shop_m2, model2.get_id());
+        person.set_assigned_location(mio::abm::LocationType::Hospital, hospital_m2, model2.get_id());
+        person.set_assigned_location(mio::abm::LocationType::ICU, icu_m2, model2.get_id());
+        if (person.get_age() == age_group_children) {
+            person.set_assigned_location(mio::abm::LocationType::School, school_m2, model2.get_id());
+        }
+        if (person.get_age() == age_group_adults) {
+            //20% of adults in model 2 work in model 1
+            size_t work_model = mio::DiscreteDistribution<size_t>::get_instance()(mio::thread_local_rng(),
+                                                                                  std::vector<double>{0.2, 0.8});
+            if (work_model == 1) { //person works in same model
+                person.set_assigned_location(mio::abm::LocationType::Work, work_m2, model2.get_id());
+            }
+            else { //person works in other model
+                person.set_assigned_location(mio::abm::LocationType::Work, work_m1, model1.get_id());
+            }
+        }
+    }
+
+    using HistoryType = mio::History<mio::DataWriterToMemory, Logger>;
+    mio::Graph<mio::ABMSimulationNode<HistoryType>, mio::ABMMobilityEdge<HistoryType>> graph;
+    graph.add_node(model1.get_id(), HistoryType{}, start_date, std::move(model1));
+    graph.add_node(model2.get_id(), HistoryType{}, start_date, std::move(model2));
+    graph.add_edge(model1.get_id(), model2.get_id());
+    graph.add_edge(model2.get_id(), model1.get_id());
+
+    auto exchange_time_span = mio::abm::hours(12);
+    auto sim                = mio::make_abm_graph_sim<HistoryType>(start_date, exchange_time_span, std::move(graph));
+    sim.advance(end_date);
+
+    return 0;
+}