src/mesh/cfMesh/meshLibrary/cartesian2DMesh/cartesian2DMeshGenerator/cartesian2DMeshGenerator.C

   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 Description
  25
  26 \*---------------------------------------------------------------------------*/
  27
  28 #include "cartesian2DMeshGenerator.H"
  29 #include "polyMeshGen2DEngine.H"
  30 #include "triSurf.H"
  31 #include "triSurfacePatchManipulator.H"
  32 #include "demandDrivenData.H"
  33 #include "Time.H"
  34 #include "meshOctreeCreator.H"
  35 #include "cartesianMeshExtractor.H"
  36 #include "meshSurfaceEngine.H"
  37 #include "meshSurfaceMapper2D.H"
  38 #include "meshSurfaceEdgeExtractor2D.H"
  39 #include "meshSurfaceOptimizer.H"
  40 #include "topologicalCleaner.H"
  41 #include "boundaryLayers.H"
  42 #include "refineBoundaryLayers.H"
  43 #include "renameBoundaryPatches.H"
  44 #include "checkMeshDict.H"
  45 #include "checkCellConnectionsOverFaces.H"
  46 #include "checkIrregularSurfaceConnections.H"
  47 #include "checkNonMappableCellConnections.H"
  48 #include "checkBoundaryFacesSharingTwoEdges.H"
  49 #include "triSurfaceMetaData.H"
  50
  51 //#define DEBUG
  52
  53 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  54
  55 namespace Foam
  56 {
  57
  58 // * * * * * * * * * * * * Private member functions  * * * * * * * * * * * * //
  59
  60 void cartesian2DMeshGenerator::createCartesianMesh()
  61 {
  62     //- create polyMesh from octree boxes
  63     cartesianMeshExtractor cme(*octreePtr_, meshDict_, mesh_);
  64
  65     if( meshDict_.found("decomposePolyhedraIntoTetsAndPyrs") )
  66     {
  67         if( readBool(meshDict_.lookup("decomposePolyhedraIntoTetsAndPyrs")) )
  68             cme.decomposeSplitHexes();
  69     }
  70
  71     cme.createMesh();
  72
  73     # ifdef DEBUG
  74     mesh_.write();
  75     //::exit(EXIT_FAILURE);
  76     # endif
  77 }
  78
  79 void cartesian2DMeshGenerator::surfacePreparation()
  80 {
  81     //- removes unnecessary cells and morph the boundary
  82     //- such that there is only one boundary face per cell
  83     //- It also checks topology of cells after morphing is performed
  84     bool changed;
  85
  86     do
  87     {
  88         changed = false;
  89
  90         checkIrregularSurfaceConnections checkConnections(mesh_);
  91         if( checkConnections.checkAndFixIrregularConnections() )
  92             changed = true;
  93
  94         if( checkNonMappableCellConnections(mesh_).removeCells() )
  95             changed = true;
  96
  97         if( checkCellConnectionsOverFaces(mesh_).checkCellGroups() )
  98             changed = true;
  99     } while( changed );
 100
 101     checkBoundaryFacesSharingTwoEdges(mesh_).improveTopology();
 102
 103     # ifdef DEBUG
 104     mesh_.write();
 105     //::exit(EXIT_FAILURE);
 106     # endif
 107 }
 108
 109 void cartesian2DMeshGenerator::mapMeshToSurface()
 110 {
 111     //- calculate mesh surface
 112     meshSurfaceEngine* msePtr = new meshSurfaceEngine(mesh_);
 113
 114     //- pre-map mesh surface
 115     meshSurfaceMapper2D mapper(*msePtr, *octreePtr_);
 116
 117     mapper.adjustZCoordinates();
 118
 119     mapper.preMapVertices();
 120
 121     # ifdef DEBUG
 122     mesh_.write();
 123     //::exit(EXIT_FAILURE);
 124     # endif
 125
 126     //- map mesh surface on the geometry surface
 127     mapper.mapVerticesOntoSurface();
 128
 129     # ifdef DEBUG
 130     mesh_.write();
 131     //::exit(EXIT_SUCCESS);
 132     # endif
 133
 134     deleteDemandDrivenData(msePtr);
 135 }
 136
 137 void cartesian2DMeshGenerator::mapEdgesAndCorners()
 138 {
 139     meshSurfaceEdgeExtractor2D(mesh_, *octreePtr_);
 140
 141     # ifdef DEBUG
 142     mesh_.write();
 143     //::exit(0);
 144     # endif
 145 }
 146
 147 void cartesian2DMeshGenerator::optimiseMeshSurface()
 148 {
 149     meshSurfaceEngine mse(mesh_);
 150     meshSurfaceOptimizer optimizer(mse, *octreePtr_);
 151     optimizer.optimizeSurface2D();
 152     optimizer.untangleSurface2D();
 153
 154     # ifdef DEBUG
 155     mesh_.write();
 156     //::exit(0);
 157     # endif
 158 }
 159
 160 void cartesian2DMeshGenerator::generateBoundaryLayers()
 161 {
 162     boundaryLayers bl(mesh_);
 163
 164     bl.activate2DMode();
 165
 166     bl.addLayerForAllPatches();
 167
 168     # ifdef DEBUG
 169     mesh_.write();
 170     //::exit(0);
 171     # endif
 172 }
 173
 174 void cartesian2DMeshGenerator::refBoundaryLayers()
 175 {
 176     if( meshDict_.isDict("boundaryLayers") )
 177     {
 178         refineBoundaryLayers refLayers(mesh_);
 179
 180         refineBoundaryLayers::readSettings(meshDict_, refLayers);
 181
 182         refLayers.activate2DMode();
 183
 184         refLayers.refineLayers();
 185
 186         meshSurfaceEngine mse(mesh_);
 187         meshSurfaceOptimizer optimizer(mse, *octreePtr_);
 188
 189         optimizer.untangleSurface2D();
 190     }
 191 }
 192
 193 void cartesian2DMeshGenerator::replaceBoundaries()
 194 {
 195     renameBoundaryPatches rbp(mesh_, meshDict_);
 196
 197     # ifdef DEBUG
 198     mesh_.write();
 199     //::exit(0);
 200     # endif
 201 }
 202
 203 void cartesian2DMeshGenerator::renumberMesh()
 204 {
 205     polyMeshGenModifier(mesh_).renumberMesh();
 206
 207     # ifdef DEBUG
 208     mesh_.write();
 209     //::exit(0);
 210     # endif
 211 }
 212
 213 void cartesian2DMeshGenerator::generateMesh()
 214 {
 215     createCartesianMesh();
 216
 217     surfacePreparation();
 218
 219     mapMeshToSurface();
 220
 221     mapEdgesAndCorners();
 222
 223     optimiseMeshSurface();
 224
 225     generateBoundaryLayers();
 226
 227     optimiseMeshSurface();
 228
 229     refBoundaryLayers();
 230
 231     renumberMesh();
 232
 233     replaceBoundaries();
 234 }
 235
 236 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 237
 238 // Construct from objectRegistry
 239 cartesian2DMeshGenerator::cartesian2DMeshGenerator(const Time& time)
 240 :
 241     db_(time),
 242     surfacePtr_(NULL),
 243     meshDict_
 244     (
 245         IOobject
 246         (
 247             "meshDict",
 248             db_.system(),
 249             db_,
 250             IOobject::MUST_READ,
 251             IOobject::NO_WRITE
 252         )
 253     ),
 254     octreePtr_(NULL),
 255     mesh_(time)
 256 {
 257     if( true )
 258     {
 259         checkMeshDict cmd(meshDict_);
 260     }
 261
 262     fileName surfaceFile = meshDict_.lookup("surfaceFile");
 263     if( Pstream::parRun() )
 264         surfaceFile = ".."/surfaceFile;
 265
 266     surfacePtr_ = new triSurf(db_.path()/surfaceFile);
 267
 268     if( true )
 269     {
 270         //- save meta data with the mesh (surface mesh + its topology info)
 271         triSurfaceMetaData sMetaData(*surfacePtr_);
 272         const dictionary& surfMetaDict = sMetaData.metaData();
 273
 274         mesh_.metaData().add("surfaceFile", surfaceFile);
 275         mesh_.metaData().add("surfaceMeta", surfMetaDict);
 276     }
 277
 278     if( surfacePtr_->featureEdges().size() != 0 )
 279     {
 280         //- create surface patches based on the feature edges
 281         //- and update the meshDict based on the given data
 282         triSurfacePatchManipulator manipulator(*surfacePtr_);
 283
 284         const triSurf* surfaceWithPatches =
 285             manipulator.surfaceWithPatches(&meshDict_);
 286
 287         //- delete the old surface and assign the new one
 288         deleteDemandDrivenData(surfacePtr_);
 289         surfacePtr_ = surfaceWithPatches;
 290     }
 291
 292     octreePtr_ = new meshOctree(*surfacePtr_, true);
 293
 294     meshOctreeCreator(*octreePtr_, meshDict_).createOctreeBoxes();
 295
 296     generateMesh();
 297 }
 298
 299 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 300
 301 cartesian2DMeshGenerator::~cartesian2DMeshGenerator()
 302 {
 303     deleteDemandDrivenData(surfacePtr_);
 304     deleteDemandDrivenData(octreePtr_);
 305 }
 306
 307 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 308
 309 void cartesian2DMeshGenerator::writeMesh() const
 310 {
 311     mesh_.write();
 312 }
 313
 314 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 315
 316 } // End namespace Foam
 317
 318 // ************************************************************************* //