VTK  9.0.20210418
vtkStructuredGridConnectivity.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkStructuredGridConnectivity.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  =========================================================================*/
29 #ifndef vtkStructuredGridConnectivity_h
30 #define vtkStructuredGridConnectivity_h
31 
32 #define VTK_NO_OVERLAP 0
33 #define VTK_NODE_OVERLAP 1
34 #define VTK_EDGE_OVERLAP 2
35 #define VTK_PARTIAL_OVERLAP 3
36 
37 // VTK include directives
39 #include "vtkFiltersGeometryModule.h" // For export macro
40 #include "vtkStructuredData.h" // For data description definitions
41 #include "vtkStructuredNeighbor.h" // For Structured Neighbor object definition
42 
43 // C++ include directives
44 #include <cassert> // For assert()
45 #include <iostream> // For cout
46 #include <map> // For STL map
47 #include <utility> // For STL pair and overloaded relational operators
48 #include <vector> // For STL vector
49 
50 // Forward Declarations
51 class vtkIdList;
53 class vtkPointData;
54 class vtkCellData;
55 class vtkPoints;
56 
57 class VTKFILTERSGEOMETRY_EXPORT vtkStructuredGridConnectivity : public vtkAbstractGridConnectivity
58 {
59 public:
62  void PrintSelf(ostream& os, vtkIndent indent) override;
63 
65 
68  vtkSetVector6Macro(WholeExtent, int);
69  vtkGetVector6Macro(WholeExtent, int);
71 
73 
76  vtkGetMacro(DataDimension, int);
78 
82  void SetNumberOfGrids(const unsigned int N) override;
83 
88  virtual void RegisterGrid(const int gridID, int extents[6], vtkUnsignedCharArray* nodesGhostArray,
89  vtkUnsignedCharArray* cellGhostArray, vtkPointData* pointData, vtkCellData* cellData,
90  vtkPoints* gridNodes);
91 
95  void GetGridExtent(const int gridID, int extent[6]);
96 
101  void SetGhostedGridExtent(const int gridID, int ext[6]);
102 
106  void GetGhostedGridExtent(const int gridID, int ext[6]);
107 
111  void ComputeNeighbors() override;
112 
117  int GetNumberOfNeighbors(const int gridID)
118  {
119  return (static_cast<int>(this->Neighbors[gridID].size()));
120  }
121 
126  vtkStructuredNeighbor GetGridNeighbor(const int gridID, const int nei);
127 
135  vtkIdList* GetNeighbors(const int gridID, int* extents);
136 
143  const int gridID, vtkUnsignedCharArray* nodesArray, vtkUnsignedCharArray* cellsArray) override;
144 
148  void CreateGhostLayers(const int N = 1) override;
149 
150 protected:
153 
157  bool InBounds(const int idx, const int Lo, const int Hi) { return ((idx >= Lo) && (idx <= Hi)); }
158 
162  bool StrictlyInsideBounds(const int idx, const int Lo, const int Hi)
163  {
164  return ((idx > Lo) && (idx < Hi));
165  }
166 
170  bool IsSubset(int A[2], int B[2])
171  {
172  return (this->InBounds(A[0], B[0], B[1]) && this->InBounds(A[1], B[0], B[1]));
173  }
174 
178  int Cardinality(int S[2]) { return (S[1] - S[0] + 1); }
179 
181 
184  int GetNumberOfNodesPerCell(const int dim)
185  {
186  int numNodes = 0;
187  switch (dim)
188  {
189  case 1:
190  numNodes = 2; // line cell
191  break;
192  case 2:
193  numNodes = 4; // quad cell
194  break;
195  case 3:
196  numNodes = 8; // hex cell
197  break;
198  default:
199  assert("ERROR: code should not reach here!" && false);
200  } // END switch
201  return (numNodes);
202  }
204 
208  void FillNodesGhostArray(const int gridID, const int dataDescription, int GridExtent[6],
209  int RealExtent[6], vtkUnsignedCharArray* nodesArray);
210 
214  void FillCellsGhostArray(const int dataDescription, const int numNodesPerCell, int dims[3],
215  int CellExtent[6], vtkUnsignedCharArray* nodesArray, vtkUnsignedCharArray* cellsArray);
216 
222  void SearchNeighbors(const int gridID, const int i, const int j, const int k, vtkIdList* neiList);
223 
228  void MarkNodeProperty(const int gridID, const int i, const int j, const int k, int ext[6],
229  int RealExtent[6], unsigned char& pfield);
230 
235  void MarkCellProperty(unsigned char& pfield, unsigned char* nodeGhostFields, const int numNodes);
236 
240  void GetRealExtent(const int gridID, int GridExtent[6], int RealExtent[6]);
241 
246  bool IsGhostNode(int GridExtent[6], int RealExtent[6], const int i, const int j, const int k);
247 
252  bool IsNodeOnBoundaryOfExtent(const int i, const int j, const int k, int ext[6]);
253 
260  const int gridID, int RealExtent[6], const int i, const int j, const int k);
261 
266  bool IsNodeOnBoundary(const int i, const int j, const int k);
267 
272  bool IsNodeInterior(const int i, const int j, const int k, int GridExtent[6]);
273 
278  bool IsNodeWithinExtent(const int i, const int j, const int k, int GridExtent[6])
279  {
280  bool status = false;
281 
282  switch (this->DataDescription)
283  {
284  case VTK_X_LINE:
285  if ((GridExtent[0] <= i) && (i <= GridExtent[1]))
286  {
287  status = true;
288  }
289  break;
290  case VTK_Y_LINE:
291  if ((GridExtent[2] <= j) && (j <= GridExtent[3]))
292  {
293  status = true;
294  }
295  break;
296  case VTK_Z_LINE:
297  if ((GridExtent[4] <= k) && (k <= GridExtent[5]))
298  {
299  status = true;
300  }
301  break;
302  case VTK_XY_PLANE:
303  if ((GridExtent[0] <= i) && (i <= GridExtent[1]) && (GridExtent[2] <= j) &&
304  (j <= GridExtent[3]))
305  {
306  status = true;
307  }
308  break;
309  case VTK_YZ_PLANE:
310  if ((GridExtent[2] <= j) && (j <= GridExtent[3]) && (GridExtent[4] <= k) &&
311  (k <= GridExtent[5]))
312  {
313  status = true;
314  }
315  break;
316  case VTK_XZ_PLANE:
317  if ((GridExtent[0] <= i) && (i <= GridExtent[1]) && (GridExtent[4] <= k) &&
318  (k <= GridExtent[5]))
319  {
320  status = true;
321  }
322  break;
323  case VTK_XYZ_GRID:
324  if ((GridExtent[0] <= i) && (i <= GridExtent[1]) && (GridExtent[2] <= j) &&
325  (j <= GridExtent[3]) && (GridExtent[4] <= k) && (k <= GridExtent[5]))
326  {
327  status = true;
328  }
329  break;
330  default:
331  std::cout << "Data description is: " << this->DataDescription << "\n";
332  std::cout.flush();
333  assert("pre: Undefined data-description!" && false);
334  } // END switch
335 
336  return (status);
337  }
338 
343  const int i, const int j, int i2jOrientation[3], int j2iOrientation[3], int overlapExtent[6]);
344 
353  void DetermineNeighborOrientation(
354  const int idx, int A[2], int B[2], int overlap[2], int orient[3]);
355 
362  const int i, const int j, int ex1[6], int ex2[6], int orientation[3], int ndim);
363 
373  int IntervalOverlap(int A[2], int B[2], int overlap[2]);
374 
384  int DoPartialOverlap(int s[2], int S[2], int overlap[2]);
385 
396  int A[2], const int CardinalityOfA, int B[2], const int CardinalityOfB, int overlap[2]);
397 
402  void EstablishNeighbors(const int i, const int j);
403 
409 
424  bool HasBlockConnection(const int gridID, const int blockDirection);
425 
440  void RemoveBlockConnection(const int gridID, const int blockDirection);
441 
456  void AddBlockConnection(const int gridID, const int blockDirection);
457 
462  void ClearBlockConnections(const int gridID);
463 
471  int GetNumberOfConnectingBlockFaces(const int gridID);
472 
476  void SetBlockTopology(const int gridID);
477 
485  const int i, const int j, const int k, int ext[6], int orientation[3]);
486 
491  int Get1DOrientation(const int idx, const int ExtentLo, const int ExtentHi, const int OnLo,
492  const int OnHi, const int NotOnBoundary);
493 
498  void CreateGhostedExtent(const int gridID, const int N);
499 
505  void GetGhostedExtent(
506  int* ghostedExtent, int GridExtent[6], const int minIdx, const int maxIdx, const int N);
507 
512  void CreateGhostedMaskArrays(const int gridID);
513 
520  void InitializeGhostData(const int gridID);
521 
527  void AllocatePointData(vtkPointData* RPD, const int N, vtkPointData* PD);
528 
534  void AllocateCellData(vtkCellData* RCD, const int N, vtkCellData* CD);
535 
540  void TransferRegisteredDataToGhostedData(const int gridID);
541 
546  void ComputeNeighborSendAndRcvExtent(const int gridID, const int N);
547 
553  virtual void TransferGhostDataFromNeighbors(const int gridID);
554 
558  void TransferLocalNeighborData(const int gridID, const vtkStructuredNeighbor& Neighbor);
559 
564  vtkPoints* source, vtkIdType sourceIdx, vtkPoints* target, vtkIdType targetIdx);
565 
573  vtkFieldData* source, vtkIdType sourceIdx, vtkFieldData* target, vtkIdType targetIdx);
574 
580  int GetNeighborIndex(const int gridIdx, const int NeighborGridIdx);
581 
585  void PrintExtent(int extent[6]);
586 
589  int WholeExtent[6];
590 
591  std::vector<int> GridExtents;
592  std::vector<int> GhostedExtents;
593  std::vector<unsigned char> BlockTopology;
594  std::vector<std::vector<vtkStructuredNeighbor>> Neighbors;
595  std::map<std::pair<int, int>, int> NeighborPair2NeighborListIndex;
596 
597 private:
599  void operator=(const vtkStructuredGridConnectivity&) = delete;
600 };
601 
602 //=============================================================================
603 // INLINE METHODS
604 //=============================================================================
605 
606 //------------------------------------------------------------------------------
608  const int gridIdx, const int NeighborGridIdx)
609 {
610  assert("pre: Grid index is out-of-bounds!" && (gridIdx >= 0) &&
611  (gridIdx < static_cast<int>(this->NumberOfGrids)));
612  assert("pre: Neighbor grid index is out-of-bounds!" && (NeighborGridIdx >= 0) &&
613  (NeighborGridIdx < static_cast<int>(this->NumberOfGrids)));
614 
615  std::pair<int, int> gridPair = std::make_pair(gridIdx, NeighborGridIdx);
616  assert("pre: Neighboring grid pair does not exist in hash!" &&
617  (this->NeighborPair2NeighborListIndex.find(gridPair) !=
618  this->NeighborPair2NeighborListIndex.end()));
619 
620  return (this->NeighborPair2NeighborListIndex[gridPair]);
621 }
622 
623 //------------------------------------------------------------------------------
625  int* ghostedExtent, int GridExtent[6], const int minIdx, const int maxIdx, const int N)
626 {
627  assert("pre: Number of ghost layers must be N >= 1" && (N >= 1));
628  assert("pre: ghosted extent pointer is nullptr" && ghostedExtent != nullptr);
629 
630  ghostedExtent[minIdx] = GridExtent[minIdx] - N;
631  ghostedExtent[maxIdx] = GridExtent[maxIdx] + N;
632 
633  // Clamp the ghosted extent to be within the WholeExtent
634  ghostedExtent[minIdx] = (ghostedExtent[minIdx] < this->WholeExtent[minIdx])
635  ? this->WholeExtent[minIdx]
636  : ghostedExtent[minIdx];
637  ghostedExtent[maxIdx] = (ghostedExtent[maxIdx] > this->WholeExtent[maxIdx])
638  ? this->WholeExtent[maxIdx]
639  : ghostedExtent[maxIdx];
640 }
641 
642 //------------------------------------------------------------------------------
643 inline void vtkStructuredGridConnectivity::SetGhostedGridExtent(const int gridID, int ext[6])
644 {
645  assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
646  (gridID < static_cast<int>(this->NumberOfGrids)));
647  assert("pre: ghosted-extents vector has not been allocated" &&
648  (this->NumberOfGrids == this->GhostedExtents.size() / 6));
649 
650  for (int i = 0; i < 6; ++i)
651  {
652  this->GhostedExtents[gridID * 6 + i] = ext[i];
653  }
654 }
655 
656 //------------------------------------------------------------------------------
657 inline void vtkStructuredGridConnectivity::GetGridExtent(const int gridID, int ext[6])
658 {
659  assert("pre: gridID out-of-bounds!" &&
660  (gridID >= 0 && gridID < static_cast<int>(this->NumberOfGrids)));
661  for (int i = 0; i < 6; ++i)
662  {
663  ext[i] = this->GridExtents[gridID * 6 + i];
664  }
665 }
666 
667 //------------------------------------------------------------------------------
668 inline void vtkStructuredGridConnectivity::GetGhostedGridExtent(const int gridID, int ext[6])
669 {
670  assert("pre: gridID out-of-bounds!" &&
671  (gridID >= 0 && gridID < static_cast<int>(this->NumberOfGrids)));
672 
673  if (this->GhostedExtents.empty())
674  {
675  ext[0] = ext[2] = ext[4] = -1;
676  ext[1] = ext[3] = ext[5] = 0;
677  vtkErrorMacro("No ghosted extents found for registered grid extends!!!");
678  return;
679  }
680 
681  assert("GhostedExtents are not aligned with registered grid extents" &&
682  (this->GhostedExtents.size() == this->GridExtents.size()));
683  for (int i = 0; i < 6; ++i)
684  {
685  ext[i] = this->GhostedExtents[gridID * 6 + i];
686  }
687 }
688 
689 //------------------------------------------------------------------------------
691  const int i, const int j, const int k, int ext[6])
692 {
693  if (!this->IsNodeWithinExtent(i, j, k, ext))
694  {
695  return false;
696  }
697 
698  bool status = false;
699  switch (this->DataDescription)
700  {
701  case VTK_X_LINE:
702  if (i == ext[0] || i == ext[1])
703  {
704  status = true;
705  }
706  break;
707  case VTK_Y_LINE:
708  if (j == ext[2] || j == ext[3])
709  {
710  status = true;
711  }
712  break;
713  case VTK_Z_LINE:
714  if (k == ext[4] || k == ext[5])
715  {
716  status = true;
717  }
718  break;
719  case VTK_XY_PLANE:
720  if ((i == ext[0] || i == ext[1]) || (j == ext[2] || j == ext[3]))
721  {
722  status = true;
723  }
724  break;
725  case VTK_YZ_PLANE:
726  if ((j == ext[2] || j == ext[3]) || (k == ext[4] || k == ext[5]))
727  {
728  status = true;
729  }
730  break;
731  case VTK_XZ_PLANE:
732  if ((i == ext[0] || i == ext[1]) || (k == ext[4] || k == ext[5]))
733  {
734  status = true;
735  }
736  break;
737  case VTK_XYZ_GRID:
738  if ((i == ext[0] || i == ext[1]) || (j == ext[2] || j == ext[3]) ||
739  (k == ext[4] || k == ext[5]))
740  {
741  status = true;
742  }
743  break;
744  default:
745  std::cout << "Data description is: " << this->DataDescription << "\n";
746  std::cout.flush();
747  assert("pre: Undefined data-description!" && false);
748  } // END switch
749 
750  return (status);
751 }
752 
753 //------------------------------------------------------------------------------
755  const int i, const int j, const int k, int GridExtent[6])
756 {
757  bool status = false;
758 
759  switch (this->DataDescription)
760  {
761  case VTK_X_LINE:
762  if ((GridExtent[0] < i) && (i < GridExtent[1]))
763  {
764  status = true;
765  }
766  break;
767  case VTK_Y_LINE:
768  if ((GridExtent[2] < j) && (j < GridExtent[3]))
769  {
770  status = true;
771  }
772  break;
773  case VTK_Z_LINE:
774  if ((GridExtent[4] < k) && (k < GridExtent[5]))
775  {
776  status = true;
777  }
778  break;
779  case VTK_XY_PLANE:
780  if ((GridExtent[0] < i) && (i < GridExtent[1]) && (GridExtent[2] < j) && (j < GridExtent[3]))
781  {
782  status = true;
783  }
784  break;
785  case VTK_YZ_PLANE:
786  if ((GridExtent[2] < j) && (j < GridExtent[3]) && (GridExtent[4] < k) && (k < GridExtent[5]))
787  {
788  status = true;
789  }
790  break;
791  case VTK_XZ_PLANE:
792  if ((GridExtent[0] < i) && (i < GridExtent[1]) && (GridExtent[4] < k) && (k < GridExtent[5]))
793  {
794  status = true;
795  }
796  break;
797  case VTK_XYZ_GRID:
798  if ((GridExtent[0] < i) && (i < GridExtent[1]) && (GridExtent[2] < j) &&
799  (j < GridExtent[3]) && (GridExtent[4] < k) && (k < GridExtent[5]))
800  {
801  status = true;
802  }
803  break;
804  default:
805  std::cout << "Data description is: " << this->DataDescription << "\n";
806  std::cout.flush();
807  assert("pre: Undefined data-description!" && false);
808  } // END switch
809 
810  return (status);
811 }
812 
813 //------------------------------------------------------------------------------
815  const int idx, int A[2], int B[2], int overlap[2], int orient[3])
816 {
817  assert("pre: idx is out-of-bounds" && (idx >= 0) && (idx < 3));
818 
819  // A. Non-overlapping cases
820  if (overlap[0] == overlap[1])
821  {
822  if (A[1] == B[0])
823  {
824  orient[idx] = vtkStructuredNeighbor::HI;
825  }
826  else if (A[0] == B[1])
827  {
828  orient[idx] = vtkStructuredNeighbor::LO;
829  }
830  else
831  {
832  orient[idx] = vtkStructuredNeighbor::UNDEFINED;
833  assert("ERROR: Code should not reach here!" && false);
834  }
835  } // END non-overlapping cases
836  // B. Sub-set cases
837  else if (this->IsSubset(A, B))
838  {
839  if ((A[0] == B[0]) && (A[1] == B[1]))
840  {
841  orient[idx] = vtkStructuredNeighbor::ONE_TO_ONE;
842  }
843  else if (this->StrictlyInsideBounds(A[0], B[0], B[1]) &&
844  this->StrictlyInsideBounds(A[1], B[0], B[1]))
845  {
847  }
848  else if (A[0] == B[0])
849  {
850  orient[idx] = vtkStructuredNeighbor::SUBSET_HI;
851  }
852  else if (A[1] == B[1])
853  {
854  orient[idx] = vtkStructuredNeighbor::SUBSET_LO;
855  }
856  else
857  {
858  orient[idx] = vtkStructuredNeighbor::UNDEFINED;
859  assert("ERROR: Code should not reach here!" && false);
860  }
861  }
862  // C. Super-set cases
863  else if (this->IsSubset(B, A))
864  {
865  orient[idx] = vtkStructuredNeighbor::SUPERSET;
866  }
867  // D. Partially-overlapping (non-subset) cases
868  else if (!(this->IsSubset(A, B) || this->IsSubset(A, B)))
869  {
870  if (this->InBounds(A[0], B[0], B[1]))
871  {
872  orient[idx] = vtkStructuredNeighbor::LO;
873  }
874  else if (this->InBounds(A[1], B[0], B[1]))
875  {
876  orient[idx] = vtkStructuredNeighbor::HI;
877  }
878  else
879  {
880  orient[idx] = vtkStructuredNeighbor::UNDEFINED;
881  assert("ERROR: Code should not reach here!" && false);
882  }
883  }
884  else
885  {
886  orient[idx] = vtkStructuredNeighbor::UNDEFINED;
887  assert("ERROR: Code should not reach here!" && false);
888  }
889 }
890 
891 //------------------------------------------------------------------------------
892 inline int vtkStructuredGridConnectivity::Get1DOrientation(const int idx, const int ExtentLo,
893  const int ExtentHi, const int OnLo, const int OnHi, const int NotOnBoundary)
894 {
895  if (idx == ExtentLo)
896  {
897  return OnLo;
898  }
899  else if (idx == ExtentHi)
900  {
901  return OnHi;
902  }
903  return NotOnBoundary;
904 }
905 
906 //------------------------------------------------------------------------------
908  const int gridID, const int blockDirection)
909 {
910  // Sanity check
911  assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
912  (gridID < static_cast<int>(this->NumberOfGrids)));
913  assert("pre: BlockTopology has not been properly allocated" &&
914  (this->NumberOfGrids == this->BlockTopology.size()));
915  assert("pre: blockDirection is out-of-bounds" && (blockDirection >= 0) && (blockDirection < 6));
916  bool status = false;
917  if (this->BlockTopology[gridID] & (1 << blockDirection))
918  {
919  status = true;
920  }
921  return (status);
922 }
923 
924 //------------------------------------------------------------------------------
926  const int gridID, const int blockDirection)
927 {
928  // Sanity check
929  assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
930  (gridID < static_cast<int>(this->NumberOfGrids)));
931  assert("pre: BlockTopology has not been properly allocated" &&
932  (this->NumberOfGrids == this->BlockTopology.size()));
933  assert("pre: blockDirection is out-of-bounds" && (blockDirection >= 0) && (blockDirection < 6));
934 
935  this->BlockTopology[gridID] &= ~(1 << blockDirection);
936 }
937 
938 //------------------------------------------------------------------------------
940  const int gridID, const int blockDirection)
941 {
942  // Sanity check
943  assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
944  (gridID < static_cast<int>(this->NumberOfGrids)));
945  assert("pre: BlockTopology has not been properly allocated" &&
946  (this->NumberOfGrids == this->BlockTopology.size()));
947  assert("pre: blockDirection is out-of-bounds" && (blockDirection >= 0) && (blockDirection < 6));
948  this->BlockTopology[gridID] |= (1 << blockDirection);
949 }
950 
951 //------------------------------------------------------------------------------
953 {
954  // Sanity check
955  assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
956  (gridID < static_cast<int>(this->NumberOfGrids)));
957  assert("pre: BlockTopology has not been properly allocated" &&
958  (this->NumberOfGrids == this->BlockTopology.size()));
959  for (int i = 0; i < 6; ++i)
960  {
961  this->RemoveBlockConnection(gridID, i);
962  } // END for all block directions
963 }
964 
965 //------------------------------------------------------------------------------
967 {
968  // Sanity check
969  assert("pre: gridID is out-of-bounds" && (gridID >= 0) &&
970  (gridID < static_cast<int>(this->NumberOfGrids)));
971  assert("pre: BlockTopology has not been properly allocated" &&
972  (this->NumberOfGrids == this->BlockTopology.size()));
973 
974  int count = 0;
975  for (int i = 0; i < 6; ++i)
976  {
977  if (this->HasBlockConnection(gridID, i))
978  {
979  ++count;
980  }
981  }
982  assert("post: count must be in [0,5]" && (count >= 0 && count <= 6));
983  return (count);
984 }
985 
986 //------------------------------------------------------------------------------
987 inline void vtkStructuredGridConnectivity::SetNumberOfGrids(const unsigned int N)
988 {
989  if (N == 0)
990  {
991  vtkErrorMacro("Number of grids cannot be 0.");
992  return;
993  }
994 
995  this->NumberOfGrids = N;
997 
998  this->GridExtents.resize(6 * N, -1);
999  this->Neighbors.resize(N);
1000  this->BlockTopology.resize(N);
1001 }
1002 #endif /* vtkStructuredGridConnectivity_h */
vtkPoints
represent and manipulate 3D points
Definition: vtkPoints.h:34
vtkStructuredGridConnectivity::TransferLocalNeighborData
void TransferLocalNeighborData(const int gridID, const vtkStructuredNeighbor &Neighbor)
This method transfers the fields.
vtkStructuredGridConnectivity::CopyFieldData
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...
vtkStructuredNeighbor::SUPERSET
@ SUPERSET
Definition: vtkStructuredNeighbor.h:50
vtkStructuredGridConnectivity::GetNeighborIndex
int GetNeighborIndex(const int gridIdx, const int NeighborGridIdx)
Given a global grid ID and the neighbor grid ID, this method returns the neighbor index w....
Definition: vtkStructuredGridConnectivity.h:607
vtkStructuredGridConnectivity::GetGhostedExtent
void GetGhostedExtent(int *ghostedExtent, int GridExtent[6], const int minIdx, const int maxIdx, const int N)
Gets the ghosted extent from the given grid extent along the dimension given by minIdx and maxIdx.
Definition: vtkStructuredGridConnectivity.h:624
vtkPointData
represent and manipulate point attribute data
Definition: vtkPointData.h:33
vtkStructuredGridConnectivity::SetNumberOfGrids
void SetNumberOfGrids(const unsigned int N) override
Set/Get the total number of domains distributed among processors.
Definition: vtkStructuredGridConnectivity.h:987
vtkStructuredGridConnectivity::ClearBlockConnections
void ClearBlockConnections(const int gridID)
Clears all block connections for the block corresponding to the given grid ID.
Definition: vtkStructuredGridConnectivity.h:952
vtkStructuredGridConnectivity::FillGhostArrays
void FillGhostArrays(const int gridID, vtkUnsignedCharArray *nodesArray, vtkUnsignedCharArray *cellsArray) override
Fills the mesh property arrays, nodes and cells, for the grid corresponding to the given grid ID.
vtkIdType
int vtkIdType
Definition: vtkType.h:338
vtkStructuredGridConnectivity::AcquireDataDescription
void AcquireDataDescription()
Based on the user-supplied WholeExtent, this method determines the topology of the structured domain,...
vtkStructuredGridConnectivity::AllocateCellData
void AllocateCellData(vtkCellData *RCD, const int N, vtkCellData *CD)
Adds/creates all the arrays in the reference grid cell data, RCD, to the user-supplied cell data inst...
vtkStructuredGridConnectivity::GetGridNeighbor
vtkStructuredNeighbor GetGridNeighbor(const int gridID, const int nei)
Returns the neighbor corresponding to the index nei for the grid with the given (global) grid ID.
vtkStructuredGridConnectivity::SetBlockTopology
void SetBlockTopology(const int gridID)
Sets the block topology connections for the grid corresponding to gridID.
vtkStructuredGridConnectivity::ComputeNeighbors
void ComputeNeighbors() override
Computes neighboring information.
vtkStructuredNeighbor::ONE_TO_ONE
@ ONE_TO_ONE
Definition: vtkStructuredNeighbor.h:40
vtkStructuredGridConnectivity::HasBlockConnection
bool HasBlockConnection(const int gridID, const int blockDirection)
Checks if the block corresponding to the given grid ID has a block adjacent to it in the given block ...
Definition: vtkStructuredGridConnectivity.h:907
vtkUnsignedCharArray
dynamic, self-adjusting array of unsigned char
Definition: vtkUnsignedCharArray.h:36
vtkStructuredGridConnectivity::SetNeighbors
void SetNeighbors(const int i, const int j, int i2jOrientation[3], int j2iOrientation[3], int overlapExtent[6])
Creates a neighbor from i-to-j and from j-to-i.
vtkStructuredNeighbor::SUBSET_LO
@ SUBSET_LO
Definition: vtkStructuredNeighbor.h:35
vtkStructuredGridConnectivity::GhostedExtents
std::vector< int > GhostedExtents
Definition: vtkStructuredGridConnectivity.h:592
vtkStructuredNeighbor.h
vtkStructuredGridConnectivity::vtkStructuredGridConnectivity
vtkStructuredGridConnectivity()
vtkStructuredGridConnectivity::GetNumberOfNodesPerCell
int GetNumberOfNodesPerCell(const int dim)
Returns the number of nodes per cell according to the given dimension.
Definition: vtkStructuredGridConnectivity.h:184
vtkStructuredGridConnectivity::SetGhostedGridExtent
void SetGhostedGridExtent(const int gridID, int ext[6])
Sets the ghosted grid extent for the grid corresponding to the given grid ID to the given extent.
Definition: vtkStructuredGridConnectivity.h:643
vtkStructuredNeighbor::SUBSET_BOTH
@ SUBSET_BOTH
Definition: vtkStructuredNeighbor.h:48
vtkStructuredGridConnectivity::AllocatePointData
void AllocatePointData(vtkPointData *RPD, const int N, vtkPointData *PD)
Adds/creates all the arrays in the reference grid point data, RPD, to the user-supplied point data in...
VTK_Z_LINE
#define VTK_Z_LINE
Definition: vtkStructuredData.h:41
vtkStructuredGridConnectivity::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkStructuredGridConnectivity::IntervalOverlap
int IntervalOverlap(int A[2], int B[2], int overlap[2])
Checks if the intervals A,B overlap.
vtkStructuredGridConnectivity::AddBlockConnection
void AddBlockConnection(const int gridID, const int blockDirection)
Adds a block connection along the given direction for the block corresponding to the given gridID.
Definition: vtkStructuredGridConnectivity.h:939
vtkStructuredNeighbor::LO
@ LO
Definition: vtkStructuredNeighbor.h:37
vtkFieldData
represent and manipulate fields of data
Definition: vtkFieldData.h:54
vtkStructuredGridConnectivity::DetectNeighbors
void DetectNeighbors(const int i, const 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,...
vtkStructuredGridConnectivity::DataDimension
int DataDimension
Definition: vtkStructuredGridConnectivity.h:587
vtkStructuredGridConnectivity::WholeExtent
int WholeExtent[6]
Definition: vtkStructuredGridConnectivity.h:589
VTK_Y_LINE
#define VTK_Y_LINE
Definition: vtkStructuredData.h:40
vtkAbstractGridConnectivity::SetNumberOfGrids
virtual void SetNumberOfGrids(const unsigned int N)=0
Sets the total number of grids in the domain.
vtkStructuredData.h
target
boost::graph_traits< vtkGraph * >::vertex_descriptor target(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
Definition: vtkBoostGraphAdapter.h:965
vtkStructuredGridConnectivity::GridExtents
std::vector< int > GridExtents
Definition: vtkStructuredGridConnectivity.h:591
vtkAbstractGridConnectivity::AllocateUserRegisterDataStructures
void AllocateUserRegisterDataStructures()
Allocate/De-allocate the data-structures where the user-supplied grids will be registered.
Definition: vtkAbstractGridConnectivity.h:294
vtkStructuredGridConnectivity::IsNodeOnSharedBoundary
bool IsNodeOnSharedBoundary(const int gridID, int RealExtent[6], const int i, const int j, const int k)
Checks if the node corresponding to the given global i,j,k coordinates is on the shared boundary,...
vtkStructuredGridConnectivity::ComputeNeighborSendAndRcvExtent
void ComputeNeighborSendAndRcvExtent(const int gridID, const int N)
This method computes, the send and rcv extents for each neighbor of each grid.
vtkStructuredGridConnectivity::IsNodeOnBoundary
bool IsNodeOnBoundary(const int i, const int j, const int k)
Checks if the node corresponding to the given global i,j,k coordinates touches the real boundaries of...
vtkStructuredGridConnectivity::IsNodeInterior
bool IsNodeInterior(const int i, const int j, const int k, int GridExtent[6])
Checks if the node, corresponding to the given global i,j,k coordinates is within the interior of the...
Definition: vtkStructuredGridConnectivity.h:754
vtkStructuredGridConnectivity::GetNeighbors
vtkIdList * GetNeighbors(const int gridID, int *extents)
Returns the list of neighboring blocks for the given grid and the corresponding overlapping extents a...
VTK_X_LINE
#define VTK_X_LINE
Definition: vtkStructuredData.h:39
vtkStructuredGridConnectivity::IsNodeWithinExtent
bool IsNodeWithinExtent(const int i, const int j, const int k, int GridExtent[6])
Checks if the node corresponding to the given global i,j,k coordinates is within the given extent,...
Definition: vtkStructuredGridConnectivity.h:278
VTK_XYZ_GRID
#define VTK_XYZ_GRID
Definition: vtkStructuredData.h:45
vtkStructuredGridConnectivity::GetNumberOfNeighbors
int GetNumberOfNeighbors(const int gridID)
Returns the number of neighbors for the grid corresponding to the given grid ID.
Definition: vtkStructuredGridConnectivity.h:117
vtkStructuredGridConnectivity::NeighborPair2NeighborListIndex
std::map< std::pair< int, int >, int > NeighborPair2NeighborListIndex
Definition: vtkStructuredGridConnectivity.h:595
vtkStructuredGridConnectivity::Get1DOrientation
int Get1DOrientation(const int idx, const int ExtentLo, const int ExtentHi, const int OnLo, const int OnHi, const int NotOnBoundary)
A helper method that computes the 1-D i-j-k orientation to facilitate the implementation of GetNodeBl...
Definition: vtkStructuredGridConnectivity.h:892
vtkAbstractGridConnectivity::NumberOfGrids
unsigned int NumberOfGrids
Definition: vtkAbstractGridConnectivity.h:189
vtkStructuredGridConnectivity::CreateGhostedExtent
void CreateGhostedExtent(const int gridID, const int N)
Creates the ghosted extent of the grid corresponding to the given gridID.
vtkStructuredGridConnectivity::IsNodeOnBoundaryOfExtent
bool IsNodeOnBoundaryOfExtent(const int i, const int j, const 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...
Definition: vtkStructuredGridConnectivity.h:690
vtkCellData
represent and manipulate cell attribute data
Definition: vtkCellData.h:33
vtkStructuredGridConnectivity
vtkStructuredGridConnectivity is a concrete instance of vtkObject that implements functionality for c...
Definition: vtkStructuredGridConnectivity.h:58
vtkStructuredGridConnectivity::RegisterGrid
virtual void RegisterGrid(const 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.
vtkStructuredGridConnectivity::InBounds
bool InBounds(const int idx, const int Lo, const int Hi)
Returns true iff Lo <= idx <= Hi, otherwise false.
Definition: vtkStructuredGridConnectivity.h:157
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:34
vtkStructuredGridConnectivity::CopyCoordinates
void CopyCoordinates(vtkPoints *source, vtkIdType sourceIdx, vtkPoints *target, vtkIdType targetIdx)
Copies the coordinates from the source points to the target points.
vtkStructuredGridConnectivity::RemoveBlockConnection
void RemoveBlockConnection(const int gridID, const int blockDirection)
Removes a block connection along the given direction for the block corresponding to the given gridID.
Definition: vtkStructuredGridConnectivity.h:925
vtkStructuredGridConnectivity::GetGridExtent
void GetGridExtent(const int gridID, int extent[6])
Returns the grid extent of the grid corresponding to the given grid ID.
Definition: vtkStructuredGridConnectivity.h:657
vtkIdList
list of point or cell ids
Definition: vtkIdList.h:31
VTK_XY_PLANE
#define VTK_XY_PLANE
Definition: vtkStructuredData.h:42
vtkStructuredGridConnectivity::MarkCellProperty
void MarkCellProperty(unsigned char &pfield, unsigned char *nodeGhostFields, const int numNodes)
Marks the cell property for the cell composed by the nodes with the given ghost fields.
vtkStructuredGridConnectivity::DoPartialOverlap
int DoPartialOverlap(int s[2], int S[2], int overlap[2])
Checks if the internals s,S partially overlap where |s| < |S|.
vtkStructuredGridConnectivity::EstablishNeighbors
void EstablishNeighbors(const int i, const int j)
Establishes the neighboring information between the two grids corresponding to grid ids "i" and "j" w...
vtkX3D::size
@ size
Definition: vtkX3D.h:259
vtkStructuredNeighbor
An internal, light-weight class used to store neighbor information.
Definition: vtkStructuredNeighbor.h:27
vtkStructuredGridConnectivity::TransferGhostDataFromNeighbors
virtual void TransferGhostDataFromNeighbors(const int gridID)
This method transfers the fields (point data and cell data) to the ghost extents from the neighboring...
vtkStructuredGridConnectivity::BlockTopology
std::vector< unsigned char > BlockTopology
Definition: vtkStructuredGridConnectivity.h:593
vtkStructuredNeighbor::HI
@ HI
Definition: vtkStructuredNeighbor.h:43
vtkStructuredGridConnectivity::DetermineNeighborOrientation
void DetermineNeighborOrientation(const 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...
Definition: vtkStructuredGridConnectivity.h:814
VTK_YZ_PLANE
#define VTK_YZ_PLANE
Definition: vtkStructuredData.h:43
vtkStructuredGridConnectivity::IsGhostNode
bool IsGhostNode(int GridExtent[6], int RealExtent[6], const int i, const int j, const int k)
Checks if the node corresponding to the given global i,j,k coordinates is a ghost node or not.
vtkStructuredGridConnectivity::InitializeGhostData
void InitializeGhostData(const int gridID)
This method initializes the ghost data according to the computed ghosted grid extent for the grid wit...
vtkStructuredGridConnectivity::DataDescription
int DataDescription
Definition: vtkStructuredGridConnectivity.h:588
vtkStructuredNeighbor::SUBSET_HI
@ SUBSET_HI
Definition: vtkStructuredNeighbor.h:46
vtkStructuredGridConnectivity::SearchNeighbors
void SearchNeighbors(const int gridID, const int i, const int j, const int k, vtkIdList *neiList)
Given a point (i,j,k) belonging to the grid corresponding to the given gridID, this method searches f...
vtkStructuredGridConnectivity::MarkNodeProperty
void MarkNodeProperty(const int gridID, const int i, const int j, const 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....
vtkAbstractGridConnectivity
A superclass that defines the interface to be implemented by all concrete grid connectivity classes.
Definition: vtkAbstractGridConnectivity.h:64
vtkX3D::orientation
@ orientation
Definition: vtkX3D.h:268
vtkStructuredGridConnectivity::FillCellsGhostArray
void FillCellsGhostArray(const int dataDescription, const int numNodesPerCell, int dims[3], int CellExtent[6], vtkUnsignedCharArray *nodesArray, vtkUnsignedCharArray *cellsArray)
Fills the ghost array for the grid cells.
vtkStructuredGridConnectivity::New
static vtkStructuredGridConnectivity * New()
vtkStructuredGridConnectivity::CreateGhostedMaskArrays
void CreateGhostedMaskArrays(const int gridID)
This method creates the ghosted mask arrays, i.e., the NodeGhostArrays and the CellGhostArrays for th...
vtkStructuredGridConnectivity::Neighbors
std::vector< std::vector< vtkStructuredNeighbor > > Neighbors
Definition: vtkStructuredGridConnectivity.h:594
vtkStructuredGridConnectivity::FillNodesGhostArray
void FillNodesGhostArray(const int gridID, const int dataDescription, int GridExtent[6], int RealExtent[6], vtkUnsignedCharArray *nodesArray)
Fills the ghost array for the nodes.
vtkStructuredGridConnectivity::~vtkStructuredGridConnectivity
~vtkStructuredGridConnectivity() override
VTK_XZ_PLANE
#define VTK_XZ_PLANE
Definition: vtkStructuredData.h:44
vtkStructuredGridConnectivity::StrictlyInsideBounds
bool StrictlyInsideBounds(const int idx, const int Lo, const int Hi)
Returns true iff Lo < idx < Hi, otherwise false.
Definition: vtkStructuredGridConnectivity.h:162
vtkStructuredGridConnectivity::Cardinality
int Cardinality(int S[2])
Returns the cardinality of a range S.
Definition: vtkStructuredGridConnectivity.h:178
vtkStructuredGridConnectivity::GetIJKBlockOrientation
void GetIJKBlockOrientation(const int i, const int j, const 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...
source
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
Definition: vtkBoostGraphAdapter.h:959
vtkStructuredNeighbor::UNDEFINED
@ UNDEFINED
Definition: vtkStructuredNeighbor.h:52
vtkX3D::extent
@ extent
Definition: vtkX3D.h:351
vtkStructuredGridConnectivity::IsSubset
bool IsSubset(int A[2], int B[2])
Returns true iff A is a subset of B, otherwise false.
Definition: vtkStructuredGridConnectivity.h:170
vtkStructuredGridConnectivity::GetNumberOfConnectingBlockFaces
int GetNumberOfConnectingBlockFaces(const int gridID)
Returns the number of faces of the block corresponding to the given grid ID that are adjacent to at l...
Definition: vtkStructuredGridConnectivity.h:966
vtkStructuredGridConnectivity::CreateGhostLayers
void CreateGhostLayers(const int N=1) override
Creates ghost layers.
vtkStructuredGridConnectivity::GetRealExtent
void GetRealExtent(const int gridID, int GridExtent[6], int RealExtent[6])
Given a grid extent, this method computes the RealExtent.
vtkStructuredGridConnectivity::GetGhostedGridExtent
void GetGhostedGridExtent(const int gridID, int ext[6])
Returns the ghosted grid extent for the block corresponding the.
Definition: vtkStructuredGridConnectivity.h:668
vtkAbstractGridConnectivity.h
vtkStructuredGridConnectivity::PrintExtent
void PrintExtent(int extent[6])
Prints the extent, used for debugging.
vtkStructuredGridConnectivity::TransferRegisteredDataToGhostedData
void TransferRegisteredDataToGhostedData(const int gridID)
This method transfers the registered grid data to the corresponding ghosted grid data.
vtkStructuredGridConnectivity::PartialOverlap
int PartialOverlap(int A[2], const int CardinalityOfA, int B[2], const int CardinalityOfB, int overlap[2])
Checks if the intervals A,B partially overlap.