Accessor.hpp

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include <wmtk/simplex/IdSimplex.hpp>
#include <wmtk/simplex/Simplex.hpp>
#include "CachingAttribute.hpp"
#include "TypedAttributeHandle.hpp"
 
namespace wmtk {
class HDF5Reader;
}
namespace wmtk::tests {
class DEBUG_PointMesh;
class DEBUG_EdgeMesh;
class DEBUG_TriMesh;
} // namespace wmtk::tests
namespace wmtk::tests_3d {
class DEBUG_TetMesh;
}
 
namespace wmtk::attribute {
class MeshAttributeHandle;
 
template <typename MeshType>
class IndexFlagAccessor;
 
template <
    typename T,
    typename MeshType = Mesh,
    typename AttributeType_ = CachingAttribute<T>,
    int Dim = Eigen::Dynamic>
class Accessor
{
public:
    friend class wmtk::Mesh;
    friend class wmtk::tests::DEBUG_PointMesh;
    friend class wmtk::tests::DEBUG_EdgeMesh;
    friend class wmtk::tests::DEBUG_TriMesh;
    friend class wmtk::tests_3d::DEBUG_TetMesh;
    friend class IndexFlagAccessor<MeshType>;
    friend class wmtk::HDF5Reader;
 
    using Scalar = T;
 
    using AttributeType = AttributeType_; // CachingAttribute<T>;
 
    // Even though the attribute dimension is specified above by the Dim parameter, we still allow
    // users to specify the dimension of the attributes they extract - this lets Dim=Eigen::Dynamic
    // accessors be passed around with internal logic specifying the appropriate dimension
    // Eigen::Map<Vector<T,D>>
    template <int D = Dim>
    using MapResult = typename AttributeType::template MapResult<D>;
    // Eigen::Map<const Vector<T,D>>
    template <int D = Dim>
    using ConstMapResult = typename AttributeType::template ConstMapResult<D>;
 
 
    Accessor(MeshType& m, const TypedAttributeHandle<T>& handle);
    Accessor(const MeshType& m, const TypedAttributeHandle<T>& handle);
 
    template <typename OMType, typename OAT, int D>
    Accessor(const Accessor<T, OMType, OAT, D>& o);
 
    // dimension of the attribute (the return types are a dimensino-vector)
    auto dimension() const -> int64_t;
    // the number of (vector-)values that can be written to. Note this is can be larger than the
    // size of the mesh
    auto reserved_size() const -> int64_t;
    // the default value assigned to new values of this attribute (for vector valued attributes
    // every dimension holds is this)
    auto default_value() const -> const Scalar&;
 
 
    // =============
    // Access methods
    // =============
    // NOTE: If any compilation warnings occur check that there is an overload for an index method
 
 
    // Access to a vector-valued attribute
    template <int D = Dim, typename ArgType = wmtk::Tuple>
    MapResult<std::max(D, Dim)> vector_attribute(const ArgType& t);
    template <int D = Dim, typename ArgType = wmtk::Tuple>
    ConstMapResult<std::max(D, Dim)> const_vector_attribute(const ArgType& t) const;
 
    template <typename ArgType>
    Scalar& scalar_attribute(const ArgType& t);
    template <typename ArgType>
    const Scalar& const_scalar_attribute(const ArgType& t) const;
 
    // For topological attributes we want to select teh value (global_id) by its (local_id) index,
    // for whichever local index this attribute lies on For instance, to get the global index of a
    // vertex from a FV matrix we want to access const_vector_attribute(global_id)(local_vid). This
    // function lets us use the primitive type to identify which local id we want.
    const T& const_topological_scalar_attribute(const Tuple& t, PrimitiveType pt) const;
 
 
    MeshType& mesh();
    const MeshType& mesh() const;
 
    int64_t transaction_depth() const;
 
protected:
    int64_t index(const Tuple& t) const;
    // Simplex's primitive type must match this attribute, should assert failure if not
    int64_t index(const simplex::Simplex& t) const;
    int64_t index(const simplex::IdSimplex& t) const;
 
    int64_t index(const int64_t t) const;
 
    // The underlying attribute object.
    AttributeType& attribute();
    // The underlying attribute object
    const AttributeType& attribute() const;
 
public:
    MeshAttributeHandle handle() const;
    const TypedAttributeHandle<T>& typed_handle() const;
    PrimitiveType primitive_type() const;
 
private:
    TypedAttributeHandle<T> m_handle;
    MeshType& m_mesh;
    AttributeType& m_attribute;
};
} // namespace wmtk::attribute
#include "Accessor.hxx"