ttkPeriodicGhostsGeneration.h

Go to the documentation of this file.

 
 
#pragma once
 
// VTK Module
#include <ttkPeriodicGhostsGenerationModule.h>
 
// VTK Includes
#include <RegularGridTriangulation.h>
#include <Triangulation.h>
#include <ttkAlgorithm.h>
#include <vtkCellData.h>
#include <vtkCharArray.h>
#include <vtkDataSet.h>
#include <vtkImageData.h>
#include <vtkInformation.h>
#include <vtkInformationVector.h>
#include <vtkPointData.h>
#include <vtkStreamingDemandDrivenPipeline.h>
#include <vtkStructuredPoints.h>
 
#ifdef TTK_ENABLE_MPI
#include <cstring>
#include <vtkCommunicator.h>
#include <vtkExtentTranslator.h>
#include <vtkExtractVOI.h>
#endif
 
namespace ttk {
 
  namespace periodicGhosts {
    struct partialGlobalBound {
      unsigned char isBound{0};
      double x{0};
      double y{0};
      double z{0};
    };
  } // namespace periodicGhosts
} // namespace ttk
 
class TTKPERIODICGHOSTSGENERATION_EXPORT ttkPeriodicGhostsGeneration
  : public ttkAlgorithm {
 
private:
#ifdef TTK_ENABLE_MPI
  std::array<int, 6> outExtent_; // Global extent size before computation
  std::array<int, 6> inExtent_; // Global extent size after computation
  std::array<double, 6> boundsWithoutGhosts_; // Local Bounds without ghosts
  std::array<double, 6> globalBounds_;
  std::array<double, 3> origin_;
  std::array<double, 3> spacing_;
  bool isOutputExtentComputed_{false};
  std::array<ttk::periodicGhosts::partialGlobalBound, 6> localGlobalBounds_;
  std::vector<int> neighbors_;
  std::vector<std::array<ttk::SimplexId, 6>> neighborVertexBBoxes_;
  std::array<unsigned char, 6> isBoundaryPeriodic_{};
#endif
public:
  static ttkPeriodicGhostsGeneration *New();
  vtkTypeMacro(ttkPeriodicGhostsGeneration, ttkAlgorithm);
 
  ttkPeriodicGhostsGeneration();
  ~ttkPeriodicGhostsGeneration() override = default;
 
#ifdef TTK_ENABLE_MPI
 
  int RequestUpdateExtent(vtkInformation *ttkNotUsed(request),
                          vtkInformationVector **inputVector,
                          vtkInformationVector *outputVector) override;
 
  int RequestInformation(vtkInformation *request,
                         vtkInformationVector **inputVectors,
                         vtkInformationVector *outputVector) override;
  int MPIPeriodicGhostPipelinePreconditioning(vtkImageData *imageIn,
                                              vtkImageData *imageOut);
 
  inline std::vector<int> getNeighbors() {
    std::sort(neighbors_.begin(), neighbors_.end());
    return neighbors_;
  }
 
  inline std::map<int, int> getNeighborsToId() {
    std::map<int, int> neighborsToId{};
    int neighborNumber = neighbors_.size();
    for(int i = 0; i < neighborNumber; i++) {
      neighborsToId[neighbors_[i]] = i;
    }
    return neighborsToId;
  }
 
  inline std::array<unsigned char, 6> getIsBoundaryPeriodic() {
    return isBoundaryPeriodic_;
  }
 
#endif
 
protected:
  int FillInputPortInformation(int port, vtkInformation *info) override;
 
  int FillOutputPortInformation(int port, vtkInformation *info) override;
 
#ifdef TTK_ENABLE_MPI
 
  int ComputeOutputExtent();
 
  template <int matchesSize, int metaDataSize>
  int MarshalAndSendRecv(
    vtkImageData *imageIn,
    std::vector<std::vector<vtkSmartPointer<vtkCharArray>>>
      &charArrayBoundaries,
    std::vector<std::vector<std::array<ttk::SimplexId, metaDataSize>>>
      &charArrayBoundariesMetaData,
    std::vector<std::array<ttk::SimplexId, matchesSize>> &matches,
    std::vector<vtkSmartPointer<vtkCharArray>> &charArrayBoundariesReceived,
    std::vector<std::array<ttk::SimplexId, metaDataSize>>
      &charArrayBoundariesMetaDataReceived,
    int dim);
 
  int MergeImageAndSlice(vtkImageData *image,
                         vtkImageData *slice,
                         vtkImageData *mergedImage,
                         int direction);
 
  template <typename boundaryType>
  int UnMarshalAndMerge(
    std::vector<boundaryType> &metaDataReceived,
    std::vector<vtkSmartPointer<vtkCharArray>> &boundariesReceived,
    boundaryType direction,
    int mergeDirection,
    vtkImageData *mergedImage);
 
  template <typename boundaryType>
  int UnMarshalAndCopy(
    std::vector<boundaryType> &metaDataReceived,
    std::vector<vtkSmartPointer<vtkCharArray>> &boundariesReceived,
    boundaryType direction,
    vtkImageData *mergedImage);
 
  int MergeDataArrays(vtkDataArray *imageArray,
                      vtkDataArray *sliceArray,
                      vtkSmartPointer<vtkDataArray> &currentArray,
                      int direction,
                      int dims[3],
                      unsigned char ghostValue,
                      ttk::SimplexId numberOfSimplices,
                      ttk::SimplexId numberOfTuples);
 
#endif
 
  int RequestData(vtkInformation *request,
                  vtkInformationVector **inputVector,
                  vtkInformationVector *outputVector) override;
};