Location.h

Go to the documentation of this file.

/*
 *  This is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *  The software is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  You should have received a copy of the GNU General Public License
 *  along with the software. If not, see <http://www.gnu.org/licenses/>.
 *
 *  Copyright 2018, 2019, Jan Broeckhove and Bistromatics group.
 */

#pragma once

#include "contact/ContactType.h"
#include "contact/IdSubscriptArray.h"
#include "geopop/Coordinate.h"
#include "util/SegmentedVector.h"

#include <iostream>
#include <memory>
#include <set>
#include <string>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <vector>

namespace stride {
class ContactPool;
}

namespace geopop {

class Location
{
public:
        Location(unsigned int id, unsigned int province, Coordinate coordinate = Coordinate(0.0, 0.0),
                 std::string name = "", unsigned int popCount = 0U);

        bool operator==(const Location& other) const;

        void AddIncomingCommute(std::shared_ptr<Location> otherLocation, double fraction);

        void AddOutgoingCommute(std::shared_ptr<Location> otherLocation, double fraction);

        const Coordinate GetCoordinate() const { return m_coordinate; }

        unsigned int GetID() const { return m_id; }

        int GetIncomingCommuteCount(double fractionCommuters) const;

        unsigned int GetInfectedCount() const;

        std::string GetName() const { return m_name; }

        unsigned int GetOutgoingCommuteCount(double fractionCommuters) const;

        unsigned int GetPopCount() const { return m_pop_count; }

        unsigned int GetProvince() const { return m_province; }

        double GetPopFraction() const;

        void SetCoordinate(const Coordinate& coordinate) { m_coordinate = coordinate; }

        void SetPopCount(unsigned int totalPopCount);

        void SetPopFraction(double relativePopulation);

public:
        const stride::util::SegmentedVector<stride::ContactPool*>& CRefPools(stride::ContactType::Id id) const
        {
                return m_pool_index[id];
        }

        template <stride::ContactType::Id T>
        const stride::util::SegmentedVector<stride::ContactPool*>& CRefPools() const
        {
                return m_pool_index[T];
        }

        stride::util::SegmentedVector<stride::ContactPool*>& RefPools(stride::ContactType::Id id)
        {
                return m_pool_index[id];
        }

        template <stride::ContactType::Id T>
        stride::util::SegmentedVector<stride::ContactPool*>& RefPools()
        {
                return m_pool_index[T];
        }

        void RegisterPool(stride::ContactPool* p, stride::ContactType::Id typeId)
        {
                m_pool_index[typeId].emplace_back(p);
        }

        template <stride::ContactType::Id T>
        void RegisterPool(stride::ContactPool* p)
        {
                m_pool_index[T].emplace_back(p);
        }

public:
        const std::vector<std::pair<Location*, double>>& CRefIncomingCommutes() const { return m_inCommutes; }

        const std::vector<std::pair<Location*, double>>& CRefOutgoingCommutes() const { return m_outCommutes; }

private:
        Coordinate   m_coordinate;   
        unsigned int m_id = 0U;      
        std::string  m_name;         
        unsigned int m_pop_count;    
        double       m_pop_fraction; 
        unsigned int m_province;     

        std::vector<std::pair<Location*, double>> m_inCommutes;

        std::vector<std::pair<Location*, double>> m_outCommutes;

        stride::ContactType::IdSubscriptArray<stride::util::SegmentedVector<stride::ContactPool*>> m_pool_index;
};

} // namespace geopop