base.hh

Go to the documentation of this file.

#ifndef UTOPIA_CORE_GRIDS_BASE_HH
#define UTOPIA_CORE_GRIDS_BASE_HH
 
#include "../types.hh"
 
namespace Utopia {
enum class GridStructure {
  square,
  triangular,
  hexagonal
};
// NOTE When adding new grid structure type, take care to update 
//      grid_structure_map!
 
const std::map<std::string, GridStructure> grid_structure_map {
    {"square",      GridStructure::square},
    {"triangular",  GridStructure::triangular},
    {"hexagonal",   GridStructure::hexagonal}
};
 
 
std::string grid_structure_to_string(const GridStructure& structure) {
    for (const auto& m : grid_structure_map) {
        if (m.second == structure) {
            return m.first;
        }
    }
    // Entry is missing; this should not happen, as the
    // grid_structure_to_string is meant to include all possible enum values.
    throw std::invalid_argument(
        "The given grid structure was not available in the "
        "grid_structure_map! Are all GridStructure enum values represented "
        "in the map?"
    );
};
 
 
enum class NBMode {
    empty = 0,
    vonNeumann = 1,
    Moore = 2,
    hexagonal = 3
};
// NOTE When adding new neighborhood types, take care to update nb_mode_map!
//      Also, some high-level error messages (e.g. in the CellManager) might
//      need to be adapted.
 
const std::map<std::string, NBMode> nb_mode_map {
    {"empty",       NBMode::empty},
    {"vonNeumann",  NBMode::vonNeumann},
    {"Moore",       NBMode::Moore},
    {"hexagonal",   NBMode::hexagonal}
};
 
 
std::string nb_mode_to_string(const NBMode& nb_mode) {
    for (const auto& m : nb_mode_map) {
        if (m.second == nb_mode) {
            return m.first;
        }
    }
    // Entry is missing; this should not happen, as the nb_mode_map is meant to
    // include all possible enum values. Inform about it ...
    throw std::invalid_argument("The given nb_mode was not available in the "
        "nb_mode_map! Are all NBMode enum values represented in the map?");
};
 
template<class Grid>
using NBFuncID = std::function<IndexContainer(const IndexType)>;
 
 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
template<class Space>
class Grid {
public:
    using Self = Grid<Space>;
 
    static constexpr DimType dim = Space::dim;
 
    using SpaceVec = typename Space::SpaceVec;
 
    using MultiIndex = MultiIndexType<dim>;
 
    using Config = DataIO::Config;
 
 
protected:
    // -- Members -------------------------------------------------------------
    const std::shared_ptr<Space> _space;
 
 
    const DistType _resolution;
 
    NBMode _nb_mode;
 
    Config _nb_params;
 
    NBFuncID<Self> _nb_func;
 
 
public:
    // -- Constructors and Destructors ----------------------------------------
 
    Grid (std::shared_ptr<Space> space, const Config& cfg)
    :
        _space(space),
        _resolution([&cfg](){
            if (not cfg["resolution"]) {
                throw std::invalid_argument("Missing grid configuration "
                    "parameter 'resolution'! Please supply an integer >= 1.");
            }
 
            // Read in as signed int (allows throwing error for negative value)
            const auto res = get_as<long long>("resolution", cfg);
 
            if (res < 1) {
                throw std::invalid_argument("Grid resolution needs to be a "
                                            "positive integer, was < 1!");
            }
            return res;
        }()),
        _nb_mode(NBMode::empty),
        _nb_params()
    {
        // Set the neighborhood function to not return anything
        _nb_func = _nb_empty;
    }
 
    virtual ~Grid() = default;
 
 
    // -- Public interface ----------------------------------------------------
    // .. Neighborhood interface ..............................................
 
    IndexContainer neighbors_of(const IndexType id) const {
        return _nb_func(id);
    }
 
    void select_neighborhood(NBMode nb_mode,
                             const Config& nb_params = {})
    {
        try {
            _nb_func = get_nb_func(nb_mode, nb_params);
        }
        catch (std::exception& e) {
            throw std::invalid_argument("Failed to select neighborhood: "
                                        + ((std::string) e.what()));
        }
        
        _nb_mode = nb_mode;
        _nb_params = nb_params;
    }
 
    const NBMode& nb_mode() const {
        return _nb_mode;
    }
 
    const Config& nb_params() const {
        return _nb_params;
    }
 
    auto nb_size() const {
        return expected_num_neighbors(_nb_mode, _nb_params);
    }
 
 
    // .. Position-related methods ............................................
 
    virtual MultiIndex midx_of(const IndexType) const = 0;
 
 
    virtual SpaceVec barycenter_of(const IndexType) const = 0;
 
 
    virtual SpaceVec extent_of(const IndexType) const = 0;
 
 
    virtual std::vector<SpaceVec> vertices_of(const IndexType) const = 0;
 
 
    virtual IndexType cell_at(const SpaceVec&) const = 0;
 
 
    virtual std::set<IndexType> boundary_cells(std::string={}) const = 0;
 
 
    // .. Getters .............................................................
 
    virtual IndexType num_cells() const = 0;
    
    auto resolution() const {
        return _resolution;
    }
 
 
    virtual SpaceVec effective_resolution() const = 0;
 
    virtual MultiIndex shape() const = 0;
 
    virtual GridStructure structure() const = 0;
 
    std::string structure_name() const {
        return grid_structure_to_string(structure());
    }
 
    const std::shared_ptr<Space>& space() const {
        return _space;
    }
 
    bool is_periodic() const {
        return _space->periodic;
    }
 
 
protected:
    // -- Neighborhood functions ----------------------------------------------
 
    virtual NBFuncID<Self> get_nb_func(NBMode, const Config&) = 0;
 
    virtual DistType expected_num_neighbors(const NBMode&,
                                            const Config&) const = 0;
 
    NBFuncID<Self> _nb_empty = [](const IndexType) {
        IndexContainer idcs{};
        idcs.reserve(0);
        return idcs;
    };
};
 
 
// end group CellManager
} // namespace Utopia
 
#endif // UTOPIA_CORE_GRIDS_BASE_HH