world.hpp

Go to the documentation of this file.

#ifndef MECACELL_WORLD_H
#define MECACELL_WORLD_H
#include <array>
#include <functional>
#include <unordered_set>
#include <utility>
#include <vector>
#include "integrators.hpp"
#include "mecacell/utilities/hooktools.hpp"
#include "mecacell/utilities/threadpool.hpp"
#include "mecacell/utilities/utils.hpp"
 
namespace MecaCell {
 
template <typename Cell, typename Integrator = Euler> class World {
 private:
    size_t nbThreads = 0;
 
 public:
    using cell_t = Cell;
    using integrator_t = Integrator;
    using hook_s = void(World *);  
 
    ThreadPool threadpool;  // threadpool that can be used by plugins (and is also used to
                            // parallelize updateBehavior)
 
    // -------------------------------------
    // The following code detects if any embedded plugin type is specified and defaults
    // to the instantiation of a useles byte if not.
    struct dumb {};
    template <class, class = MecaCell::void_t<>>
    struct embedded_plugin_type {  // declaration
        using type = dumb;  // defaults to empty type if no embedded plugin is defined
    };
    template <class T>  // specialization
    struct embedded_plugin_type<T, void_t<typename T::embedded_plugin_t>> {
        using type = typename T::embedded_plugin_t;  // embedded plugin detected
    };
    using cellPlugin_t =
        typename embedded_plugin_type<cell_t>::type;  // either dumb empty struct or the
                                                      // plugin type
                                                      // defined by Cell (if existing)
 protected:
    size_t frame = 0;         
    size_t nbAddedCells = 0;  
    size_t updtBhvPeriod = 1;  
    bool parallelUpdateBehavior = false;
    bool shuffleCells = true;
 
    void deleteDeadCells() {
        for (auto i = cells.begin(); i != cells.end();) {
            if ((*i)->isDead()) {
                auto tmp = *i;
                i = cells.erase(i);
                delete tmp;
            } else {
                ++i;
            }
        }
    }
 
 public:
    double dt = 1.0 / 100.0;  
    double dtMn = dt/60.;
    double dtH = dt/3600.;
 
    cellPlugin_t cellPlugin;  // instance of the embedded cell plugin type
                              // (cellPlugin_t default to a dumb char if not specified)
 
    vector<Cell *> newCells;  
 
    /* HOOKS
     */
    DECLARE_HOOK(onAddCell, beginUpdate, preBehaviorUpdate, preDeleteDeadCellsUpdate,
                 postBehaviorUpdate, endUpdate, allForcesAppliedToCells, destructor)
 
    /* CELLS */
    std::vector<Cell *> cells;  
 
    World(size_t nThreads = 0) : nbThreads(nThreads), threadpool(nThreads) {
        registerPlugins(cellPlugin);
    }
 
    void setParallelUpdateBehavior(bool p) { parallelUpdateBehavior = p; };
 
    size_t getNbThreads() { return nbThreads; }
 
    void setNbThreads(size_t n) {
        nbThreads = n;
        threadpool.setNbThreads(n);
    }
 
    /**********************************************
     *               HOOKS & PLUGINS              *
     *********************************************/
 
    void registerHook(const Hooks &h, hook_t f) { hooks[eToUI(h)].push_back(f); }
 
    template <typename P, typename... Rest>
    void registerPlugins(P &&p, Rest &&... otherPlugins) {
        // registerPlugin returns the onRegister hook from the plugin
        registerPlugin(std::forward<P>(p))(this);
        registerPlugins(std::forward<Rest>(otherPlugins)...);
    }
    void registerPlugins() {}  
 
    void clearHooks() {
        for (auto &h : hooks) h.clear();
    }
 
    /**********************************************
     *                 GET & SET                  *
     *********************************************/
 
    size_t getNbUpdates() const { return frame; }
 
    template <typename... Args> Cell *createCell(Args &&... args) {
        Cell *c = new Cell(std::forward<Args>(args)...);
        addCell(c);
        return c;
    }
 
    void addCell(Cell *c) {
        if (c) {
            c->getBody().setCellPlugin(&cellPlugin);
            c->setWorld(this);
            newCells.push_back(c);
            c->id = nbAddedCells++;
        }
    }
 
    void addNewCells() {
        if (newCells.size()) {
            for (auto &f : hooks[eToUI(Hooks::onAddCell)]) f(this);
            cells.insert(cells.end(), newCells.begin(), newCells.end());
            newCells.clear();
        }
    }
 
    void allForcesHaveBeenAppliedToCells() {
        for (auto &f : hooks[eToUI(Hooks::allForcesAppliedToCells)]) f(this);
    }
 
    void setDt(double d) { dt = d; dtMn = d/60.; dtH = d/3600.; }
    void setDtInS(double d) { dt = d; dtMn = d/60.; dtH = d/3600.; }
    void setDtInMn(double d) { dt = d*60.; dtMn = d; dtH = d/60.; }
    void setDtInH(double d) { dt = d*3600.; dtMn = d*60.; dtH = d; }
    double getDt() const{ return dt; }
    double getDtInS() const{ return dt; }
    double getDtInMn() const{ return dtMn; }
    double getDtInH() const{ return dtH; }
 
    void setShuffleCells(bool s) { shuffleCells = s; }
 
    void setUpdateBehaviorPeriod(size_t p) { updtBhvPeriod = p; }
    
    size_t getUpdateBehaviorPeriod() const { return updtBhvPeriod; }
 
 
    std::vector<std::pair<cell_t *, cell_t *>> getConnectedCellsList() {
        std::unordered_set<ordered_pair<cell_t *>> res;
        for (auto &c : cells) {
            for (auto &connected : c->getConnectedCells())
                res.insert(make_ordered_cell_pair(c, connected));
        }
        std::vector<std::pair<cell_t *, cell_t *>> vecRes;
        for (auto &r : res) vecRes.push_back(std::make_pair(r.first, r.second));
        return vecRes;
    }
 
    void callUpdateBehavior() {
        if(shuffleCells) std::shuffle(std::begin(cells), std::end(cells), MecaCell::Config::globalRand());
        const size_t MIN_CHUNK_SIZE = 2;
        const double AVG_TASKS_PER_THREAD = 3.0;
        if (parallelUpdateBehavior && nbThreads > 0) {
            threadpool.autoChunks(cells, MIN_CHUNK_SIZE, AVG_TASKS_PER_THREAD,
                                  [](auto *c) { c->updateBehavior(); });
            threadpool.waitUntilLast();
        } else
            for (auto &c : cells) c->updateBehavior();
    }
 
    void update() {
        for (auto &f : hooks[eToUI(Hooks::beginUpdate)]) f(this);
        for (auto &f : hooks[eToUI(Hooks::preBehaviorUpdate)]) f(this);
        if (frame % updtBhvPeriod == 0) callUpdateBehavior();
        addNewCells();
        for (auto &f : hooks[eToUI(Hooks::preDeleteDeadCellsUpdate)]) f(this);
        deleteDeadCells();
        for (auto &f : hooks[eToUI(Hooks::postBehaviorUpdate)]) f(this);
        for (auto &f : hooks[eToUI(Hooks::endUpdate)]) f(this);
        ++frame;
    }
 
    ~World() {
        for (auto &f : hooks[eToUI(Hooks::destructor)]) f(this);
        while (!cells.empty()) delete cells.back(), cells.pop_back();
        while (!newCells.empty()) delete newCells.back(), newCells.pop_back();
    }
 
    EXPORTABLE(World, KV(frame), KV(cells));
};
}  // namespace MecaCell
#endif