VTK  9.1.0
vtkDIYGhostUtilities.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkDIYGhostUtilities.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
60 #ifndef vtkDIYGhostUtilities_h
61 #define vtkDIYGhostUtilities_h
62 
63 #include "vtkBoundingBox.h" // For ComputeLinkMap
64 #include "vtkDIYExplicitAssigner.h" // For DIY assigner
65 #include "vtkDIYUtilities.h" // For Block
66 #include "vtkObject.h"
67 #include "vtkParallelDIYModule.h" // For export macros
68 #include "vtkQuaternion.h" // For vtkImageData
69 #include "vtkSmartPointer.h" // For vtkSmartPointer
70 
71 #include <array> // For VectorType and ExtentType
72 #include <map> // For BlockMapType
73 #include <set> // For Link
74 #include <vector> // For LinkMap
75 
76 // clang-format off
77 #include "vtk_diy2.h" // Third party include
78 #include VTK_DIY2(diy/master.hpp)
79 // clang-format on
80 
82 class vtkAlgorithm;
83 class vtkCellArray;
84 class vtkDataArray;
85 class vtkDataSet;
86 class vtkFieldData;
87 class vtkIdList;
88 class vtkIdTypeArray;
89 class vtkImageData;
90 class vtkMatrix3x3;
92 class vtkPoints;
93 class vtkPolyData;
94 class vtkRectilinearGrid;
95 class vtkStructuredGrid;
98 
99 class VTKPARALLELDIY_EXPORT vtkDIYGhostUtilities : public vtkObject
100 {
101 public:
103  void PrintSelf(ostream& os, vtkIndent indent) override;
104 
106 
109  using VectorType = std::array<double, 3>;
111  using ExtentType = std::array<int, 6>;
112  template <class T>
113  using BlockMapType = std::map<int, T>;
114  using Links = std::set<int>;
115  using LinkMap = std::vector<Links>;
117 
122  template <class DataSetT>
124 
125 protected:
130  {
131  vtkSmartPointer<vtkFieldData> GhostCellData = nullptr;
132  vtkSmartPointer<vtkFieldData> GhostPointData = nullptr;
133  };
134 
139  {
143  GridBlockStructure(const int* extent, int dim);
144 
149 
155 
160 
165  unsigned char AdjacencyMask;
166 
171  };
172 
177  {
182 
184  };
185 
191  {
193 
197  ImageDataBlockStructure(const int extent[6], int dim, const double origin[3],
198  const double spacing[3], const double orientationQuaternion[4]);
199  ImageDataBlockStructure(const int extent[6], int dim, const double origin[3],
200  const double spacing[3], vtkMatrix3x3* directionMatrix);
202 
207 
212 
217 
222  };
223 
225  {
227 
234 
240  vtkSmartPointer<vtkDataArray> CoordinateGhosts[6];
241  };
242 
248  {
253  RectilinearGridBlockStructure(const int extent[6], int dim, vtkDataArray* xCoordinates,
254  vtkDataArray* yCoordinates, vtkDataArray* zCoordinates);
255 
260 
262 
269  };
270 
272  {
278  {
283 
288  };
289 
294  OuterPointLayersType OuterPointLayers[6];
295 
300  };
301 
307  {
313 
318 
322  vtkSmartPointer<vtkPoints> OuterPointLayers[6];
323 
328  struct Grid2D
329  {
333  int StartX = 0;
334 
338  int StartY = 0;
339 
343  int EndX = 0;
344 
348  int EndY = 0;
349 
353  int XOrientation = 0;
354 
358  int YOrientation = 0;
359 
364  int ExtentId = -1;
365  };
366 
373 
378  };
379 
381  {
386 
391  vtkSmartPointer<vtkIdList> OutputToInputCellIdRedirectionMap = nullptr;
392 
394 
398  vtkSmartPointer<vtkIdList> InputToOutputPointIdRedirectionMap = nullptr;
399  vtkSmartPointer<vtkIdList> OutputToInputPointIdRedirectionMap = nullptr;
401 
408 
415 
420 
425 
427  /*
428  * This is a cursor telling the amount of points / cells information,
429  * that has
430  * already been added to the output. This variable is used at the very end of the pipeline.
431  */
435 
437 
443  };
444 
446  {
452 
458 
464 
468  vtkSmartPointer<vtkIdTypeArray> InterfacingGlobalPointIds = nullptr;
469 
474  vtkSmartPointer<vtkIdTypeArray> GhostGlobalPointIds = nullptr;
475 
480 
486 
488 
497 
502  std::map<vtkIdType, vtkIdType> RedirectionMapForDuplicatePointIds;
503 
509  };
510 
512  {
517  vtkIdType CurrentFacesSize = 0;
518 
523  vtkIdType CurrentConnectivitySize = 0;
524 
525  vtkIdTypeArray* Faces = nullptr;
526  vtkIdTypeArray* FaceLocations = nullptr;
527 
529 
533  vtkIdType InputConnectivitySize = 0;
534 
538  vtkIdType InputFacesSize = 0;
539  };
540 
542  {
547  {
550  vtkSmartPointer<vtkIdTypeArray> FaceLocations = nullptr;
552  };
553 
556 
558 
561  vtkIdType FacesSize = 0;
562  vtkIdType ConnectivitySize = 0;
564  };
565 
567  {
569 
571 
579 
581 
585  vtkIdType CurrentMaxPolyId = 0;
586  vtkIdType CurrentMaxStripId = 0;
587  vtkIdType CurrentMaxLineId = 0;
589 
591 
599 
601 
609 
611 
620  };
621 
623  {
625 
633 
635  {
639  };
640 
643 
645 
648  vtkIdType NumberOfPolysToSend = 0;
649  vtkIdType NumberOfStripsToSend = 0;
650  vtkIdType NumberOfLinesToSend = 0;
652 
654 
657  vtkIdType PolyConnectivitySize = 0;
658  vtkIdType StripConnectivitySize = 0;
659  vtkIdType LineConnectivitySize = 0;
661  };
662 
663 public:
672  template <class BlockStructureT, class InformationT>
673  struct Block
674  {
676 
679  typedef BlockStructureT BlockStructureType;
680  typedef InformationT InformationType;
682 
687 
693 
695 
697 
700  };
701 
703 
713 
722  template <class DataSetT>
723  static int GenerateGhostCells(std::vector<DataSetT*>& inputsDS, std::vector<DataSetT*>& outputsDS,
724  int outputGhostLevels, vtkMultiProcessController* controller);
725 
726 protected:
729 
734  template <class DataSetT>
736  typename DataSetTypeToBlockTypeConverter<DataSetT>::BlockType* block, DataSetT* output);
737 
742  template <class DataSetT>
744  typename DataSetTypeToBlockTypeConverter<DataSetT>::BlockType* block, DataSetT* output);
745 
747 
751  std::vector<vtkImageData*>& inputs, std::vector<vtkImageData*>& outputs);
753  std::vector<vtkRectilinearGrid*>& inputs, std::vector<vtkRectilinearGrid*>& outputs);
755  std::vector<vtkStructuredGrid*>& inputs, std::vector<vtkStructuredGrid*>& outputs);
757  std::vector<vtkUnstructuredGrid*>& inputs, std::vector<vtkUnstructuredGrid*>& outputs);
759  std::vector<vtkPolyData*>& inputs, std::vector<vtkPolyData*>& outputs);
761 
763 
769  static void InitializeBlocks(diy::Master& master, std::vector<vtkImageData*>& inputs);
770  static void InitializeBlocks(diy::Master& master, std::vector<vtkRectilinearGrid*>& inputs);
771  static void InitializeBlocks(diy::Master& master, std::vector<vtkStructuredGrid*>& inputs);
772  static void InitializeBlocks(diy::Master& master, std::vector<vtkUnstructuredGrid*>& inputs);
773  static void InitializeBlocks(diy::Master& master, std::vector<vtkPolyData*>& inputs);
775 
779  template <class DataSetT>
781  diy::Master& master, const vtkDIYExplicitAssigner& assigner, std::vector<DataSetT*>& inputs);
782 
783  template <class BlockT>
784  static LinkMap ComputeLinkMapUsingBoundingBoxes(const diy::Master& master);
785 
787 
793  static void ExchangeBlockStructures(diy::Master& master, std::vector<vtkImageData*>& inputs);
795  diy::Master& master, std::vector<vtkRectilinearGrid*>& inputs);
796  static void ExchangeBlockStructures(diy::Master& master, std::vector<vtkStructuredGrid*>& inputs);
798  diy::Master& master, std::vector<vtkUnstructuredGrid*>& inputs);
799  static void ExchangeBlockStructures(diy::Master& master, std::vector<vtkPolyData*>& inputs);
801 
803 
809  const diy::Master& master, std::vector<vtkImageData*>& inputs, int outputGhostLevels);
811  const diy::Master& master, std::vector<vtkRectilinearGrid*>& inputs, int outputGhostLevels);
813  const diy::Master& master, std::vector<vtkStructuredGrid*>& inputs, int outputGhostLevels);
815  const diy::Master& master, std::vector<vtkUnstructuredGrid*>& inputs, int outputGhostLevels);
817  const diy::Master& master, std::vector<vtkPolyData*>& inputs, int outputGhostLevels);
819 
821 
825  static void EnqueueGhosts(const diy::Master::ProxyWithLink& cp, const diy::BlockID& blockId,
826  vtkImageData* input, ImageDataBlock* block);
827  static void EnqueueGhosts(const diy::Master::ProxyWithLink& cp, const diy::BlockID& blockId,
829  static void EnqueueGhosts(const diy::Master::ProxyWithLink& cp, const diy::BlockID& blockId,
830  vtkStructuredGrid* input, StructuredGridBlock* block);
831  static void EnqueueGhosts(const diy::Master::ProxyWithLink& cp, const diy::BlockID& blockId,
833  static void EnqueueGhosts(const diy::Master::ProxyWithLink& cp, const diy::BlockID& blockId,
834  vtkPolyData* input, PolyDataBlock* block);
836 
838 
843  static void DequeueGhosts(
844  const diy::Master::ProxyWithLink& cp, int gid, ImageDataBlockStructure& blockStructure);
845  static void DequeueGhosts(
846  const diy::Master::ProxyWithLink& cp, int gid, RectilinearGridBlockStructure& blockStructure);
847  static void DequeueGhosts(
848  const diy::Master::ProxyWithLink& cp, int gid, StructuredGridBlockStructure& blockStructure);
849  static void DequeueGhosts(
850  const diy::Master::ProxyWithLink& cp, int gid, UnstructuredGridBlockStructure& blockStructure);
851  static void DequeueGhosts(
852  const diy::Master::ProxyWithLink& cp, int gid, PolyDataBlockStructure& blockStructure);
854 
856 
861  static void DeepCopyInputsAndAllocateGhosts(const diy::Master& master,
862  std::vector<vtkImageData*>& inputs, std::vector<vtkImageData*>& outputs);
863  static void DeepCopyInputsAndAllocateGhosts(const diy::Master& master,
864  std::vector<vtkRectilinearGrid*>& inputs, std::vector<vtkRectilinearGrid*>& outputs);
865  static void DeepCopyInputsAndAllocateGhosts(const diy::Master& master,
866  std::vector<vtkStructuredGrid*>& inputs, std::vector<vtkStructuredGrid*>& outputs);
867  static void DeepCopyInputsAndAllocateGhosts(const diy::Master& master,
868  std::vector<vtkUnstructuredGrid*>& inputs, std::vector<vtkUnstructuredGrid*>& outputs);
869  static void DeepCopyInputsAndAllocateGhosts(const diy::Master& master,
870  std::vector<vtkPolyData*>& inputs, std::vector<vtkPolyData*>& outputs);
872 
876  template <class DataSetT>
877  static void ExchangeGhosts(diy::Master& master, std::vector<DataSetT*>& inputs);
878 
882  template <class DataSetT>
883  static void InitializeGhostArrays(diy::Master& master, std::vector<DataSetT*>& outputs);
884 
889  template <class DataSetT>
890  static void AddGhostArrays(diy::Master& master, std::vector<DataSetT*>& outputs);
891 
893 
896  static void FillGhostArrays(const diy::Master& master, std::vector<vtkImageData*>& outputs);
897  static void FillGhostArrays(const diy::Master& master, std::vector<vtkRectilinearGrid*>& outputs);
898  static void FillGhostArrays(const diy::Master& master, std::vector<vtkStructuredGrid*>& outputs);
899  static void FillGhostArrays(
900  const diy::Master& master, std::vector<vtkUnstructuredGrid*>& outputs);
901  static void FillGhostArrays(const diy::Master& master, std::vector<vtkPolyData*>& outputs);
903 
904 private:
906  void operator=(const vtkDIYGhostUtilities&) = delete;
907 };
908 
909 #include "vtkDIYGhostUtilities.txx" // for template implementations
910 
911 #endif
abstract class to quickly locate points in 3-space
Superclass for all sources, filters, and sinks in VTK.
Definition: vtkAlgorithm.h:64
Fast, simple class for representing and operating on 3D bounds.
object to represent cell connectivity
Definition: vtkCellArray.h:181
assigner for use with DIY
Utilities to produce ghost cells between a collection of data sets of same type.
static void EnqueueGhosts(const diy::Master::ProxyWithLink &cp, const diy::BlockID &blockId, vtkImageData *input, ImageDataBlock *block)
This method enqueues ghosts between communicating blocks.
static void InitializeGhostPointArray(typename DataSetTypeToBlockTypeConverter< DataSetT >::BlockType *block, DataSetT *output)
This method will set all ghosts points in output to zero.
static void DequeueGhosts(const diy::Master::ProxyWithLink &cp, int gid, RectilinearGridBlockStructure &blockStructure)
This method dequeues ghosts sent between communicating blocks.
static void InitializeGhostCellArray(typename DataSetTypeToBlockTypeConverter< DataSetT >::BlockType *block, DataSetT *output)
This method will set all ghosts cells in output to zero.
static void ExchangeBlockStructures(diy::Master &master, std::vector< vtkRectilinearGrid * > &inputs)
Method to be overloaded for each supported type of input data set.
static LinkMap ComputeLinkMap(const diy::Master &master, std::vector< vtkRectilinearGrid * > &inputs, int outputGhostLevels)
Method to be overloaded for each supported input data set type, that computes the minimal link map be...
static void DeepCopyInputsAndAllocateGhosts(const diy::Master &master, std::vector< vtkPolyData * > &inputs, std::vector< vtkPolyData * > &outputs)
Method to be overloaded for each supported input data set type, This method allocates ghosts in the o...
static LinkMap ComputeLinkMap(const diy::Master &master, std::vector< vtkUnstructuredGrid * > &inputs, int outputGhostLevels)
Method to be overloaded for each supported input data set type, that computes the minimal link map be...
static void DequeueGhosts(const diy::Master::ProxyWithLink &cp, int gid, UnstructuredGridBlockStructure &blockStructure)
This method dequeues ghosts sent between communicating blocks.
static void InitializeBlocks(diy::Master &master, std::vector< vtkStructuredGrid * > &inputs)
Method to be overloaded for each supported type of input data set.
static void ExchangeGhosts(diy::Master &master, std::vector< DataSetT * > &inputs)
This method exchanges ghosts between connected blocks.
static void FillGhostArrays(const diy::Master &master, std::vector< vtkPolyData * > &outputs)
This method sets the ghost arrays in the output.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
static void CloneGeometricStructures(std::vector< vtkUnstructuredGrid * > &inputs, std::vector< vtkUnstructuredGrid * > &outputs)
Block typedefs.
static void InitializeBlocks(diy::Master &master, std::vector< vtkUnstructuredGrid * > &inputs)
Method to be overloaded for each supported type of input data set.
static void CloneGeometricStructures(std::vector< vtkImageData * > &inputs, std::vector< vtkImageData * > &outputs)
Block typedefs.
static void FillGhostArrays(const diy::Master &master, std::vector< vtkUnstructuredGrid * > &outputs)
This method sets the ghost arrays in the output.
static void CloneGeometricStructures(std::vector< vtkPolyData * > &inputs, std::vector< vtkPolyData * > &outputs)
Block typedefs.
static void InitializeBlocks(diy::Master &master, std::vector< vtkImageData * > &inputs)
Method to be overloaded for each supported type of input data set.
static void DeepCopyInputsAndAllocateGhosts(const diy::Master &master, std::vector< vtkRectilinearGrid * > &inputs, std::vector< vtkRectilinearGrid * > &outputs)
Method to be overloaded for each supported input data set type, This method allocates ghosts in the o...
static void CloneGeometricStructures(std::vector< vtkStructuredGrid * > &inputs, std::vector< vtkStructuredGrid * > &outputs)
Block typedefs.
std::set< int > Links
Convenient typedefs.
static void DequeueGhosts(const diy::Master::ProxyWithLink &cp, int gid, ImageDataBlockStructure &blockStructure)
This method dequeues ghosts sent between communicating blocks.
static void EnqueueGhosts(const diy::Master::ProxyWithLink &cp, const diy::BlockID &blockId, vtkPolyData *input, PolyDataBlock *block)
This method enqueues ghosts between communicating blocks.
static void InitializeBlocks(diy::Master &master, std::vector< vtkPolyData * > &inputs)
Method to be overloaded for each supported type of input data set.
static void ExchangeBoundingBoxes(diy::Master &master, const vtkDIYExplicitAssigner &assigner, std::vector< DataSetT * > &inputs)
This method exchanges the bounding boxes among blocks.
~vtkDIYGhostUtilities() override
Block typedefs.
static void EnqueueGhosts(const diy::Master::ProxyWithLink &cp, const diy::BlockID &blockId, vtkUnstructuredGrid *input, UnstructuredGridBlock *block)
This method enqueues ghosts between communicating blocks.
static void DeepCopyInputsAndAllocateGhosts(const diy::Master &master, std::vector< vtkUnstructuredGrid * > &inputs, std::vector< vtkUnstructuredGrid * > &outputs)
Method to be overloaded for each supported input data set type, This method allocates ghosts in the o...
static LinkMap ComputeLinkMap(const diy::Master &master, std::vector< vtkStructuredGrid * > &inputs, int outputGhostLevels)
Method to be overloaded for each supported input data set type, that computes the minimal link map be...
static void EnqueueGhosts(const diy::Master::ProxyWithLink &cp, const diy::BlockID &blockId, vtkStructuredGrid *input, StructuredGridBlock *block)
This method enqueues ghosts between communicating blocks.
static void CloneGeometricStructures(std::vector< vtkRectilinearGrid * > &inputs, std::vector< vtkRectilinearGrid * > &outputs)
Block typedefs.
static void DequeueGhosts(const diy::Master::ProxyWithLink &cp, int gid, StructuredGridBlockStructure &blockStructure)
This method dequeues ghosts sent between communicating blocks.
static void ExchangeBlockStructures(diy::Master &master, std::vector< vtkImageData * > &inputs)
Method to be overloaded for each supported type of input data set.
static void FillGhostArrays(const diy::Master &master, std::vector< vtkRectilinearGrid * > &outputs)
This method sets the ghost arrays in the output.
std::array< double, 3 > VectorType
Convenient typedefs.
static void DeepCopyInputsAndAllocateGhosts(const diy::Master &master, std::vector< vtkStructuredGrid * > &inputs, std::vector< vtkStructuredGrid * > &outputs)
Method to be overloaded for each supported input data set type, This method allocates ghosts in the o...
std::map< int, T > BlockMapType
Convenient typedefs.
static void FillGhostArrays(const diy::Master &master, std::vector< vtkImageData * > &outputs)
This method sets the ghost arrays in the output.
std::array< int, 6 > ExtentType
Convenient typedefs.
static void ExchangeBlockStructures(diy::Master &master, std::vector< vtkPolyData * > &inputs)
Method to be overloaded for each supported type of input data set.
static void DequeueGhosts(const diy::Master::ProxyWithLink &cp, int gid, PolyDataBlockStructure &blockStructure)
This method dequeues ghosts sent between communicating blocks.
static void ExchangeBlockStructures(diy::Master &master, std::vector< vtkUnstructuredGrid * > &inputs)
Method to be overloaded for each supported type of input data set.
vtkDIYGhostUtilities()
Block typedefs.
static LinkMap ComputeLinkMap(const diy::Master &master, std::vector< vtkPolyData * > &inputs, int outputGhostLevels)
Method to be overloaded for each supported input data set type, that computes the minimal link map be...
std::vector< Links > LinkMap
Convenient typedefs.
static void DeepCopyInputsAndAllocateGhosts(const diy::Master &master, std::vector< vtkImageData * > &inputs, std::vector< vtkImageData * > &outputs)
Method to be overloaded for each supported input data set type, This method allocates ghosts in the o...
static void AddGhostArrays(diy::Master &master, std::vector< DataSetT * > &outputs)
Adds ghost arrays, which are present in blocks of master, to outputs point and / or cell data.
static void InitializeGhostArrays(diy::Master &master, std::vector< DataSetT * > &outputs)
This methods allocate a point and cell ghost array and fills it with 0.
static void EnqueueGhosts(const diy::Master::ProxyWithLink &cp, const diy::BlockID &blockId, vtkRectilinearGrid *input, RectilinearGridBlock *block)
This method enqueues ghosts between communicating blocks.
static LinkMap ComputeLinkMapUsingBoundingBoxes(const diy::Master &master)
static LinkMap ComputeLinkMap(const diy::Master &master, std::vector< vtkImageData * > &inputs, int outputGhostLevels)
Method to be overloaded for each supported input data set type, that computes the minimal link map be...
static void InitializeBlocks(diy::Master &master, std::vector< vtkRectilinearGrid * > &inputs)
Method to be overloaded for each supported type of input data set.
static int GenerateGhostCells(std::vector< DataSetT * > &inputsDS, std::vector< DataSetT * > &outputsDS, int outputGhostLevels, vtkMultiProcessController *controller)
Main pipeline generating ghosts.
static void ExchangeBlockStructures(diy::Master &master, std::vector< vtkStructuredGrid * > &inputs)
Method to be overloaded for each supported type of input data set.
static void FillGhostArrays(const diy::Master &master, std::vector< vtkStructuredGrid * > &outputs)
This method sets the ghost arrays in the output.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:50
abstract class to specify dataset behavior
Definition: vtkDataSet.h:57
represent and manipulate fields of data
Definition: vtkFieldData.h:55
list of point or cell ids
Definition: vtkIdList.h:31
dynamic, self-adjusting array of vtkIdType
topologically and geometrically regular array of data
Definition: vtkImageData.h:48
a simple class to control print indentation
Definition: vtkIndent.h:34
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:34
Multiprocessing communication superclass.
abstract base class for most VTK objects
Definition: vtkObject.h:63
represent and manipulate 3D points
Definition: vtkPoints.h:34
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:86
a dataset that is topologically regular with variable spacing in the three coordinate directions
topologically regular array of data
dynamic, self-adjusting array of unsigned char
dataset represents arbitrary combinations of all possible cell types
@ points
Definition: vtkX3D.h:452
@ info
Definition: vtkX3D.h:382
@ extent
Definition: vtkX3D.h:351
@ spacing
Definition: vtkX3D.h:487
@ image
Definition: vtkX3D.h:380
Block structure to be used for diy communication.
vtkSmartPointer< vtkUnsignedCharArray > GhostPointArray
BlockMapType< vtkBoundingBox > NeighborBoundingBoxes
BlockStructureT BlockStructureType
Typedef handle on block structure and block information.
vtkSmartPointer< vtkUnsignedCharArray > GhostCellArray
BlockMapType< BlockStructureType > BlockStructures
BlockStructures maps a neighboring block globald id to its block structure.
InformationT InformationType
Typedef handle on block structure and block information.
InformationType Information
InformationT holds any information from the current block that is necessary to exchange ghosts.
Base block structure for data sets.
This helper structure owns a typedef to the block type of DataSetT used with diy to generate ghosts.
Structure to inherit from for data sets having a structured grid topology.
GridBlockStructure(const int *extent, int dim)
GridBlockStructure constructor.
ExtentType ShiftedExtentWithNewGhosts
Extent of neighboring block that include ghost layers, shifted to match our mapping of the extent in ...
ExtentType Extent
Extent of neighboring block with no ghosts.
ExtentType ShiftedExtent
Extent of the neighboring block, shifted to match our mapping of the extent in the 3D world.
int DataDimension
This stores the dimension of the grid (1D, 2D, or 3D).
unsigned char AdjacencyMask
Binary mask encoding the adjacency of the neighboring block w.r.t.
Structure storing information needed by a block on it's own grid structure.
ExtentType Extent
Extent without ghost layers.
Block structure storing information being communicated by neighboring blocks for vtkImageData.
VectorType Origin
Origin of the neighboring vtkImageData.
ImageDataBlockStructure(vtkImageData *image, const GridInformation &info)
Copy constructor.
VectorType Spacing
Spacing of the neighboring vtkImageData.
ImageDataBlockStructure(const int extent[6], int dim, const double origin[3], const double spacing[3], vtkMatrix3x3 *directionMatrix)
Constructor taking the extent (without ghosts) of the neighboring vtkImageData, as well as well as th...
QuaternionType OrientationQuaternion
Orientation of the neighboring vtkImageData.
ImageDataBlockStructure(const int extent[6], int dim, const double origin[3], const double spacing[3], const double orientationQuaternion[4])
Constructor taking the extent (without ghosts) of the neighboring vtkImageData, as well as well as th...
vtkNew< vtkIdList > StripIdsToSend
This lists the ids of the cells that we own and need to send to the current neighboring block.
vtkNew< vtkIdList > LineIdsToSend
This lists the ids of the cells that we own and need to send to the current neighboring block.
vtkNew< vtkIdList > PolyIdsToSend
This lists the ids of the cells that we own and need to send to the current neighboring block.
vtkIdType CurrentPolyConnectivitySize
This is a cursor telling how much the corresponding output connectivity array is filled.
vtkIdType NumberOfInputPolys
Number of cells of respective type when the input has its ghost cells removed.
vtkIdType NumberOfInputVerts
Number of cells of respective type when the input has its ghost cells removed.
vtkIdType CurrentLineConnectivitySize
This is a cursor telling how much the corresponding output connectivity array is filled.
vtkIdType NumberOfInputStrips
Number of cells of respective type when the input has its ghost cells removed.
vtkNew< vtkIdList > OutputToInputLineCellIdRedirectionMap
Cell connectivity array size of the input if ghost cells are removed.
vtkNew< vtkIdList > OutputToInputStripCellIdRedirectionMap
Cell connectivity array size of the input if ghost cells are removed.
vtkIdType CurrentStripConnectivitySize
This is a cursor telling how much the corresponding output connectivity array is filled.
vtkIdType InputPolyConnectivitySize
Cell connectivity array size of the input if ghost cells are removed.
vtkIdType NumberOfInputLines
Number of cells of respective type when the input has its ghost cells removed.
vtkIdType InputStripConnectivitySize
Cell connectivity array size of the input if ghost cells are removed.
vtkNew< vtkIdList > OutputToInputVertCellIdRedirectionMap
In the event that the input has ghost cells, this maps the output cells (with input ghosts removed) t...
vtkIdType InputLineConnectivitySize
Cell connectivity array size of the input if ghost cells are removed.
vtkNew< vtkIdList > OutputToInputPolyCellIdRedirectionMap
Cell connectivity array size of the input if ghost cells are removed.
vtkIdType InputVertConnectivitySize
Cell connectivity array size of the input if ghost cells are removed.
Block structure storing information being communicated by neighboring blocks for vtkRectilinearGrid.
vtkSmartPointer< vtkDataArray > ZCoordinates
Point coordinate arrays of the rectilinear grid.
vtkSmartPointer< vtkDataArray > YCoordinates
Point coordinate arrays of the rectilinear grid.
vtkSmartPointer< vtkDataArray > XCoordinates
Point coordinate arrays of the rectilinear grid.
RectilinearGridBlockStructure(vtkRectilinearGrid *grid, const RectilinearGridInformation &info)
Copy constructor.
RectilinearGridBlockStructure(const int extent[6], int dim, vtkDataArray *xCoordinates, vtkDataArray *yCoordinates, vtkDataArray *zCoordinates)
Constructor taking the extent (without ghosts) of the neighboring vtkRectilinearGrid,...
vtkSmartPointer< vtkDataArray > YCoordinates
Point coordinates without ghosts.
vtkSmartPointer< vtkDataArray > XCoordinates
Point coordinates without ghosts.
vtkSmartPointer< vtkDataArray > ZCoordinates
Point coordinates without ghosts.
Block structure storing information being communicated by neighboring blocks for vtkStructuredGrid.
vtkNew< vtkPoints > GhostPoints
Buffer to store received ghost points from neighboring blocks.
StructuredGridBlockStructure(vtkStructuredGrid *grid, const StructuredGridInformation &info)
Copy constructor.
StructuredGridBlockStructure(const int extent[6], int dim, vtkDataArray *points[6])
Constructor taking the extent (without ghosts) of the neighboring vtkStructuredGrid,...
Grid2D GridInterface
2D grid interfacing 2 blocks.
This structure represents the set of points and their corresponding extent of an external face of the...
ExtentType Extent
Extent (which represents a 2D, 1D, or 0D grid), of an external face.
vtkSmartPointer< vtkPoints > Points
Points of an external face.
vtkPoints * InputPoints
Handle on input points for current block.
vtkNew< vtkIdTypeArray > RemappedMatchingReceivedPointIdsSortedLikeTarget
This array describes the same points as MatchingReceivedPointIds, but points are ordered like in the ...
std::map< vtkIdType, vtkIdType > RedirectionMapForDuplicatePointIds
This is a mapping from points that have been sent by the current neighboring block and have already b...
vtkNew< vtkIdList > PointIdsToSend
This lists the ids of the points that we own and need to send to the current neighboring block.
vtkNew< vtkIdTypeArray > MatchingReceivedPointIds
This lists the matching point ids to the interfacing points that are exchanged with current neighbori...
vtkSmartPointer< vtkIdTypeArray > ReceivedSharedPointIds
It can happen that a point can be sent by multiple blocks.
vtkNew< vtkIdTypeArray > SharedPointIds
It can happen that a point can be sent by multiple blocks.
vtkNew< vtkIdList > CellIdsToSend
This lists the ids of the cells that we own and need to send to the current neighboring block.
vtkNew< vtkPoints > GhostPoints
Ghost points sent by the current neighboring block.
vtkNew< vtkPoints > InterfacingPoints
These are the interfacing points sent by the current neighboring block.
vtkIdTypeArray * InterfacePointIds
Handle to the local point ids of the surface of the input.
vtkIdTypeArray * InterfaceGlobalPointIds
Handle to the point ids of the input surface, if present.
vtkIdType NumberOfInputPoints
Number of input points / cell in the input when ghosts are removed.
vtkIdType NumberOfInputCells
Number of input points / cell in the input when ghosts are removed.
vtkDataArray * InterfacePoints
Handle to the points of the surface of the input.
vtkSmartPointer< vtkAlgorithm > InterfaceExtractor
Filter that is being used to extract the surface of the input.
vtkBoundingBox BoundingBox
Bounding box of input.
int vtkIdType
Definition: vtkType.h:332