metapopulation_mobility_stochastic.h

Go to the documentation of this file.

/*
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Daniel Abele
*
* 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 METAPOPULATION_MOBILITY_STOCHASTIC_H
#define METAPOPULATION_MOBILITY_STOCHASTIC_H
 
#include "memilio/epidemiology/contact_matrix.h"
#include "memilio/mobility/graph_simulation.h"
#include "memilio/mobility/metapopulation_mobility_instant.h"
 
namespace mio
{
 
template <typename FP>
using MobilityCoefficients = DampingMatrixExpression<FP, VectorDampings<FP>>;
 
template <typename FP>
class MobilityParametersStochastic
{
public:
    MobilityParametersStochastic(const MobilityCoefficients<FP>& coeffs)
        : m_coefficients(coeffs)
    {
    }
 
    MobilityParametersStochastic(const Eigen::VectorX<FP>& coeffs)
        : m_coefficients(MobilityCoefficients<FP>(coeffs))
    {
    }
 
    bool operator==(const MobilityParametersStochastic& other) const
    {
        return m_coefficients == other.m_coefficients;
    }
    bool operator!=(const MobilityParametersStochastic& other) const
    {
        return m_coefficients != other.m_coefficients;
    }
 
    const MobilityCoefficients<FP>& get_coefficients() const
    {
        return m_coefficients;
    }
    MobilityCoefficients<FP>& get_coefficients()
    {
        return m_coefficients;
    }
    void set_coefficients(const MobilityCoefficients<FP>& coeffs)
    {
        m_coefficients = coeffs;
    }
 
    template <class IOContext>
    void serialize(IOContext& io) const
    {
        auto obj = io.create_object("MobilityParameters");
        obj.add_element("Coefficients", m_coefficients);
    }
 
    template <class IOContext>
    static IOResult<MobilityParametersStochastic> deserialize(IOContext& io)
    {
        auto obj = io.expect_object("MobilityParameters");
        auto c   = obj.expect_element("Coefficients", Tag<MobilityCoefficients<FP>>{});
        return apply(
            io,
            [](auto&& c_) {
                MobilityParametersStochastic params(c_);
                return params;
            },
            c);
    }
 
private:
    MobilityCoefficients<FP> m_coefficients; //one per group and compartment
};
 
template <typename FP>
class MobilityEdgeStochastic
{
public:
    MobilityEdgeStochastic(const MobilityParametersStochastic<FP>& params)
        : m_parameters(params)
    {
    }
 
    MobilityEdgeStochastic(const Eigen::VectorX<FP>& coeffs)
        : m_parameters(coeffs)
    {
    }
 
    const MobilityParametersStochastic<FP>& get_parameters() const
    {
        return m_parameters;
    }
 
    template <class Sim>
    Eigen::VectorX<FP> get_transition_rates(SimulationNode<FP, Sim>& node_from)
    {
        Eigen::VectorX<FP> transitionRates(node_from.get_last_state().size());
        for (Eigen::Index i = 0; i < node_from.get_last_state().size(); ++i) {
            transitionRates[i] =
                node_from.get_last_state()(i) * m_parameters.get_coefficients().get_baseline()[(size_t)i];
        }
        return transitionRates;
    }
 
    template <class Sim>
    void apply_mobility(size_t event, SimulationNode<FP, Sim>& node_from, SimulationNode<FP, Sim>& node_to);
 
private:
    MobilityParametersStochastic<FP> m_parameters;
};
 
template <typename FP>
template <class Sim>
void MobilityEdgeStochastic<FP>::apply_mobility(size_t event, SimulationNode<FP, Sim>& node_from,
                                                SimulationNode<FP, Sim>& node_to)
{
    node_from.get_result().get_last_value()[event] -= 1;
    node_to.get_result().get_last_value()[event] += 1;
}
 
template <typename FP, class Sim, class StochasticEdge>
void apply_mobility(StochasticEdge& mobilityEdge, size_t event, SimulationNode<FP, Sim>& node_from,
                    SimulationNode<FP, Sim>& node_to)
{
    mobilityEdge.apply_mobility(event, node_from, node_to);
}
 
template <typename FP, class Sim>
GraphSimulationStochastic<FP, Graph<SimulationNode<FP, Sim>, MobilityEdgeStochastic<FP>>>
make_mobility_sim(FP t0, FP dt, const Graph<SimulationNode<FP, Sim>, MobilityEdgeStochastic<FP>>& graph)
{
    return make_graph_sim_stochastic<FP>(
        t0, dt, graph, &advance_model<FP, Sim>,
        static_cast<void (*)(MobilityEdgeStochastic<FP>&, size_t, SimulationNode<FP, Sim>&, SimulationNode<FP, Sim>&)>(
            &apply_mobility<FP, Sim, MobilityEdgeStochastic<FP>>));
}
 
template <typename FP, class Sim>
GraphSimulationStochastic<FP, Graph<SimulationNode<FP, Sim>, MobilityEdgeStochastic<FP>>>
make_mobility_sim(FP t0, FP dt, Graph<SimulationNode<FP, Sim>, MobilityEdgeStochastic<FP>>&& graph)
{
    return make_graph_sim_stochastic<FP>(
        t0, dt, std::move(graph), &advance_model<FP, Sim>,
        static_cast<void (*)(MobilityEdgeStochastic<FP>&, size_t, SimulationNode<FP, Sim>&, SimulationNode<FP, Sim>&)>(
            &apply_mobility<FP, Sim, MobilityEdgeStochastic<FP>>));
}
 
} // namespace mio
 
#endif //METAPOPULATION_MOBILITY_STOCHASTIC_H