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
82class vtkAlgorithm;
83class vtkCellArray;
84class vtkDataArray;
85class vtkDataSet;
86class vtkFieldData;
87class vtkIdList;
88class vtkIdTypeArray;
89class vtkImageData;
90class vtkMatrix3x3;
92class vtkPoints;
93class vtkPolyData;
98
99class VTKPARALLELDIY_EXPORT vtkDIYGhostUtilities : public vtkObject
100{
101public:
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
125protected:
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 {
312 StructuredGridBlockStructure(const int extent[6], int dim, vtkDataArray* points[6]);
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
663public:
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
726protected:
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,
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
904private:
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:123
Fast, simple class for representing and operating on 3D bounds.
object to represent cell connectivity
Definition: vtkCellArray.h:290
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:159
abstract class to specify dataset behavior
Definition: vtkDataSet.h:166
represent and manipulate fields of data
Definition: vtkFieldData.h:164
list of point or cell ids
Definition: vtkIdList.h:140
dynamic, self-adjusting array of vtkIdType
topologically and geometrically regular array of data
Definition: vtkImageData.h:157
a simple class to control print indentation
Definition: vtkIndent.h:113
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:63
Multiprocessing communication superclass.
Allocate and hold a VTK object.
Definition: vtkNew.h:165
abstract base class for most VTK objects
Definition: vtkObject.h:82
represent and manipulate 3D points
Definition: vtkPoints.h:143
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:195
a dataset that is topologically regular with variable spacing in the three coordinate directions
Hold a reference to a vtkObjectBase instance.
topologically regular array of data
dynamic, self-adjusting array of unsigned char
dataset represents arbitrary combinations of all possible cell types
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