graph_abm_mobility.h

Go to the documentation of this file.

/*
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Julia Bicker
*
* 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 MIO_ABM_GRAPH_MOBILITY_H
#define MIO_ABM_GRAPH_MOBILITY_H
 
#include "abm/simulation.h"
#include "abm/time.h"
#include "abm/location_type.h"
#include "graph_abm/graph_abmodel.h"
#include "memilio/mobility/graph_simulation.h"
#include "memilio/mobility/graph.h"
 
#include <algorithm>
#include <utility>
 
namespace mio
{
template <class... History>
class ABMSimulationNode
{
 
public:
    using Sim = abm::Simulation<abm::GraphABModel>;
 
    template <class... Args, typename = std::enable_if_t<std::is_constructible<Sim, Args...>::value, void>>
    ABMSimulationNode(std::tuple<History...>&& history, Args&&... args)
        : m_simulation(std::forward<Args>(args)...)
        , m_history(history)
    {
    }
 
    Sim& get_simulation()
    {
        return m_simulation;
    }
    const Sim& get_simulation() const
    {
        return m_simulation;
    }
 
    std::tuple<History...>& get_history()
    {
        return m_history;
    }
    const std::tuple<History...>& get_history() const
    {
        return m_history;
    }
 
    void advance(mio::abm::TimePoint t, mio::abm::TimeSpan dt)
    {
        m_simulation.advance(t + dt, std::get<0>(m_history));
    }
 
private:
    Sim m_simulation; 
    std::tuple<History...> m_history;
};
 
template <class... History>
class ABMMobilityEdge
{
 
public:
    void apply_mobility(ABMSimulationNode<History...>& node_from, ABMSimulationNode<History...>& node_to,
                        abm::TimePoint /*t*/)
    {
        auto& model_from        = node_from.get_simulation().get_model();
        auto& model_to          = node_to.get_simulation().get_model();
        auto& persons_to_change = model_from.get_person_buffer();
        //sort vector such that we start removing the persons from the bottom
        std::sort(persons_to_change.begin(), persons_to_change.end());
        //iterate over all persons that change from node_from
        for (int i = int(persons_to_change.size()) - 1; i >= 0; --i) {
            auto& person     = model_from.get_persons()[persons_to_change[i]];
            auto target_type = person.get_location_type();
            if (target_type == abm::LocationType::Invalid) {
                target_type = model_to.get_location(person.get_location()).get_type();
            }
            //check if Person uses this edge
            if (person.get_assigned_location_model_id(target_type) == model_to.get_id()) {
 
                auto target_id = person.get_assigned_location(target_type);
                //set correct location for person
                person.set_location(target_type, target_id, model_to.get_id());
                //add person to model_to
                model_to.add_person(std::move(person));
                //remove person from model_from
                model_from.remove_person(persons_to_change[i]);
                //correct indices in persons buffer from node_from
                //here it is required that the vector is sorted
                for (size_t j = i + 1; j < persons_to_change.size(); ++j) {
                    persons_to_change[j]--;
                }
                //delete current index from list
                persons_to_change.erase(persons_to_change.begin() + i);
            }
        }
    }
};
 
template <class... History>
void apply_mobility(abm::TimePoint t, abm::TimeSpan /*dt*/, ABMMobilityEdge<History...>& edge,
                    ABMSimulationNode<History...>& node_from, ABMSimulationNode<History...>& node_to)
{
    edge.apply_mobility(node_from, node_to, t);
}
 
template <class... History>
void advance_model(abm::TimePoint t, abm::TimeSpan dt, ABMSimulationNode<History...>& node)
{
    node.advance(t, dt);
}
 
template <class... History>
GraphSimulation<ScalarType, Graph<ABMSimulationNode<History...>, ABMMobilityEdge<History...>>, abm::TimePoint,
                abm::TimeSpan,
                void (*)(mio::abm::TimePoint, mio::abm::TimeSpan, mio::ABMMobilityEdge<History...>&,
                         mio::ABMSimulationNode<History...>&, mio::ABMSimulationNode<History...>&),
                void (*)(mio::abm::TimePoint, mio::abm::TimeSpan, mio::ABMSimulationNode<History...>&)>
make_abm_graph_sim(abm::TimePoint t0, abm::TimeSpan dt,
                   Graph<ABMSimulationNode<History...>, ABMMobilityEdge<History...>>&& graph)
{
    return make_graph_sim<ScalarType>(t0, dt, std::move(graph), &advance_model<History...>,
                                      &apply_mobility<History...>);
}
 
} // namespace mio
 
#endif // MIO_ABM_GRAPH_MOBILITY_H