vtkRedistributeDataSetFilter.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkRedistributeDataSetFilter_h
#define vtkRedistributeDataSetFilter_h
 
#include "vtkDataObjectAlgorithm.h"
#include "vtkFiltersParallelDIY2Module.h" // for export macros
#include "vtkPartitioningStrategy.h"      // for PartitionInformation
#include "vtkSmartPointer.h"              // for vtkSmartPointer
 
#include <memory> // for std::shared_ptr
#include <vector> // for std::vector
 
// clang-format off
#include "vtk_diy2.h" // for DIY2 APIs
#include VTK_DIY2(diy/assigner.hpp)
// clang-format on
 
VTK_ABI_NAMESPACE_BEGIN
class vtkMultiProcessController;
class vtkBoundingBox;
class vtkPartitionedDataSet;
class vtkMultiBlockDataSet;
class vtkMultiPieceDataSet;
class vtkDataObjectTree;
class VTKFILTERSPARALLELDIY2_EXPORT vtkRedistributeDataSetFilter : public vtkDataObjectAlgorithm
{
public:
  static vtkRedistributeDataSetFilter* New();
  vtkTypeMacro(vtkRedistributeDataSetFilter, vtkDataObjectAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  vtkMTimeType GetMTime() override;
 
 
  void SetController(vtkMultiProcessController*);
  vtkGetObjectMacro(Controller, vtkMultiProcessController);
 
  enum BoundaryModes
  {
    ASSIGN_TO_ONE_REGION = 0,
    ASSIGN_TO_ALL_INTERSECTING_REGIONS = 1,
    SPLIT_BOUNDARY_CELLS = 2
  };
 
 
  vtkSetClampMacro(BoundaryMode, int, ASSIGN_TO_ONE_REGION, SPLIT_BOUNDARY_CELLS);
  vtkGetMacro(BoundaryMode, int);
  void SetBoundaryModeToAssignToOneRegion() { this->SetBoundaryMode(ASSIGN_TO_ONE_REGION); }
  void SetBoundaryModeToAssignToAllIntersectingRegions()
  {
    this->SetBoundaryMode(ASSIGN_TO_ALL_INTERSECTING_REGIONS);
  }
  void SetBoundaryModeToSplitBoundaryCells() { this->SetBoundaryMode(SPLIT_BOUNDARY_CELLS); }
 
 
  void SetUseExplicitCuts(bool);
  bool GetUseExplicitCuts() const;
  vtkBooleanMacro(UseExplicitCuts, bool);
 
 
  void SetExplicitCuts(const std::vector<vtkBoundingBox>& boxes);
  const std::vector<vtkBoundingBox>& GetExplicitCuts() const;
  void RemoveAllExplicitCuts();
  void AddExplicitCut(const vtkBoundingBox& bbox);
  void AddExplicitCut(const double bbox[6]);
  int GetNumberOfExplicitCuts() const;
  const vtkBoundingBox& GetExplicitCut(int index) const;
 
 
  void SetAssigner(std::shared_ptr<diy::Assigner> assigner);
  std::shared_ptr<diy::Assigner> GetAssigner();
  std::shared_ptr<const diy::Assigner> GetAssigner() const;
 
 
  void SetExpandExplicitCuts(bool);
  bool GetExpandExplicitCuts() const;
  vtkBooleanMacro(ExpandExplicitCuts, bool);
 
 
  const std::vector<vtkBoundingBox>& GetCuts() const;
 
 
  void SetNumberOfPartitions(vtkIdType);
  vtkIdType GetNumberOfPartitions() const;
 
 
  vtkSetMacro(PreservePartitionsInOutput, bool);
  vtkGetMacro(PreservePartitionsInOutput, bool);
  vtkBooleanMacro(PreservePartitionsInOutput, bool);
 
 
  vtkSetMacro(GenerateGlobalCellIds, bool);
  vtkGetMacro(GenerateGlobalCellIds, bool);
  vtkBooleanMacro(GenerateGlobalCellIds, bool);
 
 
  vtkSetMacro(EnableDebugging, bool);
  vtkGetMacro(EnableDebugging, bool);
  vtkBooleanMacro(EnableDebugging, bool);
 
 
  void SetLoadBalanceAcrossAllBlocks(bool);
  bool GetLoadBalanceAcrossAllBlocks();
  vtkBooleanMacro(LoadBalanceAcrossAllBlocks, bool);
 
 
  vtkPartitioningStrategy* GetStrategy();
  void SetStrategy(vtkPartitioningStrategy*);
 
protected:
  vtkRedistributeDataSetFilter();
  ~vtkRedistributeDataSetFilter() override;
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
  int RequestDataObject(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  /*
   * A method with this signature used to exist. With the refactoring of this filter to accept
   * different partitioning strategies, this method no longer had any meaning in the generic
   * sense.
   *
   * If you inherited this filter and overrid this method, please implement a new partitioning
   * strategy instead.
   */
  // virtual vtkSmartPointer<vtkPartitionedDataSet> SplitDataSet(
  // vtkDataSet* dataset, const std::vector<vtkBoundingBox>& cuts);
 
private:
  vtkRedistributeDataSetFilter(const vtkRedistributeDataSetFilter&) = delete;
  void operator=(const vtkRedistributeDataSetFilter&) = delete;
 
  virtual vtkSmartPointer<vtkPartitionedDataSet> SplitDataSet(
    vtkDataSet* dataset, const vtkPartitioningStrategy::PartitionInformation& info);
 
  bool Redistribute(vtkPartitionedDataSetCollection* inputCollection,
    vtkPartitionedDataSetCollection* outputCollection,
    const std::vector<vtkPartitioningStrategy::PartitionInformation>& info,
    bool preserve_input_hierarchy);
 
  bool RedistributePTD(vtkPartitionedDataSet*, vtkPartitionedDataSet*,
    const std::vector<vtkPartitioningStrategy::PartitionInformation>&, unsigned int*, vtkIdType*);
 
  bool RedistributeDataSet(vtkDataSet* inputDS, vtkPartitionedDataSet* outputPDS,
    const vtkPartitioningStrategy::PartitionInformation& info);
  vtkSmartPointer<vtkDataSet> ClipDataSet(vtkDataSet* dataset, const vtkBoundingBox& bbox);
 
  void MarkGhostCells(vtkPartitionedDataSet* pieces);
 
  vtkSmartPointer<vtkPartitionedDataSet> AssignGlobalCellIds(
    vtkPartitionedDataSet* input, vtkIdType* mb_offset = nullptr);
  vtkSmartPointer<vtkDataSet> AssignGlobalCellIds(
    vtkDataSet* input, vtkIdType* mb_offset = nullptr);
 
  void MarkValidDimensions(const vtkBoundingBox& gbounds);
 
  std::shared_ptr<diy::Assigner> Assigner;
 
  vtkMultiProcessController* Controller;
  int BoundaryMode;
  bool PreservePartitionsInOutput;
  bool GenerateGlobalCellIds;
  bool EnableDebugging;
  bool ValidDim[3];
 
  vtkSmartPointer<vtkPartitioningStrategy> Strategy;
};
 
VTK_ABI_NAMESPACE_END
#endif