Triangulation.h

Go to the documentation of this file.

 
 
#pragma once
 
// base code includes
#include <AbstractTriangulation.h>
#include <CompactTriangulation.h>
#include <ExplicitTriangulation.h>
#include <ImplicitTriangulation.h>
#include <PeriodicImplicitTriangulation.h>
 
#include <array>
 
namespace ttk {
 
  class Triangulation final : public AbstractTriangulation {
 
  public:
    Triangulation();
    Triangulation(const Triangulation &);
    Triangulation(Triangulation &&) noexcept;
    Triangulation &operator=(const Triangulation &);
    Triangulation &operator=(Triangulation &&) noexcept;
    ~Triangulation() override;
 
    enum class Type {
      EXPLICIT,
      IMPLICIT,
      HYBRID_IMPLICIT,
      PERIODIC,
      HYBRID_PERIODIC,
      COMPACT
    };
 
    enum class STRATEGY {
      DEFAULT = 0,
      WITH_PRECONDITIONS = 1,
      NO_PRECONDITIONS = 2,
    };
 
    inline int clear() {
 
      if(abstractTriangulation_) {
        return abstractTriangulation_->clear();
      }
 
      return 0;
    }
 
    inline size_t footprint() const {
 
      if(abstractTriangulation_) {
        return abstractTriangulation_->footprint();
      }
 
      return 0;
    }
 
    inline int getCellEdge(const SimplexId &cellId,
                           const int &localEdgeId,
                           SimplexId &edgeId) const override {
 
      // initialize output variable before early return
      edgeId = -1;
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
 
      return abstractTriangulation_->getCellEdge(cellId, localEdgeId, edgeId);
    }
 
    inline SimplexId getCellEdgeNumber(const SimplexId &cellId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getCellEdgeNumber(cellId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *getCellEdges() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getCellEdges();
    }
 
    inline int
      getCellIncenter(SimplexId cellId, int dim, float incenter[3]) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getCellIncenter(cellId, dim, incenter);
    }
 
    inline int getCellNeighbor(const SimplexId &cellId,
                               const int &localNeighborId,
                               SimplexId &neighborId) const override {
 
      // initialize output variable before early return
      neighborId = -1;
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getCellNeighbor(
        cellId, localNeighborId, neighborId);
    }
 
    inline SimplexId
      getCellNeighborNumber(const SimplexId &cellId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getCellNeighborNumber(cellId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *
      getCellNeighbors() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getCellNeighbors();
    }
 
    inline int getCellTriangle(const SimplexId &cellId,
                               const int &localTriangleId,
                               SimplexId &triangleId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      triangleId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getCellTriangle(
        cellId, localTriangleId, triangleId);
    }
 
    inline SimplexId
      getCellTriangleNumber(const SimplexId &cellId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getCellTriangleNumber(cellId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *
      getCellTriangles() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getCellTriangles();
    }
 
    inline int getCellVertex(const SimplexId &cellId,
                             const int &localVertexId,
                             SimplexId &vertexId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      vertexId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
 
      return abstractTriangulation_->getCellVertex(
        cellId, localVertexId, vertexId);
    }
 
    inline SimplexId
      getCellVertexNumber(const SimplexId &cellId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getCellVertexNumber(cellId);
    }
 
    inline int getDimensionality() const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getDimensionality();
    }
 
    inline const std::vector<std::array<SimplexId, 2>> *getEdges() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getEdges();
    }
 
    inline int getEdgeIncenter(SimplexId edgeId, float incenter[3]) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getEdgeIncenter(edgeId, incenter);
    }
 
    inline int getTriangleIncenter(SimplexId triangleId,
                                   float incenter[3]) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getTriangleIncenter(triangleId, incenter);
    }
 
    inline int getEdgeLink(const SimplexId &edgeId,
                           const int &localLinkId,
                           SimplexId &linkId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      linkId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getEdgeLink(edgeId, localLinkId, linkId);
    }
 
    inline SimplexId getEdgeLinkNumber(const SimplexId &edgeId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getEdgeLinkNumber(edgeId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *getEdgeLinks() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getEdgeLinks();
    }
 
    inline int getEdgeStar(const SimplexId &edgeId,
                           const int &localStarId,
                           SimplexId &starId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      starId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getEdgeStar(edgeId, localStarId, starId);
    }
 
    inline SimplexId getEdgeStarNumber(const SimplexId &edgeId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getEdgeStarNumber(edgeId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *getEdgeStars() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getEdgeStars();
    }
 
    inline int getEdgeTriangle(const SimplexId &edgeId,
                               const int &localTriangleId,
                               SimplexId &triangleId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      triangleId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getEdgeTriangle(
        edgeId, localTriangleId, triangleId);
    }
 
    inline SimplexId
      getEdgeTriangleNumber(const SimplexId &edgeId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getEdgeTriangleNumber(edgeId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *
      getEdgeTriangles() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getEdgeTriangles();
    }
 
    inline int getEdgeVertex(const SimplexId &edgeId,
                             const int &localVertexId,
                             SimplexId &vertexId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      vertexId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getEdgeVertex(
        edgeId, localVertexId, vertexId);
    }
 
    inline AbstractTriangulation *getData() {
      return abstractTriangulation_;
    }
 
    inline SimplexId getNumberOfCells() const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
 
      return abstractTriangulation_->getNumberOfCells();
    }
 
    inline SimplexId getNumberOfEdges() const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getNumberOfEdges();
    }
 
    inline SimplexId getNumberOfTriangles() const override {
#ifndef TTK_ENABLE_KAMIKAZE
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getNumberOfTriangles();
    }
 
    inline SimplexId getNumberOfVertices() const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getNumberOfVertices();
    }
 
    int getTetraIncenter(SimplexId tetraId, float incenter[3]) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getTetraIncenter(tetraId, incenter);
    }
 
    inline const std::vector<std::array<SimplexId, 3>> *
      getTriangles() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getTriangles();
    }
 
    inline int getTriangleEdge(const SimplexId &triangleId,
                               const int &localEdgeId,
                               SimplexId &edgeId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      edgeId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getTriangleEdge(
        triangleId, localEdgeId, edgeId);
    }
 
    inline SimplexId
      getTriangleEdgeNumber(const SimplexId &triangleId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getTriangleEdgeNumber(triangleId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *
      getTriangleEdges() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getTriangleEdges();
    }
 
    inline int getTriangleLink(const SimplexId &triangleId,
                               const int &localLinkId,
                               SimplexId &linkId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      linkId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getTriangleLink(
        triangleId, localLinkId, linkId);
    }
 
    inline SimplexId
      getTriangleLinkNumber(const SimplexId &triangleId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getTriangleLinkNumber(triangleId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *
      getTriangleLinks() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getTriangleLinks();
    }
 
    inline int getTriangleStar(const SimplexId &triangleId,
                               const int &localStarId,
                               SimplexId &starId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      starId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getTriangleStar(
        triangleId, localStarId, starId);
    }
 
    inline SimplexId
      getTriangleStarNumber(const SimplexId &triangleId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getTriangleStarNumber(triangleId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *
      getTriangleStars() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getTriangleStars();
    }
 
    inline int getTriangleVertex(const SimplexId &triangleId,
                                 const int &localVertexId,
                                 SimplexId &vertexId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      vertexId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getTriangleVertex(
        triangleId, localVertexId, vertexId);
    }
 
    inline Triangulation::Type getType() const {
      if(abstractTriangulation_ == &explicitTriangulation_)
        return Triangulation::Type::EXPLICIT;
      else if(abstractTriangulation_ == &implicitTriangulation_)
        return Triangulation::Type::IMPLICIT;
      else if(abstractTriangulation_ == &implicitPreconditionsTriangulation_)
        return Triangulation::Type::HYBRID_IMPLICIT;
      else if(abstractTriangulation_ == &compactTriangulation_)
        return Triangulation::Type::COMPACT;
      else if(abstractTriangulation_ == &periodicImplicitTriangulation_)
        return Triangulation::Type::PERIODIC;
      else
        return Triangulation::Type::HYBRID_PERIODIC;
    }
 
    inline int getVertexEdge(const SimplexId &vertexId,
                             const int &localEdgeId,
                             SimplexId &edgeId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      edgeId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getVertexEdge(
        vertexId, localEdgeId, edgeId);
    }
 
    inline SimplexId
      getVertexEdgeNumber(const SimplexId &vertexId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getVertexEdgeNumber(vertexId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *
      getVertexEdges() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      if(getDimensionality() == 1)
        return abstractTriangulation_->getVertexStars();
 
      return abstractTriangulation_->getVertexEdges();
    }
 
#ifdef TTK_ENABLE_MPI
 
    inline SimplexId getVertexGlobalId(const SimplexId lvid) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getVertexGlobalId(lvid);
    }
 
    inline std::unordered_map<SimplexId, SimplexId> &getVertexGlobalIdMap() {
      return this->explicitTriangulation_.getVertexGlobalIdMap();
    }
 
    inline void setHasPreconditionedDistributedVertices(bool flag) override {
      abstractTriangulation_->setHasPreconditionedDistributedVertices(flag);
    }
 
    inline bool hasPreconditionedDistributedCells() const override {
      return abstractTriangulation_->hasPreconditionedDistributedCells();
    }
    inline bool hasPreconditionedDistributedVertices() const override {
      return abstractTriangulation_->hasPreconditionedDistributedVertices();
    }
 
    inline const std::vector<int> &getNeighborRanks() const override {
      return abstractTriangulation_->getNeighborRanks();
    }
    inline std::vector<int> &getNeighborRanks() override {
      return abstractTriangulation_->getNeighborRanks();
    }
 
    inline std::map<int, int> &getNeighborsToId() override {
      return abstractTriangulation_->getNeighborsToId();
    }
 
    inline const std::map<int, int> &getNeighborsToId() const override {
      return abstractTriangulation_->getNeighborsToId();
    }
 
    inline const std::vector<std::array<ttk::SimplexId, 6>> &
      getNeighborVertexBBoxes() const override {
      return abstractTriangulation_->getNeighborVertexBBoxes();
    }
 
    inline const std::vector<std::vector<SimplexId>> &
      getGhostCellsPerOwner() const override {
      return abstractTriangulation_->getGhostCellsPerOwner();
    }
 
    inline const std::vector<std::vector<SimplexId>> &
      getRemoteGhostCells() const override {
      return abstractTriangulation_->getRemoteGhostCells();
    }
 
    inline int getVertexRank(const SimplexId lvid) const override {
      return this->abstractTriangulation_->getVertexRank(lvid);
    }
 
    inline SimplexId getVertexLocalId(const SimplexId geid) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getVertexLocalId(geid);
    }
 
    inline void createMetaGrid(const double *const bounds) {
      this->implicitPreconditionsTriangulation_.createMetaGrid(bounds);
      this->periodicImplicitTriangulation_.createMetaGrid(bounds);
      this->implicitTriangulation_.createMetaGrid(bounds);
      this->periodicPreconditionsTriangulation_.createMetaGrid(bounds);
      // also pass bounding box to ExplicitTriangulation...
      this->explicitTriangulation_.setBoundingBox(bounds);
    }
 
    inline void setIsBoundaryPeriodic(std::array<unsigned char, 6> boundary) {
      this->periodicImplicitTriangulation_.setIsBoundaryPeriodic(boundary);
      this->periodicPreconditionsTriangulation_.setIsBoundaryPeriodic(boundary);
    }
 
    inline int getDistributedGlobalCellId(const ttk::SimplexId &localCellId,
                                          const int &cellDim,
                                          ttk::SimplexId &globalCellId) const {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return this->abstractTriangulation_->getDistributedGlobalCellId(
        localCellId, cellDim, globalCellId);
    }
 
    inline bool isOrderArrayGlobal(const void *data) const {
      return this->abstractTriangulation_->isOrderArrayGlobal(data);
    }
 
    inline void setIsOrderArrayGlobal(const void *data, bool flag) {
      this->abstractTriangulation_->setIsOrderArrayGlobal(data, flag);
    }
 
#endif // TTK_ENABLE_MPI
 
    inline int getVertexLink(const SimplexId &vertexId,
                             const int &localLinkId,
                             SimplexId &linkId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      linkId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getVertexLink(
        vertexId, localLinkId, linkId);
    }
 
    inline SimplexId
      getVertexLinkNumber(const SimplexId &vertexId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getVertexLinkNumber(vertexId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *
      getVertexLinks() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getVertexLinks();
    }
 
    inline int getVertexNeighbor(const SimplexId &vertexId,
                                 const int &localNeighborId,
                                 SimplexId &neighborId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      neighborId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getVertexNeighbor(
        vertexId, localNeighborId, neighborId);
    }
 
    inline SimplexId
      getVertexNeighborNumber(const SimplexId &vertexId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getVertexNeighborNumber(vertexId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *
      getVertexNeighbors() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getVertexNeighbors();
    }
 
    inline int getVertexPoint(const SimplexId &vertexId,
                              float &x,
                              float &y,
                              float &z) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variables before early return
      x = NAN;
      y = NAN;
      z = NAN;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getVertexPoint(vertexId, x, y, z);
    }
 
    inline int getVertexStar(const SimplexId &vertexId,
                             const int &localStarId,
                             SimplexId &starId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      starId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getVertexStar(
        vertexId, localStarId, starId);
    }
 
    inline SimplexId
      getVertexStarNumber(const SimplexId &vertexId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getVertexStarNumber(vertexId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *
      getVertexStars() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getVertexStars();
    }
 
    inline int getVertexTriangle(const SimplexId &vertexId,
                                 const int &localTriangleId,
                                 SimplexId &triangleId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      // initialize output variable before early return
      triangleId = -1;
 
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getVertexTriangle(
        vertexId, localTriangleId, triangleId);
    }
 
    inline SimplexId
      getVertexTriangleNumber(const SimplexId &vertexId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->getVertexTriangleNumber(vertexId);
    }
 
    inline const std::vector<std::vector<SimplexId>> *
      getVertexTriangles() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return nullptr;
#endif
      return abstractTriangulation_->getVertexTriangles();
    }
 
    inline bool isEdgeOnBoundary(const SimplexId &edgeId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return false;
#endif
      return abstractTriangulation_->isEdgeOnBoundary(edgeId);
    }
 
    inline bool isEmpty() const override {
      return !abstractTriangulation_;
    }
 
    inline bool isManifold() const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(this->isEmptyCheck()) {
        return true;
      }
#endif // TTK_ENABLE_KAMIKAZE
      return this->abstractTriangulation_->isManifold();
    }
 
    inline int preconditionManifold() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(this->isEmptyCheck())
        return false;
#endif // TTK_ENABLE_KAMIKAZE
      return this->abstractTriangulation_->preconditionManifold();
    }
 
    inline bool
      isTriangleOnBoundary(const SimplexId &triangleId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return false;
#endif
      return abstractTriangulation_->isTriangleOnBoundary(triangleId);
    }
 
    inline bool isVertexOnBoundary(const SimplexId &vertexId) const override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return false;
#endif
      return abstractTriangulation_->isVertexOnBoundary(vertexId);
    }
 
    inline int preconditionBoundaryEdges() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionBoundaryEdges();
    }
 
    inline int preconditionBoundaryTriangles() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
 
      return abstractTriangulation_->preconditionBoundaryTriangles();
    }
 
    inline int preconditionBoundaryVertices() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionBoundaryVertices();
    }
 
    inline int preconditionCellEdges() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
 
      return abstractTriangulation_->preconditionCellEdges();
    }
 
    inline int preconditionCellNeighbors() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionCellNeighbors();
    }
 
    inline int preconditionCellTriangles() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionCellTriangles();
    }
 
    inline int preconditionEdges() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
 
      return abstractTriangulation_->preconditionEdges();
    }
 
    inline int preconditionEdgeLinks() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionEdgeLinks();
    }
 
    inline int preconditionEdgeStars() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionEdgeStars();
    }
 
    inline int preconditionEdgeTriangles() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
 
      return abstractTriangulation_->preconditionEdgeTriangles();
    }
 
    inline int preconditionTriangles() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionTriangles();
    }
 
    inline int preconditionTriangleEdges() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionTriangleEdges();
    }
 
    inline int preconditionTriangleLinks() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionTriangleLinks();
    }
 
    inline int preconditionTriangleStars() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
 
      return abstractTriangulation_->preconditionTriangleStars();
    }
 
    inline int preconditionVertexEdges() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
 
      return abstractTriangulation_->preconditionVertexEdges();
    }
 
    inline int getCellVTKID(const int &ttkId, int &vtkId) const override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
 
      return abstractTriangulation_->getCellVTKID(ttkId, vtkId);
    }
 
#ifdef TTK_ENABLE_MPI
    inline int preconditionDistributedVertices() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionDistributedVertices();
    }
 
    inline int preconditionEdgeRankArray() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionEdgeRankArray();
    }
 
    inline int preconditionTriangleRankArray() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionTriangleRankArray();
    }
 
    inline int setVertexRankArray(const int *rankArray) override {
      return abstractTriangulation_->setVertexRankArray(rankArray);
    }
 
    inline int setCellRankArray(const int *rankArray) override {
      return abstractTriangulation_->setCellRankArray(rankArray);
    }
 
 
    inline int preconditionGlobalBoundary() override {
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionGlobalBoundary();
    }
    inline int preconditionDistributedCells() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionDistributedCells();
    }
 
    inline int preconditionExchangeGhostCells() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionExchangeGhostCells();
    }
 
    inline int preconditionExchangeGhostVertices() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionExchangeGhostVertices();
    }
#endif // TTK_ENABLE_MPI
 
    inline int preconditionVertexLinks() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
 
      return abstractTriangulation_->preconditionVertexLinks();
    }
 
    inline int preconditionVertexNeighbors() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionVertexNeighbors();
    }
 
    inline int preconditionVertexStars() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
 
      return abstractTriangulation_->preconditionVertexStars();
    }
 
    inline int preconditionVertexTriangles() override {
 
#ifndef TTK_ENABLE_KAMIKAZE
      if(isEmptyCheck())
        return -1;
#endif
      return abstractTriangulation_->preconditionVertexTriangles();
    }
 
    inline int setDebugLevel(const int &debugLevel) override {
      explicitTriangulation_.setDebugLevel(debugLevel);
      compactTriangulation_.setDebugLevel(debugLevel);
      implicitTriangulation_.setDebugLevel(debugLevel);
      implicitPreconditionsTriangulation_.setDebugLevel(debugLevel);
      periodicImplicitTriangulation_.setDebugLevel(debugLevel);
      periodicPreconditionsTriangulation_.setDebugLevel(debugLevel);
      debugLevel_ = debugLevel;
      return 0;
    }
 
    // Set the cache size
    inline int setCacheSize(const float &ratio) {
      if(abstractTriangulation_ == &compactTriangulation_) {
        compactTriangulation_.initCache(ratio);
      }
      return 0;
    }
 
#ifdef TTK_CELL_ARRAY_NEW
    inline int setInputCells(const SimplexId &cellNumber,
                             const LongSimplexId *connectivity,
                             const LongSimplexId *offset) {
      abstractTriangulation_ = &explicitTriangulation_;
      gridDimensions_[0] = gridDimensions_[1] = gridDimensions_[2] = -1;
      return explicitTriangulation_.setInputCells(
        cellNumber, connectivity, offset);
    }
 
    inline int setStellarInputCells(const SimplexId &cellNumber,
                                    const LongSimplexId *connectivity,
                                    const LongSimplexId *offset) {
      abstractTriangulation_ = &compactTriangulation_;
      gridDimensions_[0] = gridDimensions_[1] = gridDimensions_[2] = -1;
      return compactTriangulation_.setInputCells(
        cellNumber, connectivity, offset);
    }
#else
    inline int setInputCells(const SimplexId &cellNumber,
                             const LongSimplexId *cellArray) {
      abstractTriangulation_ = &explicitTriangulation_;
      gridDimensions_[0] = gridDimensions_[1] = gridDimensions_[2] = -1;
      return explicitTriangulation_.setInputCells(cellNumber, cellArray);
    }
 
    inline int setStellarInputCells(const SimplexId &cellNumber,
                                    const LongSimplexId *cellArray) {
 
      abstractTriangulation_ = &compactTriangulation_;
      gridDimensions_[0] = gridDimensions_[1] = gridDimensions_[2] = -1;
 
      return compactTriangulation_.setInputCells(cellNumber, cellArray);
    }
#endif
    inline int setInputGrid(const float &xOrigin,
                            const float &yOrigin,
                            const float &zOrigin,
                            const float &xSpacing,
                            const float &ySpacing,
                            const float &zSpacing,
                            const SimplexId &xDim,
                            const SimplexId &yDim,
                            const SimplexId &zDim) {
      gridDimensions_[0] = xDim;
      gridDimensions_[1] = yDim;
      gridDimensions_[2] = zDim;
 
      int ret{};
 
      ret |= periodicImplicitTriangulation_.setInputGrid(
        xOrigin, yOrigin, zOrigin, xSpacing, ySpacing, zSpacing, xDim, yDim,
        zDim);
      ret |= periodicPreconditionsTriangulation_.setInputGrid(
        xOrigin, yOrigin, zOrigin, xSpacing, ySpacing, zSpacing, xDim, yDim,
        zDim);
      ret |= implicitTriangulation_.setInputGrid(xOrigin, yOrigin, zOrigin,
                                                 xSpacing, ySpacing, zSpacing,
                                                 xDim, yDim, zDim);
      ret |= implicitPreconditionsTriangulation_.setInputGrid(
        xOrigin, yOrigin, zOrigin, xSpacing, ySpacing, zSpacing, xDim, yDim,
        zDim);
      const auto useImplicitPreconditions = this->processImplicitStrategy();
 
      this->switchGrid(this->hasPeriodicBoundaries_, useImplicitPreconditions);
      return ret;
    }
 
    inline void
      setPeriodicBoundaryConditions(const bool &usePeriodicBoundaries) {
 
      if(abstractTriangulation_ == &implicitTriangulation_
         || abstractTriangulation_ == &periodicImplicitTriangulation_
         || abstractTriangulation_ == &implicitPreconditionsTriangulation_
         || abstractTriangulation_ == &periodicPreconditionsTriangulation_) {
        if(usePeriodicBoundaries == hasPeriodicBoundaries_) {
          return;
        }
        const auto hasPreconditions{this->hasImplicitPreconditions()};
 
        this->switchGrid(usePeriodicBoundaries, hasPreconditions);
 
        // reset hasPreconditioned boolean
        AbstractTriangulation::clear();
        // but don't forget to set hasPeriodicBoundaries_
        hasPeriodicBoundaries_ = usePeriodicBoundaries;
      }
    }
 
    inline void setImplicitPreconditions(const STRATEGY strategy) {
      if(abstractTriangulation_ == &implicitTriangulation_
         || abstractTriangulation_ == &periodicImplicitTriangulation_
         || abstractTriangulation_ == &implicitPreconditionsTriangulation_
         || abstractTriangulation_ == &periodicPreconditionsTriangulation_) {
 
        const auto useImplicitPreconditions
          = this->processImplicitStrategy(strategy);
 
        if(useImplicitPreconditions == this->hasImplicitPreconditions()) {
          return;
        }
        const auto isPeriodic{this->hasPeriodicBoundaries_};
 
        this->switchGrid(isPeriodic, useImplicitPreconditions);
 
        // reset hasPreconditioned boolean
        AbstractTriangulation::clear();
        // but don't forget to set hasImplicitPreconditions_
        hasPeriodicBoundaries_ = isPeriodic;
      }
    }
 
    inline int setInputPoints(const SimplexId &pointNumber,
                              const void *pointSet,
                              const bool &doublePrecision = false) {
 
      abstractTriangulation_ = &explicitTriangulation_;
      gridDimensions_[0] = gridDimensions_[1] = gridDimensions_[2] = -1;
      return explicitTriangulation_.setInputPoints(
        pointNumber, pointSet, doublePrecision);
    }
 
    inline int setStellarInputPoints(const SimplexId &pointNumber,
                                     const void *pointSet,
                                     const int *indexArray,
                                     const bool &doublePrecision = false) {
 
      abstractTriangulation_ = &compactTriangulation_;
      gridDimensions_[0] = gridDimensions_[1] = gridDimensions_[2] = -1;
      return compactTriangulation_.setInputPoints(
        pointNumber, pointSet, indexArray, doublePrecision);
    }
 
    inline int setThreadNumber(const ThreadId threadNumber) override {
      explicitTriangulation_.setThreadNumber(threadNumber);
      implicitTriangulation_.setThreadNumber(threadNumber);
      implicitPreconditionsTriangulation_.setThreadNumber(threadNumber);
      periodicImplicitTriangulation_.setThreadNumber(threadNumber);
      periodicPreconditionsTriangulation_.setThreadNumber(threadNumber);
      compactTriangulation_.setThreadNumber(threadNumber);
      threadNumber_ = threadNumber;
      return 0;
    }
 
    inline int setWrapper(const Wrapper *wrapper) override {
      explicitTriangulation_.setWrapper(wrapper);
      implicitTriangulation_.setWrapper(wrapper);
      implicitPreconditionsTriangulation_.setWrapper(wrapper);
      periodicImplicitTriangulation_.setWrapper(wrapper);
      periodicPreconditionsTriangulation_.setWrapper(wrapper);
      compactTriangulation_.setWrapper(wrapper);
      return 0;
    }
 
    inline bool hasImplicitPreconditions() const {
      return abstractTriangulation_ == &implicitPreconditionsTriangulation_
             || abstractTriangulation_ == &periodicPreconditionsTriangulation_;
    }
 
#ifdef TTK_ENABLE_MPI
 
    // GlobalPointIds, GlobalCellIds (only for ExplicitTriangulation)
 
    inline void setVertsGlobalIds(const LongSimplexId *data) {
      this->explicitTriangulation_.setVertsGlobalIds(data);
    }
    inline void setCellsGlobalIds(const LongSimplexId *const data) {
      this->explicitTriangulation_.setCellsGlobalIds(data);
    }
 
    // "vtkGhostType" on vertices & cells
 
    inline void setVertexGhostArray(const unsigned char *data) {
      this->abstractTriangulation_->setVertexGhostArray(data);
    }
    inline void setCellGhostArray(const unsigned char *data) {
      this->abstractTriangulation_->setCellGhostArray(data);
    }
 
    inline bool getIsMPIValid() const {
      return isMPIValid_;
    }
 
    inline void setIsMPIValid(bool flag) {
      isMPIValid_ = flag;
    }
#endif // TTK_ENABLE_MPI
 
  protected:
#ifdef TTK_ENABLE_MPI
    bool isMPIValid_{true};
#endif
    inline bool isEmptyCheck() const {
      if(!abstractTriangulation_) {
        printErr("Trying to access an empty data-structure!");
        return true;
      }
      return false;
    }
 
    bool processImplicitStrategy(const STRATEGY strategy
                                 = STRATEGY::DEFAULT) const;
 
    void switchGrid(const bool usePeriodic, const bool usePreconditions);
 
    AbstractTriangulation *abstractTriangulation_;
    ExplicitTriangulation explicitTriangulation_;
    ImplicitNoPreconditions implicitTriangulation_;
    ImplicitWithPreconditions implicitPreconditionsTriangulation_;
    PeriodicNoPreconditions periodicImplicitTriangulation_;
    PeriodicWithPreconditions periodicPreconditionsTriangulation_;
    CompactTriangulation compactTriangulation_;
  };
} // namespace ttk