foamVtuSizingTemplates.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | www.openfoam.com
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8  Copyright (C) 2016-2020 OpenCFD Ltd.
9 -------------------------------------------------------------------------------
10 License
11  This file is part of OpenFOAM.
12 
13  OpenFOAM is free software: you can redistribute it and/or modify it
14  under the terms of the GNU General Public License as published by
15  the Free Software Foundation, either version 3 of the License, or
16  (at your option) any later version.
17 
18  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
20  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21  for more details.
22 
23  You should have received a copy of the GNU General Public License
24  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
25 
26 \*---------------------------------------------------------------------------*/
27 
28 #include "foamVtuSizing.H"
29 #include "foamVtkCore.H"
30 #include "polyMesh.H"
31 #include "cellShape.H"
32 
33 // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
34 
35 template<class LabelType, class LabelType2>
36 void Foam::vtk::vtuSizing::populateArrays
37 (
38  const polyMesh& mesh,
39  const vtk::vtuSizing& sizing,
40  UList<uint8_t>& cellTypes,
41  UList<LabelType>& vertLabels,
42  UList<LabelType>& vertOffset,
43  UList<LabelType>& faceLabels,
44  UList<LabelType>& faceOffset,
45  const enum contentType output,
46  UList<LabelType2>& cellMap,
47  UList<LabelType2>& addPointsIds
48 )
49 {
50  // Characteristics
51 
52  // Are vertLabels prefixed with the size?
53  // Also use as the size of the prefixed information
54  const int prefix =
55  (
56  output == contentType::LEGACY
57  || output == contentType::INTERNAL1
58  ) ? 1 : 0;
59 
60 
61  // STAGE 1: Verify storage sizes
62 
63  if (cellTypes.size() != sizing.nFieldCells())
64  {
65  FatalErrorInFunction
66  << " cellTypes size=" << cellTypes.size()
67  << " expected " << sizing.nFieldCells()
68  << exit(FatalError);
69  }
70 
71  if (cellMap.size() != sizing.nFieldCells())
72  {
73  FatalErrorInFunction
74  << " cellMap size=" << cellMap.size()
75  << " expected " << sizing.nFieldCells()
76  << exit(FatalError);
77  }
78 
79  if (addPointsIds.size() != sizing.nAddPoints())
80  {
81  FatalErrorInFunction
82  << " addPointsIds size=" << addPointsIds.size()
83  << " expected " << sizing.nAddPoints()
84  << exit(FatalError);
85  }
86 
87  switch (output)
88  {
89  case contentType::LEGACY:
90  {
91  if (vertLabels.size() != sizing.sizeLegacy())
92  {
93  FatalErrorInFunction
94  << " legacy size=" << vertLabels.size()
95  << " expected " << sizing.sizeLegacy()
96  << exit(FatalError);
97  }
98  break;
99  }
100 
101  case contentType::XML:
102  {
103  // XML uses connectivity/offset pair.
104  if
105  (
106  vertLabels.size()
107  != sizing.sizeXml(slotType::CELLS)
108  )
109  {
110  FatalErrorInFunction
111  << " connectivity size=" << vertLabels.size()
112  << " expected "
113  << sizing.sizeXml(slotType::CELLS)
114  << exit(FatalError);
115  }
116 
117  if
118  (
119  vertOffset.size()
120  != sizing.sizeXml(slotType::CELLS_OFFSETS)
121  )
122  {
123  FatalErrorInFunction
124  << " offsets size=" << vertOffset.size()
125  << " expected "
126  << sizing.sizeXml(slotType::CELLS_OFFSETS)
127  << exit(FatalError);
128  }
129 
130  if (sizing.nFaceLabels())
131  {
132  if
133  (
134  faceLabels.size()
135  != sizing.sizeXml(slotType::FACES)
136  )
137  {
138  FatalErrorInFunction
139  << " faces size=" << faceLabels.size()
140  << " expected "
141  << sizing.sizeXml(slotType::FACES)
142  << exit(FatalError);
143  }
144 
145  if
146  (
147  faceOffset.size()
148  != sizing.sizeXml(slotType::FACES_OFFSETS)
149  )
150  {
151  FatalErrorInFunction
152  << " facesOffsets size=" << faceOffset.size()
153  << " expected "
154  << sizing.sizeXml(slotType::FACES_OFFSETS)
155  << exit(FatalError);
156  }
157  }
158  break;
159  }
160 
161  case contentType::INTERNAL1:
162  {
163  // VTK-internal1 connectivity/offset pair.
164  if
165  (
166  vertLabels.size()
167  != sizing.sizeInternal1(slotType::CELLS)
168  )
169  {
170  FatalErrorInFunction
171  << " connectivity size=" << vertLabels.size()
172  << " expected "
173  << sizing.sizeInternal1(slotType::CELLS)
174  << exit(FatalError);
175  }
176 
177  if
178  (
179  vertOffset.size()
180  != sizing.sizeInternal1(slotType::CELLS_OFFSETS)
181  )
182  {
183  FatalErrorInFunction
184  << " offsets size=" << vertOffset.size()
185  << " expected "
186  << sizing.sizeInternal1(slotType::CELLS_OFFSETS)
187  << exit(FatalError);
188  }
189 
190  if (sizing.nFaceLabels())
191  {
192  if
193  (
194  faceLabels.size()
195  != sizing.sizeInternal1(slotType::FACES)
196  )
197  {
198  FatalErrorInFunction
199  << " faces size=" << faceLabels.size()
200  << " expected "
201  << sizing.sizeInternal1(slotType::FACES)
202  << exit(FatalError);
203  }
204 
205  if
206  (
207  faceOffset.size()
208  != sizing.sizeInternal1(slotType::FACES_OFFSETS)
209  )
210  {
211  FatalErrorInFunction
212  << " facesOffsets size=" << faceOffset.size()
213  << " expected "
214  << sizing.sizeInternal1(slotType::FACES_OFFSETS)
215  << exit(FatalError);
216  }
217  }
218  break;
219  }
220 
221  case contentType::INTERNAL2:
222  {
223  // VTK-internal2 connectivity/offset pair.
224  if
225  (
226  vertLabels.size()
227  != sizing.sizeInternal2(slotType::CELLS)
228  )
229  {
230  FatalErrorInFunction
231  << " connectivity size=" << vertLabels.size()
232  << " expected "
233  << sizing.sizeInternal2(slotType::CELLS)
234  << exit(FatalError);
235  }
236 
237  if
238  (
239  vertOffset.size()
240  != sizing.sizeInternal2(slotType::CELLS_OFFSETS)
241  )
242  {
243  FatalErrorInFunction
244  << " offsets size=" << vertOffset.size()
245  << " expected "
246  << sizing.sizeInternal2(slotType::CELLS_OFFSETS)
247  << exit(FatalError);
248  }
249 
250  if (sizing.nFaceLabels())
251  {
252  if
253  (
254  faceLabels.size()
255  != sizing.sizeInternal2(slotType::FACES)
256  )
257  {
258  FatalErrorInFunction
259  << " faces size=" << faceLabels.size()
260  << " expected "
261  << sizing.sizeInternal2(slotType::FACES)
262  << exit(FatalError);
263  }
264 
265  if
266  (
267  faceOffset.size()
268  != sizing.sizeInternal2(slotType::FACES_OFFSETS)
269  )
270  {
271  FatalErrorInFunction
272  << " facesOffsets size=" << faceOffset.size()
273  << " expected "
274  << sizing.sizeInternal2(slotType::FACES_OFFSETS)
275  << exit(FatalError);
276  }
277  }
278  break;
279  }
280  }
281 
282 
283  // Initialization
284 
285  faceOffset = -1;
286 
287  // For INTERNAL2, the vertOffset is (nFieldCells+1), which means that
288  // the last entry is never visited. Set as zero now.
289 
290  if (vertOffset.size())
291  {
292  vertOffset.first() = 0;
293  vertOffset.last() = 0;
294  }
295 
296 
297  const cellModel& tet = cellModel::ref(cellModel::TET);
298  const cellModel& pyr = cellModel::ref(cellModel::PYR);
299  const cellModel& prism = cellModel::ref(cellModel::PRISM);
300  const cellModel& wedge = cellModel::ref(cellModel::WEDGE);
301  const cellModel& tetWedge = cellModel::ref(cellModel::TETWEDGE);
302  const cellModel& hex = cellModel::ref(cellModel::HEX);
303 
304  const cellShapeList& shapes = mesh.cellShapes();
305 
306  // The face owner is needed to determine the face orientation
307  const labelList& owner = mesh.faceOwner();
308 
309  // Unique vertex labels per polyhedral
310  labelHashSet hashUniqId(512);
311 
312  // Index into vertLabels, faceLabels for normal cells
313  label nVertLabels = 0;
314  label nFaceLabels = 0;
315 
316  // Index into vertLabels for decomposed polys
317  label nVertDecomp = sizing.nVertLabels() + prefix*sizing.nCells();
318 
319  // Placement of decomposed cells
320  label nCellDecomp = mesh.nCells();
321 
322  // Placement of additional point labels
323  label nPointDecomp = 0;
324 
325  // Non-decomposed polyhedral are represented as a face-stream.
326  // For legacy format, this stream replaces the normal connectivity
327  // information. Use references to alias where the face output should land.
328 
329  UList<LabelType>& faceOutput =
330  (
331  output == contentType::LEGACY
332  ? vertLabels
333  : faceLabels
334  );
335 
336  label& faceIndexer =
337  (
338  output == contentType::LEGACY
339  ? nVertLabels
340  : nFaceLabels
341  );
342 
343  // ===========================================
344  // STAGE 2: Rewrite in VTK form
345  // During this stage, the vertOffset contains the *size* associated with
346  // the per-cell vertLabels entries, and the faceOffset contains the *size*
347  // associated with the per-cell faceLabels.
348 
349  const label len = shapes.size();
350 
351  for (label celli=0; celli < len; ++celli)
352  {
353  const cellShape& shape = shapes[celli];
354  const cellModel& model = shape.model();
355 
356  cellMap[celli] = celli;
357 
358  if (model == tet)
359  {
360  cellTypes[celli] = vtk::cellType::VTK_TETRA;
361  constexpr label nShapePoints = 4; // OR shape.size();
362 
363  if (vertOffset.size())
364  {
365  vertOffset[celli] = nShapePoints;
366  }
367  if (prefix)
368  {
369  vertLabels[nVertLabels++] = nShapePoints;
370  }
371 
372  for (const label cpi : shape)
373  {
374  vertLabels[nVertLabels++] = cpi;
375  }
376  }
377  else if (model == pyr)
378  {
379  cellTypes[celli] = vtk::cellType::VTK_PYRAMID;
380  constexpr label nShapePoints = 5; // OR shape.size();
381 
382  if (vertOffset.size())
383  {
384  vertOffset[celli] = nShapePoints;
385  }
386  if (prefix)
387  {
388  vertLabels[nVertLabels++] = nShapePoints;
389  }
390 
391  for (const label cpi : shape)
392  {
393  vertLabels[nVertLabels++] = cpi;
394  }
395  }
396  else if (model == hex)
397  {
398  cellTypes[celli] = vtk::cellType::VTK_HEXAHEDRON;
399  constexpr label nShapePoints = 8; // OR shape.size();
400 
401  if (vertOffset.size())
402  {
403  vertOffset[celli] = nShapePoints;
404  }
405  if (prefix)
406  {
407  vertLabels[nVertLabels++] = nShapePoints;
408  }
409 
410  for (const label cpi : shape)
411  {
412  vertLabels[nVertLabels++] = cpi;
413  }
414  }
415  else if (model == prism)
416  {
417  cellTypes[celli] = vtk::cellType::VTK_WEDGE;
418  constexpr label nShapePoints = 6; // OR shape.size();
419 
420  if (vertOffset.size())
421  {
422  vertOffset[celli] = nShapePoints;
423  }
424  if (prefix)
425  {
426  vertLabels[nVertLabels++] = nShapePoints;
427  }
428 
429  // VTK_WEDGE triangles point outwards (swap 1<->2, 4<->5)
430  vertLabels[nVertLabels++] = shape[0];
431  vertLabels[nVertLabels++] = shape[2];
432  vertLabels[nVertLabels++] = shape[1];
433  vertLabels[nVertLabels++] = shape[3];
434  vertLabels[nVertLabels++] = shape[5];
435  vertLabels[nVertLabels++] = shape[4];
436  }
437  else if (model == tetWedge && sizing.decompose())
438  {
439  // Treat as squeezed prism
440  cellTypes[celli] = vtk::cellType::VTK_WEDGE;
441  constexpr label nShapePoints = 6;
442 
443  if (vertOffset.size())
444  {
445  vertOffset[celli] = nShapePoints;
446  }
447  if (prefix)
448  {
449  vertLabels[nVertLabels++] = nShapePoints;
450  }
451 
452  vertLabels[nVertLabels++] = shape[0];
453  vertLabels[nVertLabels++] = shape[2];
454  vertLabels[nVertLabels++] = shape[1];
455  vertLabels[nVertLabels++] = shape[3];
456  vertLabels[nVertLabels++] = shape[4];
457  vertLabels[nVertLabels++] = shape[3];
458  }
459  else if (model == wedge && sizing.decompose())
460  {
461  // Treat as squeezed hex
462  cellTypes[celli] = vtk::cellType::VTK_HEXAHEDRON;
463  constexpr label nShapePoints = 8;
464 
465  if (vertOffset.size())
466  {
467  vertOffset[celli] = nShapePoints;
468  }
469  if (prefix)
470  {
471  vertLabels[nVertLabels++] = nShapePoints;
472  }
473 
474  vertLabels[nVertLabels++] = shape[0];
475  vertLabels[nVertLabels++] = shape[1];
476  vertLabels[nVertLabels++] = shape[2];
477  vertLabels[nVertLabels++] = shape[2];
478  vertLabels[nVertLabels++] = shape[3];
479  vertLabels[nVertLabels++] = shape[4];
480  vertLabels[nVertLabels++] = shape[5];
481  vertLabels[nVertLabels++] = shape[6];
482  }
483  else if (sizing.decompose())
484  {
485  // Polyhedral cell - decompose into tet/pyr.
486 
487  // Ensure we have the correct orientation for the base of the
488  // primitive cell shape.
489  // If the cell is face owner, the orientation needs to be flipped
490  // to avoid defining negative cells.
491  // VTK may not care, but we'll do it anyhow for safety.
492 
493  // Mapping from additional point to cell, and the new vertex from
494  // the cell-centre
495  const label newVertexLabel = mesh.nPoints() + nPointDecomp;
496 
497  addPointsIds[nPointDecomp++] = celli;
498 
499  // Whether to insert cell in place of original or not.
500  bool first = true;
501 
502  const labelList& cFaces = mesh.cells()[celli];
503 
504  for (const label facei : cFaces)
505  {
506  const face& f = mesh.faces()[facei];
507  const bool isOwner = (owner[facei] == celli);
508 
509  // Count triangles/quads in decomposition
510  label nTria = 0, nQuad = 0;
511  f.nTrianglesQuads(mesh.points(), nTria, nQuad);
512 
513  // Do actual decomposition
514  faceList faces3(nTria);
515  faceList faces4(nQuad);
516  nTria = 0, nQuad = 0;
517  f.trianglesQuads(mesh.points(), nTria, nQuad, faces3, faces4);
518 
519  for (const face& quad : faces4)
520  {
521  // Quad becomes a pyramid
522 
523  constexpr label nShapePoints = 5; // pyr (5 vertices)
524 
525  label celLoc, vrtLoc;
526  if (first)
527  {
528  first = false;
529  celLoc = celli;
530  vrtLoc = nVertLabels;
531  nVertLabels += prefix + nShapePoints;
532  }
533  else
534  {
535  celLoc = nCellDecomp++;
536  vrtLoc = nVertDecomp;
537  nVertDecomp += prefix + nShapePoints;
538  }
539  cellMap[celLoc] = celli;
540 
541  cellTypes[celLoc] = vtk::cellType::VTK_PYRAMID;
542  if (vertOffset.size())
543  {
544  vertOffset[celLoc] = nShapePoints;
545  }
546  if (prefix)
547  {
548  vertLabels[vrtLoc++] = nShapePoints;
549  }
550 
551  // See note above about the orientation.
552  if (isOwner)
553  {
554  vertLabels[vrtLoc++] = quad[3];
555  vertLabels[vrtLoc++] = quad[2];
556  vertLabels[vrtLoc++] = quad[1];
557  vertLabels[vrtLoc++] = quad[0];
558  }
559  else
560  {
561  vertLabels[vrtLoc++] = quad[0];
562  vertLabels[vrtLoc++] = quad[1];
563  vertLabels[vrtLoc++] = quad[2];
564  vertLabels[vrtLoc++] = quad[3];
565  }
566 
567  // The apex
568  vertLabels[vrtLoc++] = newVertexLabel;
569  }
570 
571  for (const face& tria : faces3)
572  {
573  // Triangle becomes a tetrahedral
574 
575  constexpr label nShapePoints = 4; // tet (4 vertices)
576 
577  label celLoc, vrtLoc;
578  if (first)
579  {
580  first = false;
581  celLoc = celli;
582  vrtLoc = nVertLabels;
583  nVertLabels += prefix + nShapePoints;
584  }
585  else
586  {
587  celLoc = nCellDecomp++;
588  vrtLoc = nVertDecomp;
589  nVertDecomp += prefix + nShapePoints;
590  }
591  cellMap[celLoc] = celli;
592 
593  cellTypes[celLoc] = vtk::cellType::VTK_TETRA;
594  if (vertOffset.size())
595  {
596  vertOffset[celLoc] = nShapePoints;
597  }
598  if (prefix)
599  {
600  vertLabels[vrtLoc++] = nShapePoints;
601  }
602 
603  // See note above about the orientation.
604  if (isOwner)
605  {
606  vertLabels[vrtLoc++] = tria[2];
607  vertLabels[vrtLoc++] = tria[1];
608  vertLabels[vrtLoc++] = tria[0];
609  }
610  else
611  {
612  vertLabels[vrtLoc++] = tria[0];
613  vertLabels[vrtLoc++] = tria[1];
614  vertLabels[vrtLoc++] = tria[2];
615  }
616 
617  // The apex
618  vertLabels[vrtLoc++] = newVertexLabel;
619  }
620  }
621  }
622  else
623  {
624  // Polyhedral cell - not decomposed
625  hashUniqId.clear(); // unique node ids used (XML, INTERNAL)
626 
627  // face-stream
628  // [nFaces, nFace0Pts, id1, id2, ..., nFace1Pts, id1, id2, ...]
629  cellTypes[celli] = vtk::cellType::VTK_POLYHEDRON;
630  const labelList& cFaces = mesh.cells()[celli];
631 
632  const label startLabel = faceIndexer;
633 
634  if (output == contentType::LEGACY)
635  {
636  faceOutput[startLabel] = 0; // placeholder for size
637  ++faceIndexer;
638  }
639 
640  faceOutput[faceIndexer++] = cFaces.size();
641 
642  for (const label facei : cFaces)
643  {
644  const face& f = mesh.faces()[facei];
645  const bool isOwner = (owner[facei] == celli);
646 
647  hashUniqId.insert(f);
648 
649  // The number of labels for this face
650  faceOutput[faceIndexer++] = f.size();
651 
652  if (isOwner)
653  {
654  forAll(f, fp)
655  {
656  faceOutput[faceIndexer++] = f[fp];
657  }
658  }
659  else
660  {
661  // fairly immaterial if we reverse the list
662  // or use face::reverseFace()
663  forAllReverse(f, fp)
664  {
665  faceOutput[faceIndexer++] = f[fp];
666  }
667  }
668  }
669 
670  if (output == contentType::LEGACY)
671  {
672  // Update size for legacy face stream
673  // (subtract 1 to avoid counting the storage location)
674  faceOutput[startLabel] = (faceIndexer - 1 - startLabel);
675  }
676  else
677  {
678  // Size for face stream
679  faceOffset[celli] = (faceIndexer - startLabel);
680 
681  vertOffset[celli] = hashUniqId.size();
682  if (prefix)
683  {
684  vertLabels[nVertLabels++] = hashUniqId.size();
685  }
686 
687  const labelList uniq = hashUniqId.sortedToc();
688  for (const label fpi : uniq)
689  {
690  vertLabels[nVertLabels++] = fpi;
691  }
692  }
693  }
694  }
695 
696  // ===========================================
697  // STAGE 3: Adjust vertOffset for all cells
698  // A second pass is needed for several reasons.
699  // - Additional (decomposed) cells are placed out of sequence
700  // - INTERNAL1 connectivity has size prefixed
701  //
702  // Cell offsets:
703  // - XML format expects end-offsets,
704  // - INTERNAL1 expects begin-offsets
705  // - INTERNAL2 expects begin/end-offsets
706 
707  switch (output)
708  {
709  case contentType::LEGACY: // nothing to do
710  break;
711 
712  case contentType::XML:
713  {
714  // Transform cell sizes (vertOffset) into begin offsets
715 
716  // vertOffset[0] already contains its size, leave untouched
717  for (label i = 1; i < vertOffset.size(); ++i)
718  {
719  vertOffset[i] += vertOffset[i-1];
720  }
721 
722  // The end face offsets, leaving -1 untouched
723  if (sizing.nFaceLabels())
724  {
725  LabelType prev(0);
726 
727  for (LabelType& off : faceOffset)
728  {
729  const auto sz = off;
730  if (sz > 0)
731  {
732  prev += sz;
733  off = prev;
734  }
735  }
736  }
737  break;
738  }
739 
740  case contentType::INTERNAL1:
741  {
742  // Transform cell sizes (vertOffset) into begin offsets
743  {
744  LabelType beg(0);
745 
746  for (LabelType& off : vertOffset)
747  {
748  const auto sz = off;
749  off = beg;
750  beg += 1 + sz; // Additional 1 to skip embedded prefix
751  }
752  }
753 
754  // The begin face offsets, leaving -1 untouched
755  if (sizing.nFaceLabels())
756  {
757  LabelType beg(0);
758 
759  for (LabelType& off : faceOffset)
760  {
761  const auto sz = off;
762  if (sz > 0)
763  {
764  off = beg;
765  beg += sz;
766  }
767  }
768  }
769  break;
770  }
771 
772  case contentType::INTERNAL2:
773  {
774  // Transform cell sizes (vertOffset) into begin/end offsets
775  // input [n1, n2, n3, ..., 0]
776  // becomes [0, n1, n1+n2, n1+n2+n3, ..., nTotal]
777 
778  // The last entry of vertOffset was initialized as zero and
779  // never revisited, so the following loop is OK
780  {
781  LabelType total(0);
782 
783  for (LabelType& off : vertOffset)
784  {
785  const auto sz = off;
786  off = total;
787  total += sz;
788  }
789  }
790 
791  // The begin face offsets, leaving -1 untouched
792  if (sizing.nFaceLabels())
793  {
794  LabelType beg(0);
795 
796  for (LabelType& off : faceOffset)
797  {
798  const auto sz = off;
799  if (sz > 0)
800  {
801  off = beg;
802  beg += sz;
803  }
804  }
805  }
806  break;
807  }
808  }
809 }
810 
811 
812 //unused template<class LabelType, class LabelType2>
813 //unused void Foam::vtk::vtuSizing::renumberVertLabelsInternalImpl
814 //unused (
815 //unused UList<uint8_t>& cellTypes,
816 //unused UList<LabelType>& vertLabels,
817 //unused const LabelType2 globalPointOffset
818 //unused )
819 //unused {
820 //unused // INTERNAL vertLabels = "connectivity" contain
821 //unused // [nLabels, vertex labels...]
822 //unused
823 //unused auto iter = vertLabels.begin();
824 //unused const auto last = vertLabels.end();
825 //unused
826 //unused while (iter < last)
827 //unused {
828 //unused LabelType nLabels = *iter;
829 //unused ++iter;
830 //unused
831 //unused while (nLabels--)
832 //unused {
833 //unused *iter += globalPointOffset;
834 //unused ++iter;
835 //unused }
836 //unused }
837 //unused }
838 
839 
840 // ************************************************************************* //
Foam::labelList
List< label > labelList
A List of labels.
Definition: List.H:71
Foam::cellModel::HEX
hex
Definition: cellModel.H:81
Foam::vtk::VTK_HEXAHEDRON
Definition: foamVtkCore.H:103
Foam::cellShapeList
List< cellShape > cellShapeList
List of cellShapes and PtrList of List of cellShape.
Definition: cellShapeList.H:45
Foam::vtk::VTK_PYRAMID
Definition: foamVtkCore.H:105
Foam::vtk::dataArrayAttr::FACES
"faces"
Foam::vtk::VTK_POLYHEDRON
Definition: foamVtkCore.H:108
polyMesh.H
Foam::cellModel::TET
tet
Definition: cellModel.H:85
forAll
#define forAll(list, i)
Loop across all elements in list.
Definition: stdFoam.H:296
foamVtuSizing.H
Foam::vtk::fileTag::CELLS
"Cells"
Foam::vtk::vtuSizing::nFaceLabels
label nFaceLabels() const
Number of polyhedral face labels for the mesh.
Definition: foamVtuSizingI.H:56
Foam::vtk::VTK_WEDGE
Definition: foamVtkCore.H:104
Foam::cellModel::PRISM
prism
Definition: cellModel.H:83
Foam::cellModel::ref
static const cellModel & ref(const modelType model)
Look up reference to cellModel by enumeration. Fatal on failure.
Definition: cellModels.C:157
Foam::FatalError
error FatalError
mesh
dynamicFvMesh & mesh
Definition: createDynamicFvMesh.H:6
Foam::vtk::vtuSizing::nVertLabels
label nVertLabels() const
Number of vertex labels for the mesh.
Definition: foamVtuSizingI.H:50
Foam::exit
errorManipArg< error, int > exit(error &err, const int errNo=1)
Definition: errorManip.H:130
Foam::hex
IOstream & hex(IOstream &io)
Definition: IOstream.H:437
Foam::cellModel::WEDGE
wedge
Definition: cellModel.H:82
FatalErrorInFunction
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:372
Foam::cellModel::PYR
pyr
Definition: cellModel.H:84
cellTypes
const labelList & cellTypes
Definition: setCellMask.H:33
f
labelList f(nPoints)
Foam::faceList
List< face > faceList
A List of faces.
Definition: faceListFwd.H:47
foamVtkCore.H
Foam::vtk::VTK_TETRA
Definition: foamVtkCore.H:101
cellShape.H
forAllReverse
#define forAllReverse(list, i)
Reverse loop across all elements in list.
Definition: stdFoam.H:309
Foam::cellModel::TETWEDGE
tetWedge
Definition: cellModel.H:87
Foam::labelHashSet
HashSet< label, Hash< label > > labelHashSet
A HashSet with label keys and label hasher.
Definition: HashSet.H:410