1318 add graph with timed edges

cpp/CMakeLists.txt

@@ -136,7 +136,7 @@ endif()
 # exclude some warnings we accept
 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
     string(APPEND MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS
-        "-Wno-unknown-warning;-Wno-pragmas;-Wno-deprecated-copy;-Wno-expansion-to-defined;")
+        "-Wno-unknown-warning;-Wno-pragmas;-Wno-deprecated-copy;-Wno-expansion-to-defined;-Wno-shadow;")
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     string(APPEND MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS
         "-Wno-unknown-warning-option;-Wno-deprecated;-Wno-gnu-zero-variadic-macro-arguments;")

cpp/examples/CMakeLists.txt

@@ -112,6 +112,22 @@ add_executable(graph_stochastic_mobility_example graph_stochastic_mobility.cpp)
 target_link_libraries(graph_stochastic_mobility_example PRIVATE memilio ode_secir)
 target_compile_options(graph_stochastic_mobility_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 
+add_executable(asymmetric_graph_example asymmetric_graph.cpp)
+target_link_libraries(asymmetric_graph_example PRIVATE memilio smm)
+target_compile_options(asymmetric_graph_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
+
+add_executable(asymmetric_graph_data asym_ex_data.cpp)
+target_link_libraries(asymmetric_graph_data PRIVATE memilio smm)
+target_compile_options(asymmetric_graph_data PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
+
+add_executable(asym_ben asym_graph_ben.cpp)
+target_link_libraries(asym_ben PRIVATE memilio smm)
+target_compile_options(asym_ben PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
+
+add_executable(asymmetric_params asymmetric_params.cpp)
+target_link_libraries(asymmetric_params PRIVATE memilio smm)
+target_compile_options(asymmetric_params PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
+
 add_executable(abm_minimal_example abm_minimal.cpp)
 target_link_libraries(abm_minimal_example PRIVATE memilio abm)
 target_compile_options(abm_minimal_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})

cpp/examples/abm_parameter_study.cpp

@@ -228,4 +228,4 @@ int main()
     mio::mpi::finalize();
 
     return 0;
-}
+}

cpp/examples/asym_ex_data.cpp

@@ -0,0 +1,121 @@
+/* 
+* Copyright (C) 2020-2025 MEmilio
+*
+* Authors: Kilian Volmer
+*
+* 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 "memilio/config.h"
+#include "memilio/geography/geolocation.h"
+#include "memilio/geography/rtree.h"
+#include "memilio/geography/distance.h"
+#include "memilio/mobility/graph_simulation.h"
+#include "memilio/mobility/metapopulation_mobility_asymmetric.h"
+#include "memilio/mobility/graph.h"
+#include "memilio/mobility/graph_builder.h"
+#include "memilio/utils/compiler_diagnostics.h"
+#include "memilio/utils/index.h"
+#include "memilio/utils/logging.h"
+#include "memilio/timer/auto_timer.h"
+#include "memilio/utils/parameter_distributions.h"
+#include "memilio/utils/random_number_generator.h"
+#include "smm/simulation.h"
+#include "smm/parameters.h"
+#include "fmd/infection_state.h"
+#include "fmd/model.h"
+#include "fmd/adoption_rates.h"
+#include "thirdparty/csv.h"
+#include <ranges>
+#include <omp.h>
+
+int main(int /*argc*/, char** /*argv*/)
+{
+    const auto t0   = 0.;
+    const auto tmax = 1000.;
+    const auto dt   = 1.; //initial time step
+    using mio::fmd::InfectionState;
+    using Status = mio::Index<InfectionState>;
+    using mio::regions::Region;
+
+    //total compartment sizes
+
+    using Model = mio::smm::Model<ScalarType, InfectionState, Status, Region>;
+
+    mio::fmd::Builder builder;
+    mio::log_info("Starting Graph generation");
+    {
+        mio::timing::AutoTimer<"Graph Nodes Generation"> timer;
+        io::CSVReader<4> farms("/home/kilian/Documents/data/read_data/farms.csv");
+        farms.read_header(io::ignore_extra_column, "id_dec", "x", "y", "farm_size");
+        size_t farm_id, num_cows;
+        double latitude, longitude;
+        while (farms.read_row(farm_id, latitude, longitude, num_cows)) {
+            auto curr_model = mio::fmd::create_model(num_cows, mio::fmd::generic_adoption_rates());
+            builder.add_node(farm_id, longitude, latitude, curr_model, t0);
+        }
+    }
+    mio::log_info("Nodes added to Graph");
+    auto rng = mio::RandomNumberGenerator();
+
+    std::vector<std::vector<size_t>> interesting_indices;
+    interesting_indices.push_back(
+        {Model(Status{InfectionState::Count}, Region(1)).populations.get_flat_index({Region(0), InfectionState::I})});
+
+    {
+        mio::timing::AutoTimer<"Graph Edges Generation"> timer;
+        io::CSVReader<2> edges("/home/kilian/Documents/data/read_data/edges.csv");
+        edges.read_header(io::ignore_extra_column, "from", "to");
+        size_t from, to;
+        while (edges.read_row(from, to)) {
+            builder.add_edge(from, to, interesting_indices);
+        }
+    }
+    auto graph = std::move(builder).build();
+    mio::log_info("Graph generated");
+
+    mio::fmd::generate_neighbours(graph, {mio::geo::kilometers(2.0)});
+
+    mio::log_info("Neighbors set");
+    auto sim = mio::make_mobility_sim(t0, dt, std::move(graph));
+
+    io::CSVReader<4> exchanges("/home/kilian/Documents/data/read_data/exchanges.csv");
+    exchanges.read_header(io::ignore_extra_column, "from_dec", "to_dec", "day", "weight");
+
+    size_t date, num_animals;
+    size_t from, to;
+    while (exchanges.read_row(from, to, date, num_animals)) {
+        sim.add_exchange(date, num_animals, from, to);
+    }
+    mio::log_info("Exchanges added");
+
+    // #ifdef MEMILIO_ENABLE_OPENMP
+    // #pragma omp parallel for
+    //     for (size_t i = 0; i < 100; ++i) {
+    // #endif
+
+    auto sim2(sim);
+    mio::log_info("new Simulation created");
+
+    sim2.advance(tmax);
+    mio::log_info("Simulation finished");
+
+    auto sth = sim2.exchanges_per_timestep().export_csv("Exchange_statistics.csv", {"Commuter Sick", "Commuter Total"});
+
+    sth = sim2.statistics_per_timestep().export_csv("Simulation_statistics.csv");
+
+    mio::log_info("Finished postprocessing");
+
+    return 0;
+}

cpp/examples/asym_graph_ben.cpp

@@ -0,0 +1,168 @@
+/* 
+* Copyright (C) 2020-2025 MEmilio
+*
+* Authors: Kilian Volmer
+*
+* 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 "memilio/config.h"
+#include "memilio/geography/geolocation.h"
+#include "memilio/geography/rtree.h"
+#include "memilio/geography/distance.h"
+#include "memilio/mobility/graph_simulation.h"
+#include "memilio/mobility/metapopulation_mobility_asymmetric.h"
+#include "memilio/mobility/graph.h"
+#include "memilio/mobility/graph_builder.h"
+#include "memilio/utils/compiler_diagnostics.h"
+#include "memilio/utils/index.h"
+#include "memilio/utils/logging.h"
+#include "memilio/timer/auto_timer.h"
+#include "memilio/utils/parameter_distributions.h"
+#include "memilio/utils/random_number_generator.h"
+#include "smm/simulation.h"
+#include "smm/parameters.h"
+#include "fmd/infection_state.h"
+#include "fmd/model.h"
+#include "fmd/adoption_rates.h"
+#include "thirdparty/csv.h"
+#include <ranges>
+#include <omp.h>
+#include <chrono>
+
+int main(int /*argc*/, char** /*argv*/)
+{
+    const auto t0 = 0.;
+    // const auto tmax = 100.;
+    const auto dt = 1.; //initial time step
+
+    //total compartment sizes
+    using mio::fmd::InfectionState;
+    using Status = mio::Index<InfectionState>;
+    using mio::regions::Region;
+
+    using Model = mio::smm::Model<ScalarType, InfectionState, Status, Region>;
+    auto home   = Region(0);
+
+    auto adoption_rates = mio::fmd::generic_adoption_rates();
+
+    mio::log_info("Reading CSVs");
+    std::vector<ScalarType> latitudes, longitudes;
+    std::vector<int> farm_ids, num_cows_vec, dates, num_animals_exchanges;
+    std::vector<int> froms, tos, from_exchanges, to_exchanges;
+    io::CSVReader<4> farms("../../../farms16mio.csv");
+    farms.read_header(io::ignore_extra_column, "farms", "num_cows", "latitude", "longitude");
+    int farm_id, num_cows;
+    double latitude, longitude;
+    while (farms.read_row(farm_id, num_cows, latitude, longitude)) {
+        farm_ids.push_back(farm_id);
+        num_cows_vec.push_back(num_cows);
+        latitudes.push_back(latitude);
+        longitudes.push_back(longitude);
+    }
+    io::CSVReader<2> edges("../../../edges16mio.csv");
+    edges.read_header(io::ignore_extra_column, "from", "to");
+    size_t from, to;
+    while (edges.read_row(from, to)) {
+        froms.push_back(from);
+        tos.push_back(to);
+    }
+    io::CSVReader<4> exchanges("../../../trade16mio.csv");
+    exchanges.read_header(io::ignore_extra_column, "date", "num_animals", "from", "to");
+    int date, num_animals;
+    while (exchanges.read_row(date, num_animals, from, to)) {
+        dates.push_back(date);
+        num_animals_exchanges.push_back(num_animals);
+        from_exchanges.push_back(from);
+        to_exchanges.push_back(to);
+    }
+    std::vector<std::vector<size_t>> interesting_indices;
+    interesting_indices.push_back(
+        {Model(Status{InfectionState::Count}, Region(1)).populations.get_flat_index({home, InfectionState::I})});
+
+    for (size_t num_edges_benchmark = 1024; num_edges_benchmark < 16000000; num_edges_benchmark *= 2) {
+        mio::log_info("Running with {} edges", num_edges_benchmark);
+
+        mio::fmd::Graph graph;
+        mio::fmd::Builder builder;
+
+        auto start = std::chrono::high_resolution_clock::now();
+
+        for (size_t i = 0; i < farm_ids.size(); ++i) {
+            Model curr_model(Status{InfectionState::Count}, Region(1));
+            curr_model.populations[{home, InfectionState::S}]                                        = num_cows_vec[i];
+            curr_model.populations[{home, InfectionState::E}]                                        = 0;
+            curr_model.populations[{home, InfectionState::I}]                                        = 0;
+            curr_model.populations[{home, InfectionState::INS}]                                      = 0;
+            curr_model.populations[{home, InfectionState::ICS}]                                      = 0;
+            curr_model.populations[{home, InfectionState::R}]                                        = 0;
+            curr_model.populations[{home, InfectionState::V}]                                        = 0;
+            curr_model.populations[{home, InfectionState::D}]                                        = 0;
+            curr_model.parameters.get<mio::smm::AdoptionRates<ScalarType, Status, Region>>() = adoption_rates;
+            graph.add_node(farm_ids[i], longitudes[i], latitudes[i], curr_model, t0);
+        }
+        auto rng = mio::RandomNumberGenerator();
+
+        for (size_t i = 0; i < num_edges_benchmark; ++i) {
+            graph.add_edge(froms[i], tos[i], interesting_indices);
+        }
+        auto end      = std::chrono::high_resolution_clock::now();
+        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+
+        mio::log_info("Classic graph generation finished for {} edges in {} milliseconds", num_edges_benchmark,
+                      duration.count());
+        start = std::chrono::high_resolution_clock::now();
+        for (size_t i = 0; i < farm_ids.size(); ++i) {
+            Model curr_model(Status{InfectionState::Count}, Region(1));
+            curr_model.populations[{home, InfectionState::S}]                                        = num_cows_vec[i];
+            curr_model.populations[{home, InfectionState::E}]                                        = 0;
+            curr_model.populations[{home, InfectionState::I}]                                        = 0;
+            curr_model.populations[{home, InfectionState::INS}]                                      = 0;
+            curr_model.populations[{home, InfectionState::ICS}]                                      = 0;
+            curr_model.populations[{home, InfectionState::R}]                                        = 0;
+            curr_model.populations[{home, InfectionState::V}]                                        = 0;
+            curr_model.populations[{home, InfectionState::D}]                                        = 0;
+            curr_model.parameters.get<mio::smm::AdoptionRates<ScalarType, Status, Region>>() = adoption_rates;
+            builder.add_node(farm_ids[i], longitudes[i], latitudes[i], curr_model, t0);
+        }
+        for (size_t i = 0; i < num_edges_benchmark; ++i) {
+            builder.add_edge(from_exchanges[i], to_exchanges[i], interesting_indices);
+        }
+        auto graph2 = std::move(builder).build(true);
+        end         = std::chrono::high_resolution_clock::now();
+        duration    = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+
+        mio::log_info("New graph construction finished using {} edges in {} milliseconds", num_edges_benchmark,
+                      duration.count());
+
+        // auto nodes = graph.nodes() | std::views::transform([](const auto& node) {
+        //                  return &node.property;
+        //              });
+        // auto tree  = mio::geo::RTree(nodes.begin(), nodes.end());
+
+        // for (auto& node : graph.nodes()) {
+        //     node.property.set_regional_neighbors(
+        //         tree.in_range_indices_query(node.property.get_location(), {mio::geo::kilometers(2.0)}));
+        // }
+
+        auto sim = mio::make_mobility_sim(t0, dt, std::move(graph));
+
+        for (size_t i = 0; i < dates.size(); ++i) {
+            sim.add_exchange(dates[i], num_animals_exchanges[i], from_exchanges[i], to_exchanges[i]);
+        }
+
+        mio::log_info("Starting and immediately finishing simulation");
+    }
+    return 0;
+}