ShapeStorage_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_OPERATORS_SHAPESTORAGE_FWD_HPP_
#define MEDUSA_BITS_OPERATORS_SHAPESTORAGE_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <medusa/bits/types/Range_fwd.hpp>
#include <medusa/bits/utils/stdtypesutils.hpp>
#include <medusa/bits/approximations/Operators_fwd.hpp>
#include <iosfwd>
#include <tuple>
#include <Eigen/Core>
 
namespace mm {
 
template <class shape_storage_type>
class ExplicitOperators;
 
template <class shape_storage_type>
class ExplicitVectorOperators;
 
template <class shape_storage_type, class matrix_type, class rhs_type>
class ImplicitOperators;
 
template <class shape_storage_type, class matrix_type, class rhs_type>
class ImplicitVectorOperators;
 
template <typename Derived, typename vec_t, typename OpFamilies =
        std::tuple<Lap<vec_t::dim>, Der1s<vec_t::dim>, Der2s<vec_t::dim>>>
class ShapeStorage {
  public:
    typedef vec_t vector_t;  
    typedef typename vec_t::scalar_t scalar_t;  
    enum {  dim = vec_t::dim };
    typedef OpFamilies op_families_tuple;  
    constexpr static int num_operators = std::tuple_size<op_families_tuple>::value;
 
    friend Derived;  
 
  private:
    int domain_size_;
    Range<int> support_;
 
    std::array<Range<scalar_t>, num_operators> shapes_;
 
    template <typename T> SINL T* access(std::vector<T>& v, int op, int node) const {
        return static_cast<const Derived*>(this)->access(v, op, node); }
    template <typename T> SINL T* access(std::vector<T>& v, int node) const {
        return static_cast<const Derived*>(this)->access(v, node); }
    template <typename T> SINL const T* access(const std::vector<T>& v, int op, int node) const {
        return static_cast<const Derived*>(this)->access(v, op, node); }
    template <typename T> SINL const T* access(const std::vector<T>& v, int node) const {
        return static_cast<const Derived*>(this)->access(v, node); }
 
    ShapeStorage() : domain_size_(0) {}
 
  public:
    void resize(const std::vector<int>& support_sizes) {
        domain_size_ = support_sizes.size();
        static_cast<Derived*>(this)->resize_(support_sizes);
    }
 
    int size() const { return domain_size_; }
 
    SINL int support(int node, int j) const;
 
    SINL Eigen::Map<const Eigen::Matrix<int, Eigen::Dynamic, 1>> support(int node) const;
 
    void setSupport(int node_idx, const std::vector<int>& support);
 
    int supportSize(int node) const { return static_cast<const Derived*>(this)->supportSize(node); }
 
    Range<int> supportSizes() const;
 
    Range<int> supportSizesVec() const;
 
    // GENERAL GETTERS
    const std::array<Range<scalar_t>, num_operators>& shapes() const { return shapes_; }
 
    template <int op_family> SINL scalar_t get(int op, int node, int j) const {
        return access(shapes_[op_family], op, node)[j];
    }
 
    template <typename op_family> SINL scalar_t get(int op, int node, int j) const {
        return get<tuple_index<op_family, op_families_tuple>::value>(op, node, j);
    }
 
    template <int op_family> SINL scalar_t get(int node, int j) const {
        return access(shapes_[op_family], node)[j];
    }
 
    template <typename op_family> SINL scalar_t get(int node, int j) const {
        return get<tuple_index<op_family, op_families_tuple>::value>(node, j);
    }
 
    template <int op_family> Eigen::Map<const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>>
    getShape(int op, int node) const {
        return {access(shapes_[op_family], op, node), supportSize(node)};
    }
 
    template <typename op_family> Eigen::Map<const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>>
    getShape(int op, int node) const {
        return getShape<tuple_index<op_family, op_families_tuple>::value>(op, node);
    }
 
    template <int op_family>
    SINL Eigen::Map<const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>> getShape(int node) const {
        return {access(shapes_[op_family], node), supportSize(node)};
    }
 
    template <typename op_family>
    SINL Eigen::Map<const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>> getShape(int node) const {
        return getShape<tuple_index<op_family, op_families_tuple>::value>(node);
    }
 
    // GENERAL SETTERS
    template <int op_family>
    SINL void setShape(int op, int node, const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>& shape) {
        std::memcpy(access(shapes_[op_family], op, node), shape.data(),
                    supportSize(node)*sizeof(scalar_t));
    }
 
    template <typename op_family>
    SINL void setShape(int op, int node, const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>& shape) {
        return setShape<tuple_index<op_family, op_families_tuple>::value>(op, node, shape);
    }
 
    template <int op_family>
    SINL void setShape(int node, const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>& shape) {
        std::memcpy(access(shapes_[op_family], node), shape.data(),
                    supportSize(node)*sizeof(scalar_t));    }
 
    template <typename op_family>
    SINL void setShape(int node, const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>& shape) {
        return setShape<tuple_index<op_family, op_families_tuple>::value>(node, shape);
    }
 
    // SPECIFIC ACCESSORS
 
    SINL scalar_t laplace(int node, int j) const;
 
    Eigen::Map<const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>> laplace(int node) const;
 
    SINL void setLaplace(int node, const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>& shape);
 
    SINL scalar_t d1(int var, int node, int j) const;
 
    Eigen::Map<const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>> d1(int var, int node) const;
 
    SINL void setD1(int var, int node, const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>& shape);
 
    SINL scalar_t d2(int varmin, int varmax, int node, int j) const;
 
    Eigen::Map<const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>>
    d2(int varmin, int varmax, int node) const;
 
    SINL void setD2(int varmin, int varmax, int node,
                    const Eigen::Matrix<scalar_t, Eigen::Dynamic, 1>& shape);
 
    size_t memoryUsed() const;
 
    ExplicitOperators<Derived> explicitOperators() const;
    ExplicitVectorOperators<Derived> explicitVectorOperators() const;
    template <typename M, typename R>
    ImplicitOperators<Derived, M, R> implicitOperators(M& matrix, R& rhs) const;
    template <typename M, typename R>
    ImplicitVectorOperators<Derived, M, R> implicitVectorOperators(M& matrix, R& rhs) const;
 
    template <typename D, typename V, typename O>
    friend std::ostream& operator<<(std::ostream& os, const ShapeStorage<D, V, O>& shapes);
};
 
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_OPERATORS_SHAPESTORAGE_FWD_HPP_