person.h

Go to the documentation of this file.

/* 
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Daniel Abele, Elisabeth Kluth, David Kerkmann, 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_PERSON_H
#define MIO_ABM_PERSON_H
 
#include "abm/infection.h"
#include "abm/infection_state.h"
#include "abm/location_id.h"
#include "abm/location.h"
#include "abm/location_type.h"
#include "abm/parameters.h"
#include "abm/person_id.h"
#include "abm/personal_rng.h"
#include "memilio/io/default_serialize.h"
#include "abm/time.h"
#include "abm/test_type.h"
#include "abm/protection_event.h"
#include "abm/intervention_type.h"
#include "abm/mask.h"
#include "abm/mobility_data.h"
#include "memilio/epidemiology/age_group.h"
#include "memilio/utils/random_number_generator.h"
#include <cstdint>
 
namespace mio
{
namespace abm
{
 
class Person
{
public:
    explicit Person(mio::RandomNumberGenerator& rng, LocationType location_type, LocationId location_id,
                    int location_model_id, AgeGroup age, PersonId person_id = PersonId::invalid_ID());
 
    explicit Person(const Person& other, PersonId person_id);
 
    bool operator==(const Person& other) const
    {
        return (m_person_id == other.m_person_id);
    }
 
    Infection& get_infection();
    const Infection& get_infection() const;
 
    std::vector<ProtectionEvent>& get_vaccinations()
    {
        return m_vaccinations;
    }
 
    const std::vector<ProtectionEvent>& get_vaccinations() const
    {
        return m_vaccinations;
    }
    bool is_infected(TimePoint t) const;
 
    InfectionState get_infection_state(TimePoint t) const;
 
    void add_new_infection(Infection&& inf);
 
    AgeGroup get_age() const
    {
        return m_age;
    }
 
    LocationId get_location() const;
 
    LocationType get_location_type() const
    {
        return m_location_type;
    }
 
    int get_location_model_id() const
    {
        return m_location_model_id;
    }
 
    void set_location(LocationType type, LocationId id, int model_id);
 
    TimeSpan get_time_at_location() const
    {
        return m_time_at_location;
    }
 
    void add_time_at_location(const TimeSpan dt)
    {
        m_time_at_location += dt;
    }
 
    void set_assigned_location(LocationType type, LocationId id, int model_id);
 
    LocationId get_assigned_location(LocationType type) const;
 
    const std::vector<LocationId>& get_assigned_locations() const
    {
        return m_assigned_locations;
    }
 
    int get_assigned_location_model_id(LocationType type) const;
 
    const std::vector<int>& get_assigned_location_model_ids() const
    {
        return m_assigned_location_model_ids;
    }
 
    bool goes_to_work(TimePoint t, const Parameters& params) const;
 
    TimeSpan get_go_to_work_time(const Parameters& params) const;
 
    bool goes_to_school(TimePoint t, const Parameters& params) const;
 
    TimeSpan get_go_to_school_time(const Parameters& params) const;
 
    bool is_in_quarantine(TimePoint t, const Parameters& params) const
    {
        return t < m_home_isolation_start + params.get<mio::abm::QuarantineDuration>();
    }
 
    void remove_quarantine();
 
    bool get_tested(PersonalRandomNumberGenerator& rng, TimePoint t, const TestParameters& params);
 
    PersonId get_id() const;
 
    std::vector<uint32_t>& get_cells();
 
    const std::vector<uint32_t>& get_cells() const;
 
    Mask& get_mask()
    {
        return m_mask;
    }
 
    const Mask& get_mask() const
    {
        return m_mask;
    }
 
    ScalarType get_mask_protective_factor(const Parameters& params) const;
 
    void set_compliance(InterventionType intervention_type, ScalarType value)
    {
        m_compliance[static_cast<uint32_t>(intervention_type)] = value;
    }
 
    ScalarType get_compliance(InterventionType intervention_type) const
    {
        return m_compliance[static_cast<uint32_t>(intervention_type)];
    }
 
    bool is_compliant(PersonalRandomNumberGenerator& rng, InterventionType intervention) const;
 
    void set_mask(MaskType type, TimePoint t);
 
    ScalarType get_protection_factor(TimePoint t, VirusVariant virus, const Parameters& params) const;
 
    void add_new_vaccination(ProtectionType v, TimePoint t)
    {
        m_vaccinations.push_back(ProtectionEvent(v, t));
    }
 
    mio::abm::TransportMode get_last_transport_mode() const
    {
        return m_last_transport_mode;
    }
 
    void set_last_transport_mode(const mio::abm::TransportMode mode)
    {
        m_last_transport_mode = mode;
    }
 
    Counter<uint32_t>& get_rng_counter()
    {
        return m_rng_counter;
    }
 
    uint32_t get_rng_index()
    {
        return m_rng_index;
    }
 
    mio::Key<uint64_t> get_rng_key()
    {
        return m_rng_key;
    }
 
    ProtectionEvent get_latest_protection(TimePoint t) const;
 
    auto default_serialize()
    {
        return Members("Person")
            .add("location", m_location)
            .add("location_type", m_location_type)
            .add("assigned_locations", m_assigned_locations)
            .add("vaccinations", m_vaccinations)
            .add("infections", m_infections)
            .add("home_isolation_start", m_home_isolation_start)
            .add("age_group", m_age)
            .add("time_at_location", m_time_at_location)
            .add("rnd_workgroup", m_random_workgroup)
            .add("rnd_schoolgroup", m_random_schoolgroup)
            .add("rnd_go_to_work_hour", m_random_goto_work_hour)
            .add("rnd_go_to_school_hour", m_random_goto_school_hour)
            .add("mask", m_mask)
            .add("compliance", m_compliance)
            .add("cells", m_cells)
            .add("last_transport_mode", m_last_transport_mode)
            .add("rng_counter", m_rng_counter)
            .add("test_results", m_test_results)
            .add("id", m_person_id)
            .add("rng_index", m_rng_index);
    }
 
    void add_test_result(TimePoint t, TestType type, bool result);
 
    TestResult get_test_result(TestType type) const;
 
private:
    LocationId m_location; 
    LocationType m_location_type; 
    int m_location_model_id; 
    std::vector<LocationId> m_assigned_locations; 
    std::vector<ProtectionEvent> m_vaccinations; 
    std::vector<Infection> m_infections; 
    TimePoint m_home_isolation_start; 
    AgeGroup m_age; 
    TimeSpan m_time_at_location; 
    ScalarType
        m_random_workgroup; 
    ScalarType
        m_random_schoolgroup; 
    ScalarType m_random_goto_work_hour; 
    ScalarType m_random_goto_school_hour; 
    Mask m_mask; 
    std::vector<ScalarType>
        m_compliance; 
    std::vector<uint32_t> m_cells; 
    mio::abm::TransportMode m_last_transport_mode; 
    CustomIndexArray<TestResult, TestType> m_test_results; 
    std::vector<int>
        m_assigned_location_model_ids; 
    PersonId m_person_id; 
    mio::Key<uint64_t> m_rng_key; 
    uint32_t m_rng_index; 
    Counter<uint32_t> m_rng_counter{0}; 
};
 
} // namespace abm
 
template <>
struct DefaultFactory<abm::Person> {
    static abm::Person create()
    {
        return abm::Person(thread_local_rng(), abm::LocationType::Count, abm::LocationId(), 0, AgeGroup(0),
                           abm::PersonId());
    }
};
 
} // namespace mio
 
#endif