polyMesh.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 | Copyright (C) 2011-2016 OpenFOAM Foundation
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8 License
9  This file is part of OpenFOAM.
10 
11  OpenFOAM is free software: you can redistribute it and/or modify it
12  under the terms of the GNU General Public License as published by
13  the Free Software Foundation, either version 3 of the License, or
14  (at your option) any later version.
15 
16  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
17  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19  for more details.
20 
21  You should have received a copy of the GNU General Public License
22  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
23 
24 Class
25  Foam::polyMesh
26 
27 Description
28  Mesh consisting of general polyhedral cells.
29 
30 SourceFiles
31  polyMesh.C
32  polyMeshInitMesh.C
33  polyMeshClear.C
34  polyMeshFromShapeMesh.C
35  polyMeshIO.C
36  polyMeshUpdate.C
37  polyMeshCheck.C
38 
39 \*---------------------------------------------------------------------------*/
40 
41 #ifndef polyMesh_H
42 #define polyMesh_H
43 
44 #include "objectRegistry.H"
45 #include "primitiveMesh.H"
46 #include "pointField.H"
47 #include "faceList.H"
48 #include "cellList.H"
49 #include "cellShapeList.H"
50 #include "pointIOField.H"
51 #include "faceIOList.H"
52 #include "labelIOList.H"
53 #include "polyBoundaryMesh.H"
54 #include "boundBox.H"
55 #include "pointZoneMesh.H"
56 #include "faceZoneMesh.H"
57 #include "cellZoneMesh.H"
58 
59 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
60 
61 namespace Foam
62 {
63 
64 // Forward declaration of classes
65 class globalMeshData;
66 class mapPolyMesh;
67 class polyMeshTetDecomposition;
68 class treeDataCell;
69 template<class Type> class indexedOctree;
70 
71 /*---------------------------------------------------------------------------*\
72  Class polyMesh Declaration
73 \*---------------------------------------------------------------------------*/
74 
75 class polyMesh
76 :
77  public objectRegistry,
78  public primitiveMesh
79 {
80 
81 public:
82 
83  // Public data types
84 
85  //- Enumeration defining the state of the mesh after a read update.
86  // Used for post-processing applications, where the mesh
87  // needs to update based on the files written in time
88  // directores
89  enum readUpdateState
90  {
95  };
96 
97  //- Enumeration defining the decomposition of the cell for
98  // inside/outside test
100  {
101  FACE_PLANES, //- Faces considered as planes
103  FACE_CENTRE_TRIS, //- Faces decomposed into triangles
104  // using face-centre
106  FACE_DIAG_TRIS, //- Faces decomposed into triangles diagonally
108  CELL_TETS //- Cell decomposed into tets
109  };
110 
111 
112 private:
113 
114  // Permanent data
115 
116  // Primitive mesh data
117 
118  //- Points
119  pointIOField points_;
120 
121  //- Faces
122  faceCompactIOList faces_;
123 
124  //- Face owner
125  labelIOList owner_;
126 
127  //- Face neighbour
128  labelIOList neighbour_;
129 
130  //- Have the primitives been cleared
131  bool clearedPrimitives_;
132 
133 
134  //- Boundary mesh
135  mutable polyBoundaryMesh boundary_;
136 
137  //- Mesh bounding-box.
138  // Created from points on construction, updated when the mesh moves
139  boundBox bounds_;
140 
141  //- Communicator used for parallel communication
142  label comm_;
143 
144  //- Vector of non-constrained directions in mesh
145  // defined according to the presence of empty and wedge patches
146  mutable Vector<label> geometricD_;
147 
148  //- Vector of valid directions in mesh
149  // defined according to the presence of empty patches
150  mutable Vector<label> solutionD_;
151 
152  //- Base point for face decomposition into tets
153  mutable autoPtr<labelList> tetBasePtIsPtr_;
154 
155  //- Search tree to allow spatial cell searching
156  mutable autoPtr<indexedOctree<treeDataCell>> cellTreePtr_;
157 
158 
159  // Zoning information
160 
161  //- Point zones
162  pointZoneMesh pointZones_;
163 
164  //- Face zones
165  faceZoneMesh faceZones_;
166 
167  //- Cell zones
168  cellZoneMesh cellZones_;
169 
170 
171  //- Parallel info
172  mutable autoPtr<globalMeshData> globalMeshDataPtr_;
173 
174 
175  // Mesh motion related data
176 
177  //- Is the mesh moving
178  bool moving_;
179 
180  //- Is the mesh topology changing
181  bool topoChanging_;
182 
183  //- Current time index for mesh motion
184  mutable label curMotionTimeIndex_;
185 
186  //- Old points (for the last mesh motion)
187  mutable autoPtr<pointField> oldPointsPtr_;
188 
189 
190  // Private Member Functions
191 
192  //- Disallow construct as copy
193  polyMesh(const polyMesh&);
194 
195  //- Disallow default bitwise assignment
196  void operator=(const polyMesh&);
197 
198  //- Initialise the polyMesh from the primitive data
199  void initMesh();
200 
201  //- Initialise the polyMesh from the given set of cells
202  void initMesh(cellList& c);
203 
204  //- Calculate the valid directions in the mesh from the boundaries
205  void calcDirections() const;
206 
207  //- Calculate the cell shapes from the primitive
208  // polyhedral information
209  void calcCellShapes() const;
210 
211 
212  // Helper functions for constructor from cell shapes
213 
214  labelListList cellShapePointCells(const cellShapeList&) const;
215 
216  labelList facePatchFaceCells
217  (
218  const faceList& patchFaces,
219  const labelListList& pointCells,
220  const faceListList& cellsFaceShapes,
221  const label patchID
222  ) const;
223 
224  void setTopology
225  (
226  const cellShapeList& cellsAsShapes,
227  const faceListList& boundaryFaces,
228  const wordList& boundaryPatchNames,
229  labelList& patchSizes,
230  labelList& patchStarts,
231  label& defaultPatchStart,
232  label& nFaces,
233  cellList& cells
234  );
235 
236 
237  // Geometry checks
238 
239  //- Check non-orthogonality
240  bool checkFaceOrthogonality
241  (
242  const vectorField& fAreas,
243  const vectorField& cellCtrs,
244  const bool report,
245  const bool detailedReport,
246  labelHashSet* setPtr
247  ) const;
248 
249  //- Check face skewness
250  bool checkFaceSkewness
251  (
252  const pointField& points,
253  const vectorField& fCtrs,
254  const vectorField& fAreas,
255  const vectorField& cellCtrs,
256  const bool report,
257  const bool detailedReport,
258  labelHashSet* setPtr
259  ) const;
260 
261  bool checkEdgeAlignment
262  (
263  const pointField& p,
264  const bool report,
265  const Vector<label>& directions,
266  labelHashSet* setPtr
267  ) const;
268 
269  bool checkCellDeterminant
270  (
271  const vectorField& faceAreas,
272  const bool report,
273  labelHashSet* setPtr,
274  const Vector<label>& meshD
275  ) const;
276 
277  bool checkFaceWeight
278  (
279  const vectorField& fCtrs,
280  const vectorField& fAreas,
281  const vectorField& cellCtrs,
282  const bool report,
283  const scalar minWeight,
284  labelHashSet* setPtr
285  ) const;
286 
287  bool checkVolRatio
288  (
289  const scalarField& cellVols,
290  const bool report,
291  const scalar minRatio,
292  labelHashSet* setPtr
293  ) const;
294 
295 public:
296 
297  // Public typedefs
299  typedef polyMesh Mesh;
301 
302 
303  //- Runtime type information
304  TypeName("polyMesh");
305 
306  //- Return the default region name
307  static word defaultRegion;
308 
309  //- Return the mesh sub-directory name (usually "polyMesh")
310  static word meshSubDir;
311 
312 
313  // Constructors
314 
315  //- Construct from IOobject
316  explicit polyMesh(const IOobject& io);
317 
318  //- Construct from IOobject or from components.
319  // Boundary is added using addPatches() member function
320  polyMesh
321  (
322  const IOobject& io,
323  const Xfer<pointField>& points,
324  const Xfer<faceList>& faces,
325  const Xfer<labelList>& owner,
326  const Xfer<labelList>& neighbour,
327  const bool syncPar = true
328  );
329 
330  //- Construct without boundary with cells rather than owner/neighbour.
331  // Boundary is added using addPatches() member function
332  polyMesh
333  (
334  const IOobject& io,
335  const Xfer<pointField>& points,
336  const Xfer<faceList>& faces,
337  const Xfer<cellList>& cells,
338  const bool syncPar = true
339  );
340 
341  //- Construct from cell shapes
342  polyMesh
343  (
344  const IOobject& io,
345  const Xfer<pointField>& points,
346  const cellShapeList& shapes,
347  const faceListList& boundaryFaces,
348  const wordList& boundaryPatchNames,
349  const wordList& boundaryPatchTypes,
350  const word& defaultBoundaryPatchName,
351  const word& defaultBoundaryPatchType,
352  const wordList& boundaryPatchPhysicalTypes,
353  const bool syncPar = true
354  );
355 
356  //- Construct from cell shapes with patch information in dictionary
357  // format.
358  polyMesh
359  (
360  const IOobject& io,
361  const Xfer<pointField>& points,
362  const cellShapeList& shapes,
363  const faceListList& boundaryFaces,
364  const wordList& boundaryPatchNames,
365  const PtrList<dictionary>& boundaryDicts,
366  const word& defaultBoundaryPatchName,
367  const word& defaultBoundaryPatchType,
368  const bool syncPar = true
369  );
370 
371 
372  //- Destructor
373  virtual ~polyMesh();
374 
375 
376  // Member Functions
377 
378  // Database
379 
380  //- Override the objectRegistry dbDir for a single-region case
381  virtual const fileName& dbDir() const;
382 
383  //- Return the local mesh directory (dbDir()/meshSubDir)
384  fileName meshDir() const;
385 
386  //- Return the current instance directory for points
387  // Used in the consruction of gemometric mesh data dependent
388  // on points
389  const fileName& pointsInstance() const;
390 
391  //- Return the current instance directory for faces
392  const fileName& facesInstance() const;
393 
394  //- Set the instance for mesh files
395  void setInstance(const fileName&);
396 
397 
398  // Access
399 
400  //- Return raw points
401  virtual const pointField& points() const;
402 
403  //- Return true if io is up-to-date with points
404  virtual bool upToDatePoints(const regIOobject& io) const;
405 
406  //- Set io to be up-to-date with points
407  virtual void setUpToDatePoints(regIOobject& io) const;
408 
409  //- Return raw faces
410  virtual const faceList& faces() const;
411 
412  //- Return face owner
413  virtual const labelList& faceOwner() const;
414 
415  //- Return face neighbour
416  virtual const labelList& faceNeighbour() const;
417 
418  //- Return old points for mesh motion
419  virtual const pointField& oldPoints() const;
420 
421  //- Return boundary mesh
422  const polyBoundaryMesh& boundaryMesh() const
423  {
424  return boundary_;
425  }
426 
427  //- Return mesh bounding box
428  const boundBox& bounds() const
429  {
430  return bounds_;
431  }
432 
433  //- Return the vector of geometric directions in mesh.
434  // Defined according to the presence of empty and wedge patches.
435  // 1 indicates unconstrained direction and -1 a constrained
436  // direction.
437  const Vector<label>& geometricD() const;
438 
439  //- Return the number of valid geometric dimensions in the mesh
440  label nGeometricD() const;
441 
442  //- Return the vector of solved-for directions in mesh.
443  // Differs from geometricD in that it includes for wedge cases
444  // the circumferential direction in case of swirl.
445  // 1 indicates valid direction and -1 an invalid direction.
446  const Vector<label>& solutionD() const;
447 
448  //- Return the number of valid solved-for dimensions in the mesh
449  label nSolutionD() const;
450 
451  //- Return the tetBasePtIs
452  const labelList& tetBasePtIs() const;
453 
454  //- Return the cell search tree
455  const indexedOctree<treeDataCell>& cellTree() const;
456 
457  //- Return point zone mesh
458  const pointZoneMesh& pointZones() const
459  {
460  return pointZones_;
461  }
462 
463  //- Return face zone mesh
464  const faceZoneMesh& faceZones() const
465  {
466  return faceZones_;
467  }
468 
469  //- Return cell zone mesh
470  const cellZoneMesh& cellZones() const
471  {
472  return cellZones_;
473  }
474 
475  //- Return parallel info
476  const globalMeshData& globalData() const;
477 
478  //- Return communicator used for parallel communication
479  label comm() const;
480 
481  //- Return communicator used for parallel communication
482  label& comm();
483 
484  //- Return the object registry
485  const objectRegistry& thisDb() const
486  {
487  return *this;
488  }
489 
490 
491  // Mesh motion
492 
493  //- Is mesh moving
494  bool moving() const
495  {
496  return moving_;
497  }
498 
499  //- Set the mesh to be moving
500  bool moving(const bool m)
501  {
502  bool m0 = moving_;
503  moving_ = m;
504  return m0;
505  }
506 
507  //- Is mesh topology changing
508  bool topoChanging() const
509  {
510  return topoChanging_;
511  }
512 
513  //- Set the mesh topology to be changing
514  bool topoChanging(const bool c)
515  {
516  bool c0 = topoChanging_;
517  topoChanging_ = c;
518  return c0;
519  }
520 
521  //- Is mesh changing (topology changing and/or moving)
522  bool changing() const
523  {
524  return moving()||topoChanging();
525  }
526 
527  //- Move points, returns volumes swept by faces in motion
528  virtual tmp<scalarField> movePoints(const pointField&);
529 
530  //- Reset motion
531  void resetMotion() const;
532 
533 
534  // Topological change
535 
536  //- Return non-const access to the pointZones
538  {
539  return pointZones_;
540  }
541 
542  //- Return non-const access to the faceZones
544  {
545  return faceZones_;
546  }
547 
548  //- Return non-const access to the cellZones
550  {
551  return cellZones_;
552  }
553 
554  //- Add boundary patches
555  void addPatches
556  (
557  const List<polyPatch*>&,
558  const bool validBoundary = true
559  );
560 
561  //- Add mesh zones
562  void addZones
563  (
564  const List<pointZone*>& pz,
565  const List<faceZone*>& fz,
566  const List<cellZone*>& cz
567  );
568 
569  //- Update the mesh based on the mesh files saved in
570  // time directories
571  virtual readUpdateState readUpdate();
572 
573  //- Update the mesh corresponding to given map
574  virtual void updateMesh(const mapPolyMesh& mpm);
575 
576  //- Remove boundary patches
577  void removeBoundary();
578 
579  //- Reset mesh primitive data. Assumes all patch info correct
580  // (so does e.g. parallel communication). If not use
581  // validBoundary=false
582  void resetPrimitives
583  (
584  const Xfer<pointField>& points,
585  const Xfer<faceList>& faces,
586  const Xfer<labelList>& owner,
587  const Xfer<labelList>& neighbour,
588  const labelList& patchSizes,
589  const labelList& patchStarts,
590  const bool validBoundary = true
591  );
592 
593 
594  // Storage management
595 
596  //- Clear geometry
597  void clearGeom();
598 
599  //- Clear addressing
600  void clearAddressing(const bool isMeshUpdate = false);
601 
602  //- Clear all geometry and addressing unnecessary for CFD
603  void clearOut();
604 
605  //- Clear primitive data (points, faces and cells)
606  void clearPrimitives();
607 
608  //- Clear geometry not used for CFD (cellTree, tetBasePtIs)
609  void clearAdditionalGeom();
610 
611  //- Clear cell tree data
612  void clearCellTree();
613 
614  //- Remove all files from mesh instance
615  void removeFiles(const fileName& instanceDir) const;
616 
617  //- Remove all files from mesh instance()
618  void removeFiles() const;
619 
620 
621  // Geometric checks. Selectively override primitiveMesh functionality.
622 
623  //- Check non-orthogonality
624  virtual bool checkFaceOrthogonality
625  (
626  const bool report = false,
627  labelHashSet* setPtr = NULL
628  ) const;
629 
630  //- Check face skewness
631  virtual bool checkFaceSkewness
632  (
633  const bool report = false,
634  labelHashSet* setPtr = NULL
635  ) const;
636 
637  //- Check edge alignment for 1D/2D cases
638  virtual bool checkEdgeAlignment
639  (
640  const bool report,
641  const Vector<label>& directions,
642  labelHashSet* setPtr
643  ) const;
644 
645  virtual bool checkCellDeterminant
646  (
647  const bool report,
648  labelHashSet* setPtr
649  ) const;
650 
651  //- Check mesh motion for correctness given motion points
652  virtual bool checkMeshMotion
653  (
654  const pointField& newPoints,
655  const bool report = false,
656  const bool detailedReport = false
657  ) const;
658 
659  //- Check for face weights
660  virtual bool checkFaceWeight
661  (
662  const bool report,
663  const scalar minWeight = 0.05,
664  labelHashSet* setPtr = NULL
665  ) const;
666 
667  //- Check for neighbouring cell volumes
668  virtual bool checkVolRatio
669  (
670  const bool report,
671  const scalar minRatio = 0.01,
672  labelHashSet* setPtr = NULL
673  ) const;
674 
675 
676  // Position search functions
677 
678  //- Find the cell, tetFacei and tetPti for point p
679  void findCellFacePt
680  (
681  const point& p,
682  label& celli,
683  label& tetFacei,
684  label& tetPti
685  ) const;
686 
687  //- Find the tetFacei and tetPti for point p in celli.
688  // tetFacei and tetPtI are set to -1 if not found
689  void findTetFacePt
690  (
691  const label celli,
692  const point& p,
693  label& tetFacei,
694  label& tetPti
695  ) const;
696 
697  //- Test if point p is in the celli
698  bool pointInCell
699  (
700  const point& p,
701  label celli,
703  ) const;
704 
705  //- Find cell enclosing this location and return index
706  // If not found -1 is returned
708  (
709  const point& p,
711  ) const;
712 };
713 
714 
715 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
716 
717 } // End namespace Foam
718 
719 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
720 
721 #endif
722 
723 // ************************************************************************* //
A simple container for copying or transferring objects of type <T>.
Definition: Xfer.H:85
polyMesh Mesh
Definition: polyMesh.H:298
virtual tmp< scalarField > movePoints(const pointField &)
Move points, returns volumes swept by faces in motion.
Definition: polyMesh.C:1048
const indexedOctree< treeDataCell > & cellTree() const
Return the cell search tree.
Definition: polyMesh.C:843
void clearAddressing()
Clear topological data.
intWM_LABEL_SIZE_t label
A label is an int32_t or int64_t as specified by the pre-processor macro WM_LABEL_SIZE.
Definition: label.H:59
label comm() const
Return communicator used for parallel communication.
Definition: polyMesh.C:1158
A class for handling file names.
Definition: fileName.H:69
void removeFiles() const
Remove all files from mesh instance()
Definition: polyMesh.C:1194
const boundBox & bounds() const
Return mesh bounding box.
Definition: polyMesh.H:427
void resetMotion() const
Reset motion.
Definition: polyMesh.C:1133
const fileName & facesInstance() const
Return the current instance directory for faces.
Definition: polyMesh.C:778
const Vector< label > & solutionD() const
Return the vector of solved-for directions in mesh.
Definition: polyMesh.C:801
Cell-face mesh analysis engine.
Definition: primitiveMesh.H:74
const vectorField & faceAreas() const
Various mesh related information for a parallel run. Upon construction, constructs all info using par...
void clearOut()
Clear all geometry and addressing unnecessary for CFD.
static word meshSubDir
Return the mesh sub-directory name (usually "polyMesh")
Definition: polyMesh.H:309
Set of directions for each cell in the mesh. Either uniform and size=1 or one set of directions per c...
Definition: directions.H:64
const Vector< label > & geometricD() const
Return the vector of geometric directions in mesh.
Definition: polyMesh.C:784
static word defaultRegion
Return the default region name.
Definition: polyMesh.H:306
Foam::pointZoneMesh.
A bounding box defined in terms of the points at its extremities.
Definition: boundBox.H:58
label nSolutionD() const
Return the number of valid solved-for dimensions in the mesh.
Definition: polyMesh.C:812
const cellList & cells() const
virtual bool checkMeshMotion(const pointField &newPoints, const bool report=false, const bool detailedReport=false) const
Check mesh motion for correctness given motion points.
label nGeometricD() const
Return the number of valid geometric dimensions in the mesh.
Definition: polyMesh.C:795
cellDecomposition
Enumeration defining the decomposition of the cell for.
Definition: polyMesh.H:98
fileName meshDir() const
Return the local mesh directory (dbDir()/meshSubDir)
Definition: polyMesh.C:766
const polyBoundaryMesh & boundaryMesh() const
Return boundary mesh.
Definition: polyMesh.H:421
Class containing mesh-to-mesh mapping information after a change in polyMesh topology.
Definition: mapPolyMesh.H:158
bool moving() const
Is mesh moving.
Definition: polyMesh.H:493
void clearAdditionalGeom()
Clear geometry not used for CFD (cellTree, tetBasePtIs)
Definition: polyMeshClear.C:79
virtual const pointField & points() const
Return raw points.
Definition: polyMesh.C:979
Foam::cellZoneMesh.
const labelListList & pointCells() const
void clearPrimitives()
Clear primitive data (points, faces and cells)
virtual void setUpToDatePoints(regIOobject &io) const
Set io to be up-to-date with points.
Definition: polyMesh.C:998
virtual const pointField & oldPoints() const
Return old points for mesh motion.
Definition: polyMesh.C:1029
void findCellFacePt(const point &p, label &celli, label &tetFacei, label &tetPti) const
Find the cell, tetFacei and tetPti for point p.
Definition: polyMesh.C:1201
void resetPrimitives(const Xfer< pointField > &points, const Xfer< faceList > &faces, const Xfer< labelList > &owner, const Xfer< labelList > &neighbour, const labelList &patchSizes, const labelList &patchStarts, const bool validBoundary=true)
Reset mesh primitive data. Assumes all patch info correct.
Definition: polyMesh.C:642
virtual void updateMesh(const mapPolyMesh &mpm)
Update the mesh corresponding to given map.
A class for handling words, derived from string.
Definition: word.H:59
virtual bool upToDatePoints(const regIOobject &io) const
Return true if io is up-to-date with points.
Definition: polyMesh.C:992
virtual const fileName & dbDir() const
Override the objectRegistry dbDir for a single-region case.
Definition: polyMesh.C:753
const objectRegistry & thisDb() const
Return the object registry.
Definition: polyMesh.H:484
bool changing() const
Is mesh changing (topology changing and/or moving)
Definition: polyMesh.H:521
void findTetFacePt(const label celli, const point &p, label &tetFacei, label &tetPti) const
Find the tetFacei and tetPti for point p in celli.
Definition: polyMesh.C:1273
Foam::polyBoundaryMesh.
const globalMeshData & globalData() const
Return parallel info.
Definition: polyMesh.C:1140
void clearGeom()
Clear geometry.
Definition: polyMeshClear.C:53
void removeBoundary()
Remove boundary patches.
Definition: polyMeshClear.C:36
const labelList & tetBasePtIs() const
Return the tetBasePtIs.
Definition: polyMesh.C:818
const scalarField & cellVols
const pointZoneMesh & pointZones() const
Return point zone mesh.
Definition: polyMesh.H:457
void setInstance(const fileName &)
Set the instance for mesh files.
Definition: polyMeshIO.C:32
void addPatches(const List< polyPatch * > &, const bool validBoundary=true)
Add boundary patches.
Definition: polyMesh.C:878
label nFaces() const
bool topoChanging() const
Is mesh topology changing.
Definition: polyMesh.H:507
TypeName("polyMesh")
Runtime type information.
bool pointInCell(const point &p, label celli, const cellDecomposition=CELL_TETS) const
Test if point p is in the celli.
Definition: polyMesh.C:1289
const cellZoneMesh & cellZones() const
Return cell zone mesh.
Definition: polyMesh.H:469
virtual const labelList & faceNeighbour() const
Return face neighbour.
Definition: polyMesh.C:1023
Non-pointer based hierarchical recursive searching.
Definition: treeDataEdge.H:47
A templated 1D list of pointers to objects of type <T>, where the size of the array is known and used...
Definition: List.H:62
const fileName & pointsInstance() const
Return the current instance directory for points.
Definition: polyMesh.C:772
const dimensionedScalar c
Speed of light in a vacuum.
polyBoundaryMesh BoundaryMesh
Definition: polyMesh.H:299
virtual ~polyMesh()
Destructor.
Definition: polyMesh.C:744
label findCell(const point &p, const cellDecomposition=CELL_TETS) const
Find cell enclosing this location and return index.
Definition: polyMesh.C:1408
regIOobject is an abstract class derived from IOobject to handle automatic object registration with t...
Definition: regIOobject.H:60
const faceZoneMesh & faceZones() const
Return face zone mesh.
Definition: polyMesh.H:463
void addZones(const List< pointZone * > &pz, const List< faceZone * > &fz, const List< cellZone * > &cz)
Add mesh zones.
Definition: polyMesh.C:922
An auto-pointer similar to the STL auto_ptr but with automatic casting to a reference to the type and...
Definition: PtrList.H:53
Mesh consisting of general polyhedral cells.
Definition: polyMesh.H:74
readUpdateState
Enumeration defining the state of the mesh after a read update.
Definition: polyMesh.H:88
volScalarField & p
A class for managing temporary objects.
Definition: PtrList.H:54
virtual readUpdateState readUpdate()
Update the mesh based on the mesh files saved in.
Definition: polyMeshIO.C:65
virtual const labelList & faceOwner() const
Return face owner.
Definition: polyMesh.C:1017
Registry of regIOobjects.
virtual const faceList & faces() const
Return raw faces.
Definition: polyMesh.C:1004
IOobject defines the attributes of an object for which implicit objectRegistry management is supporte...
Definition: IOobject.H:91
Foam::faceZoneMesh.
void clearCellTree()
Clear cell tree data.
Namespace for OpenFOAM.