ttkAlgorithm.h

Go to the documentation of this file.

 
 
#pragma once
 
// VTK Module
#include <ttkAlgorithmModule.h>
 
// VTK Includes
#include <vtkAlgorithm.h>
class vtkDataSet;
class vtkInformation;
class vtkInformationIntegerKey;
 
// Base Includes
#include <Debug.h>
 
namespace ttk {
  class Triangulation;
}
 
class TTKALGORITHM_EXPORT ttkAlgorithm : public vtkAlgorithm,
                                         virtual public ttk::Debug {
private:
  int ThreadNumber{1};
  bool UseAllCores{true};
 
public:
  static ttkAlgorithm *New();
  vtkTypeMacro(ttkAlgorithm, vtkAlgorithm);
 
  void UpdateThreadNumber() {
    // update ttk::BaseClass member
    this->setThreadNumber(this->UseAllCores ? ttk::OsCall::getNumberOfCores()
                                            : this->ThreadNumber);
    this->Modified();
  }
 
  void SetThreadNumber(int threadNumber) {
    this->ThreadNumber = threadNumber;
    this->UpdateThreadNumber();
  }
 
  void SetUseAllCores(bool useAllCores) {
    this->UseAllCores = useAllCores;
    this->UpdateThreadNumber();
  }
 
  void SetDebugLevel(int debugLevel) {
    this->setDebugLevel(debugLevel); // from ttk::Debug
    this->Modified();
  }
 
  void SetCompactTriangulationCacheSize(float cacheSize) {
    this->CompactTriangulationCacheSize = cacheSize;
    this->Modified();
  }
 
  vtkDataArray *GetOptionalArray(const bool &enforceArrayIndex,
                                 const int &arrayIndex,
                                 const std::string &arrayName,
                                 vtkDataSet *const inputData,
                                 const int &inputPort = 0);
 
  static std::string GetOrderArrayName(vtkDataArray *const array);
 
  vtkDataArray *GetOrderArray(vtkDataSet *const inputData,
                              const int scalarArrayIdx,
                              ttk::Triangulation *triangulation,
                              const bool getGlobalOrder = false,
                              const int orderArrayIdx = 0,
                              const bool enforceOrderArrayIdx = false);
 
  vtkDataArray *
    checkForGlobalAndComputeOrderArray(vtkDataSet *const inputData,
                                       vtkDataArray *scalarArray,
                                       const int scalarArrayIdx,
                                       const bool getGlobalOrder,
                                       vtkDataArray *orderArray,
                                       ttk::Triangulation *triangulation,
                                       const bool enforceOrderArrayIdx);
 
  vtkDataArray *ComputeOrderArray(vtkDataSet *const inputData,
                                  vtkDataArray *scalarArray,
                                  const int scalarArrayIdx,
                                  const bool getGlobalOrder,
                                  vtkDataArray *oldOrderArray,
                                  ttk::Triangulation *triangulation);
  ttk::SimplexId *
    GetIdentifierArrayPtr(const bool &enforceArrayIndex,
                          const int &arrayIndex,
                          const std::string &arrayName,
                          vtkDataSet *const inputData,
                          std::vector<ttk::SimplexId> &spareStorage,
                          const int inputPort = 0,
                          const bool printErr = true);
 
  ttk::Triangulation *GetTriangulation(vtkDataSet *dataSet);
 
  static vtkInformationIntegerKey *SAME_DATA_TYPE_AS_INPUT_PORT();
 
  int ProcessRequest(vtkInformation *request,
                     vtkInformationVector **inputVectors,
                     vtkInformationVector *outputVector) override;
 
  vtkDataSet *GetOutput();
  vtkDataSet *GetOutput(int);
 
  void SetInputData(vtkDataSet *);
  void SetInputData(int, vtkDataSet *);
 
  void AddInputData(vtkDataSet *);
  void AddInputData(int, vtkDataSet *);
 
  template <typename inputType>
  inline int checkEmptyMPIInput(inputType *input) {
    if(!input) {
#ifdef TTK_ENABLE_MPI
      if(ttk::isRunningWithMPI()) {
        return 1;
      } else {
#endif
        return 0;
#ifdef TTK_ENABLE_MPI
      }
#endif
    }
    return 2;
  };
 
protected:
  ttkAlgorithm();
  ~ttkAlgorithm() override;
  float CompactTriangulationCacheSize{0.2f};
 
#ifdef TTK_ENABLE_MPI
  int updateMPICommunicator(vtkDataSet *input);
#endif
  void MPIGhostPipelinePreconditioning(vtkDataSet *input);
 
  void MPIPipelinePreconditioning(vtkDataSet *input,
                                  std::vector<int> &neighbors,
                                  std::map<int, int> &neighToId,
                                  ttk::Triangulation *triangulation = nullptr);
 
  bool checkGlobalIdValidity(ttk::LongSimplexId *globalIds,
                             ttk::SimplexId simplexNumber,
                             unsigned char *ghost,
                             int *rankArray);
  int GenerateGlobalIds(
    vtkDataSet *input,
    std::unordered_map<ttk::SimplexId, ttk::SimplexId> &vertGtoL,
    std::vector<int> &neighborRanks,
    std::map<int, int> &neighborsToId);
 
  void MPITriangulationPreconditioning(ttk::Triangulation *triangulation,
                                       vtkDataSet *input);
 
  virtual int RequestDataObject(vtkInformation *request,
                                vtkInformationVector **inputVectors,
                                vtkInformationVector *outputVector);
 
  virtual int
    RequestInformation(vtkInformation *ttkNotUsed(request),
                       vtkInformationVector **ttkNotUsed(inputVectors),
                       vtkInformationVector *ttkNotUsed(outputVector)) {
    return 1;
  }
 
  virtual int
    RequestUpdateTime(vtkInformation *ttkNotUsed(request),
                      vtkInformationVector **ttkNotUsed(inputVectors),
                      vtkInformationVector *ttkNotUsed(outputVector)) {
    return 1;
  }
 
  virtual int RequestUpdateTimeDependentInformation(
    vtkInformation *ttkNotUsed(request),
    vtkInformationVector **ttkNotUsed(inputVectors),
    vtkInformationVector *ttkNotUsed(outputVector)) {
    return 1;
  }
 
  virtual int
    RequestUpdateExtent(vtkInformation *ttkNotUsed(request),
                        vtkInformationVector **ttkNotUsed(inputVectors),
                        vtkInformationVector *ttkNotUsed(outputVector)) {
    return 1;
  }
 
  virtual int
    RequestDataNotGenerated(vtkInformation *ttkNotUsed(request),
                            vtkInformationVector **ttkNotUsed(inputVectors),
                            vtkInformationVector *ttkNotUsed(outputVector)) {
    return 1;
  }
 
  virtual int RequestData(vtkInformation *ttkNotUsed(request),
                          vtkInformationVector **ttkNotUsed(inputVectors),
                          vtkInformationVector *ttkNotUsed(outputVector)) {
    return 1;
  }
 
  int FillInputPortInformation(int ttkNotUsed(port),
                               vtkInformation *ttkNotUsed(info)) override {
    return 0;
  }
 
  int FillOutputPortInformation(int ttkNotUsed(port),
                                vtkInformation *ttkNotUsed(info)) override {
    return 0;
  }
};