faMesh.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) 2016-2017 Wikki 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 Class
27  Foam::faMesh
28 
29 Description
30  Finite area mesh. Used for 2-D non-Euclidian finite area method.
31 
32 SourceFiles
33  faMesh.C
34  faMeshDemandDrivenData.C
35 
36 Author
37  Zeljko Tukovic, FMENA
38  Hrvoje Jasak, Wikki Ltd.
39 
40 \*---------------------------------------------------------------------------*/
41 
42 #ifndef faMesh_H
43 #define faMesh_H
44 
45 #include "GeoMesh.H"
46 #include "MeshObject.H"
47 #include "polyMesh.H"
48 #include "lduMesh.H"
49 #include "faBoundaryMesh.H"
50 #include "edgeList.H"
51 #include "faceList.H"
52 #include "primitiveFieldsFwd.H"
53 #include "DimensionedField.H"
54 #include "areaFieldsFwd.H"
55 #include "edgeFieldsFwd.H"
56 #include "indirectPrimitivePatch.H"
57 #include "edgeInterpolation.H"
58 #include "labelIOList.H"
59 #include "FieldFields.H"
60 #include "faGlobalMeshData.H"
61 #include "faSchemes.H"
62 #include "faSolution.H"
63 #include "data.H"
64 
65 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
66 
67 namespace Foam
68 {
69 
70 // Class forward declarations
71 class faMeshLduAddressing;
72 class faMeshMapper;
73 
74 /*---------------------------------------------------------------------------*\
75  Class faMesh Declaration
76 \*---------------------------------------------------------------------------*/
77 
78 class faMesh
79 :
80  public GeoMesh<polyMesh>,
81  public MeshObject<polyMesh, Foam::UpdateableMeshObject, faMesh>,
82  public lduMesh,
83  public edgeInterpolation,
84  public faSchemes,
85  public faSolution,
86  public data
87 {
88  // Private data
89 
90  //- Face labels
91  labelIOList faceLabels_;
92 
93  //- Boundary mesh
94  faBoundaryMesh boundary_;
95 
96 
97  // Primitive mesh data
98 
99  //- Edges, addressing into local point list
100  edgeList edges_;
101 
102  //- Edge owner
103  labelList edgeOwner_;
104 
105  //- Edge neighbour
106  labelList edgeNeighbour_;
107 
108 
109  // Primitive size data
110 
111  //- Number of points
112  mutable label nPoints_;
113 
114  //- Number of edges
115  mutable label nEdges_;
116 
117  //- Number of internal edges
118  mutable label nInternalEdges_;
119 
120  //- Number of faces
121  mutable label nFaces_;
122 
123 
124  // Communication support
125 
126  //- Communicator used for parallel communication
127  label comm_;
128 
129 
130  // Demand-driven data
131 
132  //- Primitive patch
133  mutable indirectPrimitivePatch* patchPtr_;
134 
135  //- Ldu addressing data
136  mutable faMeshLduAddressing* lduPtr_;
137 
138  //- Current time index for motion
139  // Note. The whole mechanism will be replaced once the
140  // dimensionedField is created and the dimensionedField
141  // will take care of the old-time levels.
142  mutable label curTimeIndex_;
143 
144  //- Face areas
145  mutable DimensionedField<scalar, areaMesh>* SPtr_;
146 
147  //- Face areas old time level
148  mutable DimensionedField<scalar, areaMesh>* S0Ptr_;
149 
150  //- Face areas old-old time level
151  mutable DimensionedField<scalar, areaMesh>* S00Ptr_;
152 
153  //- Patch starts in the edge list
154  mutable labelList* patchStartsPtr_;
155 
156  //- Edge length vectors
157  mutable edgeVectorField* LePtr_;
158 
159  //- Mag edge length vectors
160  mutable edgeScalarField* magLePtr_;
161 
162  //- Face centres
163  mutable areaVectorField* centresPtr_;
164 
165  //- Edge centres
166  mutable edgeVectorField* edgeCentresPtr_;
167 
168  //- Face area normals
169  mutable areaVectorField* faceAreaNormalsPtr_;
170 
171  //- Edge area normals
172  mutable edgeVectorField* edgeAreaNormalsPtr_;
173 
174  //- Edge area normals
175  mutable vectorField* pointAreaNormalsPtr_;
176 
177  //- Face curvatures
178  mutable areaScalarField* faceCurvaturesPtr_;
179 
180  //- Edge transformation tensors
181  mutable FieldField<Field, tensor>* edgeTransformTensorsPtr_;
182 
183  //- Whether point normals must be corrected for a patch
184  mutable boolList* correctPatchPointNormalsPtr_;
185 
186 
187  // Other mesh-related data
188 
189  //- Parallel info
190  mutable faGlobalMeshData* globalMeshDataPtr_;
191 
192 
193  // Static Private Data
194 
195  //- Use quadrics fit
196  static const int quadricsFit_;
197 
198 
199  // Private Member Functions
200 
201  //- No copy construct
202  faMesh(const faMesh&) = delete;
203 
204  //- No copy assignment
205  void operator=(const faMesh&) = delete;
206 
207 
208  //- Set primitive mesh data
209  void setPrimitiveMeshData();
210 
211 
212  // Private member functions to calculate demand driven data
213 
214  //- Calculate ldu addressing
215  void calcLduAddressing() const;
216 
217  //- Calculate patch starts in the edge list
218  void calcPatchStarts() const;
219 
220  //- Calculate edge lengths
221  void calcLe() const;
222 
223  //- Calculate mag edge lengths
224  void calcMagLe() const;
225 
226  //- Calculate face centres
227  void calcAreaCentres() const;
228 
229  //- Calculate edge centres
230  void calcEdgeCentres() const;
231 
232  //- Calculate face areas
233  void calcS() const;
234 
235  //- Calculate face area normals
236  void calcFaceAreaNormals() const;
237 
238  //- Calculate edge area normals
239  void calcEdgeAreaNormals() const;
240 
241  //- Calculate point area normals
242  void calcPointAreaNormals() const;
243 
244  //- Calculate point area normals by quadrics fit
245  void calcPointAreaNormalsByQuadricsFit() const;
246 
247  //- Calculate face curvatures
248  void calcFaceCurvatures() const;
249 
250  //- Calculate edge transformation tensors
251  void calcEdgeTransformTensors() const;
252 
253  //- Clear geometry but not the face areas
254  void clearGeomNotAreas() const;
255 
256  //- Clear geometry
257  void clearGeom() const;
258 
259  //- Clear addressing
260  void clearAddressing() const;
261 
262  //- Clear demand-driven data
263  void clearOut() const;
264 
265 public:
266 
267  // Public typedefs
268 
269  typedef faMesh Mesh;
271 
272 
273  //- Runtime type information
274  TypeName("faMesh");
275 
276 
277  //- Return the mesh sub-directory name (usually "faMesh")
278  static word meshSubDir;
279 
280 
281  // Constructors
282 
283  //- Construct from polyMesh
284  explicit faMesh(const polyMesh& m);
285 
286  //- Construct from components without boundary.
287  // Boundary is added using addFaPatches() member function
288  faMesh
289  (
290  const polyMesh& m,
291  const labelList& faceLabels
292  );
293 
294  //- Construct from finite area mesh definition file
295  faMesh
296  (
297  const polyMesh& m,
298  const fileName& defFile
299  );
300 
301  //- Construct from polyPatch
302  faMesh
303  (
304  const polyMesh& m,
305  const label polyPatchID
306  );
307 
308 
309  //- Destructor
310  virtual ~faMesh();
311 
312 
313  // Member Functions
314 
315  // Helpers
316 
317  //- Add boundary patches. Constructor helper
318  void addFaPatches(const List<faPatch*> &);
319 
320 
321  // Database
322 
323  //- Return access to polyMesh
324  const polyMesh& mesh() const
325  {
326  return
327  MeshObject
328  <
329  polyMesh,
331  faMesh
332  >::mesh();
333  }
334 
335  //- Return the local mesh directory (dbDir()/meshSubDir)
336  fileName meshDir() const;
337 
338  //- Return reference to time
339  const Time& time() const;
340 
341  //- Return the current instance directory for points
342  // Used in the construction of geometric mesh data dependent
343  // on points
344  const fileName& pointsInstance() const;
345 
346  //- Return the current instance directory for faces
347  const fileName& facesInstance() const;
348 
349 
350  // Mesh size parameters
351 
352  inline label nPoints() const
353  {
354  return nPoints_;
355  }
356 
357  inline label nEdges() const
358  {
359  return nEdges_;
360  }
361 
362  inline label nInternalEdges() const
363  {
364  return nInternalEdges_;
365  }
366 
367  inline label nFaces() const
368  {
369  return nFaces_;
370  }
371 
372 
373  // Primitive mesh data
374 
375  //- Return mesh points
376  const pointField& points() const;
377 
378  //- Return edges
379  const edgeList& edges() const;
380 
381  //- Return faces
382  const faceList& faces() const;
383 
384  //- Edge owner addressing
385  inline const labelList& edgeOwner() const
386  {
387  return edgeOwner_;
388  }
389 
390  //- Edge neighbour addressing
391  inline const labelList& edgeNeighbour() const
392  {
393  return edgeNeighbour_;
394  }
395 
396 
397  // Communication support
398 
399  //- Return communicator used for parallel communication
400  label comm() const;
401 
402  //- Return communicator used for parallel communication
403  label& comm();
404 
405 
406  // Access
407 
408  //- Return true if thisDb() is a valid DB
409  virtual bool hasDb() const;
410 
411  //- Return reference to the mesh database
412  virtual const objectRegistry& thisDb() const;
413 
414  //- Name function is needed to disambiguate those inherited
415  // from base classes
416  const word& name() const
417  {
418  return thisDb().name();
419  }
420 
421  //- Return constant reference to boundary mesh
422  const faBoundaryMesh& boundary() const;
423 
424  //- Return faMesh face labels
425  const labelList& faceLabels() const
426  {
427  return faceLabels_;
428  }
429 
430 
431  //- Return parallel info
432  const faGlobalMeshData& globalData() const;
433 
434  //- Return ldu addressing
435  virtual const lduAddressing& lduAddr() const;
436 
437  //- Return a list of pointers for each patch
438  // with only those pointing to interfaces being set
439  virtual lduInterfacePtrsList interfaces() const
440  {
441  return boundary().interfaces();
442  }
443 
444  //- Internal face owner
445  const labelUList& owner() const
446  {
447  return lduAddr().lowerAddr();
448  }
449 
450  //- Internal face neighbour
451  const labelUList& neighbour() const
452  {
453  return lduAddr().upperAddr();
454  }
455 
456  //- Return true if given edge label is internal to the mesh
457  inline bool isInternalEdge(const label edgeIndex) const
458  {
459  return edgeIndex < nInternalEdges();
460  }
461 
462 
463  // Mesh motion and morphing
464 
465  //- Is mesh moving
466  bool moving() const
467  {
468  return mesh().moving();
469  }
470 
471  //- Update after mesh motion
472  virtual bool movePoints();
473 
474  //- Update after topo change
475  virtual void updateMesh(const mapPolyMesh&);
476 
477 
478  // Mapping
479 
480  //- Map all fields in time using given map.
481  virtual void mapFields(const faMeshMapper& mapper) const;
482 
483  //- Map face areas in time using given map.
484  virtual void mapOldAreas(const faMeshMapper& mapper) const;
485 
486 
487  // Demand-driven data
488 
489  //- Return constant reference to primitive patch
490  const indirectPrimitivePatch& patch() const;
491 
492  //- Return reference to primitive patch
494 
495  //- Return patch starts
496  const labelList& patchStarts() const;
497 
498  //- Return edge length vectors
499  const edgeVectorField& Le() const;
500 
501  //- Return edge length magnitudes
502  const edgeScalarField& magLe() const;
503 
504  //- Return face centres as areaVectorField
505  const areaVectorField& areaCentres() const;
506 
507  //- Return edge centres as edgeVectorField
508  const edgeVectorField& edgeCentres() const;
509 
510  //- Return face areas
511  const DimensionedField<scalar, areaMesh>& S() const;
512 
513  //- Return old-time face areas
514  const DimensionedField<scalar, areaMesh>& S0() const;
515 
516  //- Return old-old-time face areas
518 
519  //- Return face area normals
520  const areaVectorField& faceAreaNormals() const;
521 
522  //- Return edge area normals
523  const edgeVectorField& edgeAreaNormals() const;
524 
525  //- Return point area normals
526  const vectorField& pointAreaNormals() const;
527 
528  //- Return face curvatures
529  const areaScalarField& faceCurvatures() const;
530 
531  //- Return edge transformation tensors
533 
534  //- Return internal point labels
535  labelList internalPoints() const;
536 
537  //- Return boundary point labels
538  labelList boundaryPoints() const;
539 
540  //- Return edge length correction
542 
543  //- Whether point normals should be corrected for a patch
544  bool correctPatchPointNormals(const label patchID) const;
545 
546  //- Set whether point normals should be corrected for a patch
548 
549  //- Write mesh
550  virtual bool write(const bool valid = true) const;
551 
552 
553  // Member Operators
554 
555  bool operator!=(const faMesh& m) const;
556 
557  bool operator==(const faMesh& m) const;
558 };
559 
560 
561 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
562 
563 } // End namespace Foam
564 
565 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
566 
567 #ifdef NoRepository
568  #include "faPatchFaMeshTemplates.C"
569 #endif
570 
571 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
572 
573 #endif
574 
575 // ************************************************************************* //
Foam::lduAddressing
The class contains the addressing required by the lduMatrix: upper, lower and losort.
Definition: lduAddressing.H:114
Foam::faMesh::name
const word & name() const
Name function is needed to disambiguate those inherited.
Definition: faMesh.H:415
Foam::faMesh::meshDir
fileName meshDir() const
Return the local mesh directory (dbDir()/meshSubDir)
Definition: faMesh.C:891
Foam::faMesh::Le
const edgeVectorField & Le() const
Return edge length vectors.
Definition: faMesh.C:1036
primitiveFieldsFwd.H
Forward declarations of the specialisations of Field<T> for scalar, vector and tensor.
Foam::faMesh::mapOldAreas
virtual void mapOldAreas(const faMeshMapper &mapper) const
Map face areas in time using given map.
Definition: faMeshUpdate.C:178
Foam::faMesh::Mesh
faMesh Mesh
Definition: faMesh.H:268
Foam::Time
Class to control time during OpenFOAM simulations that is also the top-level objectRegistry.
Definition: Time.H:73
Foam::IOobject::name
const word & name() const
Return name.
Definition: IOobjectI.H:70
Foam::word
A class for handling words, derived from Foam::string.
Definition: word.H:62
Foam::faMesh::faces
const faceList & faces() const
Return faces.
Definition: faMesh.C:965
Foam::fileName
A class for handling file names.
Definition: fileName.H:69
Foam::FieldField
A field of fields is a PtrList of fields with reference counting.
Definition: FieldField.H:53
Foam::faMesh::write
virtual bool write(const bool valid=true) const
Write mesh.
Definition: faMesh.C:1305
Foam::faSchemes
Selector class for finite area differencing schemes. faMesh is derived from faShemes so that all fiel...
Definition: faSchemes.H:52
Foam::tmp
A class for managing temporary objects.
Definition: PtrList.H:59
Foam::faMesh::patch
const indirectPrimitivePatch & patch() const
Return constant reference to primitive patch.
Definition: faMesh.C:915
FieldFields.H
DimensionedField.H
Foam::faMesh::edgeLengthCorrection
tmp< edgeScalarField > edgeLengthCorrection() const
Return edge length correction.
Definition: faMeshDemandDrivenData.C:1808
Foam::polyMesh::moving
bool moving() const
Is mesh moving.
Definition: polyMesh.H:513
Foam::faMesh::internalPoints
labelList internalPoints() const
Return internal point labels.
Definition: faMeshDemandDrivenData.C:848
Foam::faMesh::faceLabels
const labelList & faceLabels() const
Return faMesh face labels.
Definition: faMesh.H:424
Foam::faMesh::edges
const edgeList & edges() const
Return edges.
Definition: faMesh.C:959
Foam::faGlobalMeshData
Various mesh related information for a parallel run.
Definition: faGlobalMeshData.H:54
Foam::faMesh::nPoints
label nPoints() const
Definition: faMesh.H:351
Foam::faMesh::pointAreaNormals
const vectorField & pointAreaNormals() const
Return point area normals.
Definition: faMesh.C:1153
Foam::faMesh::~faMesh
virtual ~faMesh()
Destructor.
Definition: faMesh.C:883
Foam::faMesh::S00
const DimensionedField< scalar, areaMesh > & S00() const
Return old-old-time face areas.
Definition: faMesh.C:1107
Foam::DynamicID< polyBoundaryMesh >
faceList.H
polyMesh.H
Foam::UpdateableMeshObject
Definition: MeshObject.H:241
Foam::lduAddressing::upperAddr
virtual const labelUList & upperAddr() const =0
Return upper addressing.
Foam::polyMesh
Mesh consisting of general polyhedral cells.
Definition: polyMesh.H:77
Foam::faMesh::patchStarts
const labelList & patchStarts() const
Return patch starts.
Definition: faMesh.C:1025
Foam::faMesh::globalData
const faGlobalMeshData & globalData() const
Return parallel info.
Definition: faMesh.C:1192
Foam::objectRegistry
Registry of regIOobjects.
Definition: objectRegistry.H:60
Foam::faBoundaryMesh
Finite area boundary mesh.
Definition: faBoundaryMesh.H:66
faSolution.H
Foam::faMesh::edgeTransformTensors
const FieldField< Field, tensor > & edgeTransformTensors() const
Return edge transformation tensors.
Definition: faMesh.C:1181
Foam::faMeshMapper
Class holds all the necessary information for mapping fields associated with faMesh.
Definition: faMeshMapper.H:68
Foam::faMesh::S0
const DimensionedField< scalar, areaMesh > & S0() const
Return old-time face areas.
Definition: faMesh.C:1093
Foam::Field< vector >
Foam::faMesh::S
const DimensionedField< scalar, areaMesh > & S() const
Return face areas.
Definition: faMesh.C:1081
Foam::faMesh::operator==
bool operator==(const faMesh &m) const
Definition: faMesh.C:1322
Foam::faMesh::lduAddr
virtual const lduAddressing & lduAddr() const
Return ldu addressing.
Definition: faMesh.C:1203
Foam::faMesh::addFaPatches
void addFaPatches(const List< faPatch * > &)
Add boundary patches. Constructor helper.
Definition: faMesh.C:971
areaFieldsFwd.H
Forwards and collection of common area field types.
Foam::faMesh::faceAreaNormals
const areaVectorField & faceAreaNormals() const
Return face area normals.
Definition: faMesh.C:1131
Foam::faMesh::time
const Time & time() const
Return reference to time.
Definition: faMesh.C:897
edgeInterpolation.H
patchID
label patchID
Definition: boundaryProcessorFaPatchPoints.H:5
Foam::UPtrList< const lduInterface >
Foam::faSolution
Selector class for finite area solution. faMesh is derived from faSolution so that all fields have ac...
Definition: faSolution.H:53
Foam::faMesh::magLe
const edgeScalarField & magLe() const
Return edge length magnitudes.
Definition: faMesh.C:1047
Foam::faMesh::facesInstance
const fileName & facesInstance() const
Return the current instance directory for faces.
Definition: faMesh.C:909
indirectPrimitivePatch.H
Foam::faMesh::nEdges
label nEdges() const
Definition: faMesh.H:356
Foam::faMesh::operator!=
bool operator!=(const faMesh &m) const
Definition: faMesh.C:1316
edgeList.H
faBoundaryMesh.H
Foam::faMesh::moving
bool moving() const
Is mesh moving.
Definition: faMesh.H:465
Foam::faMesh::points
const pointField & points() const
Return mesh points.
Definition: faMesh.C:953
Foam::GeoMesh
Generic mesh wrapper used by volMesh, surfaceMesh, pointMesh etc.
Definition: GeoMesh.H:48
Foam::faMesh::neighbour
const labelUList & neighbour() const
Internal face neighbour.
Definition: faMesh.H:450
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.C:33
Foam::faMesh::nInternalEdges
label nInternalEdges() const
Definition: faMesh.H:361
Foam::faMesh::edgeOwner
const labelList & edgeOwner() const
Edge owner addressing.
Definition: faMesh.H:384
Foam::faMesh::edgeAreaNormals
const edgeVectorField & edgeAreaNormals() const
Return edge area normals.
Definition: faMesh.C:1142
Foam::faMesh::mesh
const polyMesh & mesh() const
Return access to polyMesh.
Definition: faMesh.H:323
Foam::faMesh::boundaryPoints
labelList boundaryPoints() const
Return boundary point labels.
Definition: faMeshDemandDrivenData.C:881
Foam::faMesh::correctPatchPointNormals
boolList & correctPatchPointNormals() const
Set whether point normals should be corrected for a patch.
Definition: faMesh.C:1294
Foam::faMesh::owner
const labelUList & owner() const
Internal face owner.
Definition: faMesh.H:444
Foam::faMesh::thisDb
virtual const objectRegistry & thisDb() const
Return reference to the mesh database.
Definition: faMesh.C:1013
Foam::faMeshLduAddressing
lduAddressing wrapper for faMesh
Definition: faMeshLduAddressing.H:56
Foam::faMesh::hasDb
virtual bool hasDb() const
Return true if thisDb() is a valid DB.
Definition: faMesh.C:1007
Foam::faMesh::faceCurvatures
const areaScalarField & faceCurvatures() const
Return face curvatures.
Definition: faMesh.C:1169
Foam::lduAddressing::lowerAddr
virtual const labelUList & lowerAddr() const =0
Return lower addressing.
faSchemes.H
Foam::List< edge >
Foam::faMesh::meshSubDir
static word meshSubDir
Return the mesh sub-directory name (usually "faMesh")
Definition: faMesh.H:277
labelIOList.H
Foam::UList< label >
Foam::faMesh::boundary
const faBoundaryMesh & boundary() const
Return constant reference to boundary mesh.
Definition: faMesh.C:1019
Foam::IOList< label >
Foam::faMesh::edgeCentres
const edgeVectorField & edgeCentres() const
Return edge centres as edgeVectorField.
Definition: faMesh.C:1069
Foam::faMesh::mapFields
virtual void mapFields(const faMeshMapper &mapper) const
Map all fields in time using given map.
Definition: faMeshUpdate.C:156
Foam::faMesh::interfaces
virtual lduInterfacePtrsList interfaces() const
Return a list of pointers for each patch.
Definition: faMesh.H:438
MeshObject.H
Foam::mapPolyMesh
Class containing mesh-to-mesh mapping information after a change in polyMesh topology.
Definition: mapPolyMesh.H:160
Foam::faMesh::updateMesh
virtual void updateMesh(const mapPolyMesh &)
Update after topo change.
Definition: faMeshUpdate.C:38
Foam::faMesh
Finite area mesh. Used for 2-D non-Euclidian finite area method.
Definition: faMesh.H:77
Foam::MeshObject
Templated abstract base-class for optional mesh objects used to automate their allocation to the mesh...
Definition: MeshObject.H:88
data.H
Foam::faMesh::pointsInstance
const fileName & pointsInstance() const
Return the current instance directory for points.
Definition: faMesh.C:903
Foam::faMesh::nFaces
label nFaces() const
Definition: faMesh.H:366
Foam::GeometricField
Generic GeometricField class.
Definition: areaFieldsFwd.H:53
lduMesh.H
Foam::faMesh::isInternalEdge
bool isInternalEdge(const label edgeIndex) const
Return true if given edge label is internal to the mesh.
Definition: faMesh.H:456
faPatchFaMeshTemplates.C
Foam::faMesh::TypeName
TypeName("faMesh")
Runtime type information.
edgeFieldsFwd.H
Forwards for edge field types.
GeoMesh.H
Foam::edgeInterpolation
Face to edge interpolation scheme. Included in faMesh.
Definition: edgeInterpolation.H:60
Foam::data
Database for solution data, solver performance and other reduced data.
Definition: data.H:54
Foam::faMesh::edgeNeighbour
const labelList & edgeNeighbour() const
Edge neighbour addressing.
Definition: faMesh.H:390
Foam::faMesh::BoundaryMesh
faBoundaryMesh BoundaryMesh
Definition: faMesh.H:269
Foam::lduMesh
Abstract base class for meshes which provide LDU addressing for the construction of lduMatrix and LDU...
Definition: lduMesh.H:62
Foam::faMesh::movePoints
virtual bool movePoints()
Update after mesh motion.
Definition: faMesh.C:1214
Foam::faMesh::comm
label comm() const
Return communicator used for parallel communication.
Definition: faMesh.C:995
Foam::DimensionedField
Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a...
Definition: DimensionedField.H:54
Foam::PrimitivePatch
A list of faces which address into the list of points.
Definition: PrimitivePatch.H:85
Foam::faMesh::areaCentres
const areaVectorField & areaCentres() const
Return face centres as areaVectorField.
Definition: faMesh.C:1058
faGlobalMeshData.H
Foam::faBoundaryMesh::interfaces
lduInterfacePtrsList interfaces() const
Return a list of pointers for each patch.
Definition: faBoundaryMesh.C:201