CompactTriangulationPreconditioning.h

Go to the documentation of this file.

 
 
#pragma once
 
// ttk common includes
#include <Debug.h>
#include <Octree.h>
#include <Triangulation.h>
 
namespace ttk {
 
  class CompactTriangulationPreconditioning : virtual public Debug {
 
  public:
    CompactTriangulationPreconditioning() {
      this->setDebugMsgPrefix(
        "CompactTriangulationPreconditioning"); // inherited from Debug: prefix
                                                // will be printed at the
      // beginning of every msg
    };
    ~CompactTriangulationPreconditioning() override = default;
    ;
 
    template <class triangulationType = ttk::AbstractTriangulation>
    int execute(const triangulationType *triangulation,
                const int &argument) const {
      // start global timer
      ttk::Timer globalTimer;
 
      // print horizontal separator
      this->printMsg(ttk::debug::Separator::L1); // L1 is the '=' separator
 
      // print input parameters in table format
      this->printMsg({
        {"#Threads", std::to_string(this->threadNumber_)},
        {"#Vertices", std::to_string(triangulation->getNumberOfVertices())},
      });
      this->printMsg(ttk::debug::Separator::L1);
 
      // -----------------------------------------------------------------------
      // Compute Octree
      // -----------------------------------------------------------------------
      {
#ifndef TTK_ENABLE_KAMIKAZE
        if(!triangulation)
          return -1;
#endif
 
        SimplexId vertexNumber = triangulation->getNumberOfVertices();
        SimplexId const cellNumber = triangulation->getNumberOfCells();
 
        // create the octree
        Octree preOctree(triangulation, argument);
        for(SimplexId i = 0; i < vertexNumber; i++) {
          preOctree.insertVertex(i);
        }
 
        for(SimplexId i = 0; i < cellNumber; i++) {
          preOctree.insertCell(i);
        }
 
        if(preOctree.verifyTree(vertexNumber)) {
          this->printErr("The construction of the tree failed!");
          return -1;
        }
 
        preOctree.reindex(this->vertices, this->nodes, this->cells);
        this->printMsg({
          {"Size of vertex vector", std::to_string(this->vertices.size())},
          {"Size of cell vector", std::to_string(this->cells.size())},
        });
      }
 
      // ---------------------------------------------------------------------
      // print global performance
      // ---------------------------------------------------------------------
      {
        this->printMsg(ttk::debug::Separator::L2); // horizontal '-' separator
        this->printMsg(
          "Complete", 1, globalTimer.getElapsedTime() // global progress, time
        );
        this->printMsg(ttk::debug::Separator::L1); // horizontal '=' separator
      }
 
      return 1; // return success
    }
 
    void clear() {
      this->vertices.clear();
      this->nodes.clear();
      this->cells.clear();
    }
 
    const std::vector<SimplexId> &getVertices() const {
      return this->vertices;
    }
    const std::vector<SimplexId> &getNodes() const {
      return this->nodes;
    }
    const std::vector<SimplexId> &getCells() const {
      return this->cells;
    }
 
  protected:
    mutable std::vector<SimplexId> vertices, nodes, cells;
 
  }; // CompactTriangulationPreconditioning class
 
} // namespace ttk