src/mesh/cfMesh/utilities/meshes/polyMeshGenModifier/polyMeshGenModifier.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     polyMeshGenModifier
  26
  27 Description
  28     Modifier for polyMeshGen
  29
  30 SourceFiles
  31     polyMeshGenModifier.C
  32
  33 \*---------------------------------------------------------------------------*/
  34
  35 #ifndef polyMeshGenModifier_H
  36 #define polyMeshGenModifier_H
  37
  38 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  39
  40 #include "polyMeshGen.H"
  41 #include "boolList.H"
  42 #include "VRWGraph.H"
  43 #include "demandDrivenData.H"
  44
  45 namespace Foam
  46 {
  47
  48 // Forward declarations
  49 class VRWGraphList;
  50
  51 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  52
  53 class polyMeshGenModifier
  54 {
  55     // Private data
  56         //- reference to the mesh
  57         polyMeshGen& mesh_;
  58
  59         //- helper data for adding cells
  60         VRWGraph* pointFacesPtr_;
  61
  62     // Private member functions
  63         //- calculate and return point faces
  64         inline void calculatePointFaces()
  65         {
  66             const faceListPMG& faces = mesh_.faces();
  67
  68             pointFacesPtr_ = new VRWGraph();
  69             VRWGraph& pointFaces = *pointFacesPtr_;
  70
  71             pointFaces.reverseAddressing(mesh_.points().size(), faces);
  72         };
  73
  74         //- re-order positions of processor boundary faces
  75         //- they should comea immediately after the internal faces
  76         void reorderProcBoundaryFaces();
  77
  78 protected:
  79
  80         VRWGraph& pointFaces()
  81         {
  82             if( !pointFacesPtr_ )
  83                 calculatePointFaces();
  84
  85             return *pointFacesPtr_;
  86         };
  87
  88 public:
  89
  90     // Constructors
  91         //- Construct from the reference to the mesh
  92         polyMeshGenModifier(polyMeshGen& mesh)
  93         :
  94             mesh_(mesh),
  95             pointFacesPtr_(NULL)
  96         {
  97             //mesh_.clearOut();
  98         };
  99
 100     // Destructor
 101         ~polyMeshGenModifier()
 102         {
 103             this->clearOut();
 104         };
 105
 106     // Member functions
 107         //- access to mesh points
 108         inline pointFieldPMG& pointsAccess()
 109         {
 110             return mesh_.points_;
 111         };
 112
 113         //- access to mesh faces
 114         inline faceListPMG& facesAccess()
 115         {
 116             return mesh_.faces_;
 117         };
 118
 119         //- access to cells
 120         inline cellListPMG& cellsAccess()
 121         {
 122             return mesh_.cells_;
 123         };
 124
 125         //- access to processor boundary data
 126         inline PtrList<processorBoundaryPatch>& procBoundariesAccess()
 127         {
 128             return mesh_.procBoundaries_;
 129         }
 130
 131         //- access to boundary data
 132         inline PtrList<boundaryPatch>& boundariesAccess()
 133         {
 134             return mesh_.boundaries_;
 135         }
 136
 137         //- functions which change the mesh
 138         //- reorder boundary faces
 139         void reorderBoundaryFaces();
 140
 141         //- remove unused vertices
 142         void removeUnusedVertices();
 143
 144         //- remove faces
 145         void removeFaces(const boolList& removeFace);
 146
 147         //- remove duplicate faces from the mesh
 148         void removeDuplicateFaces();
 149
 150         //- remove cells
 151         void removeCells
 152         (
 153             const boolList& removeCell,
 154             const bool removeProcFaces = true
 155         );
 156
 157         //- add cells (vertices must be added)
 158         void addCells(const LongList<faceList>& cellFaces);
 159         void addCells(const VRWGraphList& cellFaces);
 160         void addCell(const faceList& cellFaces);
 161
 162         //- replace the boundary with new boundary faces
 163         void replaceBoundary
 164         (
 165             const wordList& patchNames,
 166             const VRWGraph& boundaryFaces,
 167             const labelLongList& faceOwners,
 168             const labelLongList& facePatches
 169         );
 170
 171         //- add additional faces into processor patches
 172         void addProcessorFaces
 173         (
 174             const VRWGraph& procFaces,
 175             const labelLongList& facePatches
 176         );
 177
 178         //- add new processor patch and return its label
 179         label addProcessorPatch(const label otherProcLabel);
 180
 181         //- remove empty processor patch
 182         bool removeEmptyProcessorPatches();
 183
 184         //- add buffer cells needed for exporting the mesh in the format
 185         //- required by some solvers
 186         void addBufferCells();
 187
 188         //- zip up topologically open cells
 189         void zipUpCells();
 190
 191         //- reorder the cells and faces to reduce the matrix bandwidth
 192         void renumberMesh();
 193
 194         //- clear out unnecessary data (pointFacesPtr_);
 195         inline void clearOut()
 196         {
 197             deleteDemandDrivenData(pointFacesPtr_);
 198         }
 199
 200         //- clear out all allocated data
 201         inline void clearAll()
 202         {
 203             clearOut();
 204             mesh_.clearOut();
 205         }
 206 };
 207
 208 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 209
 210 } // End namespace Foam
 211
 212 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 213
 214 #endif
 215
 216 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //