polyTopoChange.H
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) 2011-2016 OpenFOAM Foundation
9  Copyright (C) 2018-2020 OpenCFD Ltd.
10 -------------------------------------------------------------------------------
11 License
12  This file is part of OpenFOAM.
13 
14  OpenFOAM is free software: you can redistribute it and/or modify it
15  under the terms of the GNU General Public License as published by
16  the Free Software Foundation, either version 3 of the License, or
17  (at your option) any later version.
18 
19  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
20  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
21  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22  for more details.
23 
24  You should have received a copy of the GNU General Public License
25  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
26 
27 Class
28  Foam::polyTopoChange
29 
30 Description
31  Direct mesh changes based on v1.3 polyTopoChange syntax.
32 
33  Instead of recording changes and executing them all in one go (as did
34  v1.3 polyTopoChange) this class actually holds the current
35  points/faces/cells and does the change immediately.
36  It can be asked to compress out all unused points/faces/cells and
37  renumber everything to be consistent.
38 
39  Note:
40  - polyTopoChange can be copied.
41  - adding a face using non-existing cells causes all intermediate cells
42  to be added. So always first add cells/points and then faces.
43  (or set strict checking)
44  - strict checking:
45  - any added/modified face can only use already existing vertices
46  - any added face can only use already existing cells
47  - no item can be removed more than once.
48  - removed cell: cell set to 0 faces.
49  - removed face: face set to 0 vertices.
50  - removed point: coordinate set to vector::max (VGREAT,VGREAT,VGREAT).
51  Note that this might give problems if this value is used already.
52  To see if point is equal to above value we don't use == (which might give
53  problems with roundoff error) but instead compare the individual component
54  with >.
55  - coupled patches: the reorderCoupledFaces routine (borrowed from
56  the couplePatches utility) reorders coupled patch faces and
57  uses the cyclicPolyPatch,processorPolyPatch functionality.
58 
59 SourceFiles
60  polyTopoChange.C
61  polyTopoChangeI.H
62  polyTopoChangeTemplates.C
63 
64 \*---------------------------------------------------------------------------*/
65 
66 #ifndef polyTopoChange_H
67 #define polyTopoChange_H
68 
69 #include "DynamicList.H"
70 #include "labelList.H"
71 #include "pointField.H"
72 #include "Map.H"
73 #include "HashSet.H"
74 #include "mapPolyMesh.H"
75 #include "bitSet.H"
76 
77 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
78 
79 namespace Foam
80 {
81 
82 // Forward declarations
83 class face;
84 class primitiveMesh;
85 class polyMesh;
86 class Time;
87 class fileName;
88 class polyBoundaryMesh;
89 class polyPatch;
90 class dictionary;
91 class topoAction;
92 class objectMap;
93 class IOobject;
94 template<class T, class Container> class CompactListList;
95 
96 /*---------------------------------------------------------------------------*\
97  Class polyTopoChange Declaration
98 \*---------------------------------------------------------------------------*/
99 
100 class polyTopoChange
101 {
102  // Private data
103 
104  //- Whether to allow referencing illegal points/cells/faces
105  // when adding/removing data.
106  bool strict_;
107 
108 
109  // Patches
110 
111  //- Number of patches
112  label nPatches_;
113 
114 
115  // Points
116 
117  //- Current point set
118  DynamicList<point> points_;
119 
120  //- Original point label (or masterpoint for added points)
121  DynamicList<label> pointMap_;
122 
123  //- For all original and added points contains new point label.
124  //- (used to map return value of addPoint to new mesh point)
125  DynamicList<label> reversePointMap_;
126 
127  //- Zone of point
128  Map<label> pointZone_;
129 
130  //- Retired points
131  labelHashSet retiredPoints_;
132 
133 
134  // Faces
135 
136  //- Current faceList
137  DynamicList<face> faces_;
138 
139  //- Patch for every external face (-1 for internal faces)
140  DynamicList<label> region_;
141 
142  //- Owner for all faces
143  DynamicList<label> faceOwner_;
144 
145  //- Neighbour for internal faces (-1 for external faces)
146  DynamicList<label> faceNeighbour_;
147 
148  //- Original face label. Or master face for added-from-faces;
149  // -1 for faces added-from-edge or added-from-point)
150  DynamicList<label> faceMap_;
151 
152  //- For all original and added faces contains new face label
153  // (used to map return value of addFace to new mesh face)
154  DynamicList<label> reverseFaceMap_;
155 
156  //- Faces added from point (corresponding faceMap_ will
157  // be -1)
158  Map<label> faceFromPoint_;
159 
160  //- Faces added from edge (corresponding faceMap_ will
161  // be -1)
162  Map<label> faceFromEdge_;
163 
164  //- In mapping whether to reverse the flux.
165  bitSet flipFaceFlux_;
166 
167  //- Zone of face
168  Map<label> faceZone_;
169 
170  //- Orientation of face in zone
171  bitSet faceZoneFlip_;
172 
173  //- Active faces
174  label nActiveFaces_;
175 
176 
177  // Cells
178 
179  //- Original cell label or master cell for added-from-cell;
180  // -1 for cells added from face or edge.
181  DynamicList<label> cellMap_;
182 
183  //- For all original and added cells contains new cell label
184  // (used to map return value of addCell to new mesh cell)
185  DynamicList<label> reverseCellMap_;
186 
187  //- Cells added from point
188  Map<label> cellFromPoint_;
189 
190  //- Cells added from edge
191  Map<label> cellFromEdge_;
192 
193  //- Cells added from face
194  Map<label> cellFromFace_;
195 
196  //- Zone of cell
197  DynamicList<label> cellZone_;
198 
199 
200  // Private Member Functions
201 
202  //- Reorder contents of container according to oldToNew map
203  template<class Type>
204  static void reorder
205  (
206  const labelUList& oldToNew,
207  DynamicList<Type>& lst
208  );
209 
210  template<class Type>
211  static void reorder
212  (
213  const labelUList& oldToNew,
214  List<DynamicList<Type>>& lst
215  );
216 
217  template<class Type>
218  static void renumberKey
219  (
220  const labelUList& oldToNew,
221  Map<Type>& map
222  );
223 
224  //- Renumber elements of container according to oldToNew map
225  static void renumber
226  (
227  const labelUList& oldToNew,
228  labelHashSet& labels
229  );
230 
231  //- Special handling of reverse maps which have <-1 in them
232  static void renumberReverseMap
233  (
234  const labelUList& oldToNew,
235  DynamicList<label>& elems
236  );
237 
238  //- Renumber & compact elements of list according to map
239  static void renumberCompact
240  (
241  const labelUList& oldToNew,
242  labelList& elems
243  );
244 
245  //- Count number of added and removed quantities from maps.
246  static void countMap
247  (
248  const labelUList& map,
249  const labelUList& reverseMap,
250  label& nAdd,
251  label& nInflate,
252  label& nMerge,
253  label& nRemove
254  );
255 
256  //- Print some stats about mesh
257  static void writeMeshStats(const polyMesh& mesh, Ostream& os);
258 
259  //- Calculate object maps. Requires reverseMap to have destination
260  // to be marked with <-1.
261  static void getMergeSets
262  (
263  const labelUList& reverseCellMap,
264  const labelUList& cellMap,
265  List<objectMap>& cellsFromCells
266  );
267 
268  //- Are all face vertices valid
269  bool hasValidPoints(const face& f) const;
270 
271  //- Return face points
272  pointField facePoints(const face& f) const;
273 
274  //- Check inputs to modFace or addFace
275  void checkFace
276  (
277  const face& f,
278  const label facei,
279  const label own,
280  const label nei,
281  const label patchi,
282  const label zoneI
283  ) const;
284 
285  //- Construct cells (in packed storage)
286  void makeCells
287  (
288  const label nActiveFaces,
289  labelList& cellFaces,
290  labelList& cellFaceOffsets
291  ) const;
292 
293  //- Construct cellCells (in packed storage)
294  void makeCellCells
295  (
296  const label nActiveFaces,
298  ) const;
299 
300  //- Cell ordering (bandCompression). Returns number of remaining cells.
301  label getCellOrder
302  (
303  const CompactListList<label, labelList>& cellCellAddressing,
304  labelList& oldToNew
305  ) const;
306 
307  //- Do upper-triangular ordering and patch ordering.
308  void getFaceOrder
309  (
310  const label nActiveFaces,
311  const labelUList& cellFaces,
312  const labelUList& cellFaceOffsets,
313 
314  labelList& oldToNew,
315  labelList& patchSizes,
316  labelList& patchStarts
317  ) const;
318 
319  //- Compact and reorder faces according to map
320  void reorderCompactFaces
321  (
322  const label newSize,
323  const labelUList& oldToNew
324  );
325 
326  //- Remove all unused/removed points/faces/cells and update
327  //- face ordering (always), cell ordering (bandcompression,
328  //- orderCells=true),
329  //- point ordering (sorted into internal and boundary points,
330  //- orderPoints=true)
331  void compact
332  (
333  const bool orderCells,
334  const bool orderPoints,
335  label& nInternalPoints,
336  labelList& patchSizes,
337  labelList& patchStarts
338  );
339 
340  //- Select either internal or external faces out of faceLabels
341  static labelList selectFaces
342  (
343  const primitiveMesh& mesh,
344  const labelUList& faceLabels,
345  const bool internalFacesOnly
346  );
347 
348  //- Calculate mapping for patchpoints only
349  void calcPatchPointMap
350  (
351  const UList<Map<label>>& oldPatchMeshPointMaps,
352  const polyBoundaryMesh& boundary,
353  labelListList& patchPointMap
354  ) const;
355 
356  void calcFaceInflationMaps
357  (
358  const polyMesh& mesh,
359  List<objectMap>& facesFromPoints,
360  List<objectMap>& facesFromEdges,
361  List<objectMap>& facesFromFaces
362  ) const;
363 
364  void calcCellInflationMaps
365  (
366  const polyMesh& mesh,
367  List<objectMap>& cellsFromPoints,
368  List<objectMap>& cellsFromEdges,
369  List<objectMap>& cellsFromFaces,
370  List<objectMap>& cellsFromCells
371  ) const;
372 
373  void resetZones
374  (
375  const polyMesh& mesh, // mesh to get existing info from
376  polyMesh& newMesh, // mesh to change zones on
377  labelListList& pointZoneMap,
378  labelListList& faceZoneFaceMap,
379  labelListList& cellZoneMap
380  ) const;
381 
382  void calcFaceZonePointMap
383  (
384  const polyMesh& mesh,
385  const UList<Map<label>>& oldFaceZoneMeshPointMaps,
386  labelListList& faceZonePointMap
387  ) const;
388 
389 
390  // Coupling
391 
392  //- Do all coupled patch face reordering
393  void reorderCoupledFaces
394  (
395  const bool syncParallel,
396  const polyBoundaryMesh& boundary,
397  const labelUList& patchStarts,
398  const labelUList& patchSizes,
399  const pointField& points
400  );
401 
402  void compactAndReorder
403  (
404  const polyMesh& mesh,
405  const bool syncParallel,
406  const bool orderCells,
407  const bool orderPoints,
408  label& nInternalPoints,
409  pointField& newPoints,
410  labelList& patchSizes,
411  labelList& patchStarts,
412  List<objectMap>& pointsFromPoints,
413  List<objectMap>& facesFromPoints,
414  List<objectMap>& facesFromEdges,
415  List<objectMap>& facesFromFaces,
416  List<objectMap>& cellsFromPoints,
417  List<objectMap>& cellsFromEdges,
418  List<objectMap>& cellsFromFaces,
419  List<objectMap>& cellsFromCells,
420  List<Map<label>>& oldPatchMeshPointMaps,
421  labelList& oldPatchNMeshPoints,
422  labelList& oldPatchStarts,
423  List<Map<label>>& oldFaceZoneMeshPointMaps
424  );
425 
426 public:
427 
428  //- Runtime type information
429  ClassName("polyTopoChange");
430 
431 
432 
433  // Constructors
434 
435  //- Construct without mesh. Either specify nPatches or use
436  //- setNumPatches before trying to make a mesh (makeMesh, changeMesh)
437  polyTopoChange(const label nPatches, const bool strict = true);
438 
439  //- Construct from mesh. Adds all points/face/cells from mesh.
440  polyTopoChange(const polyMesh& mesh, const bool strict = true);
441 
442 
443  // Member Functions
444 
445  // Access
446 
447  //- Points. Shrunk after constructing mesh (or calling of compact())
448  const DynamicList<point>& points() const
449  {
450  return points_;
451  }
452 
453  const DynamicList<face>& faces() const
454  {
455  return faces_;
456  }
457 
458  const DynamicList<label>& region() const
459  {
460  return region_;
461  }
462 
463  const DynamicList<label>& faceOwner() const
464  {
465  return faceOwner_;
466  }
467 
468  const DynamicList<label>& faceNeighbour() const
469  {
470  return faceNeighbour_;
471  }
472 
473  //- Is point removed?
474  //- Considered removed if point is GREAT.
475  inline bool pointRemoved(const label pointi) const;
476 
477  //- Is face removed?
478  //- Considered removed if face is empty
479  inline bool faceRemoved(const label facei) const;
480 
481  //- Is cell removed?
482  //- Considered removed if the cellMap is -2
483  inline bool cellRemoved(const label celli) const;
484 
485 
486  // Edit
487 
488  //- Clear all storage
489  void clear();
490 
491  //- Add all points/faces/cells of mesh. Additional offset for patch
492  //- or zone ids.
493  void addMesh
494  (
495  const polyMesh& mesh,
496  const labelUList& patchMap,
497  const labelUList& pointZoneMap,
498  const labelUList& faceZoneMap,
499  const labelUList& cellZoneMap
500  );
501 
502  //- Explicitly pre-size the dynamic storage for expected mesh
503  //- size for if construct-without-mesh
504  void setCapacity
505  (
506  const label nPoints,
507  const label nFaces,
508  const label nCells
509  );
510 
511  //- Move all points. Incompatible with other topology changes.
512  void movePoints(const pointField& newPoints);
513 
514  //- For compatibility with polyTopoChange: set topological action.
515  label setAction(const topoAction& action);
516 
517  //- Add point. Return new point label.
518  // Notes:
519  // - masterPointID can be < 0 (appended points)
520  // - inCell = false: add retired point (to end of point list)
521  label addPoint
522  (
523  const point& pt,
524  const label masterPointID,
525  const label zoneID,
526  const bool inCell
527  );
528 
529  //- Modify coordinate.
530  // Notes:
531  // - zoneID = +ve (add to zoneID), -ve (remove from zones)
532  // - inCell = false: add retired point (to end of point list)
533  void modifyPoint
534  (
535  const label pointi,
536  const point& pt,
537  const label zoneID,
538  const bool inCell
539  );
540 
541  //- Remove/merge point.
542  void removePoint(const label pointi, const label mergePointi);
543 
544  //- Add face to cells. Return new face label.
545  // own,nei<0, zoneID>=0 : add inactive face (to end of face list)
546  label addFace
547  (
548  const face& f,
549  const label own,
550  const label nei,
551  const label masterPointID,
552  const label masterEdgeID,
553  const label masterFaceID,
554  const bool flipFaceFlux,
555  const label patchID,
556  const label zoneID,
557  const bool zoneFlip
558  );
559 
560  //- Modify vertices or cell of face.
561  void modifyFace
562  (
563  const face& f,
564  const label facei,
565  const label own,
566  const label nei,
567  const bool flipFaceFlux,
568  const label patchID,
569  const label zoneID,
570  const bool zoneFlip
571  );
572 
573  //- Remove/merge face.
574  void removeFace(const label facei, const label mergeFacei);
575 
576  //- Add cell. Return new cell label.
577  label addCell
578  (
579  const label masterPointID,
580  const label masterEdgeID,
581  const label masterFaceID,
582  const label masterCellID,
583  const label zoneID
584  );
585 
586  //- Modify zone of cell
587  void modifyCell(const label celli, const label zoneID);
588 
589  //- Remove/merge cell.
590  void removeCell(const label celli, const label mergeCelli);
591 
592  //- Explicitly set the number of patches if construct-without-mesh
593  //- used.
594  inline void setNumPatches(const label nPatches);
595 
596  // Other
597 
598  //- Inplace changes mesh without change of patches.
599  // Adapts patch start/end and by default does parallel matching.
600  // Clears all data. Returns map.
601  // inflate = true : keep old mesh points. Put new points into the
602  // returned map (preMotionPoints) so we can use inflation. Any
603  // points out of nothing (appended points) are vector::zero.
604  // inflate = false: set mesh points directly. Empty preMotionPoints
605  // in the map.
606  // orderCells : whether to order the cells (see bandCompression.H)
607  // orderPoints : whether to order the points into internal first
608  // followed by boundary points. This is not fully consistent
609  // with upper-triangular ordering of points and edges so
610  // is only done when explicitly asked for.
612  (
613  polyMesh& mesh,
614  const bool inflate,
615  const bool syncParallel = true,
616  const bool orderCells = false,
617  const bool orderPoints = false
618  );
619 
620  //- Create new mesh with old mesh patches
621  template<class Type>
623  (
624  autoPtr<Type>& newMesh,
625  const IOobject& io,
626  const polyMesh& mesh,
627  const bool syncParallel = true,
628  const bool orderCells = false,
629  const bool orderPoints = false
630  );
631 };
632 
633 
634 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
635 
636 } // End namespace Foam
637 
638 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
639 
640 #include "polyTopoChangeI.H"
641 
642 #ifdef NoRepository
643  #include "polyTopoChangeTemplates.C"
644 #endif
645 
646 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
647 
648 #endif
649 
650 // ************************************************************************* //
Foam::polyTopoChange::addCell
label addCell(const label masterPointID, const label masterEdgeID, const label masterFaceID, const label masterCellID, const label zoneID)
Add cell. Return new cell label.
Definition: polyTopoChange.C:2870
Foam::IOobject
Defines the attributes of an object for which implicit objectRegistry management is supported,...
Definition: IOobject.H:104
Foam::polyTopoChange::clear
void clear()
Clear all storage.
Definition: polyTopoChange.C:2188
Foam::polyTopoChange::addMesh
void addMesh(const polyMesh &mesh, const labelUList &patchMap, const labelUList &pointZoneMap, const labelUList &faceZoneMap, const labelUList &cellZoneMap)
Definition: polyTopoChange.C:2219
Foam::bitSet
A bitSet stores bits (elements with only two states) in packed internal format and supports a variety...
Definition: bitSet.H:64
Foam::polyBoundaryMesh
A polyBoundaryMesh is a polyPatch list with additional search methods and registered IO.
Definition: polyBoundaryMesh.H:62
nPatches
label nPatches
Definition: readKivaGrid.H:396
Foam::polyTopoChange::changeMesh
autoPtr< mapPolyMesh > changeMesh(polyMesh &mesh, const bool inflate, const bool syncParallel=true, const bool orderCells=false, const bool orderPoints=false)
Inplace changes mesh without change of patches.
Definition: polyTopoChange.C:2955
Foam::DynamicList< point >
Foam::polyTopoChange::removePoint
void removePoint(const label pointi, const label mergePointi)
Remove/merge point.
Definition: polyTopoChange.C:2674
Foam::polyTopoChange::removeCell
void removeCell(const label celli, const label mergeCelli)
Remove/merge cell.
Definition: polyTopoChange.C:2917
Foam::polyTopoChange::points
const DynamicList< point > & points() const
Points. Shrunk after constructing mesh (or calling of compact())
Definition: polyTopoChange.H:447
Foam::CompactListList
A packed storage unstructured matrix of objects of type <T> using an offset table for access.
Definition: polyTopoChange.H:93
mapPolyMesh.H
Foam::polyTopoChange::addFace
label addFace(const face &f, const label own, const label nei, const label masterPointID, const label masterEdgeID, const label masterFaceID, const bool flipFaceFlux, const label patchID, const label zoneID, const bool zoneFlip)
Add face to cells. Return new face label.
Definition: polyTopoChange.C:2722
Foam::polyTopoChange::pointRemoved
bool pointRemoved(const label pointi) const
Definition: polyTopoChangeI.H:32
Foam::polyTopoChange::addPoint
label addPoint(const point &pt, const label masterPointID, const label zoneID, const bool inCell)
Add point. Return new point label.
Definition: polyTopoChange.C:2585
Foam::polyTopoChange
Direct mesh changes based on v1.3 polyTopoChange syntax.
Definition: polyTopoChange.H:99
Foam::Map< label >
polyTopoChangeI.H
Foam::polyTopoChange::faceRemoved
bool faceRemoved(const label facei) const
Definition: polyTopoChangeI.H:43
Foam::polyTopoChange::modifyCell
void modifyCell(const label celli, const label zoneID)
Modify zone of cell.
Definition: polyTopoChange.C:2907
Foam::polyTopoChange::faceOwner
const DynamicList< label > & faceOwner() const
Definition: polyTopoChange.H:462
Foam::HashSet< label, Hash< label > >
bitSet.H
Foam::polyMesh
Mesh consisting of general polyhedral cells.
Definition: polyMesh.H:77
Foam::polyTopoChange::faceNeighbour
const DynamicList< label > & faceNeighbour() const
Definition: polyTopoChange.H:467
Foam::polyTopoChange::setCapacity
void setCapacity(const label nPoints, const label nFaces, const label nCells)
Definition: polyTopoChange.C:2424
nPoints
label nPoints
Definition: gmvOutputHeader.H:2
Map.H
Foam::polyTopoChange::polyTopoChange
polyTopoChange(const label nPatches, const bool strict=true)
Definition: polyTopoChange.C:2112
labelList.H
Foam::Field< vector >
Foam::polyTopoChange::faces
const DynamicList< face > & faces() const
Definition: polyTopoChange.H:452
patchID
label patchID
Definition: boundaryProcessorFaPatchPoints.H:5
Foam::polyTopoChange::modifyFace
void modifyFace(const face &f, const label facei, const label own, const label nei, const bool flipFaceFlux, const label patchID, const label zoneID, const bool zoneFlip)
Modify vertices or cell of face.
Definition: polyTopoChange.C:2786
Foam::reorder
ListType reorder(const labelUList &oldToNew, const ListType &input, const bool prune=false)
Reorder the elements of a list.
Definition: ListOpsTemplates.C:80
HashSet.H
polyTopoChangeTemplates.C
mesh
dynamicFvMesh & mesh
Definition: createDynamicFvMesh.H:6
zoneID
const labelIOList & zoneID
Definition: interpolatedFaces.H:22
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.C:33
Foam::polyTopoChange::cellRemoved
bool cellRemoved(const label celli) const
Definition: polyTopoChangeI.H:49
Foam::polyTopoChange::removeFace
void removeFace(const label facei, const label mergeFacei)
Remove/merge face.
Definition: polyTopoChange.C:2823
Foam::polyTopoChange::ClassName
ClassName("polyTopoChange")
Runtime type information.
pointField.H
Foam::autoPtr
Pointer management similar to std::unique_ptr, with some additional methods and type checking.
Definition: HashPtrTable.H:53
Foam::polyTopoChange::setAction
label setAction(const topoAction &action)
For compatibility with polyTopoChange: set topological action.
Definition: polyTopoChange.C:2456
f
labelList f(nPoints)
Foam::Vector< scalar >
Foam::polyTopoChange::modifyPoint
void modifyPoint(const label pointi, const point &pt, const label zoneID, const bool inCell)
Modify coordinate.
Definition: polyTopoChange.C:2613
Foam::List
A 1D array of objects of type <T>, where the size of the vector is known and used for subscript bound...
Definition: HashTable.H:102
Foam::UList< label >
Foam::polyTopoChange::setNumPatches
void setNumPatches(const label nPatches)
Definition: polyTopoChangeI.H:55
Foam::topoAction
A virtual base class for topological actions.
Definition: topoAction.H:51
Foam::face
A face is a list of labels corresponding to mesh vertices.
Definition: face.H:72
DynamicList.H
Foam::polyTopoChange::region
const DynamicList< label > & region() const
Definition: polyTopoChange.H:457
Foam::Ostream
An Ostream is an abstract base class for all output systems (streams, files, token lists,...
Definition: Ostream.H:56
Foam::polyTopoChange::makeMesh
autoPtr< mapPolyMesh > makeMesh(autoPtr< Type > &newMesh, const IOobject &io, const polyMesh &mesh, const bool syncParallel=true, const bool orderCells=false, const bool orderPoints=false)
Create new mesh with old mesh patches.
boundary
faceListList boundary
Definition: createBlockMesh.H:4
Foam::polyTopoChange::movePoints
void movePoints(const pointField &newPoints)
Move all points. Incompatible with other topology changes.
Definition: polyTopoChange.C:2655
Foam::primitiveMesh
Cell-face mesh analysis engine.
Definition: primitiveMesh.H:78