VTK  9.5.20250718
vtkStructuredGridConnectivity.h
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2// SPDX-License-Identifier: BSD-3-Clause
20#ifndef vtkStructuredGridConnectivity_h
21#define vtkStructuredGridConnectivity_h
22
23#define VTK_NO_OVERLAP 0
24#define VTK_NODE_OVERLAP 1
25#define VTK_EDGE_OVERLAP 2
26#define VTK_PARTIAL_OVERLAP 3
27
28// VTK include directives
30#include "vtkFiltersGeometryModule.h" // For export macro
31#include "vtkStructuredData.h" // For data description definitions
32#include "vtkStructuredNeighbor.h" // For Structured Neighbor object definition
33
34// C++ include directives
35#include <cassert> // For assert()
36#include <iostream> // For cout
37#include <map> // For STL map
38#include <utility> // For STL pair and overloaded relational operators
39#include <vector> // For STL vector
40
41// Forward Declarations
42VTK_ABI_NAMESPACE_BEGIN
43class vtkIdList;
45class vtkPointData;
46class vtkCellData;
47class vtkPoints;
48
49class VTKFILTERSGEOMETRY_EXPORT vtkStructuredGridConnectivity : public vtkAbstractGridConnectivity
50{
51public:
54 void PrintSelf(ostream& os, vtkIndent indent) override;
55
57
60 vtkSetVector6Macro(WholeExtent, int);
61 vtkGetVector6Macro(WholeExtent, int);
63
65
68 vtkGetMacro(DataDimension, int);
70
74 void SetNumberOfGrids(unsigned int N) override;
75
80 virtual void RegisterGrid(int gridID, int extents[6], vtkUnsignedCharArray* nodesGhostArray,
81 vtkUnsignedCharArray* cellGhostArray, vtkPointData* pointData, vtkCellData* cellData,
82 vtkPoints* gridNodes);
83
87 void GetGridExtent(int gridID, int extent[6]);
88
93 void SetGhostedGridExtent(int gridID, int ext[6]);
94
98 void GetGhostedGridExtent(int gridID, int ext[6]);
99
103 void ComputeNeighbors() override;
104
109 int GetNumberOfNeighbors(int gridID)
110 {
111 return (static_cast<int>(this->Neighbors[gridID].size()));
112 }
113
119
127 vtkIdList* GetNeighbors(int gridID, int* extents);
128
135 int gridID, vtkUnsignedCharArray* nodesArray, vtkUnsignedCharArray* cellsArray) override;
136
140 void CreateGhostLayers(int N = 1) override;
141
142protected:
145
149 bool InBounds(int idx, int Lo, int Hi) { return ((idx >= Lo) && (idx <= Hi)); }
150
154 bool StrictlyInsideBounds(int idx, int Lo, int Hi) { return ((idx > Lo) && (idx < Hi)); }
155
159 bool IsSubset(int A[2], int B[2])
160 {
161 return (this->InBounds(A[0], B[0], B[1]) && this->InBounds(A[1], B[0], B[1]));
162 }
163
167 int Cardinality(int S[2]) { return (S[1] - S[0] + 1); }
168
170
174 {
175 int numNodes = 0;
176 switch (dim)
177 {
178 case 1:
179 numNodes = 2; // line cell
180 break;
181 case 2:
182 numNodes = 4; // quad cell
183 break;
184 case 3:
185 numNodes = 8; // hex cell
186 break;
187 default:
188 assert("ERROR: code should not reach here!" && false);
189 } // END switch
190 return (numNodes);
191 }
193
197 void FillNodesGhostArray(int gridID, int dataDescription, int GridExtent[6], int RealExtent[6],
198 vtkUnsignedCharArray* nodesArray);
199
203 void FillCellsGhostArray(int dataDescription, int numNodesPerCell, int dims[3], int CellExtent[6],
204 vtkUnsignedCharArray* nodesArray, vtkUnsignedCharArray* cellsArray);
205
211 void SearchNeighbors(int gridID, int i, int j, int k, vtkIdList* neiList);
212
218 int gridID, int i, int j, int k, int ext[6], int RealExtent[6], unsigned char& pfield);
219
224 void MarkCellProperty(unsigned char& pfield, unsigned char* nodeGhostFields, int numNodes);
225
229 void GetRealExtent(int gridID, int GridExtent[6], int RealExtent[6]);
230
235 bool IsGhostNode(int GridExtent[6], int RealExtent[6], int i, int j, int k);
236
241 bool IsNodeOnBoundaryOfExtent(int i, int j, int k, int ext[6]);
242
248 bool IsNodeOnSharedBoundary(int gridID, int RealExtent[6], int i, int j, int k);
249
254 bool IsNodeOnBoundary(int i, int j, int k);
255
260 bool IsNodeInterior(int i, int j, int k, int GridExtent[6]);
261
266 bool IsNodeWithinExtent(int i, int j, int k, int GridExtent[6])
267 {
268 bool status = false;
269
270 switch (this->DataDescription)
271 {
273 if ((GridExtent[0] <= i) && (i <= GridExtent[1]))
274 {
275 status = true;
276 }
277 break;
279 if ((GridExtent[2] <= j) && (j <= GridExtent[3]))
280 {
281 status = true;
282 }
283 break;
285 if ((GridExtent[4] <= k) && (k <= GridExtent[5]))
286 {
287 status = true;
288 }
289 break;
291 if ((GridExtent[0] <= i) && (i <= GridExtent[1]) && (GridExtent[2] <= j) &&
292 (j <= GridExtent[3]))
293 {
294 status = true;
295 }
296 break;
298 if ((GridExtent[2] <= j) && (j <= GridExtent[3]) && (GridExtent[4] <= k) &&
299 (k <= GridExtent[5]))
300 {
301 status = true;
302 }
303 break;
305 if ((GridExtent[0] <= i) && (i <= GridExtent[1]) && (GridExtent[4] <= k) &&
306 (k <= GridExtent[5]))
307 {
308 status = true;
309 }
310 break;
312 if ((GridExtent[0] <= i) && (i <= GridExtent[1]) && (GridExtent[2] <= j) &&
313 (j <= GridExtent[3]) && (GridExtent[4] <= k) && (k <= GridExtent[5]))
314 {
315 status = true;
316 }
317 break;
318 default:
319 std::cout << "Data description is: " << this->DataDescription << "\n";
320 std::cout.flush();
321 assert("pre: Undefined data-description!" && false);
322 } // END switch
323
324 return (status);
325 }
326
331 int i, int j, int i2jOrientation[3], int j2iOrientation[3], int overlapExtent[6]);
332
341 void DetermineNeighborOrientation(int idx, int A[2], int B[2], int overlap[2], int orient[3]);
342
348 void DetectNeighbors(int i, int j, int ex1[6], int ex2[6], int orientation[3], int ndim);
349
359 int IntervalOverlap(int A[2], int B[2], int overlap[2]);
360
370 int DoPartialOverlap(int s[2], int S[2], int overlap[2]);
371
381 int PartialOverlap(int A[2], int CardinalityOfA, int B[2], int CardinalityOfB, int overlap[2]);
382
387 void EstablishNeighbors(int i, int j);
388
395
410 bool HasBlockConnection(int gridID, int blockDirection);
411
426 void RemoveBlockConnection(int gridID, int blockDirection);
427
442 void AddBlockConnection(int gridID, int blockDirection);
443
448 void ClearBlockConnections(int gridID);
449
457 int GetNumberOfConnectingBlockFaces(int gridID);
458
462 void SetBlockTopology(int gridID);
463
470 void GetIJKBlockOrientation(int i, int j, int k, int ext[6], int orientation[3]);
471
476 int Get1DOrientation(int idx, int ExtentLo, int ExtentHi, int OnLo, int OnHi, int NotOnBoundary);
477
482 void CreateGhostedExtent(int gridID, int N);
483
489 void GetGhostedExtent(int* ghostedExtent, int GridExtent[6], int minIdx, int maxIdx, int N);
490
495 void CreateGhostedMaskArrays(int gridID);
496
503 void InitializeGhostData(int gridID);
504
511
518
524
529 void ComputeNeighborSendAndRcvExtent(int gridID, int N);
530
536 virtual void TransferGhostDataFromNeighbors(int gridID);
537
541 void TransferLocalNeighborData(int gridID, const vtkStructuredNeighbor& Neighbor);
542
547 vtkPoints* source, vtkIdType sourceIdx, vtkPoints* target, vtkIdType targetIdx);
548
556 vtkFieldData* source, vtkIdType sourceIdx, vtkFieldData* target, vtkIdType targetIdx);
557
563 int GetNeighborIndex(int gridIdx, int NeighborGridIdx);
564
568 void PrintExtent(int extent[6]);
569
572 int WholeExtent[6];
573
574 std::vector<int> GridExtents;
575 std::vector<int> GhostedExtents;
576 std::vector<unsigned char> BlockTopology;
577 std::vector<std::vector<vtkStructuredNeighbor>> Neighbors;
578 std::map<std::pair<int, int>, int> NeighborPair2NeighborListIndex;
579
580private:
582 void operator=(const vtkStructuredGridConnectivity&) = delete;
583};
584
585//=============================================================================
586// INLINE METHODS
587//=============================================================================
588
589//------------------------------------------------------------------------------
590inline int vtkStructuredGridConnectivity::GetNeighborIndex(int gridIdx, int NeighborGridIdx)
591{
592 assert("pre: Grid index is out-of-bounds!" && (gridIdx >= 0) &&
593 (gridIdx < static_cast<int>(this->NumberOfGrids)));
594 assert("pre: Neighbor grid index is out-of-bounds!" && (NeighborGridIdx >= 0) &&
595 (NeighborGridIdx < static_cast<int>(this->NumberOfGrids)));
596
597 std::pair<int, int> gridPair = std::make_pair(gridIdx, NeighborGridIdx);
598 assert("pre: Neighboring grid pair does not exist in hash!" &&
599 (this->NeighborPair2NeighborListIndex.find(gridPair) !=
600 this->NeighborPair2NeighborListIndex.end()));
601
602 return (this->NeighborPair2NeighborListIndex[gridPair]);
603}
604
605//------------------------------------------------------------------------------
607 int* ghostedExtent, int GridExtent[6], int minIdx, int maxIdx, int N)
608{
609 assert("pre: Number of ghost layers must be N >= 1" && (N >= 1));
610 assert("pre: ghosted extent pointer is nullptr" && ghostedExtent != nullptr);
611
612 ghostedExtent[minIdx] = GridExtent[minIdx] - N;
613 ghostedExtent[maxIdx] = GridExtent[maxIdx] + N;
614
615 // Clamp the ghosted extent to be within the WholeExtent
616 ghostedExtent[minIdx] = (ghostedExtent[minIdx] < this->WholeExtent[minIdx])
617 ? this->WholeExtent[minIdx]
618 : ghostedExtent[minIdx];
619 ghostedExtent[maxIdx] = (ghostedExtent[maxIdx] > this->WholeExtent[maxIdx])
620 ? this->WholeExtent[maxIdx]
621 : ghostedExtent[maxIdx];
622}
623
624//------------------------------------------------------------------------------
626{
627 assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
628 (gridID < static_cast<int>(this->NumberOfGrids)));
629 assert("pre: ghosted-extents vector has not been allocated" &&
630 (this->NumberOfGrids == this->GhostedExtents.size() / 6));
631
632 for (int i = 0; i < 6; ++i)
633 {
634 this->GhostedExtents[gridID * 6 + i] = ext[i];
635 }
636}
637
638//------------------------------------------------------------------------------
639inline void vtkStructuredGridConnectivity::GetGridExtent(int gridID, int ext[6])
640{
641 assert("pre: gridID out-of-bounds!" &&
642 (gridID >= 0 && gridID < static_cast<int>(this->NumberOfGrids)));
643 for (int i = 0; i < 6; ++i)
644 {
645 ext[i] = this->GridExtents[gridID * 6 + i];
646 }
647}
648
649//------------------------------------------------------------------------------
651{
652 assert("pre: gridID out-of-bounds!" &&
653 (gridID >= 0 && gridID < static_cast<int>(this->NumberOfGrids)));
654
655 if (this->GhostedExtents.empty())
656 {
657 ext[0] = ext[2] = ext[4] = -1;
658 ext[1] = ext[3] = ext[5] = 0;
659 vtkErrorMacro("No ghosted extents found for registered grid extends!!!");
660 return;
661 }
662
663 assert("GhostedExtents are not aligned with registered grid extents" &&
664 (this->GhostedExtents.size() == this->GridExtents.size()));
665 for (int i = 0; i < 6; ++i)
666 {
667 ext[i] = this->GhostedExtents[gridID * 6 + i];
668 }
669}
670
671//------------------------------------------------------------------------------
672inline bool vtkStructuredGridConnectivity::IsNodeOnBoundaryOfExtent(int i, int j, int k, int ext[6])
673{
674 if (!this->IsNodeWithinExtent(i, j, k, ext))
675 {
676 return false;
677 }
678
679 bool status = false;
680 switch (this->DataDescription)
681 {
683 if (i == ext[0] || i == ext[1])
684 {
685 status = true;
686 }
687 break;
689 if (j == ext[2] || j == ext[3])
690 {
691 status = true;
692 }
693 break;
695 if (k == ext[4] || k == ext[5])
696 {
697 status = true;
698 }
699 break;
701 if ((i == ext[0] || i == ext[1]) || (j == ext[2] || j == ext[3]))
702 {
703 status = true;
704 }
705 break;
707 if ((j == ext[2] || j == ext[3]) || (k == ext[4] || k == ext[5]))
708 {
709 status = true;
710 }
711 break;
713 if ((i == ext[0] || i == ext[1]) || (k == ext[4] || k == ext[5]))
714 {
715 status = true;
716 }
717 break;
719 if ((i == ext[0] || i == ext[1]) || (j == ext[2] || j == ext[3]) ||
720 (k == ext[4] || k == ext[5]))
721 {
722 status = true;
723 }
724 break;
725 default:
726 std::cout << "Data description is: " << this->DataDescription << "\n";
727 std::cout.flush();
728 assert("pre: Undefined data-description!" && false);
729 } // END switch
730
731 return (status);
732}
733
734//------------------------------------------------------------------------------
735inline bool vtkStructuredGridConnectivity::IsNodeInterior(int i, int j, int k, int GridExtent[6])
736{
737 bool status = false;
738
739 switch (this->DataDescription)
740 {
742 if ((GridExtent[0] < i) && (i < GridExtent[1]))
743 {
744 status = true;
745 }
746 break;
748 if ((GridExtent[2] < j) && (j < GridExtent[3]))
749 {
750 status = true;
751 }
752 break;
754 if ((GridExtent[4] < k) && (k < GridExtent[5]))
755 {
756 status = true;
757 }
758 break;
760 if ((GridExtent[0] < i) && (i < GridExtent[1]) && (GridExtent[2] < j) && (j < GridExtent[3]))
761 {
762 status = true;
763 }
764 break;
766 if ((GridExtent[2] < j) && (j < GridExtent[3]) && (GridExtent[4] < k) && (k < GridExtent[5]))
767 {
768 status = true;
769 }
770 break;
772 if ((GridExtent[0] < i) && (i < GridExtent[1]) && (GridExtent[4] < k) && (k < GridExtent[5]))
773 {
774 status = true;
775 }
776 break;
778 if ((GridExtent[0] < i) && (i < GridExtent[1]) && (GridExtent[2] < j) &&
779 (j < GridExtent[3]) && (GridExtent[4] < k) && (k < GridExtent[5]))
780 {
781 status = true;
782 }
783 break;
784 default:
785 std::cout << "Data description is: " << this->DataDescription << "\n";
786 std::cout.flush();
787 assert("pre: Undefined data-description!" && false);
788 } // END switch
789
790 return (status);
791}
792
793//------------------------------------------------------------------------------
795 int idx, int A[2], int B[2], int overlap[2], int orient[3])
796{
797 assert("pre: idx is out-of-bounds" && (idx >= 0) && (idx < 3));
798
799 // A. Non-overlapping cases
800 if (overlap[0] == overlap[1])
801 {
802 if (A[1] == B[0])
803 {
804 orient[idx] = vtkStructuredNeighbor::HI;
805 }
806 else if (A[0] == B[1])
807 {
808 orient[idx] = vtkStructuredNeighbor::LO;
809 }
810 else
811 {
813 assert("ERROR: Code should not reach here!" && false);
814 }
815 } // END non-overlapping cases
816 // B. Sub-set cases
817 else if (this->IsSubset(A, B))
818 {
819 if ((A[0] == B[0]) && (A[1] == B[1]))
820 {
822 }
823 else if (this->StrictlyInsideBounds(A[0], B[0], B[1]) &&
824 this->StrictlyInsideBounds(A[1], B[0], B[1]))
825 {
827 }
828 else if (A[0] == B[0])
829 {
831 }
832 else if (A[1] == B[1])
833 {
835 }
836 else
837 {
839 assert("ERROR: Code should not reach here!" && false);
840 }
841 }
842 // C. Super-set cases
843 else if (this->IsSubset(B, A))
844 {
846 }
847 // D. Partially-overlapping (non-subset) cases
848 else if (!(this->IsSubset(A, B) || this->IsSubset(A, B)))
849 {
850 if (this->InBounds(A[0], B[0], B[1]))
851 {
852 orient[idx] = vtkStructuredNeighbor::LO;
853 }
854 else if (this->InBounds(A[1], B[0], B[1]))
855 {
856 orient[idx] = vtkStructuredNeighbor::HI;
857 }
858 else
859 {
861 assert("ERROR: Code should not reach here!" && false);
862 }
863 }
864 else
865 {
867 assert("ERROR: Code should not reach here!" && false);
868 }
869}
870
871//------------------------------------------------------------------------------
873 int idx, int ExtentLo, int ExtentHi, int OnLo, int OnHi, int NotOnBoundary)
874{
875 if (idx == ExtentLo)
876 {
877 return OnLo;
878 }
879 else if (idx == ExtentHi)
880 {
881 return OnHi;
882 }
883 return NotOnBoundary;
884}
885
886//------------------------------------------------------------------------------
887inline bool vtkStructuredGridConnectivity::HasBlockConnection(int gridID, int blockDirection)
888{
889 // Sanity check
890 assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
891 (gridID < static_cast<int>(this->NumberOfGrids)));
892 assert("pre: BlockTopology has not been properly allocated" &&
893 (this->NumberOfGrids == this->BlockTopology.size()));
894 assert("pre: blockDirection is out-of-bounds" && (blockDirection >= 0) && (blockDirection < 6));
895 bool status = false;
896 if (this->BlockTopology[gridID] & (1 << blockDirection))
897 {
898 status = true;
899 }
900 return (status);
901}
902
903//------------------------------------------------------------------------------
904inline void vtkStructuredGridConnectivity::RemoveBlockConnection(int gridID, int blockDirection)
905{
906 // Sanity check
907 assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
908 (gridID < static_cast<int>(this->NumberOfGrids)));
909 assert("pre: BlockTopology has not been properly allocated" &&
910 (this->NumberOfGrids == this->BlockTopology.size()));
911 assert("pre: blockDirection is out-of-bounds" && (blockDirection >= 0) && (blockDirection < 6));
912
913 this->BlockTopology[gridID] &= ~(1 << blockDirection);
914}
915
916//------------------------------------------------------------------------------
917inline void vtkStructuredGridConnectivity::AddBlockConnection(int gridID, int blockDirection)
918{
919 // Sanity check
920 assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
921 (gridID < static_cast<int>(this->NumberOfGrids)));
922 assert("pre: BlockTopology has not been properly allocated" &&
923 (this->NumberOfGrids == this->BlockTopology.size()));
924 assert("pre: blockDirection is out-of-bounds" && (blockDirection >= 0) && (blockDirection < 6));
925 this->BlockTopology[gridID] |= (1 << blockDirection);
926}
927
928//------------------------------------------------------------------------------
930{
931 // Sanity check
932 assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
933 (gridID < static_cast<int>(this->NumberOfGrids)));
934 assert("pre: BlockTopology has not been properly allocated" &&
935 (this->NumberOfGrids == this->BlockTopology.size()));
936 for (int i = 0; i < 6; ++i)
937 {
938 this->RemoveBlockConnection(gridID, i);
939 } // END for all block directions
940}
941
942//------------------------------------------------------------------------------
944{
945 // Sanity check
946 assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
947 (gridID < static_cast<int>(this->NumberOfGrids)));
948 assert("pre: BlockTopology has not been properly allocated" &&
949 (this->NumberOfGrids == this->BlockTopology.size()));
950
951 int count = 0;
952 for (int i = 0; i < 6; ++i)
953 {
954 if (this->HasBlockConnection(gridID, i))
955 {
956 ++count;
957 }
958 }
959 assert("post: count must be in [0,5]" && (count >= 0 && count <= 6));
960 return (count);
961}
962
963//------------------------------------------------------------------------------
965{
966 if (N == 0)
967 {
968 vtkErrorMacro("Number of grids cannot be 0.");
969 return;
970 }
971
972 this->NumberOfGrids = N;
974
975 this->GridExtents.resize(6 * N, -1);
976 this->Neighbors.resize(N);
977 this->BlockTopology.resize(N);
978}
979VTK_ABI_NAMESPACE_END
980#endif /* vtkStructuredGridConnectivity_h */
A superclass that defines the interface to be implemented by all concrete grid connectivity classes.
void AllocateUserRegisterDataStructures()
Allocate/De-allocate the data-structures where the user-supplied grids will be registered.
virtual void SetNumberOfGrids(unsigned int N)=0
Sets the total number of grids in the domain.
represent and manipulate cell attribute data
Represents and manipulates a collection of data arrays.
list of point or cell ids
Definition vtkIdList.h:133
a simple class to control print indentation
Definition vtkIndent.h:108
represent and manipulate point attribute data
represent and manipulate 3D points
Definition vtkPoints.h:139
vtkStructuredGridConnectivity is a concrete instance of vtkObject that implements functionality for c...
void SetBlockTopology(int gridID)
Sets the block topology connections for the grid corresponding to gridID.
void SetNeighbors(int i, int j, int i2jOrientation[3], int j2iOrientation[3], int overlapExtent[6])
Creates a neighbor from i-to-j and from j-to-i.
void SearchNeighbors(int gridID, int i, int j, int k, vtkIdList *neiList)
Given a point (i,j,k) belonging to the grid corresponding to the given gridID, this method searches f...
int GetNumberOfConnectingBlockFaces(int gridID)
Returns the number of faces of the block corresponding to the given grid ID that are adjacent to at l...
int GetNeighborIndex(int gridIdx, int NeighborGridIdx)
Given a global grid ID and the neighbor grid ID, this method returns the neighbor index w....
bool IsSubset(int A[2], int B[2])
Returns true iff A is a subset of B, otherwise false.
void FillNodesGhostArray(int gridID, int dataDescription, int GridExtent[6], int RealExtent[6], vtkUnsignedCharArray *nodesArray)
Fills the ghost array for the nodes.
~vtkStructuredGridConnectivity() override
void ComputeNeighborSendAndRcvExtent(int gridID, int N)
This method computes, the send and rcv extents for each neighbor of each grid.
void CreateGhostedMaskArrays(int gridID)
This method creates the ghosted mask arrays, i.e., the NodeGhostArrays and the CellGhostArrays for th...
bool IsGhostNode(int GridExtent[6], int RealExtent[6], int i, int j, int k)
Checks if the node corresponding to the given global i,j,k coordinates is a ghost node or not.
void TransferLocalNeighborData(int gridID, const vtkStructuredNeighbor &Neighbor)
This method transfers the fields.
void CreateGhostLayers(int N=1) override
Creates ghost layers.
void CopyFieldData(vtkFieldData *source, vtkIdType sourceIdx, vtkFieldData *target, vtkIdType targetIdx)
Loops through all arrays in the source and for each array, it copies the tuples from sourceIdx to the...
void DetermineNeighborOrientation(int idx, int A[2], int B[2], int overlap[2], int orient[3])
Given two overlapping extents A,B and the corresponding overlap extent this method computes A's relat...
void EstablishNeighbors(int i, int j)
Establishes the neighboring information between the two grids corresponding to grid ids "i" and "j" w...
void ClearBlockConnections(int gridID)
Clears all block connections for the block corresponding to the given grid ID.
bool IsNodeOnSharedBoundary(int gridID, int RealExtent[6], int i, int j, int k)
Checks if the node corresponding to the given global i,j,k coordinates is on the shared boundary,...
void PrintExtent(int extent[6])
Prints the extent, used for debugging.
bool IsNodeOnBoundary(int i, int j, int k)
Checks if the node corresponding to the given global i,j,k coordinates touches the real boundaries of...
void AddBlockConnection(int gridID, int blockDirection)
Adds a block connection along the given direction for the block corresponding to the given gridID.
void FillGhostArrays(int gridID, vtkUnsignedCharArray *nodesArray, vtkUnsignedCharArray *cellsArray) override
Fills the mesh property arrays, nodes and cells, for the grid corresponding to the given grid ID.
void InitializeGhostData(int gridID)
This method initializes the ghost data according to the computed ghosted grid extent for the grid wit...
vtkIdList * GetNeighbors(int gridID, int *extents)
Returns the list of neighboring blocks for the given grid and the corresponding overlapping extents a...
int Cardinality(int S[2])
Returns the cardinality of a range S.
void DetectNeighbors(int i, int j, int ex1[6], int ex2[6], int orientation[3], int ndim)
Detects if the two extents, ex1 and ex2, corresponding to the grids with grid IDs i,...
bool IsNodeWithinExtent(int i, int j, int k, int GridExtent[6])
Checks if the node corresponding to the given global i,j,k coordinates is within the given extent,...
bool IsNodeOnBoundaryOfExtent(int i, int j, int k, int ext[6])
Checks if the node corresponding to the given global i,j,k coordinates is on the boundary of the give...
void ComputeNeighbors() override
Computes neighboring information.
bool InBounds(int idx, int Lo, int Hi)
Returns true iff Lo <= idx <= Hi, otherwise false.
void MarkCellProperty(unsigned char &pfield, unsigned char *nodeGhostFields, int numNodes)
Marks the cell property for the cell composed by the nodes with the given ghost fields.
std::vector< unsigned char > BlockTopology
void GetGhostedGridExtent(int gridID, int ext[6])
Returns the ghosted grid extent for the block corresponding the.
void GetRealExtent(int gridID, int GridExtent[6], int RealExtent[6])
Given a grid extent, this method computes the RealExtent.
vtkStructuredNeighbor GetGridNeighbor(int gridID, int nei)
Returns the neighbor corresponding to the index nei for the grid with the given (global) grid ID.
void SetNumberOfGrids(unsigned int N) override
Set/Get the total number of domains distributed among processors.
void RemoveBlockConnection(int gridID, int blockDirection)
Removes a block connection along the given direction for the block corresponding to the given gridID.
int GetNumberOfNodesPerCell(int dim)
Returns the number of nodes per cell according to the given dimension.
void GetIJKBlockOrientation(int i, int j, int k, int ext[6], int orientation[3])
Given i-j-k coordinates and the grid defined by tis extent, ext, this method determines IJK orientati...
void CopyCoordinates(vtkPoints *source, vtkIdType sourceIdx, vtkPoints *target, vtkIdType targetIdx)
Copies the coordinates from the source points to the target points.
void MarkNodeProperty(int gridID, int i, int j, int k, int ext[6], int RealExtent[6], unsigned char &pfield)
Marks the node properties with the node with the given global i,j,k grid coordinates w....
bool HasBlockConnection(int gridID, int blockDirection)
Checks if the block corresponding to the given grid ID has a block adjacent to it in the given block ...
void CreateGhostedExtent(int gridID, int N)
Creates the ghosted extent of the grid corresponding to the given gridID.
void GetGridExtent(int gridID, int extent[6])
Returns the grid extent of the grid corresponding to the given grid ID.
virtual void RegisterGrid(int gridID, int extents[6], vtkUnsignedCharArray *nodesGhostArray, vtkUnsignedCharArray *cellGhostArray, vtkPointData *pointData, vtkCellData *cellData, vtkPoints *gridNodes)
Registers the current grid corresponding to the grid ID by its global extent w.r.t.
int Get1DOrientation(int idx, int ExtentLo, int ExtentHi, int OnLo, int OnHi, int NotOnBoundary)
A helper method that computes the 1-D i-j-k orientation to facilitate the implementation of GetNodeBl...
void FillCellsGhostArray(int dataDescription, int numNodesPerCell, int dims[3], int CellExtent[6], vtkUnsignedCharArray *nodesArray, vtkUnsignedCharArray *cellsArray)
Fills the ghost array for the grid cells.
bool IsNodeInterior(int i, int j, int k, int GridExtent[6])
Checks if the node, corresponding to the given global i,j,k coordinates is within the interior of the...
std::map< std::pair< int, int >, int > NeighborPair2NeighborListIndex
int GetNumberOfNeighbors(int gridID)
Returns the number of neighbors for the grid corresponding to the given grid ID.
bool StrictlyInsideBounds(int idx, int Lo, int Hi)
Returns true iff Lo < idx < Hi, otherwise false.
void AllocatePointData(vtkPointData *RPD, int N, vtkPointData *PD)
Adds/creates all the arrays in the reference grid point data, RPD, to the user-supplied point data in...
void TransferRegisteredDataToGhostedData(int gridID)
This method transfers the registered grid data to the corresponding ghosted grid data.
int DoPartialOverlap(int s[2], int S[2], int overlap[2])
Checks if the internals s,S partially overlap where |s| < |S|.
void SetGhostedGridExtent(int gridID, int ext[6])
Sets the ghosted grid extent for the grid corresponding to the given grid ID to the given extent.
void AllocateCellData(vtkCellData *RCD, int N, vtkCellData *CD)
Adds/creates all the arrays in the reference grid cell data, RCD, to the user-supplied cell data inst...
void GetGhostedExtent(int *ghostedExtent, int GridExtent[6], int minIdx, int maxIdx, int N)
Gets the ghosted extent from the given grid extent along the dimension given by minIdx and maxIdx.
std::vector< std::vector< vtkStructuredNeighbor > > Neighbors
static vtkStructuredGridConnectivity * New()
int IntervalOverlap(int A[2], int B[2], int overlap[2])
Checks if the intervals A,B overlap.
int PartialOverlap(int A[2], int CardinalityOfA, int B[2], int CardinalityOfB, int overlap[2])
Checks if the intervals A,B partially overlap.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
virtual void TransferGhostDataFromNeighbors(int gridID)
This method transfers the fields (point data and cell data) to the ghost extents from the neighboring...
void AcquireDataDescription()
Based on the user-supplied WholeExtent, this method determines the topology of the structured domain,...
An internal, light-weight class used to store neighbor information.
dynamic, self-adjusting array of unsigned char
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
boost::graph_traits< vtkGraph * >::vertex_descriptor target(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
int vtkIdType
Definition vtkType.h:332