src/mesh/cfMesh/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 "triSurface2DCheck.H"
  30 #include "polyMeshGen2DEngine.H"
  31 #include "triSurf.H"
  32 #include "triSurfacePatchManipulator.H"
  33 #include "triSurfaceCleanupDuplicateTriangles.H"
  34 #include "demandDrivenData.H"
  35 #include "foamTime.H"
  36 #include "meshOctreeCreator.H"
  37 #include "cartesianMeshExtractor.H"
  38 #include "meshSurfaceEngine.H"
  39 #include "meshSurfaceMapper2D.H"
  40 #include "meshSurfaceEdgeExtractor2D.H"
  41 #include "meshSurfaceOptimizer.H"
  42 #include "topologicalCleaner.H"
  43 #include "boundaryLayers.H"
  44 #include "refineBoundaryLayers.H"
  45 #include "renameBoundaryPatches.H"
  46 #include "checkMeshDict.H"
  47 #include "checkCellConnectionsOverFaces.H"
  48 #include "checkIrregularSurfaceConnections.H"
  49 #include "checkNonMappableCellConnections.H"
  50 #include "checkBoundaryFacesSharingTwoEdges.H"
  51 #include "triSurfaceMetaData.H"
  52 #include "polyMeshGenGeometryModification.H"
  53 #include "surfaceMeshGeometryModification.H"
  54
  55 //#define DEBUG
  56
  57 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  58
  59 namespace Foam
  60 {
  61
  62 // * * * * * * * * * * * * Private member functions  * * * * * * * * * * * * //
  63
  64 void cartesian2DMeshGenerator::createCartesianMesh()
  65 {
  66     //- create polyMesh from octree boxes
  67     cartesianMeshExtractor cme(*octreePtr_, meshDict_, mesh_);
  68
  69     if( meshDict_.found("decomposePolyhedraIntoTetsAndPyrs") )
  70     {
  71         if( readBool(meshDict_.lookup("decomposePolyhedraIntoTetsAndPyrs")) )
  72             cme.decomposeSplitHexes();
  73     }
  74
  75     cme.createMesh();
  76 }
  77
  78 void cartesian2DMeshGenerator::surfacePreparation()
  79 {
  80     //- removes unnecessary cells and morph the boundary
  81     //- such that there is only one boundary face per cell
  82     //- It also checks topology of cells after morphing is performed
  83     bool changed;
  84
  85     do
  86     {
  87         changed = false;
  88
  89         checkIrregularSurfaceConnections checkConnections(mesh_);
  90         if( checkConnections.checkAndFixIrregularConnections() )
  91             changed = true;
  92
  93         if( checkNonMappableCellConnections(mesh_).removeCells() )
  94             changed = true;
  95
  96         if( checkCellConnectionsOverFaces(mesh_).checkCellGroups() )
  97             changed = true;
  98     } while( changed );
  99
 100     checkBoundaryFacesSharingTwoEdges(mesh_).improveTopology();
 101 }
 102
 103 void cartesian2DMeshGenerator::mapMeshToSurface()
 104 {
 105     //- calculate mesh surface
 106     meshSurfaceEngine* msePtr = new meshSurfaceEngine(mesh_);
 107
 108     //- pre-map mesh surface
 109     meshSurfaceMapper2D mapper(*msePtr, *octreePtr_);
 110
 111     mapper.adjustZCoordinates();
 112
 113     mapper.preMapVertices();
 114
 115     //- map mesh surface on the geometry surface
 116     mapper.mapVerticesOntoSurface();
 117
 118     deleteDemandDrivenData(msePtr);
 119 }
 120
 121 void cartesian2DMeshGenerator::extractPatches()
 122 {
 123     meshSurfaceEdgeExtractor2D(mesh_, *octreePtr_).distributeBoundaryFaces();
 124 }
 125
 126 void cartesian2DMeshGenerator::mapEdgesAndCorners()
 127 {
 128     meshSurfaceEdgeExtractor2D(mesh_, *octreePtr_).remapBoundaryPoints();
 129 }
 130
 131 void cartesian2DMeshGenerator::optimiseMeshSurface()
 132 {
 133     meshSurfaceEngine mse(mesh_);
 134     meshSurfaceOptimizer optimizer(mse, *octreePtr_);
 135     optimizer.optimizeSurface2D();
 136     optimizer.untangleSurface2D();
 137 }
 138
 139 void cartesian2DMeshGenerator::generateBoundaryLayers()
 140 {
 141     boundaryLayers bl(mesh_);
 142
 143     bl.activate2DMode();
 144
 145     bl.addLayerForAllPatches();
 146
 147     if( modSurfacePtr_ )
 148     {
 149         polyMeshGenGeometryModification meshMod(mesh_, meshDict_);
 150
 151         //- revert the mesh into the original space
 152         meshMod.revertGeometryModification();
 153
 154         //- delete modified surface mesh
 155         deleteDemandDrivenData(modSurfacePtr_);
 156
 157         //- delete the octree
 158         deleteDemandDrivenData(octreePtr_);
 159
 160         //- contruct a new octree from the input surface
 161         octreePtr_ = new meshOctree(*surfacePtr_, true);
 162         meshOctreeCreator(*octreePtr_).createOctreeWithRefinedBoundary(20);
 163
 164         mapEdgesAndCorners();
 165
 166         optimiseMeshSurface();
 167     }
 168 }
 169
 170 void cartesian2DMeshGenerator::refBoundaryLayers()
 171 {
 172     if( meshDict_.isDict("boundaryLayers") )
 173     {
 174         refineBoundaryLayers refLayers(mesh_);
 175
 176         refineBoundaryLayers::readSettings(meshDict_, refLayers);
 177
 178         refLayers.activate2DMode();
 179
 180         refLayers.refineLayers();
 181
 182         meshSurfaceEngine mse(mesh_);
 183         meshSurfaceOptimizer optimizer(mse, *octreePtr_);
 184
 185         optimizer.untangleSurface2D();
 186     }
 187 }
 188
 189 void cartesian2DMeshGenerator::replaceBoundaries()
 190 {
 191     renameBoundaryPatches rbp(mesh_, meshDict_);
 192 }
 193
 194 void cartesian2DMeshGenerator::renumberMesh()
 195 {
 196     polyMeshGenModifier(mesh_).renumberMesh();
 197 }
 198
 199 void cartesian2DMeshGenerator::generateMesh()
 200 {
 201     try
 202     {
 203         if( controller_.runCurrentStep("templateGeneration") )
 204         {
 205             createCartesianMesh();
 206         }
 207
 208         if( controller_.runCurrentStep("surfaceTopology") )
 209         {
 210             surfacePreparation();
 211         }
 212
 213         if( controller_.runCurrentStep("surfaceProjection") )
 214         {
 215             mapMeshToSurface();
 216         }
 217
 218         if( controller_.runCurrentStep("patchAssignment") )
 219         {
 220             extractPatches();
 221         }
 222
 223         if( controller_.runCurrentStep("edgeExtraction") )
 224         {
 225             mapEdgesAndCorners();
 226
 227             optimiseMeshSurface();
 228         }
 229
 230         if( controller_.runCurrentStep("boundaryLayerGeneration") )
 231         {
 232             generateBoundaryLayers();
 233         }
 234
 235         if( controller_.runCurrentStep("meshOptimisation") )
 236         {
 237             optimiseMeshSurface();
 238         }
 239
 240         if( controller_.runCurrentStep("boundaryLayerRefinement") )
 241         {
 242             refBoundaryLayers();
 243         }
 244
 245         renumberMesh();
 246
 247         replaceBoundaries();
 248
 249         controller_.workflowCompleted();
 250     }
 251     catch(const std::string& message)
 252     {
 253         Info << message << endl;
 254     }
 255     catch(...)
 256     {
 257         WarningIn
 258         (
 259             "void cartesian2DMeshGenerator::generateMesh()"
 260         ) << "Meshing process terminated!" << endl;
 261     }
 262 }
 263
 264 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 265
 266 cartesian2DMeshGenerator::cartesian2DMeshGenerator(const Time& time)
 267 :
 268     db_(time),
 269     surfacePtr_(NULL),
 270     modSurfacePtr_(NULL),
 271     meshDict_
 272     (
 273         IOobject
 274         (
 275             "meshDict",
 276             db_.system(),
 277             db_,
 278             IOobject::MUST_READ,
 279             IOobject::NO_WRITE
 280         )
 281     ),
 282     octreePtr_(NULL),
 283     mesh_(time),
 284     controller_(mesh_)
 285 {
 286     if( true )
 287     {
 288         checkMeshDict cmd(meshDict_);
 289     }
 290
 291     fileName surfaceFile = meshDict_.lookup("surfaceFile");
 292     if( Pstream::parRun() )
 293         surfaceFile = ".."/surfaceFile;
 294
 295     surfacePtr_ = new triSurf(db_.path()/surfaceFile);
 296
 297     if( true )
 298     {
 299         //- save meta data with the mesh (surface mesh + its topology info)
 300         triSurfaceMetaData sMetaData(*surfacePtr_);
 301         const dictionary& surfMetaDict = sMetaData.metaData();
 302
 303         mesh_.metaData().add("surfaceFile", surfaceFile, true);
 304         mesh_.metaData().add("surfaceMeta", surfMetaDict, true);
 305
 306         triSurface2DCheck surfCheck(*surfacePtr_);
 307         if( !surfCheck.is2DSurface() )
 308         {
 309             surfCheck.createSubsets();
 310
 311             Info << "Writting surface with subsets to file "
 312                  << "badSurfaceWithSubsets.fms" << endl;
 313             surfacePtr_->writeSurface("badSurfaceWithSubsets.fms");
 314         }
 315     }
 316
 317     if( surfacePtr_->featureEdges().size() != 0 )
 318     {
 319         //- get rid of duplicate triangles as they cause strange problems
 320         triSurfaceCleanupDuplicateTriangles(const_cast<triSurf&>(*surfacePtr_));
 321
 322         //- create surface patches based on the feature edges
 323         //- and update the meshDict based on the given data
 324         triSurfacePatchManipulator manipulator(*surfacePtr_);
 325
 326         const triSurf* surfaceWithPatches =
 327             manipulator.surfaceWithPatches(&meshDict_);
 328
 329         //- delete the old surface and assign the new one
 330         deleteDemandDrivenData(surfacePtr_);
 331         surfacePtr_ = surfaceWithPatches;
 332     }
 333
 334     if( meshDict_.found("anisotropicSources") )
 335     {
 336         surfaceMeshGeometryModification surfMod(*surfacePtr_, meshDict_);
 337
 338         modSurfacePtr_ = surfMod.modifyGeometry();
 339
 340         octreePtr_ = new meshOctree(*modSurfacePtr_, true);
 341     }
 342     else
 343     {
 344         octreePtr_ = new meshOctree(*surfacePtr_, true);
 345     }
 346
 347     meshOctreeCreator(*octreePtr_, meshDict_).createOctreeBoxes();
 348
 349     generateMesh();
 350 }
 351
 352 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 353
 354 cartesian2DMeshGenerator::~cartesian2DMeshGenerator()
 355 {
 356     deleteDemandDrivenData(surfacePtr_);
 357     deleteDemandDrivenData(modSurfacePtr_);
 358     deleteDemandDrivenData(octreePtr_);
 359 }
 360
 361 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 362
 363 void cartesian2DMeshGenerator::writeMesh() const
 364 {
 365     mesh_.write();
 366 }
 367
 368 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 369
 370 } // End namespace Foam
 371
 372 // ************************************************************************* //