src/mesh/cfMesh/utilities/meshes/partTetMesh/partTetMesh.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | cfMesh: A library for mesh generation
   4    \\    /   O peration     |
   5     \\  /    A nd           | Author: Franjo Juretic (franjo.juretic@c-fields.com)
   6      \\/     M anipulation  | Copyright (C) Creative Fields, Ltd.
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of cfMesh.
  10
  11     cfMesh 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     cfMesh 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 cfMesh.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     partTetMesh
  26
  27 Description
  28     Mesh smoothing without any topological changes
  29
  30 SourceFiles
  31     partTetMesh.C
  32
  33 \*---------------------------------------------------------------------------*/
  34
  35 #ifndef partTetMesh_H
  36 #define partTetMesh_H
  37
  38 #include "boolList.H"
  39 #include "labelLongList.H"
  40 #include "VRWGraph.H"
  41 #include "DynList.H"
  42 #include "partTet.H"
  43 #include "HashSet.H"
  44 #include "labelledPoint.H"
  45 #include "Map.H"
  46
  47 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  48
  49 namespace Foam
  50 {
  51
  52 // Forward declarations
  53 class polyMeshGen;
  54 class VRWGraph;
  55
  56 /*---------------------------------------------------------------------------*\
  57                         Class partTetMesh Declaration
  58 \*---------------------------------------------------------------------------*/
  59
  60 class partTetMesh
  61 {
  62     // Private data
  63         //- reference to the original mesh
  64         polyMeshGen& origMesh_;
  65
  66         //- points in the tet mesh
  67         LongList<point> points_;
  68
  69         //- tetrahedra making the mesh
  70         LongList<partTet> tets_;
  71
  72         //- label of node in the polyMeshGen
  73         labelLongList nodeLabelInOrigMesh_;
  74
  75         //- shall a node be used for smoothing or not
  76         LongList<direction> smoothVertex_;
  77
  78         //- addressing data
  79         VRWGraph pointTets_;
  80
  81         //- internal point ordering for parallel runs
  82         mutable VRWGraph* internalPointsOrderPtr_;
  83
  84         //- boundary point ordering for parallel runs
  85         mutable VRWGraph* boundaryPointsOrderPtr_;
  86
  87     // Private data for parallel runs
  88         //- global point label
  89         mutable labelLongList* globalPointLabelPtr_;
  90
  91         //- processor for containing points
  92         mutable VRWGraph* pAtProcsPtr_;
  93
  94         //- mapping between global and local point labels
  95         mutable Map<label>* globalToLocalPointAddressingPtr_;
  96
  97         //- processors which should communicate with the current one
  98         mutable DynList<label>* neiProcsPtr_;
  99
 100         //- labels of points at parallel boundaries
 101         mutable labelLongList* pAtParallelBoundariesPtr_;
 102
 103         //- labels of points serving as buffer layers on other processors
 104         mutable labelLongList* pAtBufferLayersPtr_;
 105
 106     // Private member functions
 107
 108         //- create points and tets
 109         void createPointsAndTets
 110         (
 111             const List<direction>& usedCells,
 112             const boolList& lockedPoints
 113         );
 114
 115         //- create parallel addressing
 116         void createParallelAddressing
 117         (
 118             const labelLongList& nodeLabelForPoint,
 119             const labelLongList& nodeLabelForFace,
 120             const labelLongList& nodeLabelForCell
 121         );
 122
 123         //- create buffer layers
 124         void createBufferLayers();
 125
 126         //- create ordering of internal points for parallel execution
 127         void createSMOOTHPointsOrdering() const;
 128
 129         //- create order of boundary points for parallel execution
 130         void createBOUNDARYPointsOrdering() const;
 131
 132 public:
 133
 134     // Constructors
 135         //- construct from polyMeshGen and locked points
 136         partTetMesh(polyMeshGen& mesh, const labelLongList& lockedPoints);
 137
 138         //- construct from polyMeshGen, locked points and the number of layers
 139         //- from the boundary
 140         partTetMesh
 141         (
 142             polyMeshGen& mesh,
 143             const labelLongList& lockedPoints,
 144             const direction nLayers = 2
 145         );
 146
 147         //- construct from polyMeshGen, bad faces and the number
 148         //- of additional layers
 149         partTetMesh
 150         (
 151             polyMeshGen& mesh,
 152             const labelLongList& lockedPoints,
 153             labelHashSet& badFaces,
 154             const direction additionalLayers = 0
 155         );
 156
 157     // Enumerators
 158
 159         enum vertexTypes
 160         {
 161             NONE = 0,
 162             SMOOTH = 1,
 163             FACECENTRE = 2,
 164             CELLCENTRE = 4,
 165             PARALLELBOUNDARY = 8,
 166             BOUNDARY = 16,
 167             LOCKED = 32
 168         };
 169
 170     // Destructor
 171         ~partTetMesh();
 172
 173     // Member functions
 174         //- access to points, tets and other data
 175         inline const LongList<point>& points() const
 176         {
 177             return points_;
 178         }
 179
 180         inline const LongList<partTet>& tets() const
 181         {
 182             return tets_;
 183         }
 184
 185         inline const VRWGraph& pointTets() const
 186         {
 187             return pointTets_;
 188         }
 189
 190         inline const LongList<direction>& smoothVertex() const
 191         {
 192             return smoothVertex_;
 193         }
 194
 195         inline const labelLongList& nodeLabelInOrigMesh() const
 196         {
 197             return nodeLabelInOrigMesh_;
 198         }
 199
 200     // Access to point ordering for Gauss-Seidel type of iteration
 201         //- return vertex ordering which can be executed in parallel
 202         //- the points in each row can be treated in parallel
 203         //- make sure that points added to different rows of this graph are
 204         //- not treated concurrently
 205         const VRWGraph& internalPointOrdering() const;
 206
 207         //- return vertex ordering for boundary points
 208         const VRWGraph& boundaryPointOrdering() const;
 209
 210     // Access to parallel data
 211         inline const labelLongList& globalPointLabel() const
 212         {
 213             if( !Pstream::parRun() )
 214                 FatalError << "This is a serial run" << abort(FatalError);
 215
 216             return *globalPointLabelPtr_;
 217         }
 218
 219         inline const VRWGraph& pointAtProcs() const
 220         {
 221             if( !Pstream::parRun() )
 222                 FatalError << "This is a serial run" << abort(FatalError);
 223
 224             return *pAtProcsPtr_;
 225         }
 226
 227         inline const Map<label>& globalToLocalPointAddressing() const
 228         {
 229             if( !Pstream::parRun() )
 230                 FatalError << "This is a serial run" << abort(FatalError);
 231
 232             return *globalToLocalPointAddressingPtr_;
 233         }
 234
 235         inline const DynList<label>& neiProcs() const
 236         {
 237             if( !Pstream::parRun() )
 238                 FatalError << "This is a serial run" << abort(FatalError);
 239
 240             return *neiProcsPtr_;
 241         }
 242
 243         inline const labelLongList& pointsAtProcessorBoundaries() const
 244         {
 245             if( !Pstream::parRun() )
 246                 FatalError << "This is a serial run" << abort(FatalError);
 247
 248             return *pAtParallelBoundariesPtr_;
 249         }
 250
 251         inline const labelLongList& bufferLayerPoints() const
 252         {
 253             if( !Pstream::parRun() )
 254                 FatalError << "This is a serial run" << abort(FatalError);
 255
 256             return *pAtBufferLayersPtr_;
 257         }
 258
 259     // Modifiers
 260
 261         //- move the vertex to a new position
 262         void updateVertex(const label pointI, const point& newP);
 263
 264         //- move vertices to their new positions
 265         //- intended for SMP parallelisation
 266         void updateVerticesSMP(const List<LongList<labelledPoint> >&);
 267
 268         //- updates the vertices of the original polyMeshGen
 269         void updateOrigMesh(boolList* changedFacePtr = NULL);
 270
 271         //- creates polyMeshGen from this partTetMesh
 272         void createPolyMesh(polyMeshGen& pmg) const;
 273
 274         //- add the LOCKED flag to mesh points which shall not move
 275         template<class labelListType>
 276         void lockPoints(const labelListType& l)
 277         {
 278             forAll(l, pI)
 279                 smoothVertex_[l[pI]] |= LOCKED;
 280         }
 281 };
 282
 283 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 284
 285 } // End namespace Foam
 286
 287 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 288
 289 #endif
 290
 291 // ************************************************************************* //