agent_manager.hh

Go to the documentation of this file.

#ifndef UTOPIA_CORE_AGENTMANAGER_HH
#define UTOPIA_CORE_AGENTMANAGER_HH
 
#include <algorithm>
#include <string_view>
 
#include "types.hh"
#include "exceptions.hh"
#include "agent.hh"
#include "select.hh"
 
namespace Utopia {
 
template<class AgentTraits, class Model>
class AgentManager{
public:
    using Self = AgentManager<AgentTraits, Model>;
 
    using Space = typename Model::Space;
 
    using Agent = Utopia::Agent<AgentTraits, Space>;
 
    using Entity = Agent;
 
    using AgentState = typename AgentTraits::State;
 
    static constexpr DimType dim = Space::dim;
 
    using SpaceVec = SpaceVecType<dim>;
 
    using MoveFunc = std::function<void(Agent&, const SpaceVec&)>;
 
    using PosFunc = std::function<SpaceVec(const SpaceVec&)>;
 
 
    using RuleFunc = std::function<AgentState(const std::shared_ptr<Agent>&)>;
 
 
    using VoidRuleFunc = std::function<void(const std::shared_ptr<Agent>&)>;
 
    using RNG = typename Model::RNG;
 
 
private:
    // -- Members --------–––––------------------------------------------------
    IndexType _id_counter;
 
    const std::shared_ptr<spdlog::logger> _log;
 
    const DataIO::Config _cfg;
 
    const std::shared_ptr<RNG> _rng;
 
    const std::shared_ptr<Space> _space;
 
    AgentContainer<Agent> _agents;
 
    MoveFunc _move_to_func;
 
    PosFunc _prepare_pos;
 
 
public:
    // -- Constructors --------------------------------------------------------
 
 
    AgentManager(const Model& model,
                 const DataIO::Config& custom_cfg = {})
    :
        _id_counter(0),
        _log(model.get_logger()),
        _cfg(setup_cfg(model, custom_cfg)),
        _rng(model.get_rng()),
        _space(model.get_space()),
        _agents(),
        _move_to_func(setup_move_to_func()),
        _prepare_pos(setup_prepare_pos_func())
    {
        setup_agents();
        _log->info("AgentManager is all set up.");
    }
 
 
    AgentManager(const Model& model,
                 const AgentState initial_state,
                 const DataIO::Config& custom_cfg = {})
    :
        _id_counter(0),
        _log(model.get_logger()),
        _cfg(setup_cfg(model, custom_cfg)),
        _rng(model.get_rng()),
        _space(model.get_space()),
        _agents(),
        _move_to_func(setup_move_to_func()),
        _prepare_pos(setup_prepare_pos_func())
    {
        setup_agents(initial_state);
        _log->info("AgentManager is all set up.");
    }
 
    const auto& log () const {
        return _log;
    }
 
    const DataIO::Config& cfg () const {
        return _cfg;
    }
 
    const std::shared_ptr<RNG>& rng () const {
        return _rng;
    }
 
    const std::shared_ptr<Space>& space () const {
        return _space;
    }
 
    const AgentContainer<Agent>& agents () const {
        return _agents;
    }
 
    const AgentContainer<Agent>& entities () const {
        return agents();
    }
 
    IndexType id_counter () const {
        return _id_counter;
    }
 
    // -- Public interface ----------------------------------------------------
    void move_to(const std::shared_ptr<Agent>& agent,
                 const SpaceVec& pos) const
    {
        _move_to_func(*agent, pos);
    }
 
    void move_to(Agent& agent,
                 const SpaceVec& pos) const
    {
        _move_to_func(agent, pos);
    }
 
    void move_by(const std::shared_ptr<Agent>& agent,
                 const SpaceVec& move_vec) const
    {
        _move_to_func(*agent, agent->position() + move_vec);
    }
 
    void move_by(Agent& agent,
                 const SpaceVec& move_vec) const
    {
        _move_to_func(agent, agent.position() + move_vec);
    }
 
 
 
    const std::shared_ptr<Agent>& add_agent (const AgentState& state,
                                             const SpaceVec& pos)
    {
        _log->trace("Creating agent with ID {:d} ...", _id_counter);
        _agents.emplace_back(
            std::make_shared<Agent>(_id_counter, state, _prepare_pos(pos))
        );
        ++_id_counter;
 
        return _agents.back();
    }
 
 
    const std::shared_ptr<Agent>& add_agent (const SpaceVec& pos,
                                             const Config& custom_cfg = {})
    {
        // Check if flag for default constructor was set
        if constexpr (AgentTraits::use_default_state_constructor) {
            if (custom_cfg.size()) {
                throw std::runtime_error("custom_cfg was passed but "
                    "AgentTraits specified use of default constructor!");
            }
 
            return add_agent(AgentState(), pos);
        }
        else {
            // Determine whether to use the given custom configuration or the
            // one  passed at construction of AgentManager
            DataIO::Config cfg;
 
            if (custom_cfg.size()) {
                cfg = custom_cfg;
            }
            else {
                cfg = _cfg["agent_params"];
            }
 
            // Distinguish the two config-constructible states
            if constexpr (std::is_constructible<AgentState,
                                                const DataIO::Config&,
                                                const std::shared_ptr<RNG>&
                                                >())
            {
                return add_agent(AgentState(cfg, _rng), pos);
            }
            else {
                // Should be config-constructible
                return add_agent(AgentState(cfg), pos);
            }
        }
 
    }
 
    const std::shared_ptr<Agent>& add_agent (const Config& custom_cfg = {}) {
        return add_agent(random_pos(), custom_cfg);
    }
 
 
    void remove_agent (const std::shared_ptr<Agent>& agent) {
        // Find the position in the agents container that belongs to the agent
        const auto it = std::find(_agents.cbegin(), _agents.cend(), agent);
 
        if (it == _agents.cend()) {
            throw std::invalid_argument("The given agent is not handled by "
                                        "this manager!");
        };
 
        _log->trace("Removing agent with ID {:d} ...", agent->id());
        _agents.erase(it);
    }
 
 
    template<typename UnaryPredicate>
    void erase_agent_if (UnaryPredicate&& condition) {
        _agents.erase(
            std::remove_if(_agents.begin(), _agents.end(), condition),
            _agents.cend()
        );
    }
 
 
 
    void update_agents() {
        // Assert that the agents update synchronously
        static_assert(AgentTraits::mode == Update::sync,
            "The update_agents method only makes sense to call when agents "
            "are set to be updated synchronously, which is not the case! "
            "Either adapt the AgentTraits to that update mode or remove the "
            "call to the update_agents method.");
 
        // Go through all agents and update them
        for (const auto& agent : _agents){
            agent->update();
        }
    }
 
    // .. Agent Selection .....................................................
 
    template<SelectionMode mode, class... Args>
    AgentContainer<Agent> select_agents(Args&&... args) {
        return select_entities<mode>(*this, std::forward<Args>(args)...);
    }
 
 
    AgentContainer<Agent> select_agents(const Config& sel_cfg) {
        return select_entities(*this, sel_cfg);
    }
 
    // .. Agent relations .....................................................
 
 
    SpaceVec displacement(const std::shared_ptr<Agent>& a,
                          const std::shared_ptr<Agent>& b) const
    {
        return this->_space->displacement(a->position(), b->position());
    }
 
 
    template<class NormType=std::size_t>
    double distance(const std::shared_ptr<Agent>& a,
                    const std::shared_ptr<Agent>& b,
                    const NormType p = 2) const
    {
        return this->_space->distance(a->position(), b->position(), p);
    }
 
 
    // .. Agent neighborhood ..................................................
 
 
    AgentContainer<Agent> neighbors_of(const std::shared_ptr<Agent>& agent,
                                       const double radius) const
    {
        AgentContainer<Agent> nbs{};
        for (const auto& a : agents()) {
            if (distance(a, agent) <= radius and a != agent) {
                nbs.push_back(a);
            }
        }
        return nbs;
    }
 
 
 
private:
    // -- Helper functions ----------------------------------------------------
    SpaceVec random_pos() const {
        // Create a space vector with random relative positions [0, 1), and
        // calculate the absolute position by multiplying element-wise with the
        // extent of the space
        std::uniform_real_distribution<double> dist(0., 1.);
        return (  this->_space->extent
                % SpaceVec().imbue([this,&dist](){return dist(*this->_rng);}));
    }
 
    // -- Setup functions -----------------------------------------------------
 
 
    Config setup_cfg(const Model& model, const Config& custom_cfg) {
        Config cfg;
 
        if (custom_cfg.size() > 0) {
            _log->debug("Using custom config for agent manager setup ...");
            cfg = custom_cfg;
        }
        else {
            _log->debug("Using '{}' model's configuration for agent manager "
                        "setup ... ", model.get_name());
 
            if (not model.get_cfg()["agent_manager"]) {
                throw std::invalid_argument("Missing config entry "
                    "'agent_manager' in model configuration! Either specify "
                    "that key or pass a custom configuration node to the "
                    "AgentManager constructor.");
            }
            cfg = model.get_cfg()["agent_manager"];
        }
        return cfg;
    }
 
 
    SpaceVec initial_agent_pos() {
        // By default, use a random initial position
        std::string initial_pos_mode = "random";
 
        // If given, extract the initial_position mode from the configuration
        if (_cfg["initial_position"]) {
            initial_pos_mode = get_as<std::string>("initial_position", _cfg);
        }
 
        // Return the agent position depending on the mode
        if (initial_pos_mode == "random") {
            return random_pos();
        }
        else {
            throw std::invalid_argument("AgentManager got an invalid "
                "configuration entry for 'initial_position': '"
                + initial_pos_mode + "'. Valid options are: 'random'");
        }
    }
 
 
 
    void setup_agents(const AgentState& initial_state) {
        // Extract parameters from the configuration
        if (not _cfg["initial_num_agents"]) {
            throw std::invalid_argument("AgentManager is missing the "
                "configuration entry 'initial_num_agents' that specifies the "
                "number of agents to set up!");
        }
        const auto num_agents = get_as<IndexType>("initial_num_agents", _cfg);
 
        // Construct all the agents with incremented IDs, the initial state
        // and a random position
        for (IndexType i=0; i<num_agents; ++i){
            add_agent(initial_state, initial_agent_pos());
        }
 
        // Done. Shrink it.
        _agents.shrink_to_fit();
        _log->info("Populated agent container with {:d} agents.",
                   _agents.size());
    }
 
 
 
    void setup_agents() {
        // Distinguish depending on constructor.
        // Is the default constructor to be used?
        if constexpr (AgentTraits::use_default_state_constructor) {
            static_assert(std::is_default_constructible<AgentState>(),
                "AgentTraits were configured to use the default constructor "
                "to create agent states, but the AgentState is not "
                "default-constructible! Either implement such a constructor, "
                "unset the flag in the AgentTraits, or pass an explicit "
                "initial agent state to the AgentManager.");
 
            _log->info("Setting up agents using default constructor ...");
 
            // Create the initial state (same for all agents)
            setup_agents(AgentState());
        }
 
        // Is there a constructor available that allows passing the RNG?
        else if constexpr (std::is_constructible<AgentState,
                                                 const DataIO::Config&,
                                                 const std::shared_ptr<RNG>&
                                                 >())
        {
            _log->info("Setting up agents using config constructor (with RNG) "
                       "...");
 
            // Extract the configuration parameter
            if (not _cfg["agent_params"]) {
                throw std::invalid_argument("AgentManager is missing the "
                    "configuration entry 'agent_params' to set up the agents' "
                    "initial states!");
            }
            const auto agent_params = _cfg["agent_params"];
 
            if (not _cfg["initial_num_agents"]){
                throw std::invalid_argument("AgentManager is missing the "
                    "configuration entry 'initial_num_agents' to set up the "
                    "agents!"
                    );
            }
            const auto initial_num_agents =
                get_as<IndexType>("initial_num_agents", _cfg);
 
            // Populate the container, creating the agent state anew each time
            for (IndexType i=0; i<initial_num_agents; i++) {
                add_agent(AgentState(agent_params, _rng),
                          initial_agent_pos());
            }
 
            // Done. Shrink it.
            _agents.shrink_to_fit();
            _log->info("Populated agent container with {:d} agents.",
                       _agents.size());
        }
 
        // As default, require a Config constructor
        else {
            static_assert(std::is_constructible<AgentState,
                                                const DataIO::Config&>(),
                "AgentManager::AgentState needs to be constructible using "
                "const DataIO::Config& as only argument. Either implement "
                "such a constructor, pass an explicit initial agent state to "
                "the AgentManager, or set the AgentTraits such that a default "
                "constructor is to be used.");
 
            _log->info("Setting up agents using config constructor ...");
 
            // Extract the configuration parameter
            if (not _cfg["agent_params"]) {
                throw std::invalid_argument("AgentManager is missing the "
                    "configuration entry 'agent_params' to set up the agents' "
                    "initial states!");
            }
 
            // Create the initial state (same for all agents)
            return setup_agents(AgentState(_cfg["agent_params"]));
        }
        // This point is never reached.
    }
 
 
 
    MoveFunc setup_move_to_func() const {
        // Need to distinguish by periodicity of the space the agents live in
        if (_space->periodic) {
            // Can simply use the space's mapping function
            return [this](Agent& agent, const SpaceVec& pos){
                agent.set_pos(this->_space->map_into_space(pos));
            };
        }
        else {
            // For nonperiodic space, need to make sure the position is valid
            return [this](Agent& agent, const SpaceVec& pos){
                if (not this->_space->contains(pos)) {
                    throw OutOfSpace(pos, this->_space,
                                     "Could not move agent!");
                }
 
                // Set the new agent position
                agent.set_pos(pos);
            };
        }
    }
 
 
    PosFunc setup_prepare_pos_func() const {
        // If periodic, map the position back into space
        if (_space->periodic) {
            return
                [this](const SpaceVec& pos){
                    return this->_space->map_into_space(pos);
                };
        }
        // If non-periodic, check wether the position is valid
        else {
            return
                [this](const SpaceVec& pos) {
                    if (not _space->contains(pos)) {
                        throw OutOfSpace(pos, _space,
                                         "Given position is out of space!");
                    }
                    return pos;
                };
        }
    }
 
};
 
 
// end group AgentManager
} //namespace Utopia
 
#endif // UTOPIA_CORE_AGENTMANAGER_HH