VTK  9.2.6
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 =========================================================================*/
71 #ifndef vtkDIYGhostUtilities_h
72 #define vtkDIYGhostUtilities_h
73 
74 #include "vtkBoundingBox.h" // For ComputeLinkMap
75 #include "vtkDIYExplicitAssigner.h" // For DIY assigner
76 #include "vtkDIYUtilities.h" // For Block
77 #include "vtkObject.h"
78 #include "vtkParallelDIYModule.h" // For export macros
79 #include "vtkQuaternion.h" // For vtkImageData
80 #include "vtkSmartPointer.h" // For vtkSmartPointer
81 
82 #include <array> // For VectorType and ExtentType
83 #include <map> // For BlockMapType
84 #include <set> // For Link
85 #include <vector> // For LinkMap
86 
87 // clang-format off
88 #include "vtk_diy2.h" // Third party include
89 #include VTK_DIY2(diy/assigner.hpp)
90 #include VTK_DIY2(diy/master.hpp)
91 #include VTK_DIY2(diy/partners/all-reduce.hpp)
92 // clang-format on
93 
95 class vtkAlgorithm;
96 class vtkCellArray;
97 class vtkDataArray;
98 class vtkDataSet;
99 class vtkFieldData;
100 class vtkIdList;
101 class vtkIdTypeArray;
102 class vtkImageData;
103 class vtkMatrix3x3;
105 class vtkPoints;
106 class vtkPointSet;
107 class vtkPolyData;
108 class vtkRectilinearGrid;
109 class vtkStructuredGrid;
111 class vtkUnstructuredGrid;
112 
113 class VTKPARALLELDIY_EXPORT vtkDIYGhostUtilities : public vtkObject
114 {
115 public:
117  void PrintSelf(ostream& os, vtkIndent indent) override;
118 
120 
123  using VectorType = std::array<double, 3>;
125  using ExtentType = std::array<int, 6>;
126  template <class T>
127  using BlockMapType = std::map<int, T>;
128  using Links = std::set<int>;
129  using LinkMap = std::vector<Links>;
131 
136  template <class DataSetT>
138 
139 protected:
144  {
145  vtkSmartPointer<vtkFieldData> GhostCellData = nullptr;
146  vtkSmartPointer<vtkFieldData> GhostPointData = nullptr;
147  };
148 
150  {
154  virtual bool InputNeedsGhostsPeeledOff() const = 0;
155  };
156 
161  {
165  GridBlockStructure(const int* extent, int dim);
166 
170  ExtentType Extent = ExtentType{ 1, -1, 1, -1, 1, -1 };
171 
177 
182 
183  ExtentType ReceivedGhostExtent = ExtentType{ 1, -1, 1, -1, 1, -1 };
184 
189  unsigned char AdjacencyMask;
190 
195  };
196 
201  {
202  bool InputNeedsGhostsPeeledOff() const override { return this->Extent != this->InputExtent; }
203 
207  ExtentType Extent = ExtentType{ 1, -1, 1, -1, 1, -1 };
208 
212  ExtentType InputExtent = ExtentType{ 1, -1, 1, -1, 1, -1 };
213 
215  };
216 
218  {
220  };
221 
227  {
229 
233  ImageDataBlockStructure(const int extent[6], int dim, const double origin[3],
234  const double spacing[3], const double orientationQuaternion[4]);
235  ImageDataBlockStructure(const int extent[6], int dim, const double origin[3],
236  const double spacing[3], vtkMatrix3x3* directionMatrix);
238 
243 
248 
253 
258  };
259 
261  {
263 
270 
276  vtkSmartPointer<vtkDataArray> CoordinateGhosts[6];
277 
279  };
280 
286  {
291  RectilinearGridBlockStructure(const int extent[6], int dim, vtkDataArray* xCoordinates,
292  vtkDataArray* yCoordinates, vtkDataArray* zCoordinates);
293 
298 
300 
307  };
308 
310  {
316  {
321 
326  };
327 
332  OuterPointLayersType OuterPointLayers[6];
333 
338 
340  };
341 
347  {
352  StructuredGridBlockStructure(const int extent[6], int dim, vtkDataArray* points[6]);
353 
358 
362  vtkSmartPointer<vtkPoints> OuterPointLayers[6];
363 
368  struct Grid2D
369  {
373  int StartX = 0;
374 
378  int StartY = 0;
379 
383  int EndX = 0;
384 
388  int EndY = 0;
389 
393  int XOrientation = 0;
394 
398  int YOrientation = 0;
399 
404  int ExtentId = -1;
405  };
406 
413 
418  };
419 
421  {
423  {
424  return this->OutputToInputCellIdRedirectionMap != nullptr;
425  };
426 
430  vtkBoundingBox BoundingBox;
431 
436  vtkSmartPointer<vtkIdList> OutputToInputCellIdRedirectionMap = nullptr;
437 
439 
443  vtkSmartPointer<vtkIdList> InputToOutputPointIdRedirectionMap = nullptr;
444  vtkSmartPointer<vtkIdList> OutputToInputPointIdRedirectionMap = nullptr;
446 
453 
460 
465 
470 
472  /*
473  * This is a cursor telling the amount of points / cells information,
474  * that has
475  * already been added to the output. This variable is used at the very end of the pipeline.
476  */
480 
482 
488  };
489 
491  {
497 
503 
509 
513  vtkSmartPointer<vtkIdTypeArray> InterfacingGlobalPointIds = nullptr;
514 
519  vtkSmartPointer<vtkIdTypeArray> GhostGlobalPointIds = nullptr;
520 
525 
531 
533 
542 
547  std::map<vtkIdType, vtkIdType> RedirectionMapForDuplicatePointIds;
548 
554 
560  };
561 
563  {
568  vtkIdType CurrentFacesSize = 0;
569 
574  vtkIdType CurrentConnectivitySize = 0;
575 
576  vtkIdTypeArray* Faces = nullptr;
577  vtkIdTypeArray* FaceLocations = nullptr;
578 
580 
584  vtkIdType InputConnectivitySize = 0;
585 
589  vtkIdType InputFacesSize = 0;
590  };
591 
593  {
598  {
601  vtkSmartPointer<vtkIdTypeArray> FaceLocations = nullptr;
603  };
604 
607 
609 
612  vtkIdType FacesSize = 0;
613  vtkIdType ConnectivitySize = 0;
615  };
616 
618  {
620 
622 
630 
632 
636  vtkIdType CurrentMaxPolyId = 0;
637  vtkIdType CurrentMaxStripId = 0;
638  vtkIdType CurrentMaxLineId = 0;
640 
642 
650 
652 
660 
662 
671  };
672 
674  {
676 
684 
686  {
690  };
691 
694 
696 
699  vtkIdType NumberOfPolysToSend = 0;
700  vtkIdType NumberOfStripsToSend = 0;
701  vtkIdType NumberOfLinesToSend = 0;
703 
705 
708  vtkIdType PolyConnectivitySize = 0;
709  vtkIdType StripConnectivitySize = 0;
710  vtkIdType LineConnectivitySize = 0;
712  };
713 
714 public:
723  template <class BlockStructureT, class InformationT>
724  struct Block
725  {
727 
730  typedef BlockStructureT BlockStructureType;
731  typedef InformationT InformationType;
733 
738 
743  InformationType Information;
744 
746 
748 
751  };
752 
754 
764 
773  template <class DataSetT>
774  static int GenerateGhostCells(std::vector<DataSetT*>& inputsDS, std::vector<DataSetT*>& outputsDS,
775  int outputGhostLevels, vtkMultiProcessController* controller);
776 
778 
783  static int GenerateGhostCellsImageData(std::vector<vtkImageData*>& inputs,
784  std::vector<vtkImageData*>& outputs, int outputGhostLevels,
785  vtkMultiProcessController* controller);
786  static int GenerateGhostCellsRectilinearGrid(std::vector<vtkRectilinearGrid*>& inputs,
787  std::vector<vtkRectilinearGrid*>& outputs, int outputGhostLevels,
788  vtkMultiProcessController* controller);
789  static int GenerateGhostCellsStructuredGrid(std::vector<vtkStructuredGrid*>& inputs,
790  std::vector<vtkStructuredGrid*>& outputs, int outputGhostLevels,
791  vtkMultiProcessController* controller);
792  static int GenerateGhostCellsPolyData(std::vector<vtkPolyData*>& inputs,
793  std::vector<vtkPolyData*>& outputs, int outputGhostLevels,
794  vtkMultiProcessController* controller);
795  static int GenerateGhostCellsUnstructuredGrid(std::vector<vtkUnstructuredGrid*>& inputs,
796  std::vector<vtkUnstructuredGrid*>& outputs, int outputGhostLevels,
797  vtkMultiProcessController* controller);
799 
800 protected:
802  ~vtkDIYGhostUtilities() override;
803 
807  static void ReinitializeSelectedBits(vtkUnsignedCharArray* ghosts, unsigned char mask);
808 
813  template <class DataSetT>
814  static void InitializeGhostPointArray(
815  typename DataSetTypeToBlockTypeConverter<DataSetT>::BlockType* block, DataSetT* output);
816 
821  template <class DataSetT>
822  static void InitializeGhostCellArray(
823  typename DataSetTypeToBlockTypeConverter<DataSetT>::BlockType* block, DataSetT* output);
824 
826 
829  static void CloneGeometricStructures(
830  std::vector<vtkImageData*>& inputs, std::vector<vtkImageData*>& outputs);
831  static void CloneGeometricStructures(
832  std::vector<vtkRectilinearGrid*>& inputs, std::vector<vtkRectilinearGrid*>& outputs);
833  static void CloneGeometricStructures(
834  std::vector<vtkStructuredGrid*>& inputs, std::vector<vtkStructuredGrid*>& outputs);
835  static void CloneGeometricStructures(
836  std::vector<vtkUnstructuredGrid*>& inputs, std::vector<vtkUnstructuredGrid*>& outputs);
837  static void CloneGeometricStructures(
838  std::vector<vtkPolyData*>& inputs, std::vector<vtkPolyData*>& outputs);
840 
842 
848  static void InitializeBlocks(diy::Master& master, std::vector<vtkImageData*>& inputs);
849  static void InitializeBlocks(diy::Master& master, std::vector<vtkRectilinearGrid*>& inputs);
850  static void InitializeBlocks(diy::Master& master, std::vector<vtkStructuredGrid*>& inputs);
851  static void InitializeBlocks(diy::Master& master, std::vector<vtkUnstructuredGrid*>& inputs);
852  static void InitializeBlocks(diy::Master& master, std::vector<vtkPolyData*>& inputs);
854 
858  template <class DataSetT>
859  static void ExchangeBoundingBoxes(
860  diy::Master& master, const vtkDIYExplicitAssigner& assigner, std::vector<DataSetT*>& inputs);
861 
862  template <class BlockT>
863  static LinkMap ComputeLinkMapUsingBoundingBoxes(const diy::Master& master);
864 
866 
872  static void ExchangeBlockStructures(diy::Master& master, std::vector<vtkImageData*>& inputs);
873  static void ExchangeBlockStructures(
874  diy::Master& master, std::vector<vtkRectilinearGrid*>& inputs);
875  static void ExchangeBlockStructures(diy::Master& master, std::vector<vtkStructuredGrid*>& inputs);
876  static void ExchangeBlockStructures(
877  diy::Master& master, std::vector<vtkUnstructuredGrid*>& inputs);
878  static void ExchangeBlockStructures(diy::Master& master, std::vector<vtkPolyData*>& inputs);
880 
882 
887  static LinkMap ComputeLinkMap(
888  const diy::Master& master, std::vector<vtkImageData*>& inputs, int outputGhostLevels);
889  static LinkMap ComputeLinkMap(
890  const diy::Master& master, std::vector<vtkRectilinearGrid*>& inputs, int outputGhostLevels);
891  static LinkMap ComputeLinkMap(
892  const diy::Master& master, std::vector<vtkStructuredGrid*>& inputs, int outputGhostLevels);
893  static LinkMap ComputeLinkMap(
894  const diy::Master& master, std::vector<vtkUnstructuredGrid*>& inputs, int outputGhostLevels);
895  static LinkMap ComputeLinkMap(
896  const diy::Master& master, std::vector<vtkPolyData*>& inputs, int outputGhostLevels);
898 
900 
904  static void EnqueueGhosts(const diy::Master::ProxyWithLink& cp, const diy::BlockID& blockId,
905  vtkImageData* input, ImageDataBlock* block);
906  static void EnqueueGhosts(const diy::Master::ProxyWithLink& cp, const diy::BlockID& blockId,
908  static void EnqueueGhosts(const diy::Master::ProxyWithLink& cp, const diy::BlockID& blockId,
909  vtkStructuredGrid* input, StructuredGridBlock* block);
910  static void EnqueueGhosts(const diy::Master::ProxyWithLink& cp, const diy::BlockID& blockId,
912  static void EnqueueGhosts(const diy::Master::ProxyWithLink& cp, const diy::BlockID& blockId,
913  vtkPolyData* input, PolyDataBlock* block);
915 
917 
922  static void DequeueGhosts(
923  const diy::Master::ProxyWithLink& cp, int gid, ImageDataBlockStructure& blockStructure);
924  static void DequeueGhosts(
925  const diy::Master::ProxyWithLink& cp, int gid, RectilinearGridBlockStructure& blockStructure);
926  static void DequeueGhosts(
927  const diy::Master::ProxyWithLink& cp, int gid, StructuredGridBlockStructure& blockStructure);
928  static void DequeueGhosts(
929  const diy::Master::ProxyWithLink& cp, int gid, UnstructuredGridBlockStructure& blockStructure);
930  static void DequeueGhosts(
931  const diy::Master::ProxyWithLink& cp, int gid, PolyDataBlockStructure& blockStructure);
933 
938  template <class DataSetT>
939  static void CopyInputsAndAllocateGhosts(diy::Master& master, diy::Assigner& assigner,
940  diy::RegularAllReducePartners& partners, std::vector<DataSetT*>& inputs,
941  std::vector<DataSetT*>& outputs, int outputGhostLevels);
942 
944 
949  static void DeepCopyInputAndAllocateGhosts(
950  ImageDataBlock* block, vtkImageData* input, vtkImageData* outputs);
951  static void DeepCopyInputAndAllocateGhosts(
953  static void DeepCopyInputAndAllocateGhosts(
954  StructuredGridBlock* block, vtkStructuredGrid* input, vtkStructuredGrid* outputs);
955  static void DeepCopyInputAndAllocateGhosts(
957  static void DeepCopyInputAndAllocateGhosts(
958  PolyDataBlock* block, vtkPolyData* input, vtkPolyData* outputs);
960 
964  template <class DataSetT>
965  static void ExchangeGhosts(diy::Master& master, std::vector<DataSetT*>& inputs);
966 
970  template <class DataSetT>
971  static void InitializeGhostArrays(
972  diy::Master& master, std::vector<DataSetT*>& outputs, int outputGhostLevels);
973 
978  template <class DataSetT>
979  static void AddGhostArrays(diy::Master& master, std::vector<DataSetT*>& outputs);
980 
982 
985  static void FillGhostArrays(
986  const diy::Master& master, std::vector<vtkImageData*>& outputs, int outputGhostLevels);
987  static void FillGhostArrays(
988  const diy::Master& master, std::vector<vtkRectilinearGrid*>& outputs, int outputGhostLevels);
989  static void FillGhostArrays(
990  const diy::Master& master, std::vector<vtkStructuredGrid*>& outputs, int outputGhostLevels);
991  static void FillGhostArrays(
992  const diy::Master& master, std::vector<vtkUnstructuredGrid*>& outputs, int outputGhostLevels);
993  static void FillGhostArrays(
994  const diy::Master& master, std::vector<vtkPolyData*>& outputs, int outputGhostLevels);
996 
997 private:
999  void operator=(const vtkDIYGhostUtilities&) = delete;
1000 
1002 
1009  static void InflateBoundingBoxIfNecessary(
1010  vtkDataSet* vtkNotUsed(input), vtkBoundingBox& vtkNotUsed(bb));
1011  static void InflateBoundingBoxIfNecessary(vtkPointSet* input, vtkBoundingBox& bb);
1013 };
1014 
1015 #include "vtkDIYGhostUtilities.txx" // for template implementations
1016 
1017 #endif
int DataDimension
This stores the dimension of the grid (1D, 2D, or 3D).
vtkDataArray * InterfacePoints
Handle to the points of the surface of the input.
vtkNew< vtkPoints > GhostPoints
Buffer to store received ghost points from neighboring blocks.
a dataset that is topologically regular with variable spacing in the three coordinate directions ...
Structure storing information needed by a block on it's own grid structure.
vtkSmartPointer< vtkDataArray > ZCoordinates
Point coordinates without ghosts.
abstract base class for most VTK objects
Definition: vtkObject.h:62
Grid2D GridInterface
2D grid interfacing 2 blocks.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkSmartPointer< vtkDataArray > YCoordinates
Point coordinate arrays of the rectilinear grid.
Structure to inherit from for data sets having a structured grid topology.
This structure represents the set of points and their corresponding extent of an external face of the...
abstract class to specify dataset behavior
Definition: vtkDataSet.h:62
vtkIdType NumberOfInputLines
Number of cells of respective type when the input has its ghost cells removed.
vtkSmartPointer< vtkPoints > Points
Points of an external face.
vtkNew< vtkPoints > GhostPoints
Ghost points sent by the current neighboring block.
vtkSmartPointer< vtkDataArray > ZCoordinates
Point coordinate arrays of the rectilinear grid.
InformationT InformationType
Typedef handle on block structure and block information.
vtkIdType InputVertConnectivitySize
Cell connectivity array size of the input if ghost cells are removed.
vtkNew< vtkIdList > OutputToInputLineCellIdRedirectionMap
Cell connectivity array size of the input if ghost cells are removed.
unsigned char AdjacencyMask
Binary mask encoding the adjacency of the neighboring block w.r.t.
vtkIdType NumberOfInputStrips
Number of cells of respective type when the input has its ghost cells removed.
BlockStructureT BlockStructureType
Typedef handle on block structure and block information.
concrete class for storing a set of points
Definition: vtkPointSet.h:69
vtkIdType CurrentStripConnectivitySize
This is a cursor telling how much the corresponding output connectivity array is filled.
dynamic, self-adjusting array of vtkIdType
int vtkIdType
Definition: vtkType.h:332
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:90
vtkIdType NumberOfInputPoints
Number of input points / cell in the input when ghosts are removed.
vtkNew< vtkIdTypeArray > SharedPointIds
It can happen that a point can be sent by multiple blocks.
This helper structure owns a typedef to the block type of DataSetT used with diy to generate ghosts...
vtkSmartPointer< vtkDataArray > XCoordinates
Point coordinates without ghosts.
vtkNew< vtkIdList > RemappedMatchingReceivedPointIdsSortedLikeTarget
This array describes the same points as MatchingReceivedPointIds, but points are ordered like in the ...
vtkNew< vtkPoints > InterfacingPoints
These are the interfacing points sent by the current neighboring block.
vtkIdType CurrentPolyConnectivitySize
This is a cursor telling how much the corresponding output connectivity array is filled.
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...
vtkIdType InputLineConnectivitySize
Cell connectivity array size of the input if ghost cells are removed.
ExtentType Extent
Extent (which represents a 2D, 1D, or 0D grid), of an external face.
std::set< int > Links
Convenient typedefs.
ExtentType ShiftedExtent
Extent of the neighboring block, shifted to match our mapping of the extent in the 3D world...
vtkPoints * InputPoints
Handle on input points for current block.
Superclass for all sources, filters, and sinks in VTK.
Definition: vtkAlgorithm.h:62
std::array< double, 3 > VectorType
Convenient typedefs.
vtkSmartPointer< vtkUnsignedCharArray > GhostCellArray
vtkNew< vtkIdList > PolyIdsToSend
This lists the ids of the cells that we own and need to send to the current neighboring block...
vtkSmartPointer< vtkUnsignedCharArray > GhostPointArray
vtkIdType InputStripConnectivitySize
Cell connectivity array size of the input if ghost cells are removed.
a simple class to control print indentation
Definition: vtkIndent.h:39
Utilities to produce ghost cells between a collection of data sets of same type.
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.
abstract class to quickly locate points in 3-space
vtkNew< vtkIdList > OutputToInputStripCellIdRedirectionMap
Cell connectivity array size of the input if ghost cells are removed.
VectorType Spacing
Spacing of the neighboring vtkImageData.
topologically and geometrically regular array of data
Definition: vtkImageData.h:53
list of point or cell ids
Definition: vtkIdList.h:33
vtkSmartPointer< vtkDataArray > XCoordinates
Point coordinate arrays of the rectilinear grid.
std::map< int, T > BlockMapType
Convenient typedefs.
vtkSmartPointer< vtkFieldData > InterfacingPointData
Point data at the interface sent by our neighbor.
dataset represents arbitrary combinations of all possible cell types
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
vtkNew< vtkIdList > OutputToInputPolyCellIdRedirectionMap
Cell connectivity array size of the input if ghost cells are removed.
vtkNew< vtkIdList > MatchingReceivedPointIds
This lists the matching point ids to the interfacing points that are exchanged with current neighbori...
InformationType Information
InformationT holds any information from the current block that is necessary to exchange ghosts...
std::array< int, 6 > ExtentType
Convenient typedefs.
VectorType Origin
Origin of the neighboring vtkImageData.
vtkSmartPointer< vtkAlgorithm > InterfaceExtractor
Filter that is being used to extract the surface of the input.
Base block structure for data sets.
dynamic, self-adjusting array of unsigned char
QuaternionType OrientationQuaternion
Orientation of the neighboring vtkImageData.
vtkNew< vtkIdList > PointIdsToSend
This lists the ids of the points that we own and need to send to the current neighboring block...
Block structure storing information being communicated by neighboring blocks for vtkImageData.
object to represent cell connectivity
Definition: vtkCellArray.h:186
std::vector< Links > LinkMap
Convenient typedefs.
Block structure to be used for diy communication.
topologically regular array of data
vtkIdType CurrentLineConnectivitySize
This is a cursor telling how much the corresponding output connectivity array is filled.
std::map< vtkIdType, vtkIdType > RedirectionMapForDuplicatePointIds
This is a mapping from points that have been sent by the current neighboring block and have already b...
vtkIdType NumberOfInputCells
Number of input points / cell in the input when ghosts are removed.
Block structure storing information being communicated by neighboring blocks for vtkStructuredGrid.
ExtentType ShiftedExtentWithNewGhosts
Extent of neighboring block that include ghost layers, shifted to match our mapping of the extent in ...
vtkIdTypeArray * InterfacePointIds
Handle to the local point ids of the surface of the input.
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:36
vtkIdType InputPolyConnectivitySize
Cell connectivity array size of the input if ghost cells are removed.
vtkSmartPointer< vtkIdTypeArray > ReceivedSharedPointIds
It can happen that a point can be sent by multiple blocks.
vtkNew< vtkIdList > OutputToInputVertCellIdRedirectionMap
In the event that the input has ghost cells, this maps the output cells (with input ghosts removed) t...
vtkSmartPointer< vtkDataArray > YCoordinates
Point coordinates without ghosts.
vtkNew< vtkIdList > CellIdsToSend
This lists the ids of the cells that we own and need to send to the current neighboring block...
BlockMapType< vtkBoundingBox > NeighborBoundingBoxes
Block structure storing information being communicated by neighboring blocks for vtkRectilinearGrid.
represent and manipulate 3D points
Definition: vtkPoints.h:39
vtkSmartPointer< vtkIdTypeArray > InterfaceGlobalPointIds
Handle to the point ids of the input surface, if present.
Fast, simple class for representing and operating on 3D bounds.
assigner for use with DIY
represent and manipulate fields of data
Definition: vtkFieldData.h:62
BlockMapType< BlockStructureType > BlockStructures
BlockStructures maps a neighboring block globald id to its block structure.
Multiprocessing communication superclass.