location.h

Go to the documentation of this file.

/* 
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Daniel Abele, Elisabeth Kluth, Khoa Nguyen, David Kerkmann
*
* 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_LOCATION_H
#define MIO_ABM_LOCATION_H
 
#include "abm/location_id.h"
#include "abm/mask_type.h"
#include "abm/parameters.h"
#include "abm/location_type.h"
 
#include "memilio/geography/geolocation.h"
#include "memilio/io/default_serialize.h"
#include "boost/atomic/atomic.hpp"
 
namespace mio
{
namespace abm
{
 
struct CellIndex : public mio::Index<CellIndex> {
    CellIndex(size_t i)
        : mio::Index<CellIndex>(i)
    {
    }
};
 
using ContactExposureRates = CustomIndexArray<boost::atomic<ScalarType>, CellIndex, VirusVariant, AgeGroup>;
using AirExposureRates     = CustomIndexArray<boost::atomic<ScalarType>, CellIndex, VirusVariant>;
 
struct CellCapacity {
    CellCapacity()
        : volume(0)
        , persons(std::numeric_limits<int>::max())
    {
    }
    uint32_t volume; 
    uint32_t persons; 
 
    auto default_serialize()
    {
        return Members("CellCapacity").add("volume", volume).add("persons", persons);
    }
};
 
struct Cell {
    CellCapacity m_capacity;
 
    ScalarType compute_space_per_person_relative() const;
 
    auto default_serialize()
    {
        return Members("Cell").add("capacity", m_capacity);
    }
}; // namespace mio
 
class Location
{
public:
    explicit Location(LocationType loc_type, LocationId loc_id, size_t num_agegroups = 1, int model_id = 0,
                      uint32_t num_cells = 1);
 
    explicit Location(const Location& other, LocationId id, int model_id = 0)
        : Location(other)
    {
        m_id       = id;
        m_model_id = model_id;
    }
 
    bool operator==(const Location& other) const
    {
        return (m_id == other.m_id);
    }
 
    bool operator!=(const Location& other) const
    {
        return !(*this == other);
    }
 
    LocationType get_type() const
    {
        return m_type;
    }
 
    LocationId get_id() const
    {
        return m_id;
    }
 
    LocalInfectionParameters& get_infection_parameters()
    {
        return m_parameters;
    }
 
    const LocalInfectionParameters& get_infection_parameters() const
    {
        return m_parameters;
    }
    const std::vector<Cell>& get_cells() const
    {
        return m_cells;
    }
 
    MaskType get_required_mask() const
    {
        return m_required_mask;
    }
 
    void set_required_mask(MaskType type)
    {
        m_required_mask = type;
    }
 
    void set_capacity(uint32_t persons, uint32_t volume, uint32_t cell_idx = 0)
    {
        assert(cell_idx < m_cells.size() && "Given cell index is too large.");
        m_cells[cell_idx].m_capacity.persons = persons;
        m_cells[cell_idx].m_capacity.volume  = volume;
    }
 
    CellCapacity get_capacity(uint32_t cell_idx = 0) const
    {
        assert(cell_idx < m_cells.size() && "Given cell index is too large.");
        return m_cells[cell_idx].m_capacity;
    }
 
    bool is_mask_required() const
    {
        return m_required_mask != MaskType::None;
    }
 
    mio::geo::GeographicalLocation get_geographical_location() const
    {
        return m_geographical_location;
    }
 
    void set_geographical_location(mio::geo::GeographicalLocation location)
    {
        m_geographical_location = location;
    }
 
    auto default_serialize()
    {
        return Members("Location")
            .add("type", m_type)
            .add("id", m_id)
            .add("parameters", m_parameters)
            .add("cells", m_cells)
            .add("required_mask", m_required_mask)
            .add("geographical_location", m_geographical_location);
    }
 
    int get_model_id() const
    {
        return m_model_id;
    }
 
private:
    friend DefaultFactory<Location>;
    Location() = default;
 
    LocationType m_type; 
    LocationId m_id; 
    LocalInfectionParameters m_parameters; 
    std::vector<Cell> m_cells{}; 
    MaskType m_required_mask; 
    mio::geo::GeographicalLocation
        m_geographical_location; 
    int m_model_id; 
};
 
} // namespace abm
} // namespace mio
 
#endif