src/finiteArea/faMesh/faMesh.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Class
  26     faMesh
  27
  28 Description
  29     Finite area mesh.  Used for 2-D non-Euclidian finite area method.
  30
  31 SourceFiles
  32     faMesh.C
  33     faMeshDemandDrivenData.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef faMesh_H
  38 #define faMesh_H
  39
  40 #include "GeoMesh.H"
  41 #include "polyMesh.H"
  42 #include "lduMesh.H"
  43 #include "faBoundaryMesh.H"
  44 #include "edgeList.H"
  45 #include "faceList.H"
  46 #include "primitiveFieldsFwd.H"
  47 #include "DimensionedField.H"
  48 #include "areaFieldsFwd.H"
  49 #include "edgeFieldsFwd.H"
  50 #include "indirectPrimitivePatch.H"
  51 #include "edgeInterpolation.H"
  52 #include "labelIOList.H"
  53 #include "scalarIOField.H"
  54 #include "FieldFields.H"
  55 #include "faGlobalMeshData.H"
  56
  57 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  58
  59 namespace Foam
  60 {
  61
  62 // Class forward declarations
  63 class faMeshLduAddressing;
  64
  65 /*---------------------------------------------------------------------------*\
  66                            Class faMesh Declaration
  67 \*---------------------------------------------------------------------------*/
  68
  69 class faMesh
  70 :
  71     public GeoMesh<polyMesh>,
  72     public lduMesh,
  73     public edgeInterpolation
  74 {
  75     // Private data
  76
  77         //- Face labels
  78         labelIOList faceLabels_;
  79
  80         //- Boundary mesh
  81         faBoundaryMesh boundary_;
  82
  83
  84         // Primitive mesh data
  85
  86             //- Edges, addressing into local point list
  87             edgeList edges_;
  88
  89             //- Edge owner
  90             labelList edgeOwner_;
  91
  92             //- Edge neighbour
  93             labelList edgeNeighbour_;
  94
  95
  96         // Primitive size data
  97
  98             //- Number of points
  99             mutable label nPoints_;
 100
 101             //- Number of edges
 102             mutable label nEdges_;
 103
 104             //- Number of internal edges
 105             mutable label nInternalEdges_;
 106
 107             //- Number of faces
 108             mutable label nFaces_;
 109
 110
 111     // Demand-driven data
 112
 113         //- Primitive patch
 114         mutable indirectPrimitivePatch* patchPtr_;
 115
 116         //- Ldu addressing data
 117         mutable faMeshLduAddressing* lduPtr_;
 118
 119         //- Face areas
 120         mutable DimensionedField<scalar, areaMesh>* SPtr_;
 121
 122         //- Face areas old time level
 123         mutable DimensionedField<scalar, areaMesh>* S0Ptr_;
 124
 125         //- Face areas old-old time level
 126         mutable DimensionedField<scalar, areaMesh>* S00Ptr_;
 127
 128         //- Patch starts in the edge list
 129         mutable labelList* patchStartsPtr_;
 130
 131         //- Edge length vectors
 132         mutable edgeVectorField* LePtr_;
 133
 134         //- Mag edge length vectors
 135         mutable edgeScalarField* magLePtr_;
 136
 137         //- Face centres
 138         mutable areaVectorField* centresPtr_;
 139
 140         //- Edge centres
 141         mutable edgeVectorField* edgeCentresPtr_;
 142
 143         //- Face area normals
 144         mutable areaVectorField* faceAreaNormalsPtr_;
 145
 146         //- Edge area normals
 147         mutable edgeVectorField* edgeAreaNormalsPtr_;
 148
 149         //- Edge area normals
 150         mutable vectorField* pointAreaNormalsPtr_;
 151
 152         //- Face curvatures
 153         mutable areaScalarField* faceCurvaturesPtr_;
 154
 155         //- Edge transformation tensors
 156         mutable FieldField<Field, tensor>* edgeTransformTensorsPtr_;
 157
 158         //- Whether point normals must be corrected for a patch
 159         mutable boolList* correctPatchPointNormalsPtr_;
 160
 161         // Other mesh-related data
 162
 163             //- Parallel info
 164             mutable faGlobalMeshData* globalMeshDataPtr_;
 165
 166             // Mesh motion
 167
 168                 //- Is the mesh moving
 169                 bool moving_;
 170
 171                 //- Current time index for mesh motion
 172                 mutable label curMotionTimeIndex_;
 173
 174
 175     // Static Private Data
 176
 177         static const bool quadricsFit_;
 178
 179
 180     // Private Member Functions
 181
 182         //- Disallow default bitwise copy construct
 183         faMesh(const faMesh&);
 184
 185         //- Disallow default bitwise assignment
 186         void operator=(const faMesh&);
 187
 188
 189         //- Set primitive mesh data
 190         void setPrimitiveMeshData();
 191
 192         // Private member functions to calculate demand driven data
 193
 194             //- Calculate ldu addressing
 195             void calcLduAddressing() const;
 196
 197             //- Calculate patch starts in the edge list
 198             void calcPatchStarts() const;
 199
 200             //- Calculate edge lengths
 201             void calcLe() const;
 202
 203             //- Calculate mag edge lengths
 204             void calcMagLe() const;
 205
 206             //- Calculate face centres
 207             void calcAreaCentres() const;
 208
 209             //- Calculate edge centres
 210             void calcEdgeCentres() const;
 211
 212             //- Calculate face areas
 213             void calcS() const;
 214
 215             //- Calculate face area normals
 216             void calcFaceAreaNormals() const;
 217
 218             //- Calculate edge area normals
 219             void calcEdgeAreaNormals() const;
 220
 221             //- Calculate point area normals
 222             void calcPointAreaNormals() const;
 223
 224             //- Calculate point area normals by quadrics fit
 225             void calcPointAreaNormalsByQuadricsFit() const;
 226
 227             //- Calculate face curvatures
 228             void calcFaceCurvatures() const;
 229
 230             //- Calculate edge transformation tensors
 231             void calcEdgeTransformTensors() const;
 232
 233             //- Clear geometry but not the face areas
 234             void clearGeomNotAreas() const;
 235
 236             //- Clear geometry
 237             void clearGeom() const;
 238
 239             //- Clear addressing
 240             void clearAddressing() const;
 241
 242             //- Clear demand-driven data
 243             void clearOut() const;
 244
 245 public:
 246
 247     // Public typedefs
 248
 249         typedef faMesh Mesh;
 250         typedef faBoundaryMesh BoundaryMesh;
 251
 252
 253     //- Runtime type information
 254     TypeName("faMesh");
 255
 256
 257     //- Return the mesh sub-directory name (usually "faMesh")
 258     static word meshSubDir;
 259
 260
 261     // Constructors
 262
 263         //- Construct from polyMesh
 264         explicit faMesh(const polyMesh& m);
 265
 266         //- Construct from components without boundary.
 267         //  Boundary is added using addFaPatches() member function
 268         faMesh
 269         (
 270             const polyMesh& m,
 271             const labelList& faceLabels
 272         );
 273
 274         //- Construct from finite area mesh definition file
 275         faMesh
 276         (
 277             const polyMesh& m,
 278             const fileName& defFile
 279         );
 280
 281         //- Construct from polyPatch
 282         faMesh
 283         (
 284             const polyMesh& m,
 285             const label polyPatchID
 286         );
 287
 288
 289     // Destructor
 290
 291         virtual ~faMesh();
 292
 293
 294     // Member Functions
 295
 296         // Helpers
 297
 298             //- Add boundary patches. Constructor helper
 299             void addFaPatches(const List<faPatch*> &);
 300
 301
 302         // Database
 303
 304             //- Return the local mesh directory (dbDir()/meshSubDir)
 305             fileName meshDir() const;
 306
 307             //- Return reference to time
 308             const Time& time() const;
 309
 310             //- Return the current instance directory for points
 311             //  Used in the consruction of gemometric mesh data dependent
 312             //  on points
 313             const fileName& pointsInstance() const;
 314
 315             //- Return the current instance directory for faces
 316             const fileName& facesInstance() const;
 317
 318
 319             //- Mesh size parameters
 320
 321                 inline label nPoints() const
 322                 {
 323                     return nPoints_;
 324                 }
 325
 326                 inline label nEdges() const
 327                 {
 328                     return nEdges_;
 329                 }
 330
 331                 inline label nInternalEdges() const
 332                 {
 333                     return nInternalEdges_;
 334                 }
 335
 336                 inline label nFaces() const
 337                 {
 338                     return nFaces_;
 339                 }
 340
 341             // Primitive mesh data
 342
 343                 //- Return mesh points
 344                 const pointField& points() const;
 345
 346                 //- Return edges
 347                 const edgeList& edges() const;
 348
 349                 //- Return faces
 350                 const faceList& faces() const;
 351
 352                 //- Edge owner addresing
 353                 inline const labelList& edgeOwner() const
 354                 {
 355                     return edgeOwner_;
 356                 }
 357
 358                 //- Edge neighbour addressing
 359                 inline const labelList& edgeNeighbour() const
 360                 {
 361                     return edgeNeighbour_;
 362                 }
 363
 364
 365         // Access
 366
 367             //- Return reference to the mesh database
 368             virtual const objectRegistry& thisDb() const;
 369
 370             //- Return constant reference to boundary mesh
 371             const faBoundaryMesh& boundary() const;
 372
 373             //- Return faMesh face labels
 374             const labelList& faceLabels() const
 375             {
 376                 return faceLabels_;
 377             }
 378
 379
 380             //- Return parallel info
 381             const faGlobalMeshData& globalData() const;
 382
 383             //- Return ldu addressing
 384             virtual const lduAddressing& lduAddr() const;
 385
 386             //- Return a list of pointers for each patch
 387             //  with only those pointing to interfaces being set
 388             virtual lduInterfacePtrsList interfaces() const
 389             {
 390                 return boundary().interfaces();
 391             }
 392
 393             //- Internal face owner
 394             const unallocLabelList& owner() const
 395             {
 396                 return lduAddr().lowerAddr();
 397             }
 398
 399             //- Internal face neighbour
 400             const unallocLabelList& neighbour() const
 401             {
 402                 return lduAddr().upperAddr();
 403             }
 404
 405             //- Return true if given edge label is internal to the mesh
 406             inline bool isInternalEdge(const label edgeIndex) const
 407             {
 408                 return edgeIndex < nInternalEdges();
 409             }
 410
 411
 412         // Mesh motion
 413
 414             //- Is mesh moving
 415             bool moving() const
 416             {
 417                 return moving_;
 418             }
 419
 420             //- Move points, returns volumes swept by faces in motion
 421             virtual tmp<scalarField> movePoints(const vectorField&);
 422
 423
 424         // Demand-driven data
 425
 426             //- Return constant reference to primitive patch
 427             const indirectPrimitivePatch& patch() const;
 428
 429             //- Return reference to primitive patch
 430             indirectPrimitivePatch& patch();
 431
 432             //- Return patch starts
 433             const labelList& patchStarts() const;
 434
 435             //- Return edge length vectors
 436             const edgeVectorField& Le() const;
 437
 438             //- Return edge length magnitudes
 439             const edgeScalarField& magLe() const;
 440
 441             //- Return face centres as areaVectorField
 442             const areaVectorField& areaCentres() const;
 443
 444             //- Return edge centres as edgeVectorField
 445             const edgeVectorField& edgeCentres() const;
 446
 447             //- Return face areas
 448             const DimensionedField<scalar, areaMesh>& S() const;
 449
 450             //- Return old-time face areas
 451             const DimensionedField<scalar, areaMesh>& S0() const;
 452
 453             //- Return old-old-time face areas
 454             const DimensionedField<scalar, areaMesh>& S00() const;
 455
 456             //- Return face area normals
 457             const areaVectorField& faceAreaNormals() const;
 458
 459             //- Return edge area normals
 460             const edgeVectorField& edgeAreaNormals() const;
 461
 462             //- Return point area normals
 463             const vectorField& pointAreaNormals() const;
 464
 465             //- Return face curvatures
 466             const areaScalarField& faceCurvatures() const;
 467
 468             //- Return edge transformation tensors
 469             const FieldField<Field, tensor>& edgeTransformTensors() const;
 470
 471             //- Return internal point labels
 472             labelList internalPoints() const;
 473
 474             //- Return boundary point labels
 475             labelList boundaryPoints() const;
 476
 477             //- Return edge length correction
 478             tmp<edgeScalarField> edgeLengthCorrection() const;
 479
 480             //- Whether point normals should be corrected for a patch
 481             bool correctPatchPointNormals(const label patchID) const;
 482
 483             //- Set whether point normals should be corrected for a patch
 484             boolList& correctPatchPointNormals() const;
 485
 486         //- Write mesh
 487         virtual bool write() const;
 488
 489
 490     // Member Operators
 491
 492         bool operator!=(const faMesh& m) const;
 493
 494         bool operator==(const faMesh& m) const;
 495 };
 496
 497
 498 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 499
 500 } // End namespace Foam
 501
 502 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 503
 504 #ifdef NoRepository
 505 #   include "faPatchFaMeshTemplates.C"
 506 #endif
 507
 508 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 509
 510 #endif
 511
 512 // ************************************************************************* //