space.hh

Go to the documentation of this file.

#ifndef UTOPIA_CORE_SPACE_HH
#define UTOPIA_CORE_SPACE_HH
 
#include <cmath>
 
#include <armadillo>
#include <spdlog/spdlog.h>  // for fmt
 
#include "../data_io/cfg_utils.hh"
#include "types.hh"
 
 
namespace Utopia {
 
template<std::size_t num_dims>
struct Space {
    // -- Members -------------------------------------------------------------
    static constexpr std::size_t dim = num_dims;
 
    using SpaceVec = SpaceVecType<dim>;
 
    const bool periodic;
 
    const SpaceVec extent;
 
 
    // -- Constructors --------------------------------------------------------
 
    Space(const Config& cfg)
    :
        periodic(setup_periodic(cfg)),
        extent(setup_extent(cfg))
    {
        static_assert(dim > 0, "Space::dim needs to be >= 1");
    }
 
 
    Space()
    :
        periodic(false),
        extent(setup_extent())
    {
        static_assert(dim > 0, "Space::dim needs to be >= 1");
    }
 
 
    // -- Public interface ----------------------------------------------------
 
    template<bool include_high_value_boundary=true>
    bool contains(const SpaceVec& pos) const {
        // Calculate the relative position within the space
        const auto rel_pos = pos / extent;  // element-wise division
 
        // Check that all relative positions are in the respective interval
        if constexpr (include_high_value_boundary) {
            return arma::all(rel_pos >= 0. and rel_pos <= 1.);  // [0, 1]
        }
        else {
            return arma::all(rel_pos >= 0. and rel_pos <  1.);  // [0, 1)
        }
    }
 
 
    SpaceVec map_into_space(const SpaceVec& pos) const {
        // If it is already within space, nothing to map
        // Check whether it is contained (_excluding_ high value boundary)
        if (contains<false>(pos)) {
            return pos;
        }
        // else: Need to transform back into space
 
        return pos - arma::floor(pos / extent) % extent;
    }
 
    
 
    SpaceVec displacement(const SpaceVec& pos_0, const SpaceVec& pos_1) const {
        SpaceVec dx = pos_1 - pos_0;
 
        if (not periodic) {
            return dx;
        }
        // else: Need to get shortest distance
 
        return dx - arma::round(dx / extent) % extent;
    }
 
 
    template<class NormType=std::size_t>
    auto distance(const SpaceVec& pos_0, const SpaceVec& pos_1,
                  const NormType p=2) const
    {
        return arma::norm(displacement(pos_0, pos_1), p);
    }
 
 
private:
    // -- Setup functions -----------------------------------------------------
    bool setup_periodic(const Config& cfg) const {
        if (not cfg["periodic"]) {
            throw std::invalid_argument("Missing config entry `periodic` to "
                                        "set up a Space object!");
        }
        return get_as<bool>("periodic", cfg);
    }
 
    SpaceVec setup_extent() const {
        SpaceVec ext;
        ext.fill(1.);
        return ext;
    }
 
 
    SpaceVec setup_extent(const Config& cfg) const {
        if (cfg["extent"]) {
            SpaceVec ext;
 
            if (cfg["extent"].IsScalar()) {
                ext.fill(get_as<double>("extent", cfg));
            }
            else {
                if (dim != cfg["extent"].size()) {
                    throw std::invalid_argument(fmt::format(
                        "Invalid size of `space.extent` sequence ({}) for "
                        "selected space dimensionality ({})!",
                        cfg["extent"].size(), dim
                    ));
                }
                ext = get_as_SpaceVec<dim>("extent", cfg);
            }
 
            if (ext.min() <= 0.) {
                ext.print("Invalid `space.extent`:");
                throw std::invalid_argument(
                    "The space extent needs to be strictly positive in "
                    "all entries, but it contained at least one element <= 0! "
                    "Check the `space.extent` config node to address this."
                );
            }
 
            return ext;
        }
        else {
            // Return the default extent, needs no check
            return setup_extent();
        }
    }
};
 
 
using DefaultSpace = Space<2>;
 
// end group Model
} // namespace Utopia
 
#endif // UTOPIA_CORE_SPACE_HH