AbstractTriangulation.h

Go to the documentation of this file.

 
 
#pragma once
 
// base code includes
#include <Cache.h>
#include <Geometry.h>
#include <Wrapper.h>
 
#include <array>
#include <ostream>
#include <unordered_map>
 
#ifdef TTK_ENABLE_KAMIKAZE
#define TTK_TRIANGULATION_INTERNAL(NAME) NAME
#else
#define TTK_TRIANGULATION_INTERNAL(NAME) NAME##Internal
#endif // TTK_ENABLE_KAMIKAZE
 
#define ttkTemplateMacroCase(triangulationType, triangulationClass, call) \
  case triangulationType: {                                               \
    using TTK_TT = triangulationClass;                                    \
    call;                                                                 \
  }; break
 
#define ttkTemplateMacro(triangulationType, call)                              \
  switch(triangulationType) {                                                  \
    ttkTemplateMacroCase(                                                      \
      ttk::Triangulation::Type::EXPLICIT, ttk::ExplicitTriangulation, call);   \
    ttkTemplateMacroCase(                                                      \
      ttk::Triangulation::Type::IMPLICIT, ttk::ImplicitNoPreconditions, call); \
    ttkTemplateMacroCase(ttk::Triangulation::Type::HYBRID_IMPLICIT,            \
                         ttk::ImplicitWithPreconditions, call);                \
    ttkTemplateMacroCase(                                                      \
      ttk::Triangulation::Type::PERIODIC, ttk::PeriodicNoPreconditions, call); \
    ttkTemplateMacroCase(ttk::Triangulation::Type::HYBRID_PERIODIC,            \
                         ttk::PeriodicWithPreconditions, call);                \
    ttkTemplateMacroCase(                                                      \
      ttk::Triangulation::Type::COMPACT, ttk::CompactTriangulation, call);     \
  }
 
namespace ttk {
 
  // forward declaration of the ttk::dcg::DiscreteGradient class to
  // give it access to the gradient cache (with a `friend`
  // declaration)
  namespace dcg {
    class DiscreteGradient;
  }
 
  class AbstractTriangulation : public Wrapper {
 
  public:
    AbstractTriangulation();
 
    ~AbstractTriangulation() override;
 
    AbstractTriangulation(const AbstractTriangulation &) = default;
    AbstractTriangulation(AbstractTriangulation &&) = default;
    AbstractTriangulation &operator=(const AbstractTriangulation &) = default;
    AbstractTriangulation &operator=(AbstractTriangulation &&) = default;
 
    int clear();
 
    size_t footprint(size_t size = 0) const;
 
    virtual inline int getCellEdge(const SimplexId &cellId,
                                   const int &localEdgeId,
                                   SimplexId &edgeId) const {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      edgeId = -1;
 
      if(!hasPreconditionedCellEdges())
        return -1;
#endif
 
      if(getDimensionality() == 1)
        return getCellNeighbor(cellId, localEdgeId, edgeId);
 
      else if(getDimensionality() == 2)
        return getTriangleEdgeInternal(cellId, localEdgeId, edgeId);
 
      return getCellEdgeInternal(cellId, localEdgeId, edgeId);
    }
 
    virtual inline SimplexId getCellEdgeNumber(const SimplexId &cellId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedCellEdges())
        return -1;
#endif
      if(getDimensionality() == 1)
        return getCellNeighborNumber(cellId);
 
      else if(getDimensionality() == 2)
        return getTriangleEdgeNumber(cellId);
 
      return getCellEdgeNumberInternal(cellId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *getCellEdges() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedCellEdges())
        return nullptr;
#endif
      if(getDimensionality() == 1)
        return getCellNeighbors();
 
      else if(getDimensionality() == 2)
        return getTriangleEdgesInternal();
 
      return getCellEdgesInternal();
    }
 
    virtual inline int getCellNeighbor(const SimplexId &cellId,
                                       const int &localNeighborId,
                                       SimplexId &neighborId) const {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      neighborId = -1;
 
      if(!hasPreconditionedCellNeighbors())
        return -1;
#endif
      return getCellNeighborInternal(cellId, localNeighborId, neighborId);
    }
 
    virtual inline SimplexId
      getCellNeighborNumber(const SimplexId &cellId) const {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedCellNeighbors())
        return -1;
#endif
      return getCellNeighborNumberInternal(cellId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getCellNeighbors() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedCellNeighbors())
        return nullptr;
#endif
      return getCellNeighborsInternal();
    }
 
    virtual inline int getCellTriangle(const SimplexId &cellId,
                                       const int &localTriangleId,
                                       SimplexId &triangleId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      triangleId = -1;
 
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedCellTriangles())
        return -2;
#endif
      if(getDimensionality() == 2)
        return getCellNeighbor(cellId, localTriangleId, triangleId);
 
      return getCellTriangleInternal(cellId, localTriangleId, triangleId);
    }
 
    virtual inline SimplexId
      getCellTriangleNumber(const SimplexId &cellId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedCellTriangles())
        return -2;
#endif
      if(getDimensionality() == 2)
        return getCellNeighborNumber(cellId);
 
      return getCellTriangleNumberInternal(cellId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getCellTriangles() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return nullptr;
 
      if(!hasPreconditionedCellTriangles())
        return nullptr;
#endif
      if(getDimensionality() == 2)
        return getCellNeighbors();
 
      return getCellTrianglesInternal();
    }
 
    virtual inline int getCellVertex(const SimplexId &cellId,
                                     const int &localVertexId,
                                     SimplexId &vertexId) const {
 
      return getCellVertexInternal(cellId, localVertexId, vertexId);
    }
 
    virtual inline SimplexId
      getCellVertexNumber(const SimplexId &cellId) const {
      return getCellVertexNumberInternal(cellId);
    }
 
    virtual inline int getDimensionality() const {
      return getDimensionalityInternal();
    }
 
    virtual inline const std::vector<std::array<SimplexId, 2>> *getEdges() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return nullptr;
 
      if(!hasPreconditionedEdges())
        return nullptr;
#endif
      return getEdgesInternal();
    }
 
    virtual inline int getEdgeLink(const SimplexId &edgeId,
                                   const int &localLinkId,
                                   SimplexId &linkId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      linkId = -1;
 
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedEdgeLinks())
        return -2;
#endif
      return getEdgeLinkInternal(edgeId, localLinkId, linkId);
    }
 
    virtual inline SimplexId getEdgeLinkNumber(const SimplexId &edgeId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedEdgeLinks())
        return -2;
#endif
      return getEdgeLinkNumberInternal(edgeId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *getEdgeLinks() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return nullptr;
 
      if(!hasPreconditionedEdgeLinks())
        return nullptr;
#endif
      return getEdgeLinksInternal();
    }
 
    virtual inline int getEdgeStar(const SimplexId &edgeId,
                                   const int &localStarId,
                                   SimplexId &starId) const {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      starId = -1;
 
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedEdgeStars())
        return -2;
#endif
      return getEdgeStarInternal(edgeId, localStarId, starId);
    }
 
    virtual inline SimplexId getEdgeStarNumber(const SimplexId &edgeId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedEdgeStars())
        return -2;
#endif
      return getEdgeStarNumberInternal(edgeId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *getEdgeStars() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return nullptr;
 
      if(!hasPreconditionedEdgeStars())
        return nullptr;
#endif
      return getEdgeStarsInternal();
    }
 
    virtual inline int getEdgeTriangle(const SimplexId &edgeId,
                                       const int &localTriangleId,
                                       SimplexId &triangleId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      triangleId = -1;
 
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedEdgeTriangles())
        return -2;
#endif
      if(getDimensionality() == 2)
        return getEdgeStar(edgeId, localTriangleId, triangleId);
 
      return getEdgeTriangleInternal(edgeId, localTriangleId, triangleId);
    }
 
    virtual inline SimplexId
      getEdgeTriangleNumber(const SimplexId &edgeId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedEdgeTriangles())
        return -2;
#endif
 
      if(getDimensionality() == 2)
        return getEdgeStarNumber(edgeId);
 
      return getEdgeTriangleNumberInternal(edgeId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getEdgeTriangles() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return nullptr;
 
      if(!hasPreconditionedEdgeTriangles())
        return nullptr;
#endif
 
      if(getDimensionality() == 2)
        return getEdgeStars();
 
      return getEdgeTrianglesInternal();
    }
 
    virtual inline int getEdgeVertex(const SimplexId &edgeId,
                                     const int &localVertexId,
                                     SimplexId &vertexId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      vertexId = -1;
 
      if(!hasPreconditionedEdges())
        return -2;
#endif
      if(getDimensionality() == 1)
        return getCellVertex(edgeId, localVertexId, vertexId);
 
      return getEdgeVertexInternal(edgeId, localVertexId, vertexId);
    }
 
    inline int getEdgeVertexNumber(const SimplexId ttkNotUsed(edgeId)) const {
      return 2;
    }
 
    virtual inline const std::array<SimplexId, 3> &getGridDimensions() const {
      return this->gridDimensions_;
    }
 
    virtual inline SimplexId getNumberOfCells() const {
      return getNumberOfCellsInternal();
    }
 
    virtual inline SimplexId getNumberOfEdges() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedEdges())
        return -2;
#endif
      if(getDimensionality() == 1)
        return getNumberOfCells();
 
      return getNumberOfEdgesInternal();
    }
 
    virtual inline SimplexId getNumberOfTriangles() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedTriangles())
        return -2;
#endif
      if(getDimensionality() == 2)
        return getNumberOfCells();
 
      return getNumberOfTrianglesInternal();
    }
 
    virtual inline SimplexId getNumberOfVertices() const {
      return getNumberOfVerticesInternal();
    }
 
    virtual inline const std::vector<std::array<SimplexId, 3>> *getTriangles() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedTriangles())
        return nullptr;
#endif
      return getTrianglesInternal();
    }
 
    virtual inline int getTriangleEdge(const SimplexId &triangleId,
                                       const int &localEdgeId,
                                       SimplexId &edgeId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      edgeId = -1;
 
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedTriangleEdges())
        return -2;
#endif
 
      return getTriangleEdgeInternal(triangleId, localEdgeId, edgeId);
    }
 
    virtual inline SimplexId
      getTriangleEdgeNumber(const SimplexId &triangleId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedTriangleEdges())
        return -2;
#endif
 
      return getTriangleEdgeNumberInternal(triangleId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getTriangleEdges() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return nullptr;
 
      if(!hasPreconditionedTriangleEdges())
        return nullptr;
#endif
 
      return getTriangleEdgesInternal();
    }
 
    virtual inline int getTriangleLink(const SimplexId &triangleId,
                                       const int &localLinkId,
                                       SimplexId &linkId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      linkId = -1;
 
      if(getDimensionality() != 3)
        return -1;
 
      if(!hasPreconditionedTriangleLinks())
        return -2;
#endif
      return getTriangleLinkInternal(triangleId, localLinkId, linkId);
    }
 
    virtual inline SimplexId
      getTriangleLinkNumber(const SimplexId &triangleId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() != 3)
        return -1;
 
      if(!hasPreconditionedTriangleLinks())
        return -2;
#endif
      return getTriangleLinkNumberInternal(triangleId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getTriangleLinks() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() != 3)
        return nullptr;
 
      if(!hasPreconditionedTriangleLinks())
        return nullptr;
#endif
      return getTriangleLinksInternal();
    }
 
    virtual inline int getTriangleStar(const SimplexId &triangleId,
                                       const int &localStarId,
                                       SimplexId &starId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      starId = -1;
 
      if(getDimensionality() != 3)
        return -1;
 
      if(!hasPreconditionedTriangleStars())
        return -2;
#endif
      return getTriangleStarInternal(triangleId, localStarId, starId);
    }
 
    virtual inline SimplexId
      getTriangleStarNumber(const SimplexId &triangleId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() != 3)
        return -1;
 
      if(!hasPreconditionedTriangleStars())
        return -2;
#endif
      return getTriangleStarNumberInternal(triangleId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getTriangleStars() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() != 3)
        return nullptr;
 
      if(!hasPreconditionedTriangleStars())
        return nullptr;
#endif
      return getTriangleStarsInternal();
    }
 
    virtual inline int getTriangleVertex(const SimplexId &triangleId,
                                         const int &localVertexId,
                                         SimplexId &vertexId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      vertexId = -1;
 
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedTriangles())
        return -2;
#endif
      if(getDimensionality() == 2)
        return getCellVertex(triangleId, localVertexId, vertexId);
 
      return getTriangleVertexInternal(triangleId, localVertexId, vertexId);
    }
 
    inline int
      getTriangleVertexNumber(const SimplexId ttkNotUsed(triangleId)) const {
      return 3;
    }
 
    virtual inline int getVertexEdge(const SimplexId &vertexId,
                                     const int &localEdgeId,
                                     SimplexId &edgeId) const {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      edgeId = -1;
 
      if(!hasPreconditionedVertexEdges())
        return -1;
#endif
      if(getDimensionality() == 1)
        return getVertexStar(vertexId, localEdgeId, edgeId);
 
      return getVertexEdgeInternal(vertexId, localEdgeId, edgeId);
    }
 
    virtual inline SimplexId
      getVertexEdgeNumber(const SimplexId &vertexId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedVertexEdges())
        return -1;
#endif
      if(getDimensionality() == 1)
        return getVertexStarNumber(vertexId);
 
      return getVertexEdgeNumberInternal(vertexId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *getVertexEdges() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedVertexEdges())
        return nullptr;
#endif
      if(getDimensionality() == 1)
        return getVertexStars();
 
      return getVertexEdgesInternal();
    }
 
    virtual inline int getVertexLink(const SimplexId &vertexId,
                                     const int &localLinkId,
                                     SimplexId &linkId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      linkId = -1;
 
      if(!hasPreconditionedVertexLinks())
        return -1;
#endif
      return getVertexLinkInternal(vertexId, localLinkId, linkId);
    }
 
    virtual inline SimplexId
      getVertexLinkNumber(const SimplexId &vertexId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedVertexLinks())
        return -1;
#endif
      return getVertexLinkNumberInternal(vertexId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *getVertexLinks() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedVertexLinks())
        return nullptr;
#endif
      return getVertexLinksInternal();
    }
 
    virtual inline int getVertexNeighbor(const SimplexId &vertexId,
                                         const int &localNeighborId,
                                         SimplexId &neighborId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      neighborId = -1;
 
      if(!hasPreconditionedVertexNeighbors())
        return -1;
#endif
      return getVertexNeighborInternal(vertexId, localNeighborId, neighborId);
    }
 
    virtual inline SimplexId
      getVertexNeighborNumber(const SimplexId &vertexId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedVertexNeighbors())
        return -1;
#endif
      return getVertexNeighborNumberInternal(vertexId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getVertexNeighbors() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedVertexNeighbors())
        return nullptr;
#endif
      return getVertexNeighborsInternal();
    }
 
    virtual inline int getVertexPoint(const SimplexId &vertexId,
                                      float &x,
                                      float &y,
                                      float &z) const {
      return getVertexPointInternal(vertexId, x, y, z);
    }
 
    virtual inline int getVertexStar(const SimplexId &vertexId,
                                     const int &localStarId,
                                     SimplexId &starId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      starId = -1;
 
      if(!hasPreconditionedVertexStars())
        return -1;
#endif
      return getVertexStarInternal(vertexId, localStarId, starId);
    }
 
    virtual inline SimplexId
      getVertexStarNumber(const SimplexId &vertexId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedVertexStars())
        return -1;
#endif
      return getVertexStarNumberInternal(vertexId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *getVertexStars() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedVertexStars())
        return nullptr;
#endif
      return getVertexStarsInternal();
    }
 
    virtual inline int getVertexTriangle(const SimplexId &vertexId,
                                         const int &localTriangleId,
                                         SimplexId &triangleId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      triangleId = -1;
 
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedVertexTriangles())
        return -2;
#endif
      if(getDimensionality() == 2)
        return getVertexStar(vertexId, localTriangleId, triangleId);
 
      return getVertexTriangleInternal(vertexId, localTriangleId, triangleId);
    }
 
    virtual inline SimplexId
      getVertexTriangleNumber(const SimplexId &vertexId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return -1;
 
      if(!hasPreconditionedVertexTriangles())
        return -2;
#endif
 
      if(getDimensionality() == 2)
        return getVertexStarNumber(vertexId);
 
      return getVertexTriangleNumberInternal(vertexId);
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getVertexTriangles() {
#ifndef TTK_ENABLE_KAMIKAZE
      if(getDimensionality() == 1)
        return nullptr;
 
      if(!hasPreconditionedVertexTriangles())
        return nullptr;
#endif
      if(getDimensionality() == 2)
        return getVertexStars();
 
      return getVertexTrianglesInternal();
    }
 
    inline bool hasPeriodicBoundaries() const {
      return hasPeriodicBoundaries_;
    }
 
    virtual inline bool isEdgeOnBoundary(const SimplexId &edgeId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedBoundaryEdges())
        return false;
#endif
      return isEdgeOnBoundaryInternal(edgeId);
    }
 
    virtual inline bool isEmpty() const {
      return true;
    }
 
    virtual inline bool isManifold() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!this->hasPreconditionedManifold())
        return false;
#endif
      return this->isManifold_;
    }
 
    virtual inline int preconditionManifold() {
 
      if(!this->hasPreconditionedManifold_) {
        this->preconditionManifoldInternal();
        this->hasPreconditionedManifold_ = true;
      }
      return 0;
    }
 
    virtual inline bool
      isTriangleOnBoundary(const SimplexId &triangleId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedBoundaryTriangles())
        return false;
#endif
      return isTriangleOnBoundaryInternal(triangleId);
    }
 
    virtual inline bool isVertexOnBoundary(const SimplexId &vertexId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedBoundaryVertices())
        return false;
#endif
      return isVertexOnBoundaryInternal(vertexId);
    }
 
    virtual inline int preconditionBoundaryEdges() {
 
      if(!hasPreconditionedBoundaryEdges_) {
        preconditionEdges();
        preconditionBoundaryEdgesInternal();
        hasPreconditionedBoundaryEdges_ = true;
      }
      return 0;
    }
 
    virtual inline int preconditionBoundaryTriangles() {
 
      if(!hasPreconditionedBoundaryTriangles_) {
        preconditionTriangles();
        preconditionBoundaryTrianglesInternal();
        hasPreconditionedBoundaryTriangles_ = true;
      }
      return 0;
    }
 
    virtual inline int preconditionBoundaryVertices() {
 
      if(!hasPreconditionedBoundaryVertices_) {
        preconditionBoundaryVerticesInternal();
        hasPreconditionedBoundaryVertices_ = true;
      }
      return 0;
    }
 
    virtual inline int preconditionCellEdges() {
 
      if(!hasPreconditionedCellEdges_) {
        hasPreconditionedCellEdges_ = true;
        if(getDimensionality() == 1)
          return preconditionCellNeighbors();
 
        preconditionEdges();
        preconditionCellEdgesInternal();
      }
      return 0;
    }
 
    virtual inline int preconditionCellNeighbors() {
 
      if(!hasPreconditionedCellNeighbors_) {
        preconditionCellNeighborsInternal();
        hasPreconditionedCellNeighbors_ = true;
      }
      return 0;
    }
 
    virtual inline int preconditionCellTriangles() {
 
      if(!hasPreconditionedCellTriangles_) {
        hasPreconditionedCellTriangles_ = true;
 
#ifndef TTK_ENABLE_KAMIKAZE
        if(getDimensionality() == 1)
          return -1;
#endif
        if(getDimensionality() == 2)
          return preconditionCellNeighbors();
 
        preconditionTriangles();
        preconditionCellTrianglesInternal();
      }
      return 0;
    }
 
    virtual inline int preconditionEdges() {
 
      if(!hasPreconditionedEdges_) {
        preconditionEdgesInternal();
        hasPreconditionedEdges_ = true;
      }
      return 0;
    }
 
    virtual inline int preconditionEdgeLinks() {
 
      if(!hasPreconditionedEdgeLinks_) {
#ifndef TTK_ENABLE_KAMIKAZE
        if(getDimensionality() == 1)
          return -1;
#endif
        preconditionEdges();
        preconditionEdgeLinksInternal();
        hasPreconditionedEdgeLinks_ = true;
      }
      return 0;
    }
 
    virtual inline int preconditionEdgeStars() {
 
      if(!hasPreconditionedEdgeStars_) {
#ifndef TTK_ENABLE_KAMIKAZE
        if(getDimensionality() == 1)
          return -1;
#endif
        preconditionEdges();
        preconditionEdgeStarsInternal();
        hasPreconditionedEdgeStars_ = true;
      }
      return 0;
    }
 
    virtual inline int preconditionEdgeTriangles() {
 
      if(!hasPreconditionedEdgeTriangles_) {
        hasPreconditionedEdgeTriangles_ = true;
 
#ifndef TTK_ENABLE_KAMIKAZE
        if(getDimensionality() == 1)
          return -1;
#endif
 
        if(getDimensionality() == 2)
          return preconditionEdgeStars();
 
        preconditionEdges();
        preconditionTriangles();
        preconditionEdgeTrianglesInternal();
      }
 
      return 0;
    }
 
    virtual inline int preconditionTriangles() {
 
      if(!hasPreconditionedTriangles_) {
        hasPreconditionedTriangles_ = true;
 
#ifndef TTK_ENABLE_KAMIKAZE
        if(getDimensionality() == 1)
          return -1;
#endif
        if(getDimensionality() == 2)
          return 0;
 
        preconditionTrianglesInternal();
      }
 
      return 0;
    }
 
    virtual inline int preconditionTriangleEdges() {
 
      if(!hasPreconditionedTriangleEdges_) {
        hasPreconditionedTriangleEdges_ = true;
 
#ifndef TTK_ENABLE_KAMIKAZE
        if(getDimensionality() == 1)
          return -1;
#endif
        if(getDimensionality() == 2)
          return preconditionCellEdges();
 
        preconditionEdges();
        preconditionTriangles();
        preconditionTriangleEdgesInternal();
      }
      return 0;
    }
 
    virtual inline int preconditionTriangleLinks() {
 
      if(!hasPreconditionedTriangleLinks_) {
#ifndef TTK_ENABLE_KAMIKAZE
        if(getDimensionality() != 3)
          return -2;
#endif
        preconditionTriangles();
        preconditionTriangleLinksInternal();
        hasPreconditionedTriangleLinks_ = true;
      }
      return 0;
    }
 
    virtual inline int preconditionTriangleStars() {
 
      if(!hasPreconditionedTriangleStars_) {
#ifndef TTK_ENABLE_KAMIKAZE
        if(getDimensionality() != 3)
          return -1;
#endif
        preconditionTriangles();
        preconditionTriangleStarsInternal();
        hasPreconditionedTriangleStars_ = true;
      }
      return 0;
    }
 
    virtual inline int preconditionVertexEdges() {
 
      if(!hasPreconditionedVertexEdges_) {
        hasPreconditionedVertexEdges_ = true;
 
        if(getDimensionality() == 1)
          return preconditionVertexStars();
 
        preconditionEdges();
        preconditionVertexEdgesInternal();
      }
      return 0;
    }
 
    virtual inline int preconditionVertexLinks() {
 
      if(!hasPreconditionedVertexLinks_) {
        preconditionVertexLinksInternal();
        hasPreconditionedVertexLinks_ = true;
      }
      return 0;
    }
 
    virtual inline int preconditionVertexNeighbors() {
 
      if(!hasPreconditionedVertexNeighbors_) {
        preconditionVertexNeighborsInternal();
        hasPreconditionedVertexNeighbors_ = true;
      }
      return 0;
    }
 
    virtual inline int preconditionVertexStars() {
 
      if(!hasPreconditionedVertexStars_) {
        preconditionVertexStarsInternal();
        hasPreconditionedVertexStars_ = true;
      }
      return 0;
    }
 
    virtual inline int preconditionVertexTriangles() {
 
      if(!hasPreconditionedVertexTriangles_) {
        hasPreconditionedVertexTriangles_ = true;
 
#ifndef TTK_ENABLE_KAMIKAZE
        if(getDimensionality() == 1)
          return -1;
#endif
 
        if(getDimensionality() == 2)
          return preconditionVertexStars();
 
        preconditionTriangles();
        preconditionVertexTrianglesInternal();
      }
      return 0;
    }
 
    inline int getEdgeIncenter(const SimplexId edgeId,
                               float incenter[3]) const {
      std::array<SimplexId, 2> vertexId{};
      getEdgeVertex(edgeId, 0, vertexId[0]);
      getEdgeVertex(edgeId, 1, vertexId[1]);
 
      std::array<float, 6> p{};
      getVertexPoint(vertexId[0], p[0], p[1], p[2]);
      getVertexPoint(vertexId[1], p[3], p[4], p[5]);
 
      incenter[0] = 0.5 * p[0] + 0.5 * p[3];
      incenter[1] = 0.5 * p[1] + 0.5 * p[4];
      incenter[2] = 0.5 * p[2] + 0.5 * p[5];
 
      return 0;
    }
 
    inline int getTriangleIncenter(const SimplexId triangleId,
                                   float incenter[3]) const {
 
      std::array<SimplexId, 3> vertexId{};
      if(getDimensionality() == 2) {
        getCellVertex(triangleId, 0, vertexId[0]);
        getCellVertex(triangleId, 1, vertexId[1]);
        getCellVertex(triangleId, 2, vertexId[2]);
      } else if(getDimensionality() == 3) {
        getTriangleVertex(triangleId, 0, vertexId[0]);
        getTriangleVertex(triangleId, 1, vertexId[1]);
        getTriangleVertex(triangleId, 2, vertexId[2]);
      }
 
      std::array<float, 9> p{};
      getVertexPoint(vertexId[0], p[0], p[1], p[2]);
      getVertexPoint(vertexId[1], p[3], p[4], p[5]);
      getVertexPoint(vertexId[2], p[6], p[7], p[8]);
 
      std::array<float, 3> d{};
      d[0] = Geometry::distance(&p[3], &p[6]);
      d[1] = Geometry::distance(&p[0], &p[6]);
      d[2] = Geometry::distance(&p[0], &p[3]);
      const float sum = d[0] + d[1] + d[2];
 
      d[0] = d[0] / sum;
      d[1] = d[1] / sum;
      d[2] = d[2] / sum;
 
      incenter[0] = d[0] * p[0] + d[1] * p[3] + d[2] * p[6];
      incenter[1] = d[0] * p[1] + d[1] * p[4] + d[2] * p[7];
      incenter[2] = d[0] * p[2] + d[1] * p[5] + d[2] * p[8];
 
      return 0;
    }
 
    inline int getTetraIncenter(const SimplexId tetraId,
                                float incenter[3]) const {
      incenter[0] = 0.0f;
      incenter[1] = 0.0f;
      incenter[2] = 0.0f;
 
      std::array<float, 3> p{};
      for(int i = 0; i < 4; ++i) {
        SimplexId triangleId;
        getCellTriangle(tetraId, i, triangleId);
        getTriangleIncenter(triangleId, p.data());
        incenter[0] += p[0];
        incenter[1] += p[1];
        incenter[2] += p[2];
      }
 
      incenter[0] /= 4.0f;
      incenter[1] /= 4.0f;
      incenter[2] /= 4.0f;
 
      return 0;
    }
 
    inline int getCellIncenter(const SimplexId cellid,
                               const int dim,
                               float incenter[3]) const {
      switch(dim) {
        case 0:
          getVertexPoint(cellid, incenter[0], incenter[1], incenter[2]);
          break;
        case 1:
          getEdgeIncenter(cellid, incenter);
          break;
        case 2:
          getTriangleIncenter(cellid, incenter);
          break;
        case 3:
          getTetraIncenter(cellid, incenter);
          break;
      }
      return 0;
    }
 
    virtual inline int getCellVTKID(const int &ttkId, int &vtkId) const {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      vtkId = -1;
#endif
      return getCellVTKIDInternal(ttkId, vtkId);
    }
 
#ifdef TTK_ENABLE_MPI
 
    // "vtkGhostType" on points & cells
 
    inline void setVertexGhostArray(const unsigned char *const data) {
      this->vertexGhost_ = data;
    }
 
    inline void setCellGhostArray(const unsigned char *const data) {
      this->cellGhost_ = data;
    }
 
    virtual int preconditionGlobalBoundary() {
 
      if(!hasPreconditionedGlobalBoundary_) {
        preconditionGlobalBoundaryInternal();
        hasPreconditionedGlobalBoundary_ = true;
      }
      return 0;
    }
 
    virtual inline int preconditionGlobalBoundaryInternal() {
      return 0;
    }
 
    // public preconditions methods (used in Triangulation/ttkAlgorithm)
    virtual int preconditionDistributedVertices() {
      return 0;
    }
    virtual int preconditionDistributedCells() {
      return 0;
    }
 
    // This method should be called to initialize and populate the
    // ghostCellsPerOwner_ and the remoteGhostCells_ attributes.
 
    virtual int preconditionExchangeGhostCells() {
      return 0;
    }
 
    // This method should be called to initialize and populate the
    // ghostVerticesPerOwner_ and the remoteGhostVertices_ attributes.
 
    virtual int preconditionExchangeGhostVertices() {
      return 0;
    }
 
    virtual int setVertexRankArray(const int *ttkNotUsed(rankArray)) {
      return 0;
    }
 
    virtual int setCellRankArray(const int *ttkNotUsed(rankArray)) {
      return 0;
    }
 
    virtual int preconditionEdgeRankArray() {
      return 0;
    }
 
    virtual int preconditionTriangleRankArray() {
      return 0;
    }
 
    // global <-> local id mappings
 
    virtual inline SimplexId getVertexGlobalId(const SimplexId lvid) const {
      if(!ttk::isRunningWithMPI()) {
        return lvid;
      }
#ifndef TTK_ENABLE_KAMIKAZE
      if(this->getDimensionality() != 1 && this->getDimensionality() != 2
         && this->getDimensionality() != 3) {
        this->printErr("Only 1D, 2D and 3D datasets are supported");
        return -1;
      }
      if(!this->hasPreconditionedDistributedVertices_) {
        this->printErr("VertexGlobalId query without pre-process!");
        this->printErr(
          "Please call preconditionDistributedVertices() in a pre-process.");
        return -1;
      }
      if(lvid < 0 || lvid >= this->getNumberOfVertices()) {
        return -1;
      }
#endif // TTK_ENABLE_KAMIKAZE
      return this->getVertexGlobalIdInternal(lvid);
    }
    virtual inline SimplexId getVertexLocalId(const SimplexId gvid) const {
 
      if(!ttk::isRunningWithMPI()) {
        return gvid;
      }
#ifndef TTK_ENABLE_KAMIKAZE
      if(this->getDimensionality() != 1 && this->getDimensionality() != 2
         && this->getDimensionality() != 3) {
        this->printErr("Only 1D, 2D and 3D datasets are supported");
        return -1;
      }
      if(!this->hasPreconditionedDistributedVertices_) {
        this->printErr("VertexLocalId query without pre-process!");
        this->printErr(
          "Please call preconditionDistributedVertices() in a pre-process.");
        return -1;
      }
#endif // TTK_ENABLE_KAMIKAZE
      return this->getVertexLocalIdInternal(gvid);
    }
 
    virtual inline SimplexId getCellGlobalId(const SimplexId lcid) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(this->getDimensionality() != 1 && this->getDimensionality() != 2
         && this->getDimensionality() != 3) {
        this->printErr("Only 1D, 2D and 3D datasets are supported");
        return -1;
      }
      if(!this->hasPreconditionedDistributedCells_) {
        this->printErr("CellGlobalId query without pre-process!");
        this->printErr(
          "Please call preconditionDistributedCells() in a pre-process.");
        return -1;
      }
      if(lcid < 0 || lcid >= this->getNumberOfCells()) {
        return -1;
      }
#endif // TTK_ENABLE_KAMIKAZE
      if(!ttk::isRunningWithMPI()) {
        return lcid;
      }
      return this->getCellGlobalIdInternal(lcid);
    }
    virtual inline SimplexId getCellLocalId(const SimplexId gcid) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(this->getDimensionality() != 1 && this->getDimensionality() != 2
         && this->getDimensionality() != 3) {
        this->printErr("Only 1D, 2D and 3D datasets are supported");
        return -1;
      }
      if(!this->hasPreconditionedDistributedCells_) {
        this->printErr("CellLocalId query without pre-process!");
        this->printErr(
          "Please call preconditionDistributedCells() in a pre-process.");
        return -1;
      }
#endif // TTK_ENABLE_KAMIKAZE
      if(!ttk::isRunningWithMPI()) {
        return gcid;
      }
      return this->getCellLocalIdInternal(gcid);
    }
 
    virtual inline SimplexId getEdgeGlobalId(const SimplexId leid) const {
      const auto dim{this->getDimensionality()};
#ifndef TTK_ENABLE_KAMIKAZE
      if(dim != 1 && dim != 2 && dim != 3) {
        this->printErr("Only 1D, 2D and 3D datasets are supported");
        return -1;
      }
      if(!this->hasPreconditionedDistributedEdges_) {
        this->printErr("EdgeGlobalId query without pre-process!");
        this->printErr(
          "Please call preconditionDistributedEdges() in a pre-process.");
        return -1;
      }
      if(leid < 0 || leid >= this->getNumberOfEdges()) {
        return -1;
      }
#endif // TTK_ENABLE_KAMIKAZE
      if(!ttk::isRunningWithMPI()) {
        return leid;
      }
      if(dim == 2 || dim == 3) {
        return this->getEdgeGlobalIdInternal(leid);
      } else if(dim == 1) {
        return this->getCellGlobalIdInternal(leid);
      }
      return -1;
    }
    virtual inline SimplexId getEdgeLocalId(const SimplexId geid) const {
      const auto dim{this->getDimensionality()};
#ifndef TTK_ENABLE_KAMIKAZE
      if(dim != 1 && dim != 2 && dim != 3) {
        this->printErr("Only 1D, 2D and 3D datasets are supported");
        return -1;
      }
      if(!this->hasPreconditionedDistributedEdges_) {
        this->printErr("EdgeLocalId query without pre-process!");
        this->printErr(
          "Please call preconditionDistributedEdges() in a pre-process.");
        return -1;
      }
#endif // TTK_ENABLE_KAMIKAZE
      if(!ttk::isRunningWithMPI()) {
        return geid;
      }
      if(dim == 2 || dim == 3) {
        return this->getEdgeLocalIdInternal(geid);
      } else if(dim == 1) {
        return this->getCellLocalIdInternal(geid);
      }
      return -1;
    }
 
    virtual inline SimplexId getTriangleGlobalId(const SimplexId ltid) const {
      const auto dim{this->getDimensionality()};
#ifndef TTK_ENABLE_KAMIKAZE
      if(dim != 3 && dim != 2) {
        this->printErr("Only 2D and  3D datasets are supported");
        return -1;
      }
      if(!this->hasPreconditionedDistributedEdges_) {
        this->printErr("TriangleGlobalId query without pre-process!");
        this->printErr(
          "Please call preconditionDistributedTriangles() in a pre-process.");
        return -1;
      }
      if(ltid < 0 || ltid >= this->getNumberOfTriangles()) {
        return -1;
      }
#endif // TTK_ENABLE_KAMIKAZE
      if(!ttk::isRunningWithMPI()) {
        return ltid;
      }
      if(dim == 3) {
        return this->getTriangleGlobalIdInternal(ltid);
      } else if(dim == 2) {
        return this->getCellGlobalIdInternal(ltid);
      }
      return -1;
    }
    virtual inline SimplexId getTriangleLocalId(const SimplexId gtid) const {
      const auto dim{this->getDimensionality()};
#ifndef TTK_ENABLE_KAMIKAZE
      if(dim != 3 && dim != 2) {
        this->printErr("Only 2D and 3D datasets are supported");
        return -1;
      }
      if(!this->hasPreconditionedDistributedEdges_) {
        this->printErr("TriangleLocalId query without pre-process!");
        this->printErr(
          "Please call preconditionDistributedTriangles() in a pre-process.");
        return -1;
      }
#endif // TTK_ENABLE_KAMIKAZE
      if(!ttk::isRunningWithMPI()) {
        return gtid;
      }
      if(dim == 3) {
        return this->getTriangleLocalIdInternal(gtid);
      } else if(dim == 2) {
        return this->getCellLocalIdInternal(gtid);
      }
      return -1;
    }
 
    virtual inline int getVertexRank(const SimplexId lvid) const {
 
      if(!ttk::isRunningWithMPI()) {
        return 0;
      }
#ifndef TTK_ENABLE_KAMIKAZE
      if(this->getDimensionality() != 1 && this->getDimensionality() != 2
         && this->getDimensionality() != 3) {
        this->printErr("Only 1D, 2D and 3D datasets are supported");
        return -1;
      }
      if(!this->hasPreconditionedDistributedVertices_) {
        this->printErr("VertexRankId query without pre-process!");
        this->printErr(
          "Please call preconditionDistributedVertices() in a pre-process.");
        return -1;
      }
      if(lvid < 0 || lvid >= this->getNumberOfVertices()) {
        return -1;
      }
#endif // TTK_ENABLE_KAMIKAZE
      return this->getVertexRankInternal(lvid);
    }
 
    virtual inline int getCellRank(const SimplexId lcid) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(this->getDimensionality() != 1 && this->getDimensionality() != 2
         && this->getDimensionality() != 3) {
        this->printErr("Only 1D, 2D and 3D datasets are supported");
        return -1;
      }
      if(!this->hasPreconditionedDistributedCells_) {
        this->printErr("CellRankId query without pre-process!");
        this->printErr(
          "Please call preconditionDistributedCells() in a pre-process.");
        return -1;
      }
      if(lcid < 0 || lcid >= this->getNumberOfCells()) {
        return -1;
      }
#endif // TTK_ENABLE_KAMIKAZE
      if(!ttk::isRunningWithMPI()) {
        return lcid;
      }
      return this->getCellRankInternal(lcid);
    }
 
    virtual inline const std::vector<int> &getNeighborRanks() const {
      return this->neighborRanks_;
    }
    virtual inline std::vector<int> &getNeighborRanks() {
      return this->neighborRanks_;
    }
 
    virtual inline std::map<int, int> &getNeighborsToId() {
      return this->neighborsToId_;
    }
 
    virtual inline const std::map<int, int> &getNeighborsToId() const {
      return this->neighborsToId_;
    }
 
    virtual inline const std::vector<std::array<ttk::SimplexId, 6>> &
      getNeighborVertexBBoxes() const {
      return this->neighborVertexBBoxes_;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> &
      getGhostCellsPerOwner() const {
      if(!hasPreconditionedExchangeGhostCells_) {
        printErr("The ghostCellsOwner_ attribute has not been populated!");
        printErr(
          "Please call preconditionExchangeGhostCells in a pre-process.");
      }
      return this->ghostCellsPerOwner_;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> &
      getRemoteGhostCells() const {
      if(!hasPreconditionedExchangeGhostCells_) {
        printErr("The remoteGhostCells_ attribute has not been populated!");
        printErr(
          "Please call preconditionExchangeGhostCells in a pre-process.");
      }
      return this->remoteGhostCells_;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> &
      getGhostVerticesPerOwner() const {
      if(!hasPreconditionedExchangeGhostVertices_) {
        printErr(
          "The ghostVerticesPerOwner_ attribute has not been populated!");
        printErr(
          "Please call preconditionExchangeGhostVertices in a pre-process.");
      }
      return this->ghostVerticesPerOwner_;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> &
      getRemoteGhostVertices() const {
      if(!hasPreconditionedExchangeGhostVertices_) {
        printErr("The remoteGhostVertices_ attribute has not been populated!");
        printErr(
          "Please call preconditionExchangeGhostVertices in a pre-process.");
      }
      return this->remoteGhostVertices_;
    }
 
    virtual inline void setHasPreconditionedDistributedVertices(bool flag) {
      this->hasPreconditionedDistributedVertices_ = flag;
    }
 
    virtual inline bool hasPreconditionedDistributedVertices() const {
      return this->hasPreconditionedDistributedVertices_;
    }
    virtual inline bool hasPreconditionedDistributedCells() const {
      return this->hasPreconditionedDistributedCells_;
    }
 
    inline int getDistributedGlobalCellId(const SimplexId &localCellId,
                                          const int &cellDim,
                                          SimplexId &globalCellId) const {
      if(ttk::hasInitializedMPI()) {
        switch(cellDim) {
          case 0:
            globalCellId = this->getVertexGlobalIdInternal(localCellId);
            break;
          case 1:
            globalCellId = this->getEdgeGlobalIdInternal(localCellId);
            break;
          case 2:
            if(getDimensionality() == 2) {
              globalCellId = this->getCellGlobalIdInternal(localCellId);
              break;
            } else {
              globalCellId = this->getTriangleGlobalIdInternal(localCellId);
              break;
            }
          case 3: {
            globalCellId = this->getCellGlobalIdInternal(localCellId);
            break;
          }
          default:
            globalCellId = -1;
            break;
        }
      } else {
        globalCellId = localCellId;
      }
      return 0;
    }
 
    inline bool isOrderArrayGlobal(const void *data) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isOrderArrayGlobal_.find(data) != isOrderArrayGlobal_.end())
#endif
        return isOrderArrayGlobal_.at(data);
#ifndef TTK_ENABLE_KAMIKAZE
      else {
        printErr("No global array flag has been found for this scalar field");
        return false;
      }
#endif
    }
 
    inline void setIsOrderArrayGlobal(const void *data, bool flag) {
      isOrderArrayGlobal_[data] = flag;
    }
 
  protected:
    virtual inline SimplexId
      getVertexGlobalIdInternal(const SimplexId ttkNotUsed(lvid)) const {
      return -1;
    }
 
    virtual inline SimplexId
      getVertexLocalIdInternal(const SimplexId ttkNotUsed(gvid)) const {
      return -1;
    }
 
    // overriden in ImplicitTriangulation &
    // PeriodicImplicitTriangulation (where cellGid_ refers to
    // squares/cubes and not triangles/tetrahedron)
    virtual inline SimplexId
      getCellGlobalIdInternal(const SimplexId ttkNotUsed(lcid)) const {
      return -1;
    }
 
    virtual inline SimplexId
      getCellLocalIdInternal(const SimplexId ttkNotUsed(gcid)) const {
      return -1;
    }
 
    virtual inline SimplexId
      getEdgeGlobalIdInternal(const SimplexId ttkNotUsed(leid)) const {
      return -1;
    }
 
    virtual inline SimplexId
      getEdgeLocalIdInternal(const SimplexId ttkNotUsed(geid)) const {
      return -1;
    }
 
    virtual inline SimplexId
      getTriangleGlobalIdInternal(const SimplexId ttkNotUsed(ltid)) const {
      return -1;
    }
 
    virtual inline SimplexId
      getTriangleLocalIdInternal(const SimplexId ttkNotUsed(gtid)) const {
      return -1;
    }
 
    virtual inline int
      getVertexRankInternal(const SimplexId ttkNotUsed(lvid)) const {
      return -1;
    }
 
    virtual inline int
      getCellRankInternal(const SimplexId ttkNotUsed(lcid)) const {
      return -1;
    }
 
    // these protected methods should not be exposed since they are
    // called by their non-MPI-aware conterparts
    virtual inline bool
      isVertexOnGlobalBoundaryInternal(const SimplexId ttkNotUsed(lvid)) const {
      return false;
    }
    virtual inline bool
      isEdgeOnGlobalBoundaryInternal(const SimplexId ttkNotUsed(leid)) const {
      return false;
    }
    virtual inline bool isTriangleOnGlobalBoundaryInternal(
      const SimplexId ttkNotUsed(ltid)) const {
      return false;
    }
 
#endif // TTK_ENABLE_MPI
 
  protected:
    virtual int getCellEdgeInternal(const SimplexId &ttkNotUsed(cellId),
                                    const int &ttkNotUsed(localEdgeId),
                                    SimplexId &ttkNotUsed(edgeId)) const {
      return 0;
    }
 
    virtual inline SimplexId
      getCellEdgeNumberInternal(const SimplexId &ttkNotUsed(cellId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getCellEdgesInternal() {
      return nullptr;
    }
 
    virtual inline int
      getCellNeighborInternal(const SimplexId &ttkNotUsed(cellId),
                              const int &ttkNotUsed(localNeighborId),
                              SimplexId &ttkNotUsed(neighborId)) const {
      return 0;
    }
 
    virtual inline SimplexId
      getCellNeighborNumberInternal(const SimplexId &ttkNotUsed(cellId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getCellNeighborsInternal() {
      return nullptr;
    }
 
    virtual inline int
      getCellTriangleInternal(const SimplexId &ttkNotUsed(cellId),
                              const int &ttkNotUsed(localTriangleId),
                              SimplexId &ttkNotUsed(triangleId)) const {
      return 0;
    }
 
    virtual inline SimplexId
      getCellTriangleNumberInternal(const SimplexId &ttkNotUsed(cellId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getCellTrianglesInternal() {
      return nullptr;
    }
 
    virtual inline int
      getCellVertexInternal(const SimplexId &ttkNotUsed(cellId),
                            const int &ttkNotUsed(localVertexId),
                            SimplexId &ttkNotUsed(vertexId)) const {
      return 0;
    }
 
    virtual inline SimplexId
      getCellVertexNumberInternal(const SimplexId &ttkNotUsed(cellId)) const {
      return 0;
    }
 
    virtual inline int getDimensionalityInternal() const {
      return 0;
    }
 
    virtual inline const std::vector<std::array<SimplexId, 2>> *
      getEdgesInternal() {
      return nullptr;
    }
 
    virtual inline int
      getEdgeLinkInternal(const SimplexId &ttkNotUsed(edgeId),
                          const int &ttkNotUsed(localLinkId),
                          SimplexId &ttkNotUsed(linkId)) const {
      return 0;
    }
 
    virtual inline SimplexId
      getEdgeLinkNumberInternal(const SimplexId &ttkNotUsed(edgeId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getEdgeLinksInternal() {
      return nullptr;
    }
 
    virtual inline int
      getEdgeStarInternal(const SimplexId &ttkNotUsed(edgeId),
                          const int &ttkNotUsed(localStarId),
                          SimplexId &ttkNotUsed(starId)) const {
      return 0;
    }
 
    virtual inline SimplexId
      getEdgeStarNumberInternal(const SimplexId &ttkNotUsed(edgeId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getEdgeStarsInternal() {
      return nullptr;
    }
 
    virtual inline int
      getEdgeTriangleInternal(const SimplexId &ttkNotUsed(edgeId),
                              const int &ttkNotUsed(localTriangleId),
                              SimplexId &ttkNotUsed(triangleId)) const {
      return 0;
    }
 
    virtual inline SimplexId
      getEdgeTriangleNumberInternal(const SimplexId &ttkNotUsed(edgeId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getEdgeTrianglesInternal() {
      return nullptr;
    }
 
    virtual inline int
      getEdgeVertexInternal(const SimplexId &ttkNotUsed(edgeId),
                            const int &ttkNotUsed(localVertexId),
                            SimplexId &ttkNotUsed(vertexId)) const {
      return 0;
    }
 
    virtual inline SimplexId getNumberOfCellsInternal() const {
      return 0;
    }
 
    virtual inline SimplexId getNumberOfEdgesInternal() const {
      return 0;
    }
 
    virtual inline SimplexId getNumberOfTrianglesInternal() const {
      return 0;
    }
 
    virtual inline SimplexId getNumberOfVerticesInternal() const {
      return 0;
    }
 
    virtual inline const std::vector<std::array<SimplexId, 3>> *
      getTrianglesInternal() {
      return nullptr;
    }
 
    virtual inline int
      getTriangleEdgeInternal(const SimplexId &ttkNotUsed(triangleId),
                              const int &ttkNotUsed(localEdgeId),
                              SimplexId &ttkNotUsed(edgeId)) const {
      return 0;
    }
 
    virtual inline SimplexId getTriangleEdgeNumberInternal(
      const SimplexId &ttkNotUsed(triangleId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getTriangleEdgesInternal() {
      return nullptr;
    }
 
    virtual inline int
      getTriangleLinkInternal(const SimplexId &ttkNotUsed(triangleId),
                              const int &ttkNotUsed(localLinkId),
                              SimplexId &ttkNotUsed(linkId)) const {
      return 0;
    }
 
    virtual inline SimplexId getTriangleLinkNumberInternal(
      const SimplexId &ttkNotUsed(triangleId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getTriangleLinksInternal() {
      return nullptr;
    }
 
    virtual inline int
      getTriangleStarInternal(const SimplexId &ttkNotUsed(triangleId),
                              const int &ttkNotUsed(localStarId),
                              SimplexId &ttkNotUsed(starId)) const {
      return 0;
    }
 
    virtual inline SimplexId getTriangleStarNumberInternal(
      const SimplexId &ttkNotUsed(triangleId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getTriangleStarsInternal() {
      return nullptr;
    }
 
    virtual inline int
      getTriangleVertexInternal(const SimplexId &ttkNotUsed(triangleId),
                                const int &ttkNotUsed(localVertexId),
                                SimplexId &ttkNotUsed(vertexId)) const {
      return 0;
    }
 
    virtual inline int
      getVertexEdgeInternal(const SimplexId &ttkNotUsed(vertexId),
                            const int &ttkNotUsed(localEdgeId),
                            SimplexId &ttkNotUsed(edgeId)) const {
      return 0;
    }
 
    virtual inline SimplexId
      getVertexEdgeNumberInternal(const SimplexId &ttkNotUsed(vertexId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getVertexEdgesInternal() {
      return nullptr;
    }
 
    virtual inline int
      getVertexLinkInternal(const SimplexId &ttkNotUsed(vertexId),
                            const int &ttkNotUsed(localLinkId),
                            SimplexId &ttkNotUsed(linkId)) const {
      return 0;
    }
 
    virtual inline SimplexId
      getVertexLinkNumberInternal(const SimplexId &ttkNotUsed(vertexId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getVertexLinksInternal() {
      return nullptr;
    }
 
    virtual inline int
      getVertexNeighborInternal(const SimplexId &ttkNotUsed(vertexId),
                                const int &ttkNotUsed(localNeighborId),
                                SimplexId &ttkNotUsed(neighborId)) const {
      return 0;
    }
 
    virtual inline SimplexId getVertexNeighborNumberInternal(
      const SimplexId &ttkNotUsed(vertexId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getVertexNeighborsInternal() {
      return nullptr;
    }
 
    virtual inline int
      getVertexPointInternal(const SimplexId &ttkNotUsed(vertexId),
                             float &ttkNotUsed(x),
                             float &ttkNotUsed(y),
                             float &ttkNotUsed(z)) const {
      return 0;
    }
 
    virtual inline int
      getVertexStarInternal(const SimplexId &ttkNotUsed(vertexId),
                            const int &ttkNotUsed(localStarId),
                            SimplexId &ttkNotUsed(starId)) const {
      return 0;
    }
 
    virtual inline SimplexId
      getVertexStarNumberInternal(const SimplexId &ttkNotUsed(vertexId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getVertexStarsInternal() {
      return nullptr;
    }
 
    virtual inline int
      getVertexTriangleInternal(const SimplexId &ttkNotUsed(vertexId),
                                const int &ttkNotUsed(localTriangleId),
                                SimplexId &ttkNotUsed(triangleId)) const {
      return 0;
    }
 
    virtual inline SimplexId getVertexTriangleNumberInternal(
      const SimplexId &ttkNotUsed(vertexId)) const {
      return 0;
    }
 
    virtual inline const std::vector<std::vector<SimplexId>> *
      getVertexTrianglesInternal() {
      return nullptr;
    }
 
    virtual inline bool
      isEdgeOnBoundaryInternal(const SimplexId &ttkNotUsed(edgeId)) const {
      return false;
    }
 
    virtual inline bool isTriangleOnBoundaryInternal(
      const SimplexId &ttkNotUsed(triangleId)) const {
      return false;
    }
 
    virtual inline bool
      isVertexOnBoundaryInternal(const SimplexId &ttkNotUsed(vertexId)) const {
      return false;
    }
 
    inline bool hasPreconditionedBoundaryEdges() const {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedBoundaryEdges_) {
 
        printMsg("BoundaryEdge query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionBoundaryEdges() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
      }
#endif
 
      return hasPreconditionedBoundaryEdges_;
    }
 
    inline bool hasPreconditionedBoundaryTriangles() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedBoundaryTriangles_) {
 
        printMsg("BoundaryTriangle query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg(
          "Please call preconditionBoundaryTriangles() in a pre-process.",
          debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
      }
#endif
      return hasPreconditionedBoundaryTriangles_;
    }
 
    inline bool hasPreconditionedBoundaryVertices() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedBoundaryVertices_) {
 
        printMsg("BoundaryVertex query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionBoundaryVertices() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
      }
#endif
      return hasPreconditionedBoundaryVertices_;
    }
 
    inline bool hasPreconditionedCellEdges() const {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(((getDimensionality() == 1) && (!hasPreconditionedCellNeighbors_))
         || ((getDimensionality() > 1) && (!hasPreconditionedCellEdges_))) {
 
        printMsg("CellEdge query without pre-process!", debug::Priority::ERROR,
                 debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionCellEdges() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        return false;
      }
#endif
      return true;
    }
 
    inline bool hasPreconditionedCellNeighbors() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedCellNeighbors_) {
 
        printMsg("CellNeighbor query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionCellNeighbors() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
      }
#endif
      return hasPreconditionedCellNeighbors_;
    }
 
    inline bool hasPreconditionedCellTriangles() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(((getDimensionality() == 2) && (!hasPreconditionedCellNeighbors_))
         || ((getDimensionality() == 3)
             && (!hasPreconditionedCellTriangles_))) {
 
        printMsg("CellTriangle query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionCellTriangles() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
 
        return false;
      }
#endif
      return true;
    }
 
    inline bool hasPreconditionedEdgeLinks() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedEdgeLinks_) {
 
        printMsg("EdgeLink query without pre-process!", debug::Priority::ERROR,
                 debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionEdgeLinks() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
      }
#endif
      return hasPreconditionedEdgeLinks_;
    }
 
    inline bool hasPreconditionedEdgeStars() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedEdgeStars_) {
 
        printMsg("EdgeStar query without pre-process!", debug::Priority::ERROR,
                 debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionEdgeStars() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
      }
#endif
      return hasPreconditionedEdgeStars_;
    }
 
    inline bool hasPreconditionedEdgeTriangles() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(((getDimensionality() == 2) && (!hasPreconditionedEdgeStars_))
         || ((getDimensionality() == 3)
             && (!hasPreconditionedEdgeTriangles_))) {
 
        printMsg("EdgeTriangle query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionEdgeTriangles() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
 
        return false;
      }
#endif
      return true;
    }
 
    inline bool hasPreconditionedEdges() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if((getDimensionality() != 1) && (!hasPreconditionedEdges_)) {
 
        printMsg("Edge query without pre-process!", debug::Priority::ERROR,
                 debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionEdges() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
 
        return false;
      }
#endif
      return true;
    }
 
    inline bool hasPreconditionedTriangles() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if((getDimensionality() == 3) && (!hasPreconditionedTriangles_)) {
 
        printMsg("Triangle query without pre-process!", debug::Priority::ERROR,
                 debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionTriangles() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
 
        return false;
      }
#endif
      return true;
    }
 
    inline bool hasPreconditionedTriangleEdges() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(((getDimensionality() == 2) && (!hasPreconditionedCellEdges_))
         || ((getDimensionality() == 3)
             && (!hasPreconditionedTriangleEdges_))) {
 
        printMsg("TriangleEdge query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionTriangleEdges() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
 
        return false;
      }
#endif
      return true;
    }
 
    inline bool hasPreconditionedTriangleLinks() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedTriangleLinks_) {
 
        printMsg("TriangleLink query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionTriangleLinks() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
      }
#endif
      return hasPreconditionedTriangleLinks_;
    }
 
    inline bool hasPreconditionedTriangleStars() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedTriangleStars_) {
 
        printMsg("TriangleStar query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionTriangleStars() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
      }
#endif
      return hasPreconditionedTriangleStars_;
    }
 
    inline bool hasPreconditionedVertexEdges() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(((getDimensionality() == 1) && (!hasPreconditionedVertexStars_))
         || ((getDimensionality() > 1) && (!hasPreconditionedVertexEdges_))) {
 
        printMsg("VertexEdge query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionVertexEdges() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
 
        return false;
      }
#endif
      return true;
    }
 
    inline bool hasPreconditionedVertexLinks() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedVertexLinks_) {
 
        printMsg("VertexLink query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionVertexLinks() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
      }
#endif
      return hasPreconditionedVertexLinks_;
    }
 
    inline bool hasPreconditionedVertexNeighbors() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedVertexNeighbors_) {
 
        printMsg("VertexNeighbor query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionVertexNeighbors() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
      }
#endif
      return hasPreconditionedVertexNeighbors_;
    }
 
    inline bool hasPreconditionedVertexStars() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!hasPreconditionedVertexStars_) {
 
        printMsg("VertexStar query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionVertexStars() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
      }
#endif
      return hasPreconditionedVertexStars_;
    }
 
    inline bool hasPreconditionedVertexTriangles() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(((getDimensionality() == 2) && (!hasPreconditionedVertexStars_))
         || ((getDimensionality() == 3)
             && (!hasPreconditionedVertexTriangles_))) {
 
        printMsg("VertexTriangle query without pre-process!",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        printMsg("Please call preconditionVertexTriangles() in a pre-process.",
                 debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
 
        return false;
      }
#endif
      return true;
    }
 
    inline bool hasPreconditionedManifold() const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(!this->hasPreconditionedManifold_) {
        this->printMsg("isManifold query without pre-process!",
                       debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
        this->printMsg("Please call preconditionManifold() in a pre-process.",
                       debug::Priority::ERROR, debug::LineMode::NEW, std::cerr);
      }
#endif // TTK_ENABLE_KAMIKAZE
      return this->hasPreconditionedManifold_;
    }
 
    // empty wrapping to VTK for now
    bool needsToAbort() override {
      return false;
    }
 
    virtual inline int preconditionBoundaryEdgesInternal() {
      return 0;
    }
 
    virtual inline int preconditionBoundaryTrianglesInternal() {
      return 0;
    }
 
    virtual inline int preconditionBoundaryVerticesInternal() {
      return 0;
    }
 
    virtual inline int preconditionCellEdgesInternal() {
      return 0;
    }
 
    virtual inline int preconditionCellNeighborsInternal() {
      return 0;
    }
 
    virtual inline int preconditionCellTrianglesInternal() {
      return 0;
    }
 
    virtual inline int preconditionEdgesInternal() {
      return 0;
    }
 
    virtual inline int preconditionEdgeLinksInternal() {
      return 0;
    }
 
    virtual inline int preconditionEdgeStarsInternal() {
      return 0;
    }
 
    virtual inline int preconditionEdgeTrianglesInternal() {
      return 0;
    }
 
    virtual inline int preconditionTrianglesInternal() {
      return 0;
    }
 
    virtual inline int preconditionTriangleEdgesInternal() {
      return 0;
    }
 
    virtual inline int preconditionTriangleLinksInternal() {
      return 0;
    }
 
    virtual inline int preconditionTriangleStarsInternal() {
      return 0;
    }
 
    virtual inline int preconditionVertexEdgesInternal() {
      return 0;
    }
 
    virtual inline int preconditionVertexLinksInternal() {
      return 0;
    }
 
    virtual inline int preconditionVertexNeighborsInternal() {
      return 0;
    }
 
    virtual inline int preconditionVertexStarsInternal() {
      return 0;
    }
 
    virtual inline int preconditionVertexTrianglesInternal() {
      return 0;
    }
 
    virtual inline int preconditionManifoldInternal() {
      return 0;
    }
 
    virtual inline int getCellVTKIDInternal(const int &ttkId,
                                            int &vtkId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(ttkId < 0) {
        return -1;
      }
#endif
      vtkId = ttkId;
      return 0;
    }
 
    template <class itemType>
    size_t tableFootprint(const std::vector<itemType> &table,
                          const std::string &tableName = "",
                          std::ostream &stream = std::cout) const {
 
      std::stringstream msg;
      if((table.size()) && (tableName.length())) {
        msg << tableName << ": " << table.size() * sizeof(itemType) << " bytes";
        printMsg(
          msg.str(), debug::Priority::INFO, debug::LineMode::NEW, stream);
      }
 
      return table.size() * sizeof(itemType);
    }
 
    template <class itemType>
    size_t tableTableFootprint(const std::vector<std::vector<itemType>> &table,
                               const std::string &tableName = "",
                               std::ostream &stream = std::cout) const;
 
    int updateProgress(const float &ttkNotUsed(progress)) override {
      return 0;
    }
 
    bool hasPeriodicBoundaries_, hasPreconditionedBoundaryEdges_,
      hasPreconditionedBoundaryTriangles_, hasPreconditionedBoundaryVertices_,
      hasPreconditionedCellEdges_, hasPreconditionedCellNeighbors_,
      hasPreconditionedCellTriangles_, hasPreconditionedEdges_,
      hasPreconditionedEdgeLinks_, hasPreconditionedEdgeStars_,
      hasPreconditionedEdgeTriangles_, hasPreconditionedTriangles_,
      hasPreconditionedTriangleEdges_, hasPreconditionedTriangleLinks_,
      hasPreconditionedTriangleStars_, hasPreconditionedVertexEdges_,
      hasPreconditionedVertexLinks_, hasPreconditionedVertexNeighbors_,
      hasPreconditionedVertexStars_, hasPreconditionedVertexTriangles_,
      hasPreconditionedManifold_;
 
    bool isManifold_{true};
 
    std::array<SimplexId, 3> gridDimensions_;
 
    std::vector<bool> boundaryEdges_, boundaryTriangles_, boundaryVertices_;
    std::vector<std::array<SimplexId, 6>> tetraEdgeList_;
    std::vector<std::vector<SimplexId>> cellNeighborList_;
    std::vector<std::array<SimplexId, 4>> tetraTriangleList_;
    std::vector<std::vector<SimplexId>> edgeLinkList_;
    std::vector<std::array<SimplexId, 2>> edgeList_;
    std::vector<std::vector<SimplexId>> edgeStarList_;
    std::vector<std::vector<SimplexId>> edgeTriangleList_;
    std::vector<std::array<SimplexId, 3>> triangleList_;
    std::vector<std::array<SimplexId, 3>> triangleEdgeList_;
    std::vector<std::vector<SimplexId>> triangleLinkList_;
    std::vector<std::vector<SimplexId>> triangleStarList_;
    std::vector<std::vector<SimplexId>> vertexEdgeList_;
    std::vector<std::vector<SimplexId>> vertexLinkList_;
    std::vector<std::vector<SimplexId>> vertexNeighborList_;
    std::vector<std::vector<SimplexId>> vertexStarList_;
    std::vector<std::vector<SimplexId>> vertexTriangleList_;
 
    // keep compatibility between getCellEdges(), getCellTriangles(),
    // getCellNeighbors() and getTriangleEdges()
    std::vector<std::vector<SimplexId>> cellEdgeVector_{};
    std::vector<std::vector<SimplexId>> cellTriangleVector_{};
    std::vector<std::vector<SimplexId>> triangleEdgeVector_{};
 
#ifdef TTK_ENABLE_MPI
 
    // precondition methods for distributed meshes
 
    virtual int preconditionDistributedEdges() {
      return 0;
    }
    virtual int preconditionDistributedTriangles() {
      return 0;
    }
 
    // "vtkGhostType" PointData array
    const unsigned char *vertexGhost_{};
    // "vtkGhostType" CellData array
    const unsigned char *cellGhost_{};
 
    // list of neighboring ranks (sharing ghost cells to current rank)
    std::vector<int> neighborRanks_{};
    // list of ids in the neighborRanks_ vector of neighboring ranks
    std::map<int, int> neighborsToId_{};
    // global ids of (local) ghost cells per each MPI (neighboring) rank
    std::vector<std::vector<SimplexId>> ghostCellsPerOwner_{};
    // global ids of local (owned) cells that are ghost cells of other
    // (neighboring) ranks (per MPI rank)
    std::vector<std::vector<SimplexId>> remoteGhostCells_{};
    // global ids of (local) ghost vertices per each MPI (neighboring) rank
    std::vector<std::vector<SimplexId>> ghostVerticesPerOwner_{};
    // global ids of local (owned) vertices that are ghost cells of other
    // (neighboring) ranks (per MPI rank)
    std::vector<std::vector<SimplexId>> remoteGhostVertices_{};
    // hold the neighboring ranks vertex bounding boxes (metaGrid_ coordinates)
    std::vector<std::array<SimplexId, 6>> neighborVertexBBoxes_{};
    // hold the neighboring ranks cells bounding boxes (metaGrid_ coordinates)
    std::vector<std::array<SimplexId, 6>> neighborCellBBoxes_{};
 
    bool hasPreconditionedDistributedCells_{false};
    bool hasPreconditionedExchangeGhostCells_{false};
    bool hasPreconditionedDistributedEdges_{false};
    bool hasPreconditionedDistributedTriangles_{false};
    bool hasPreconditionedDistributedVertices_{false};
    bool hasPreconditionedExchangeGhostVertices_{false};
    bool hasPreconditionedGlobalBoundary_{false};
    std::map<const void *, bool> isOrderArrayGlobal_;
 
#endif // TTK_ENABLE_MPI
 
    // only ttk::dcg::DiscreteGradient should use what's defined below.
    friend class ttk::dcg::DiscreteGradient;
 
#ifdef TTK_ENABLE_DCG_OPTIMIZE_MEMORY
    // might no be sufficient for Rips complexes, where a vertex can
    // have more than 128 neighbors
    using gradIdType = char;
#else
    using gradIdType = SimplexId;
#endif
 
    using gradientType = std::array<std::vector<gradIdType>, 6>;
    using gradientKeyType = std::pair<const void *, size_t>;
    /*
     * @brief Type for caching Discrete Gradient internal data structure.
     *
     * Uses the ttk::LRUCache with \ref gradientKeytype as key and
     * \ref gradientType as value types.
     */
    using gradientCacheType = LRUCache<gradientKeyType, gradientType>;
    /*
     * @brief Access to the gradientCache_ mutable member variable
     *
     * \warning This should only be used by the
     * ttk::dcg::DiscreteGradient class.
     */
    inline gradientCacheType *getGradientCacheHandler() const {
      return &this->gradientCache_;
    }
 
    // store, for each triangulation object and per offset field, a
    // reference to the discrete gradient internal structure
    mutable gradientCacheType gradientCache_{};
  };
} // namespace ttk