grid.h

Go to the documentation of this file.

#ifndef FPMAS_GRID_H
#define FPMAS_GRID_H
 
#include "fpmas/api/model/spatial/grid.h"
#include "fpmas/communication/communication.h"
#include "fpmas/random/random.h"
#include "spatial_model.h"
#include "fpmas/random/distribution.h"
 
namespace fpmas { namespace model {
    using api::model::DiscretePoint;
    using api::model::DiscreteCoordinate;
 
    struct PointHash {
        std::size_t operator()(const DiscretePoint& p) const;
    };
        
    template<typename GridCellType, typename Derived = GridCellType>
    class GridCellBase :
        public CellBase<api::model::GridCell, GridCellType, GridCellBase<GridCellType, Derived>> {
        friend nlohmann::adl_serializer<fpmas::api::utils::PtrWrapper<GridCellBase<GridCellType, Derived>>>;
        friend io::datapack::Serializer<fpmas::api::utils::PtrWrapper<GridCellBase<GridCellType, Derived>>>;
 
        private:
            DiscretePoint _location;
            random::FPMAS_AGENT_RNG _rd;
 
        public:
            typedef GridCellBase<GridCellType, Derived> JsonBase;
 
            GridCellBase() {}
 
            GridCellBase(DiscretePoint location)
                : _location(location) {}
 
            DiscretePoint location() const override {
                return _location;
            }
 
            random::FPMAS_AGENT_RNG& rd() override {
                return _rd;
            }
 
            void seed(random::FPMAS_AGENT_RNG::result_type seed) override {
                _rd.seed(seed);
            }
    };
 
    class GridCell : public GridCellBase<GridCell> {
        public:
            using GridCellBase<GridCell>::GridCellBase;
    };
 
    template<typename AgentType, typename GridCellType = model::GridCell, typename Derived = AgentType>
    class GridAgent :
        public SpatialAgentBase<api::model::GridAgent<GridCellType>, AgentType, GridCellType, GridAgent<AgentType, GridCellType, Derived>> {
            friend nlohmann::adl_serializer<api::utils::PtrWrapper<GridAgent<AgentType, GridCellType, Derived>>>;
            friend io::datapack::Serializer<api::utils::PtrWrapper<GridAgent<AgentType, GridCellType, Derived>>>;
            static_assert(std::is_base_of<api::model::GridCell, GridCellType>::value,
                    "The specified GridCellType must extend api::model::GridCell.");
 
            private:
            random::FPMAS_AGENT_RNG _rd;
            DiscretePoint location_point {0, 0};
 
            protected:
            using model::SpatialAgentBase<api::model::GridAgent<GridCellType>, AgentType, GridCellType, GridAgent<AgentType, GridCellType, Derived>>::moveTo;
            void moveTo(GridCellType* cell) override;
            void moveTo(DiscretePoint point) override;
 
            public:
            DiscretePoint locationPoint() const override {return location_point;}
 
            random::FPMAS_AGENT_RNG& rd() override {
                return _rd;
            }
 
            void seed(std::FPMAS_AGENT_RNG::result_type seed) override {
                _rd.seed(seed);
            }
        };
 
    template<typename AgentType, typename GridCellType, typename Derived>
        void GridAgent<AgentType, GridCellType, Derived>::moveTo(GridCellType* cell) {
            this->updateLocation(cell);
            location_point = cell->location();
        }
 
    template<typename AgentType, typename GridCellType, typename Derived>
        void GridAgent<AgentType, GridCellType, Derived>::moveTo(DiscretePoint point) {
            bool found = false;
            auto mobility_field = this->template outNeighbors<GridCellType>(SpatialModelLayers::MOVE);
            auto it = mobility_field.begin();
            while(!found && it != mobility_field.end()) {
                if((*it)->location() == point) {
                    found=true;
                } else {
                    it++;
                }
            }
            if(found)
                this->moveTo(*it);
            else
                throw api::model::OutOfMobilityFieldException(this->node()->getId(), this->locationPoint(), point);
        }
 
    template<typename GridCellType = GridCell>
        class GridCellFactory : public api::model::GridCellFactory<GridCellType> {
            public:
                GridCellType* build(DiscretePoint location) override {
                    return new GridCellType(location);
                }
        };
 
    template<>
        class GridCellFactory<api::model::GridCell> : public api::model::GridCellFactory<api::model::GridCell>{
            api::model::GridCell* build(DiscretePoint location) override {
                return new GridCell(location);
            }
        };
 
    typedef random::Index<DiscretePoint> GridAgentIndex;
 
    struct RandomGridAgentBuilder {
        static random::mt19937_64 rd;
 
        static void seed(random::mt19937_64::result_type seed);
    };
 
    template<typename CellType = GridCell>
        class GridAgentBuilder : public SpatialAgentBuilderBase<CellType, api::model::GridCell> {
            private:
                // Count of items by DiscretePoint (no entry <=> 0)
                std::map<DiscretePoint, std::size_t> item_counts;
                GridAgentIndex agent_begin {&item_counts};
                GridAgentIndex agent_end {&item_counts};
                std::map<GridAgentIndex, api::model::GridAgent<CellType>*> agent_index;
 
            public:
                void build(
                        api::model::SpatialModel<CellType>& model,
                        api::model::GroupList groups,
                        api::model::SpatialAgentFactory<CellType>& factory,
                        api::model::SpatialAgentMapping<api::model::GridCell>& agent_mapping
                        ) override;
 
                void build(
                        api::model::SpatialModel<CellType>& model,
                        api::model::GroupList groups,
                        std::function<api::model::SpatialAgent<CellType>*()> factory,
                        api::model::SpatialAgentMapping<api::model::GridCell>& agent_mapping
                        ) override;
 
                void initSample(
                        std::size_t n,
                        std::function<void(api::model::GridAgent<CellType>*)> init_function
                        ) const;
 
                template<typename T>
                    void initSequence(
                            const std::vector<T>& items,
                            std::function<void(
                                api::model::GridAgent<CellType>*,
                                typename std::vector<T>::const_reference
                                )> init_function
                            ) const;
        };
 
    template<typename CellType>
        void GridAgentBuilder<CellType>::build(
                api::model::SpatialModel<CellType>& model,
                api::model::GroupList groups,
                api::model::SpatialAgentFactory<CellType>& factory,
                api::model::SpatialAgentMapping<api::model::GridCell>& agent_mapping
                ) {
            this->build(model, groups, [&factory] () {return factory.build();}, agent_mapping);
        }
 
    template<typename CellType>
        void GridAgentBuilder<CellType>::build(
                api::model::SpatialModel<CellType>& model,
                api::model::GroupList groups,
                std::function<api::model::SpatialAgent<CellType>*()> factory,
                api::model::SpatialAgentMapping<api::model::GridCell>& agent_mapping
                ) {
            for(auto cell : model.cells()) {
                std::size_t count = agent_mapping.countAt(cell);
                if(count > 0)
                    // Does not insert useless null entries
                    item_counts[cell->location()]=count;
            }
 
            // Gather item counts from all processes
            communication::TypedMpi<decltype(item_counts)> item_counts_mpi(
                    model.getMpiCommunicator());
            item_counts =
                communication::all_reduce(item_counts_mpi, item_counts, utils::Concat());
 
            // Contains the current index of agents located at each location
            std::map<DiscretePoint, std::size_t> local_counts;
 
            // Built agents
            std::vector<api::model::GridAgent<CellType>*> agents;
 
            this->build_agents(model, groups, [&agents, &factory] {
                    auto agent = factory();
                    // Keep a reference to built agents
                    agents.push_back((api::model::GridAgent<CellType>*) agent);
                    return agent;
                    }, agent_mapping);
 
            agent_begin = GridAgentIndex::begin(&item_counts);
            agent_end = GridAgentIndex::end(&item_counts);
   
            for(std::size_t i = 0; i < agents.size(); i++) {
                std::size_t& offset = local_counts[agents[i]->locationPoint()];
                GridAgentIndex index(&item_counts, agents[i]->locationPoint(), offset);
                agent_index.insert({index, agents[i]});
 
                ++offset;
 
                // Generates seed from the current localion random number
                // generator (RNG).
                // Since the grid cell RNG initialization does not depend on
                // the current distribution, the grid agents RNG does not
                // depend neither on the distribution (i.e. the agent with the
                // current `index` is **always** associated to the same seed)
                agents[i]->seed(agents[i]->locationCell()->rd()());
            }
        }
 
    template<typename CellType>
        void GridAgentBuilder<CellType>::initSample(
                std::size_t n,
                std::function<void(api::model::GridAgent<CellType>*)> init_function
                ) const {
            std::vector<GridAgentIndex> indexes = random::sample_indexes(
                    agent_begin, agent_end, n, RandomGridAgentBuilder::rd);
            for(auto index : indexes) {
                auto it = agent_index.find(index);
                if(it != agent_index.end())
                    init_function(it->second);
            }
        }
 
    template<typename CellType>
        template<typename T>
        void GridAgentBuilder<CellType>::initSequence(
                const std::vector<T> &items,
                std::function<void (
                    api::model::GridAgent<CellType> *,
                    typename std::vector<T>::const_reference
                    )> init_function) const {
            GridAgentIndex grid_index = agent_begin;
            auto map_index = agent_index.begin();
            std::size_t i = 0;
            while(map_index != agent_index.end()) {
                if(map_index->first == grid_index) {
                    init_function(
                            map_index->second,
                            items[i]
                            );
                    ++map_index;
                }
                ++grid_index;
                ++i;
            }
        }
 
    template<typename BuilderType, typename DistanceType, typename _CellType = model::GridCell>
        struct GridConfig {
            typedef BuilderType Builder;
            typedef DistanceType Distance;
 
            typedef _CellType CellType;
        };
 
    template<typename DistanceType, typename PerimeterType>
        struct GridRangeConfig {
            typedef DistanceType Distance;
 
            typedef PerimeterType Perimeter;
        };
 
    template<typename GridConfig, typename GridRangeConfig>
        class GridRange : public api::model::Range<typename GridConfig::CellType> {
            private:
                static const typename GridConfig::Distance grid_distance;
                static const typename GridRangeConfig::Distance range_distance;
                static const typename GridRangeConfig::Perimeter perimeter;
                DiscreteCoordinate size;
 
            public:
                GridRange(DiscreteCoordinate size)
                    : size(size) {}
 
                DiscreteCoordinate getSize() const {
                    return size;
                }
 
                void setSize(DiscreteCoordinate size) {
                    this->size = size;
                }
 
                bool contains(
                        typename GridConfig::CellType* location_cell,
                        typename GridConfig::CellType* cell) const override {
                    if(this->getSize() < 0)
                        return false;
                    else
                        return range_distance(location_cell->location(), cell->location()) <= size;
                }
 
                // TODO: provide a figure with examples for VN range / VN
                // grid, VN range / Moore grid, Moore range / VN grid and
                // Moore range / Moore grid.
                std::size_t radius(typename GridConfig::CellType*) const override {
                    return grid_distance({0, 0}, perimeter(*this));
                }
        };
 
    template<typename GridConfig, typename RangeConfig>
        const typename GridConfig::Distance GridRange<GridConfig, RangeConfig>::grid_distance;
    template<typename GridConfig, typename RangeConfig>
        const typename RangeConfig::Distance GridRange<GridConfig, RangeConfig>::range_distance;
    template<typename GridConfig, typename RangeConfig>
        const typename RangeConfig::Perimeter GridRange<GridConfig, RangeConfig>::perimeter;
 
    template<
        template<typename> class SyncMode,
        typename CellType = model::GridCell,
        typename EndCondition = DynamicEndCondition<CellType>>
            using GridModel = SpatialModel<SyncMode, CellType, EndCondition>;
}}
 
FPMAS_DEFAULT_JSON(fpmas::model::GridCell)
FPMAS_DEFAULT_DATAPACK(fpmas::model::GridCell)
 
namespace nlohmann {
    template<>
        struct adl_serializer<fpmas::api::model::DiscretePoint> {
            static void to_json(nlohmann::json& j, const fpmas::api::model::DiscretePoint& point) {
                j = {point.x, point.y};
            }
            static void from_json(const nlohmann::json& j, fpmas::api::model::DiscretePoint& point) {
                point.x = j[0].get<fpmas::api::model::DiscreteCoordinate>();
                point.y = j[1].get<fpmas::api::model::DiscreteCoordinate>();
            }
        };
 
    template<typename GridCellType, typename Derived>
        struct adl_serializer<fpmas::api::utils::PtrWrapper<fpmas::model::GridCellBase<GridCellType, Derived>>> {
            typedef fpmas::api::utils::PtrWrapper<fpmas::model::GridCellBase<GridCellType, Derived>> Ptr;
 
            static void to_json(nlohmann::json& j, const Ptr& ptr) {
                // Derived serialization
                j[0] = fpmas::api::utils::PtrWrapper<Derived>(
                        const_cast<Derived*>(static_cast<const Derived*>(ptr.get())));
                // Current base serialization
                j[1] = ptr->_location;
                j[2] = ptr->_rd;
            }
 
            static Ptr from_json(const nlohmann::json& j) {
                // Derived unserialization.
                // The current base is implicitly default initialized
                fpmas::api::utils::PtrWrapper<Derived> derived_ptr
                    = j[0].get<fpmas::api::utils::PtrWrapper<Derived>>();
 
                // Initializes the current base
                derived_ptr->_location = j[1].get<fpmas::api::model::DiscretePoint>();
                derived_ptr->_rd = j[2].get<fpmas::random::FPMAS_AGENT_RNG>();
                return derived_ptr.get();
            }
        };
 
    template<typename AgentType, typename CellType, typename Derived>
        struct adl_serializer<fpmas::api::utils::PtrWrapper<fpmas::model::GridAgent<AgentType, CellType, Derived>>> {
            typedef fpmas::api::utils::PtrWrapper<fpmas::model::GridAgent<AgentType, CellType, Derived>> Ptr;
 
            static void to_json(nlohmann::json& j, const Ptr& ptr) {
                // Derived serialization
                j[0] = fpmas::api::utils::PtrWrapper<Derived>(
                        const_cast<Derived*>(static_cast<const Derived*>(ptr.get())));
                // Current base serialization
                j[1] = ptr->location_point;
                j[2] = ptr->_rd;
            }
 
            static Ptr from_json(const nlohmann::json& j) {
                // Derived unserialization.
                // The current base is implicitly default initialized
                fpmas::api::utils::PtrWrapper<Derived> derived_ptr
                    = j[0].get<fpmas::api::utils::PtrWrapper<Derived>>();
 
                // Initializes the current base
                derived_ptr->location_point = j[1].get<fpmas::api::model::DiscretePoint>();
                derived_ptr->_rd = j[2].get<fpmas::random::FPMAS_AGENT_RNG>();
                return derived_ptr.get();
            }
        };
 
}
 
namespace fpmas { namespace io { namespace json {
 
    template<typename GridCellType, typename Derived>
        struct light_serializer<PtrWrapper<fpmas::model::GridCellBase<GridCellType, Derived>>> {
            typedef PtrWrapper<fpmas::model::GridCellBase<GridCellType, Derived>> Ptr;
            static void to_json(light_json& j, const Ptr& cell) {
                // Derived serialization
                light_serializer<PtrWrapper<Derived>>::to_json(
                        j,
                        const_cast<Derived*>(static_cast<const Derived*>(cell.get()))
                        );
            }
 
            static Ptr from_json(const light_json& j) {
                // Derived unserialization.
                // The current base is implicitly default initialized
                PtrWrapper<Derived> derived_ptr
                    = light_serializer<PtrWrapper<Derived>>::from_json(j);
                return derived_ptr.get();
            }
        };
 
    template<typename AgentType, typename CellType, typename Derived>
        struct light_serializer<PtrWrapper<fpmas::model::GridAgent<AgentType, CellType, Derived>>> {
            typedef PtrWrapper<fpmas::model::GridAgent<AgentType, CellType, Derived>> Ptr;
 
            static void to_json(light_json& j, const Ptr& agent) {
                // Derived serialization
                light_serializer<PtrWrapper<Derived>>::to_json(
                        j,
                        const_cast<Derived*>(static_cast<const Derived*>(agent.get()))
                        );
            }
 
            static Ptr from_json(const light_json& j) {
                // Derived unserialization.
                // The current base is implicitly default initialized
                PtrWrapper<Derived> derived_ptr
                    = light_serializer<PtrWrapper<Derived>>::from_json(j);
                return derived_ptr.get();
            }
        };
 
}}}
 
namespace fpmas { namespace io { namespace datapack {
    template<typename GridCellType, typename Derived>
        struct Serializer<PtrWrapper<fpmas::model::GridCellBase<GridCellType, Derived>>> {
            typedef PtrWrapper<fpmas::model::GridCellBase<GridCellType, Derived>> Ptr;
 
            static std::size_t size(const ObjectPack& p, const Ptr& ptr) {
                PtrWrapper<Derived> derived = PtrWrapper<Derived>(
                        const_cast<Derived*>(static_cast<const Derived*>(ptr.get())));
                return p.size(derived) + p.size<api::model::DiscretePoint>()
                    + p.size(ptr->_rd);
            }
 
            static void to_datapack(ObjectPack& pack, const Ptr& ptr) {
                // Derived serialization
                PtrWrapper<Derived> derived = PtrWrapper<Derived>(
                        const_cast<Derived*>(static_cast<const Derived*>(ptr.get())));
                pack.put(derived);
                // Current base serialization (only location is needed)
                pack.put(ptr->_location);
                pack.put(ptr->_rd);
            }
 
            static Ptr from_datapack(const ObjectPack& pack) {
                // Derived unserialization.
                // The current base is implicitly default initialized
                PtrWrapper<Derived> derived_ptr = pack
                    .get<PtrWrapper<Derived>>();
 
                // Initializes the current base
                derived_ptr->_location = pack.get<fpmas::api::model::DiscretePoint>();
                derived_ptr->_rd = pack.get<fpmas::random::FPMAS_AGENT_RNG>();
                return derived_ptr.get();
            }
        };
 
    template<typename AgentType, typename CellType, typename Derived>
        struct Serializer<PtrWrapper<fpmas::model::GridAgent<AgentType, CellType, Derived>>> {
            typedef PtrWrapper<fpmas::model::GridAgent<AgentType, CellType, Derived>> Ptr;
 
            static std::size_t size(const ObjectPack& p, const Ptr& ptr) {
                return p.size(PtrWrapper<Derived>(
                        const_cast<Derived*>(static_cast<const Derived*>(ptr.get()))))
                    + p.size<fpmas::api::model::DiscretePoint>()
                    + p.size(ptr->_rd);
            }
 
            static void to_datapack(ObjectPack& pack, const Ptr& ptr) {
                // Derived serialization
                PtrWrapper<Derived> derived = PtrWrapper<Derived>(
                        const_cast<Derived*>(static_cast<const Derived*>(ptr.get())));
                pack.put(derived);
                // Current base serialization
                pack.put(ptr->location_point);
                pack.put(ptr->_rd);
            }
 
            static Ptr from_datapack(const ObjectPack& pack) {
                // Derived unserialization.
                // The current base is implicitly default initialized
                PtrWrapper<Derived> derived_ptr = pack
                    .get<PtrWrapper<Derived>>();
 
                // Initializes the current base
                derived_ptr->location_point =
                    pack.get<fpmas::api::model::DiscretePoint>();
                derived_ptr->_rd = pack.get<fpmas::random::FPMAS_AGENT_RNG>();
                return derived_ptr.get();
            }
        };
 
    template<typename GridCellType, typename Derived>
        struct LightSerializer<PtrWrapper<fpmas::model::GridCellBase<GridCellType, Derived>>> {
            typedef PtrWrapper<fpmas::model::GridCellBase<GridCellType, Derived>> Ptr;
 
            static std::size_t size(const LightObjectPack& p, const Ptr& ptr) {
                return p.size(PtrWrapper<Derived>(
                        const_cast<Derived*>(static_cast<const Derived*>(ptr.get()))
                        ));
            }
 
            static void to_datapack(LightObjectPack& pack, const Ptr& cell) {
                // Derived serialization
                LightSerializer<PtrWrapper<Derived>>::to_datapack(
                        pack,
                        const_cast<Derived*>(static_cast<const Derived*>(cell.get()))
                        );
            }
 
            static Ptr from_datapack(const LightObjectPack& pack) {
                // Derived unserialization.
                // The current base is implicitly default initialized
                PtrWrapper<Derived> derived_ptr
                    = LightSerializer<PtrWrapper<Derived>>::from_datapack(pack);
                return derived_ptr.get();
            }
        };
 
    template<typename AgentType, typename CellType, typename Derived>
        struct LightSerializer<PtrWrapper<fpmas::model::GridAgent<AgentType, CellType, Derived>>> {
            typedef PtrWrapper<fpmas::model::GridAgent<AgentType, CellType, Derived>> Ptr;
 
            static std::size_t size(const LightObjectPack& p, const Ptr& ptr) {
                return p.size(PtrWrapper<Derived>(
                        const_cast<Derived*>(static_cast<const Derived*>(ptr.get()))
                        ));
            }
 
            static void to_datapack(LightObjectPack& pack, const Ptr& agent) {
                // Derived serialization
                LightSerializer<PtrWrapper<Derived>>::to_datapack(
                        pack,
                        const_cast<Derived*>(static_cast<const Derived*>(agent.get()))
                        );
            }
 
            static Ptr from_datapack(const LightObjectPack& pack) {
                // Derived unserialization.
                // The current base is implicitly default initialized
                PtrWrapper<Derived> derived_ptr
                    = LightSerializer<PtrWrapper<Derived>>::from_datapack(pack);
                return derived_ptr.get();
            }
        };
 
    template<>
        struct Serializer<api::model::DiscretePoint> {
            static std::size_t size(const ObjectPack& p);
 
            static std::size_t size(const ObjectPack& p, const api::model::DiscretePoint&);
 
            static void to_datapack(
                    ObjectPack& pack, const api::model::DiscretePoint& point);
 
            static api::model::DiscretePoint from_datapack(const ObjectPack& pack);
        };
}}}
 
namespace std {
    template<>
    struct hash<fpmas::model::DiscretePoint> {
        static const fpmas::model::PointHash hasher;
        std::size_t operator()(const fpmas::model::DiscretePoint& p) const;
    };
}
#endif