mobility_io.h

Go to the documentation of this file.

/*
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Daniel Abele, Wadim Koslow, Henrik Zunker, Martin J. Kuehn
*
* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
*
* 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 MEMILIO_IO_MOBILITY_IO_H
#define MEMILIO_IO_MOBILITY_IO_H
 
#include "memilio/io/json_serializer.h"
#include "memilio/mobility/graph.h"
#include "memilio/data/analyze_result.h"
#include "memilio/mobility/metapopulation_mobility_instant.h"
 
namespace mio
{
 
std::vector<std::string> split(const std::string& s, char delimiter);
 
IOResult<int> count_lines(const std::string& filename);
 
IOResult<Eigen::MatrixXd> read_mobility_formatted(const std::string& filename);
 
IOResult<Eigen::MatrixXd> read_mobility_plain(const std::string& filename);
 
#ifdef MEMILIO_HAS_JSONCPP
 
template <typename FP, class Model>
IOResult<void> write_graph(const Graph<Model, MobilityParameters<FP>>& graph, const std::string& directory,
                           int ioflags = IOF_None)
{
    assert(graph.nodes().size() > 0 && "Graph Nodes are empty");
 
    std::string abs_path;
    BOOST_OUTCOME_TRY(auto&& created, create_directory(directory, abs_path));
 
    if (created) {
        log_info("Results are stored in {:s}/results.", mio::get_current_dir_name());
    }
    else {
        log_info("Results are stored in {:s}/results. Files from previous "
                 "graph will be "
                 "overwritten",
                 mio::get_current_dir_name());
    }
 
    //write two files per node
    //one file that contains outgoing edges from the node
    //one file for the model (parameters and population)
    for (auto inode = size_t(0); inode < graph.nodes().size(); ++inode) {
        //node
        const auto node = graph.nodes()[inode];
        BOOST_OUTCOME_TRY(auto&& js_node_model, serialize_json(node.property, ioflags));
        Json::Value js_node(Json::objectValue);
        js_node["NodeId"]  = node.id;
        js_node["Model"]   = js_node_model;
        auto node_filename = path_join(abs_path, "GraphNode" + std::to_string(inode) + ".json");
        BOOST_OUTCOME_TRY(write_json(node_filename, js_node));
 
        //list of edges
        auto out_edges = graph.out_edges(inode);
        if (out_edges.size()) {
            Json::Value js_edges(Json::arrayValue);
            for (auto& e : graph.out_edges(inode)) {
                BOOST_OUTCOME_TRY(auto&& js_edge_params, serialize_json(e.property, ioflags));
                Json::Value js_edge{Json::objectValue};
                js_edge["StartNodeIndex"] = Json::UInt64(e.start_node_idx);
                js_edge["EndNodeIndex"]   = Json::UInt64(e.end_node_idx);
                js_edge["Parameters"]     = js_edge_params;
                js_edges.append(std::move(js_edge));
            }
            auto edge_filename = path_join(abs_path, "GraphEdges_node" + std::to_string(inode) + ".json");
            BOOST_OUTCOME_TRY(write_json(edge_filename, js_edges));
        }
    }
 
    return success();
}
 
template <typename FP, class Model>
IOResult<Graph<Model, MobilityParameters<FP>>> read_graph(const std::string& directory, int ioflags = IOF_None,
                                                          bool read_edges = true)
{
    std::string abs_path;
    if (!file_exists(directory, abs_path)) {
        log_error("Directory {} does not exist.", directory);
        return failure(StatusCode::FileNotFound, directory);
    }
 
    auto graph = Graph<Model, MobilityParameters<FP>>{};
 
    //read nodes, as many as files are available
    for (auto inode = 0;; ++inode) {
        auto node_filename = path_join(abs_path, "GraphNode" + std::to_string(inode) + ".json");
        if (!file_exists(node_filename, node_filename)) {
            break;
        }
        BOOST_OUTCOME_TRY(auto&& js_node, read_json(node_filename));
        if (!js_node["NodeId"].isInt()) {
            log_error("NodeId field must be an integer.");
            return failure(StatusCode::InvalidType, node_filename + ", NodeId must be an integer.");
        }
        auto node_id = js_node["NodeId"].asInt();
        BOOST_OUTCOME_TRY(auto&& model, deserialize_json(js_node["Model"], Tag<Model>{}, ioflags));
        graph.add_node(node_id, model);
    }
 
    //read edges; nodes must already be available for that)
    if (read_edges) {
        for (auto inode = size_t(0); inode < graph.nodes().size(); ++inode) {
            //list of edges
            auto edge_filename = path_join(abs_path, "GraphEdges_node" + std::to_string(inode) + ".json");
            BOOST_OUTCOME_TRY(auto&& js_edges, read_json(edge_filename));
 
            for (auto& e : js_edges) {
                auto start_node_idx  = inode;
                auto js_end_node_idx = e["EndNodeIndex"];
                if (!js_end_node_idx.isUInt64()) {
                    log_error("EndNodeIndex must be an integer.");
                    return failure(StatusCode::InvalidType, edge_filename + ", EndNodeIndex must be an integer.");
                }
                auto end_node_idx = js_end_node_idx.asUInt64();
                if (end_node_idx >= graph.nodes().size()) {
                    log_error("EndNodeIndex not in range of number of graph nodes.");
                    return failure(StatusCode::OutOfRange,
                                   edge_filename + ", EndNodeIndex not in range of number of graph nodes.");
                }
                BOOST_OUTCOME_TRY(auto&& parameters,
                                  deserialize_json(e["Parameters"], Tag<MobilityParameters<FP>>{}, ioflags));
                graph.add_edge(start_node_idx, end_node_idx, parameters);
            }
        }
    }
 
    return success(graph);
}
 
#endif //MEMILIO_HAS_JSONCPP
#ifdef MEMILIO_HAS_HDF5
IOResult<void> save_edges(const std::vector<TimeSeries<ScalarType>>& results,
                          const std::vector<std::pair<int, int>>& ids, const std::string& filename);
 
IOResult<void> save_edges(const std::vector<std::vector<TimeSeries<ScalarType>>>& ensemble_edges,
                          const std::vector<std::pair<int, int>>& pairs_edges, const fs::path& result_dir,
                          bool save_single_runs = true, bool save_percentiles = true);
 
#endif //MEMILIO_HAS_HDF5
 
} // namespace mio
 
#endif // MEMILIO_IO_MOBILITY_IO_H