infection.h

Go to the documentation of this file.

/*
* Copyright (C) 2020-2026 MEmilio
*
* Authors: David Kerkmann, Sascha Korf, Khoa Nguyen
*
* 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_INFECTION_H
#define MIO_ABM_INFECTION_H
 
#include "abm/personal_rng.h"
#include "memilio/io/default_serialize.h"
#include "abm/time.h"
#include "abm/infection_state.h"
#include "abm/virus_variant.h"
#include "abm/parameters.h"
 
#include <vector>
 
namespace mio
{
namespace abm
{
 
struct StateTransition {
    InfectionState from_state;
    InfectionState to_state;
    TimeSpan duration; // Duration that the infection stays in from_state before transitioning to to_state.
};
 
struct ViralLoad {
    TimePoint start_date; 
    TimePoint end_date; 
    ScalarType peak; 
    ScalarType incline; 
    ScalarType decline; 
 
    auto default_serialize()
    {
        return Members("ViralLoad")
            .add("start_date", start_date)
            .add("end_date", end_date)
            .add("peak", peak)
            .add("incline", incline)
            .add("decline", decline);
    }
};
 
using InitialInfectionStateDistribution = CustomIndexArray<AbstractParameterDistribution, VirusVariant, AgeGroup>;
 
class Infection
{
public:
    Infection(PersonalRandomNumberGenerator& rng, VirusVariant virus, AgeGroup age, const Parameters& params,
              TimePoint start_date, InfectionState start_state = InfectionState::Exposed,
              ProtectionEvent latest_protection = {ProtectionType::NoProtection, TimePoint(0)}, bool detected = false);
 
    Infection(PersonalRandomNumberGenerator& rng, VirusVariant virus, AgeGroup age, const Parameters& params,
              TimePoint init_date, InfectionState init_state, const InitialInfectionStateDistribution& init_state_dist,
              ProtectionEvent latest_protection = {ProtectionType::NoProtection, TimePoint(0)}, bool detected = false);
 
    ScalarType get_viral_load(TimePoint t) const;
 
    ScalarType get_viral_shed(TimePoint t) const;
 
    VirusVariant get_virus_variant() const;
 
    InfectionState get_infection_state(TimePoint t) const;
 
    void set_detected();
 
    bool is_detected() const;
 
    TimePoint get_start_date() const;
 
    auto default_serialize()
    {
        return Members("Infection")
            .add("infection_course", m_infection_course)
            .add("virus_variant", m_virus_variant)
            .add("viral_load", m_viral_load)
            .add("log_norm_alpha", m_log_norm_alpha)
            .add("log_norm_beta", m_log_norm_beta)
            .add("individual_viral_shed_factor", m_individual_viral_shed_factor)
            .add("detected", m_detected);
    }
 
private:
    friend DefaultFactory<Infection>;
    Infection() = default;
 
    void draw_infection_course_forward(PersonalRandomNumberGenerator& rng, AgeGroup age, const Parameters& params,
                                       TimePoint init_date, InfectionState init_state,
                                       ProtectionEvent latest_protection);
 
    TimePoint draw_infection_course_backward(PersonalRandomNumberGenerator& rng, AgeGroup age, const Parameters& params,
                                             TimePoint init_date, InfectionState init_state);
 
    void initialize_viral_load(PersonalRandomNumberGenerator& rng, VirusVariant virus, AgeGroup age,
                               const Parameters& params, ProtectionEvent latest_protection);
 
    void initialize_viral_shed(PersonalRandomNumberGenerator& rng, VirusVariant virus, AgeGroup age,
                               const Parameters& params);
 
    StateTransition get_forward_transition(PersonalRandomNumberGenerator& rng, AgeGroup age, const Parameters& params,
                                           InfectionState current_state, TimePoint current_time,
                                           ProtectionEvent latest_protection) const;
 
    StateTransition get_backward_transition(PersonalRandomNumberGenerator& rng, AgeGroup age, const Parameters& params,
                                            InfectionState current_state) const;
 
    StateTransition get_recovered_backward_transition(PersonalRandomNumberGenerator& rng, AgeGroup age,
                                                      const Parameters& params) const;
 
    StateTransition get_dead_backward_transition(PersonalRandomNumberGenerator& rng, AgeGroup age,
                                                 const Parameters& params) const;
 
    ScalarType calculate_death_probability(AgeGroup age, const Parameters& params) const;
 
    ScalarType get_severity_protection_factor(const Parameters& params, ProtectionEvent latest_protection, AgeGroup age,
                                              TimePoint current_time) const;
 
    std::vector<std::pair<TimePoint, InfectionState>> m_infection_course; 
    VirusVariant m_virus_variant; 
    ViralLoad m_viral_load; 
    ScalarType m_log_norm_alpha,
        m_log_norm_beta; 
    ScalarType m_individual_viral_shed_factor; 
    bool m_detected; 
};
 
} // namespace abm
} // namespace mio
 
#endif