ide_secir/model.h

Go to the documentation of this file.

/* 
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Anna Wendler, Lena Ploetzke, 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 IDESECIR_MODEL_H
#define IDESECIR_MODEL_H
 
#include "ide_secir/parameters.h"
#include "ide_secir/infection_state.h"
#include "memilio/config.h"
#include "memilio/epidemiology/age_group.h"
#include "memilio/utils/custom_index_array.h"
#include "memilio/utils/date.h"
#include "memilio/utils/time_series.h"
 
#include "vector"
 
namespace mio
{
namespace isecir
{
// Forward declaration of friend classes/functions of Model.
class Model;
class Simulation;
template <typename EntryType>
IOResult<void> set_initial_flows(Model& model, const ScalarType dt, const std::vector<EntryType> rki_data,
                                 const Date date, const CustomIndexArray<ScalarType, AgeGroup> scale_confirmed_cases);
 
class Model
{
    using ParameterSet = Parameters;
 
public:
    Model(TimeSeries<ScalarType>&& transitions_init, CustomIndexArray<ScalarType, AgeGroup> N_init,
          CustomIndexArray<ScalarType, AgeGroup> deaths_init, size_t num_agegroups,
          CustomIndexArray<ScalarType, AgeGroup> total_confirmed_cases_init = CustomIndexArray<ScalarType, AgeGroup>());
 
    // ---- Additional functionality such as constraint checking, setters and getters, etc. ----
    bool check_constraints(ScalarType dt) const;
 
    int get_transition_flat_index(Eigen::Index transition_idx, AgeGroup agegroup) const
    {
        return (static_cast<int>(size_t(agegroup)) * int(InfectionTransition::Count) + int(transition_idx));
    }
 
    int get_state_flat_index(Eigen::Index state_idx, AgeGroup agegroup) const
    {
        return (static_cast<int>(size_t(agegroup)) * int(InfectionState::Count) + int(state_idx));
    }
 
    ScalarType get_global_support_max(ScalarType dt) const;
 
    int get_initialization_method_compartments() const
    {
        return m_initialization_method;
    }
 
    size_t get_num_agegroups() const
    {
        return m_num_agegroups;
    }
 
    void set_tol_for_support_max(ScalarType new_tol)
    {
        m_tol = new_tol;
    }
 
    // ---- Public parameters. ----
    ParameterSet parameters{AgeGroup(m_num_agegroups)}; 
    // Attention: populations and transitions do not necessarily have the same number of time points due to the
    // initialization part.
    TimeSeries<ScalarType>
        transitions; 
    // one #InfectionState to another as defined in #InfectionTransition%s for every AgeGroup.
    TimeSeries<ScalarType> populations; 
    // people in defined #InfectionState%s for every AgeGroup.
    CustomIndexArray<ScalarType, AgeGroup>
        total_confirmed_cases; 
 
private:
    // ---- Functionality to calculate the sizes of the compartments for time t0. ----
    void compute_compartment_from_flows(ScalarType dt, Eigen::Index idx_InfectionState, AgeGroup group,
                                        Eigen::Index idx_IncomingFlow, int idx_TransitionDistribution1,
                                        int idx_TransitionDistribution2 = 0);
 
    void initial_compute_compartments_infection(ScalarType dt);
 
    void initial_compute_compartments(ScalarType dt);
 
    // ---- Functionality for the iterations of a simulation. ----
    void compute_susceptibles(ScalarType dt);
 
    void compute_flow(Eigen::Index idx_InfectionTransitions, Eigen::Index idx_IncomingFlow, ScalarType dt,
                      Eigen::Index current_time_index, AgeGroup group);
 
    void compute_flow(Eigen::Index idx_InfectionTransitions, Eigen::Index idx_IncomingFlow, ScalarType dt,
                      AgeGroup group);
 
    void flows_current_timestep(ScalarType dt);
 
    void update_compartment_from_flow(InfectionState infectionState,
                                      std::vector<InfectionTransition> const& IncomingFlows,
                                      std::vector<InfectionTransition> const& OutgoingFlows, AgeGroup group);
 
    void update_compartments();
 
    void compute_forceofinfection(ScalarType dt, bool initialization = false);
 
    // ---- Functionality to set vectors with necessary information regarding TransitionDistributions. ----
    void set_transitiondistributions_support_max(ScalarType dt);
 
    void set_transitiondistributions_derivative(ScalarType dt);
 
    void set_transitiondistributions_in_forceofinfection(ScalarType dt);
 
    // ---- Private parameters. ----
    CustomIndexArray<ScalarType, AgeGroup> m_forceofinfection; 
    CustomIndexArray<ScalarType, AgeGroup>
        m_N; 
    ScalarType m_tol{1e-10}; 
    size_t m_num_agegroups; 
    int m_initialization_method{0}; 
    // See also get_initialization_method_compartments() for the number code.
    CustomIndexArray<std::vector<ScalarType>, AgeGroup> m_transitiondistributions_support_max; 
    // of Type AgeGroup containing a Vector containing the support_max for all TransitionDistributions.
    CustomIndexArray<std::vector<std::vector<ScalarType>>, AgeGroup>
        m_transitiondistributions_derivative; 
    //of Type AgeGroup containing a Vector containing the approximated derivative for all TransitionDistributions for
    // all necessary time points.
    CustomIndexArray<std::vector<std::vector<ScalarType>>, AgeGroup>
        m_transitiondistributions_in_forceofinfection; 
    // of Type AgeGroup containing a Vector containing the weighted TransitionDistributions for all necessary time
    // points in the force of infection term.
 
    // ---- Friend classes/functions. ----
    // In the Simulation class, the actual simulation is performed which is why it needs access to the here
    // defined (and private) functions to solve the model equations.
    friend class Simulation;
    // In set_initial_flows(), we compute initial flows based on RKI data using the (private) compute_flow() function
    // which is why it is defined as a friend function.
    template <typename EntryType>
    friend IOResult<void> set_initial_flows(Model& model, const ScalarType dt, const std::vector<EntryType> rki_data,
                                            const Date date,
                                            const CustomIndexArray<ScalarType, AgeGroup> scale_confirmed_cases);
};
 
} // namespace isecir
} // namespace mio
 
#endif // IDESECIR_MODEL_H