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-2017 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<labelIOList> 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  //- Read and return the tetBasePtIs
212  autoPtr<labelIOList> readTetBasePtIs() const;
213 
214 
215  // Helper functions for constructor from cell shapes
216 
217  labelListList cellShapePointCells(const cellShapeList&) const;
218 
219  labelList facePatchFaceCells
220  (
221  const faceList& patchFaces,
222  const labelListList& pointCells,
223  const faceListList& cellsFaceShapes,
224  const label patchID
225  ) const;
226 
227  void setTopology
228  (
229  const cellShapeList& cellsAsShapes,
230  const faceListList& boundaryFaces,
231  const wordList& boundaryPatchNames,
232  labelList& patchSizes,
233  labelList& patchStarts,
234  label& defaultPatchStart,
235  label& nFaces,
236  cellList& cells
237  );
238 
239 
240  // Geometry checks
241 
242  //- Check non-orthogonality
243  bool checkFaceOrthogonality
244  (
245  const vectorField& fAreas,
246  const vectorField& cellCtrs,
247  const bool report,
248  const bool detailedReport,
249  labelHashSet* setPtr
250  ) const;
251 
252  //- Check face skewness
253  bool checkFaceSkewness
254  (
255  const pointField& points,
256  const vectorField& fCtrs,
257  const vectorField& fAreas,
258  const vectorField& cellCtrs,
259  const bool report,
260  const bool detailedReport,
261  labelHashSet* setPtr
262  ) const;
263 
264  bool checkEdgeAlignment
265  (
266  const pointField& p,
267  const bool report,
268  const Vector<label>& directions,
269  labelHashSet* setPtr
270  ) const;
271 
272  bool checkCellDeterminant
273  (
274  const vectorField& faceAreas,
275  const bool report,
276  labelHashSet* setPtr,
277  const Vector<label>& meshD
278  ) const;
279 
280  bool checkFaceWeight
281  (
282  const vectorField& fCtrs,
283  const vectorField& fAreas,
284  const vectorField& cellCtrs,
285  const bool report,
286  const scalar minWeight,
287  labelHashSet* setPtr
288  ) const;
289 
290  bool checkVolRatio
291  (
292  const scalarField& cellVols,
293  const bool report,
294  const scalar minRatio,
295  labelHashSet* setPtr
296  ) const;
297 
298 public:
299 
300  // Public typedefs
302  typedef polyMesh Mesh;
304 
305 
306  //- Runtime type information
307  TypeName("polyMesh");
308 
309  //- Return the default region name
310  static word defaultRegion;
311 
312  //- Return the mesh sub-directory name (usually "polyMesh")
313  static word meshSubDir;
314 
315 
316  // Constructors
317 
318  //- Construct from IOobject
319  explicit polyMesh(const IOobject& io);
320 
321  //- Construct from IOobject or from components.
322  // Boundary is added using addPatches() member function
323  polyMesh
324  (
325  const IOobject& io,
326  const Xfer<pointField>& points,
327  const Xfer<faceList>& faces,
328  const Xfer<labelList>& owner,
329  const Xfer<labelList>& neighbour,
330  const bool syncPar = true
331  );
332 
333  //- Construct without boundary with cells rather than owner/neighbour.
334  // Boundary is added using addPatches() member function
335  polyMesh
336  (
337  const IOobject& io,
338  const Xfer<pointField>& points,
339  const Xfer<faceList>& faces,
340  const Xfer<cellList>& cells,
341  const bool syncPar = true
342  );
343 
344  //- Construct from cell shapes
345  polyMesh
346  (
347  const IOobject& io,
348  const Xfer<pointField>& points,
349  const cellShapeList& shapes,
350  const faceListList& boundaryFaces,
351  const wordList& boundaryPatchNames,
352  const wordList& boundaryPatchTypes,
353  const word& defaultBoundaryPatchName,
354  const word& defaultBoundaryPatchType,
355  const wordList& boundaryPatchPhysicalTypes,
356  const bool syncPar = true
357  );
358 
359  //- Construct from cell shapes with patch information in dictionary
360  // format.
361  polyMesh
362  (
363  const IOobject& io,
364  const Xfer<pointField>& points,
365  const cellShapeList& shapes,
366  const faceListList& boundaryFaces,
367  const wordList& boundaryPatchNames,
368  const PtrList<dictionary>& boundaryDicts,
369  const word& defaultBoundaryPatchName,
370  const word& defaultBoundaryPatchType,
371  const bool syncPar = true
372  );
373 
374 
375  //- Destructor
376  virtual ~polyMesh();
377 
378 
379  // Member Functions
380 
381  // Database
382 
383  //- Override the objectRegistry dbDir for a single-region case
384  virtual const fileName& dbDir() const;
385 
386  //- Return the local mesh directory (dbDir()/meshSubDir)
387  fileName meshDir() const;
388 
389  //- Return the current instance directory for points
390  // Used in the consruction of gemometric mesh data dependent
391  // on points
392  const fileName& pointsInstance() const;
393 
394  //- Return the current instance directory for faces
395  const fileName& facesInstance() const;
396 
397  //- Set the instance for mesh files
398  void setInstance(const fileName&);
399 
400 
401  // Access
402 
403  //- Return raw points
404  virtual const pointField& points() const;
405 
406  //- Return true if io is up-to-date with points
407  virtual bool upToDatePoints(const regIOobject& io) const;
408 
409  //- Set io to be up-to-date with points
410  virtual void setUpToDatePoints(regIOobject& io) const;
411 
412  //- Return raw faces
413  virtual const faceList& faces() const;
414 
415  //- Return face owner
416  virtual const labelList& faceOwner() const;
417 
418  //- Return face neighbour
419  virtual const labelList& faceNeighbour() const;
420 
421  //- Return old points for mesh motion
422  virtual const pointField& oldPoints() const;
423 
424  //- Return boundary mesh
425  const polyBoundaryMesh& boundaryMesh() const
426  {
427  return boundary_;
428  }
429 
430  //- Return mesh bounding box
431  const boundBox& bounds() const
432  {
433  return bounds_;
434  }
435 
436  //- Return the vector of geometric directions in mesh.
437  // Defined according to the presence of empty and wedge patches.
438  // 1 indicates unconstrained direction and -1 a constrained
439  // direction.
440  const Vector<label>& geometricD() const;
441 
442  //- Return the number of valid geometric dimensions in the mesh
443  label nGeometricD() const;
444 
445  //- Return the vector of solved-for directions in mesh.
446  // Differs from geometricD in that it includes for wedge cases
447  // the circumferential direction in case of swirl.
448  // 1 indicates valid direction and -1 an invalid direction.
449  const Vector<label>& solutionD() const;
450 
451  //- Return the number of valid solved-for dimensions in the mesh
452  label nSolutionD() const;
453 
454  //- Return the tetBasePtIs
455  const labelIOList& tetBasePtIs() const;
456 
457  //- Return the cell search tree
458  const indexedOctree<treeDataCell>& cellTree() const;
459 
460  //- Return point zone mesh
461  const pointZoneMesh& pointZones() const
462  {
463  return pointZones_;
464  }
465 
466  //- Return face zone mesh
467  const faceZoneMesh& faceZones() const
468  {
469  return faceZones_;
470  }
471 
472  //- Return cell zone mesh
473  const cellZoneMesh& cellZones() const
474  {
475  return cellZones_;
476  }
477 
478  //- Return parallel info
479  const globalMeshData& globalData() const;
480 
481  //- Return communicator used for parallel communication
482  label comm() const;
483 
484  //- Return communicator used for parallel communication
485  label& comm();
486 
487  //- Return the object registry
488  const objectRegistry& thisDb() const
489  {
490  return *this;
491  }
492 
493 
494  // Mesh motion
495 
496  //- Is mesh moving
497  bool moving() const
498  {
499  return moving_;
500  }
501 
502  //- Set the mesh to be moving
503  bool moving(const bool m)
504  {
505  bool m0 = moving_;
506  moving_ = m;
507  return m0;
508  }
509 
510  //- Is mesh topology changing
511  bool topoChanging() const
512  {
513  return topoChanging_;
514  }
515 
516  //- Set the mesh topology to be changing
517  bool topoChanging(const bool c)
518  {
519  bool c0 = topoChanging_;
520  topoChanging_ = c;
521  return c0;
522  }
523 
524  //- Is mesh changing (topology changing and/or moving)
525  bool changing() const
526  {
527  return moving()||topoChanging();
528  }
529 
530  //- Move points, returns volumes swept by faces in motion
531  virtual tmp<scalarField> movePoints(const pointField&);
532 
533  //- Reset motion
534  void resetMotion() const;
535 
536 
537  // Topological change
538 
539  //- Return non-const access to the pointZones
541  {
542  return pointZones_;
543  }
544 
545  //- Return non-const access to the faceZones
547  {
548  return faceZones_;
549  }
550 
551  //- Return non-const access to the cellZones
553  {
554  return cellZones_;
555  }
556 
557  //- Add boundary patches
558  void addPatches
559  (
560  const List<polyPatch*>&,
561  const bool validBoundary = true
562  );
563 
564  //- Add mesh zones
565  void addZones
566  (
567  const List<pointZone*>& pz,
568  const List<faceZone*>& fz,
569  const List<cellZone*>& cz
570  );
571 
572  //- Update the mesh based on the mesh files saved in
573  // time directories
574  virtual readUpdateState readUpdate();
575 
576  //- Update the mesh corresponding to given map
577  virtual void updateMesh(const mapPolyMesh& mpm);
578 
579  //- Remove boundary patches
580  void removeBoundary();
581 
582  //- Reset mesh primitive data. Assumes all patch info correct
583  // (so does e.g. parallel communication). If not use
584  // validBoundary=false
585  void resetPrimitives
586  (
587  const Xfer<pointField>& points,
588  const Xfer<faceList>& faces,
589  const Xfer<labelList>& owner,
590  const Xfer<labelList>& neighbour,
591  const labelList& patchSizes,
592  const labelList& patchStarts,
593  const bool validBoundary = true
594  );
595 
596 
597  // Storage management
598 
599  //- Clear geometry
600  void clearGeom();
601 
602  //- Clear addressing
603  void clearAddressing(const bool isMeshUpdate = false);
604 
605  //- Clear all geometry and addressing unnecessary for CFD
606  void clearOut();
607 
608  //- Clear primitive data (points, faces and cells)
609  void clearPrimitives();
610 
611  //- Clear tet base points
612  void clearTetBasePtIs();
613 
614  //- Clear cell tree data
615  void clearCellTree();
616 
617  //- Remove all files from mesh instance
618  void removeFiles(const fileName& instanceDir) const;
619 
620  //- Remove all files from mesh instance()
621  void removeFiles() const;
622 
623 
624  // Geometric checks. Selectively override primitiveMesh functionality.
625 
626  //- Check non-orthogonality
627  virtual bool checkFaceOrthogonality
628  (
629  const bool report = false,
630  labelHashSet* setPtr = nullptr
631  ) const;
632 
633  //- Check face skewness
634  virtual bool checkFaceSkewness
635  (
636  const bool report = false,
637  labelHashSet* setPtr = nullptr
638  ) const;
639 
640  //- Check edge alignment for 1D/2D cases
641  virtual bool checkEdgeAlignment
642  (
643  const bool report,
644  const Vector<label>& directions,
645  labelHashSet* setPtr
646  ) const;
647 
648  virtual bool checkCellDeterminant
649  (
650  const bool report,
651  labelHashSet* setPtr
652  ) const;
653 
654  //- Check mesh motion for correctness given motion points
655  virtual bool checkMeshMotion
656  (
657  const pointField& newPoints,
658  const bool report = false,
659  const bool detailedReport = false
660  ) const;
661 
662  //- Check for face weights
663  virtual bool checkFaceWeight
664  (
665  const bool report,
666  const scalar minWeight = 0.05,
667  labelHashSet* setPtr = nullptr
668  ) const;
669 
670  //- Check for neighbouring cell volumes
671  virtual bool checkVolRatio
672  (
673  const bool report,
674  const scalar minRatio = 0.01,
675  labelHashSet* setPtr = nullptr
676  ) const;
677 
678 
679  // Position search functions
680 
681  //- Find the cell, tetFacei and tetPti for point p
682  void findCellFacePt
683  (
684  const point& p,
685  label& celli,
686  label& tetFacei,
687  label& tetPti
688  ) const;
689 
690  //- Find the tetFacei and tetPti for point p in celli.
691  // tetFacei and tetPtI are set to -1 if not found
692  void findTetFacePt
693  (
694  const label celli,
695  const point& p,
696  label& tetFacei,
697  label& tetPti
698  ) const;
699 
700  //- Test if point p is in the celli
701  bool pointInCell
702  (
703  const point& p,
704  label celli,
706  ) const;
707 
708  //- Find cell enclosing this location and return index
709  // If not found -1 is returned
711  (
712  const point& p,
714  ) const;
715 };
716 
717 
718 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
719 
720 } // End namespace Foam
721 
722 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
723 
724 #endif
725 
726 // ************************************************************************* //
const polyBoundaryMesh & boundaryMesh() const
Return boundary mesh.
Definition: polyMesh.H:424
A simple container for copying or transferring objects of type <T>.
Definition: Xfer.H:85
bool changing() const
Is mesh changing (topology changing and/or moving)
Definition: polyMesh.H:524
polyMesh Mesh
Definition: polyMesh.H:301
virtual tmp< scalarField > movePoints(const pointField &)
Move points, returns volumes swept by faces in motion.
Definition: polyMesh.C:1080
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
A class for handling file names.
Definition: fileName.H:69
const faceZoneMesh & faceZones() const
Return face zone mesh.
Definition: polyMesh.H:466
bool moving() const
Is mesh moving.
Definition: polyMesh.H:496
const fileName & facesInstance() const
Return the current instance directory for faces.
Definition: polyMesh.C:801
virtual const labelList & faceNeighbour() const
Return face neighbour.
Definition: polyMesh.C:1055
const labelIOList & tetBasePtIs() const
Return the tetBasePtIs.
Definition: polyMesh.C:841
virtual void setUpToDatePoints(regIOobject &io) const
Set io to be up-to-date with points.
Definition: polyMesh.C:1030
Cell-face mesh analysis engine.
Definition: primitiveMesh.H:74
void resetMotion() const
Reset motion.
Definition: polyMesh.C:1175
label nFaces() 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:312
const Vector< label > & solutionD() const
Return the vector of solved-for directions in mesh.
Definition: polyMesh.C:824
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
static word defaultRegion
Return the default region name.
Definition: polyMesh.H:309
Foam::pointZoneMesh.
A bounding box defined in terms of the points at its extremities.
Definition: boundBox.H:58
const cellList & cells() const
virtual const fileName & dbDir() const
Override the objectRegistry dbDir for a single-region case.
Definition: polyMesh.C:776
bool pointInCell(const point &p, label celli, const cellDecomposition=CELL_TETS) const
Test if point p is in the celli.
Definition: polyMesh.C:1284
cellDecomposition
Enumeration defining the decomposition of the cell for.
Definition: polyMesh.H:98
label nGeometricD() const
Return the number of valid geometric dimensions in the mesh.
Definition: polyMesh.C:818
Class containing mesh-to-mesh mapping information after a change in polyMesh topology.
Definition: mapPolyMesh.H:158
virtual const pointField & points() const
Return raw points.
Definition: polyMesh.C:1011
const Vector< label > & geometricD() const
Return the vector of geometric directions in mesh.
Definition: polyMesh.C:807
Foam::cellZoneMesh.
const fileName & pointsInstance() const
Return the current instance directory for points.
Definition: polyMesh.C:795
void removeFiles() const
Remove all files from mesh instance()
Definition: polyMesh.C:1236
void clearPrimitives()
Clear primitive data (points, faces and cells)
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:665
virtual void updateMesh(const mapPolyMesh &mpm)
Update the mesh corresponding to given map.
const pointZoneMesh & pointZones() const
Return point zone mesh.
Definition: polyMesh.H:460
A class for handling words, derived from string.
Definition: word.H:59
const cellZoneMesh & cellZones() const
Return cell zone mesh.
Definition: polyMesh.H:472
void findCellFacePt(const point &p, label &celli, label &tetFacei, label &tetPti) const
Find the cell, tetFacei and tetPti for point p.
Definition: polyMesh.C:1243
virtual const pointField & oldPoints() const
Return old points for mesh motion.
Definition: polyMesh.C:1061
virtual const labelList & faceOwner() const
Return face owner.
Definition: polyMesh.C:1049
const globalMeshData & globalData() const
Return parallel info.
Definition: polyMesh.C:1182
virtual const faceList & faces() const
Return raw faces.
Definition: polyMesh.C:1036
label comm() const
Return communicator used for parallel communication.
Definition: polyMesh.C:1200
void addZones(const List< pointZone *> &pz, const List< faceZone *> &fz, const List< cellZone *> &cz)
Add mesh zones.
Definition: polyMesh.C:954
void addPatches(const List< polyPatch *> &, const bool validBoundary=true)
Add boundary patches.
Definition: polyMesh.C:910
const labelListList & pointCells() const
Foam::polyBoundaryMesh.
void clearGeom()
Clear geometry.
Definition: polyMeshClear.C:53
void removeBoundary()
Remove boundary patches.
Definition: polyMeshClear.C:36
const scalarField & cellVols
void clearTetBasePtIs()
Clear tet base points.
void setInstance(const fileName &)
Set the instance for mesh files.
Definition: polyMeshIO.C:32
label nSolutionD() const
Return the number of valid solved-for dimensions in the mesh.
Definition: polyMesh.C:835
virtual bool upToDatePoints(const regIOobject &io) const
Return true if io is up-to-date with points.
Definition: polyMesh.C:1024
TypeName("polyMesh")
Runtime type information.
const indexedOctree< treeDataCell > & cellTree() const
Return the cell search tree.
Definition: polyMesh.C:875
const boundBox & bounds() const
Return mesh bounding box.
Definition: polyMesh.H:430
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:63
const vectorField & faceAreas() const
const dimensionedScalar c
Speed of light in a vacuum.
bool topoChanging() const
Is mesh topology changing.
Definition: polyMesh.H:510
fileName meshDir() const
Return the local mesh directory (dbDir()/meshSubDir)
Definition: polyMesh.C:789
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:1268
label findCell(const point &p, const cellDecomposition=CELL_TETS) const
Find cell enclosing this location and return index.
Definition: polyMesh.C:1394
polyBoundaryMesh BoundaryMesh
Definition: polyMesh.H:302
virtual ~polyMesh()
Destructor.
Definition: polyMesh.C:767
regIOobject is an abstract class derived from IOobject to handle automatic object registration with t...
Definition: regIOobject.H:65
const objectRegistry & thisDb() const
Return the object registry.
Definition: polyMesh.H:487
An auto-pointer similar to the STL auto_ptr but with automatic casting to a reference to the type and...
Definition: PtrList.H:52
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:53
virtual readUpdateState readUpdate()
Update the mesh based on the mesh files saved in.
Definition: polyMeshIO.C:71
Registry of regIOobjects.
IOobject defines the attributes of an object for which implicit objectRegistry management is supporte...
Definition: IOobject.H:92
Foam::faceZoneMesh.
A primitive field of type <T> with automated input and output.
Definition: IOField.H:50
void clearCellTree()
Clear cell tree data.
virtual bool checkMeshMotion(const pointField &newPoints, const bool report=false, const bool detailedReport=false) const
Check mesh motion for correctness given motion points.
Namespace for OpenFOAM.