src/mesh/cfMesh/voronoiMesh/voronoiMeshGenerator/voronoiMeshGenerator.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 "voronoiMeshGenerator.H"
  29 #include "triSurf.H"
  30 #include "demandDrivenData.H"
  31 #include "objectRegistry.H"
  32 #include "foamTime.H"
  33 #include "meshOctreeCreator.H"
  34 #include "voronoiMeshExtractor.H"
  35 #include "meshSurfaceEngine.H"
  36 #include "meshSurfaceMapper.H"
  37 #include "surfaceMorpherCells.H"
  38 #include "meshOptimizer.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 "triSurfacePatchManipulator.H"
  46 #include "triSurfaceMetaData.H"
  47 #include "surfaceMeshGeometryModification.H"
  48 #include "polyMeshGenGeometryModification.H"
  49 #include "edgeExtractor.H"
  50 #include "meshSurfaceEdgeExtractorFUN.H"
  51
  52 //#define DEBUG
  53
  54 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  55
  56 namespace Foam
  57 {
  58
  59 // * * * * * * * * * * * * Private member functions  * * * * * * * * * * * * //
  60
  61 void voronoiMeshGenerator::createVoronoiMesh()
  62 {
  63     //- create voronoi mesh from octree and Delaunay tets
  64     voronoiMeshExtractor vme(*octreePtr_, meshDict_, mesh_);
  65
  66     vme.createMesh();
  67
  68     # ifdef DEBUG
  69     mesh_.write();
  70     //::exit(EXIT_FAILURE);
  71     # endif
  72 }
  73
  74 void voronoiMeshGenerator::surfacePreparation()
  75 {
  76     //- removes unnecessary cells and morphs the boundary
  77     //- such that there exists only one boundary face per cell
  78
  79     surfaceMorpherCells* cmPtr = new surfaceMorpherCells(mesh_);
  80     cmPtr->morphMesh();
  81     deleteDemandDrivenData(cmPtr);
  82
  83     # ifdef DEBUG
  84     mesh_.write();
  85     //::exit(EXIT_FAILURE);
  86     # endif
  87 }
  88
  89 void voronoiMeshGenerator::mapMeshToSurface()
  90 {
  91     //- calculate mesh surface
  92     meshSurfaceEngine* msePtr = new meshSurfaceEngine(mesh_);
  93
  94     //- map mesh surface on the geometry surface
  95     meshSurfaceMapper mapper(*msePtr, *octreePtr_);
  96     mapper.preMapVertices();
  97     mapper.mapVerticesOntoSurface();
  98
  99     # ifdef DEBUG
 100     mesh_.write();
 101     //::exit(EXIT_FAILURE);
 102     # endif
 103
 104     //- untangle surface faces
 105     meshSurfaceOptimizer(*msePtr, *octreePtr_).untangleSurface();
 106
 107     # ifdef DEBUG
 108     mesh_.write();
 109     ::exit(EXIT_FAILURE);
 110     # endif
 111
 112     deleteDemandDrivenData(msePtr);
 113 }
 114
 115 void voronoiMeshGenerator::extractPatches()
 116 {
 117     edgeExtractor extractor(mesh_, *octreePtr_);
 118
 119     Info << "Extracting edges" << endl;
 120     extractor.extractEdges();
 121
 122     extractor.updateMeshPatches();
 123 }
 124
 125 void voronoiMeshGenerator::mapEdgesAndCorners()
 126 {
 127     meshSurfaceEdgeExtractorFUN(mesh_, *octreePtr_, false);
 128
 129     # ifdef DEBUG
 130     mesh_.write();
 131     //::exit(EXIT_FAILURE);
 132     # endif
 133 }
 134
 135 void voronoiMeshGenerator::optimiseMeshSurface()
 136 {
 137     meshSurfaceEngine mse(mesh_);
 138     meshSurfaceOptimizer surfOptimiser(mse, *octreePtr_);
 139     surfOptimiser.optimizeSurface();
 140     surfOptimiser.untangleSurface();
 141
 142     # ifdef DEBUG
 143     mesh_.write();
 144     //::exit(EXIT_FAILURE);
 145     # endif
 146 }
 147
 148 void voronoiMeshGenerator::generateBoudaryLayers()
 149 {
 150     boundaryLayers bl(mesh_);
 151
 152     if( meshDict_.found("boundaryLayers") )
 153     {
 154         boundaryLayers bl(mesh_);
 155
 156         const dictionary& bndLayers = meshDict_.subDict("boundaryLayers");
 157
 158         if( bndLayers.found("nLayers") )
 159         {
 160             const label nLayers = readLabel(bndLayers.lookup("nLayers"));
 161
 162             if( nLayers > 0 )
 163                 bl.addLayerForAllPatches();
 164         }
 165         else if( bndLayers.found("patchBoundaryLayers") )
 166         {
 167             const dictionary& patchLayers =
 168                 bndLayers.subDict("patchBoundaryLayers");
 169             const wordList createLayers = patchLayers.toc();
 170
 171             forAll(createLayers, patchI)
 172                 bl.addLayerForPatch(createLayers[patchI]);
 173         }
 174     }
 175
 176     # ifdef DEBUG
 177     mesh_.write();
 178     //::exit(EXIT_FAILURE);
 179     # endif
 180 }
 181
 182 void voronoiMeshGenerator::refBoundaryLayers()
 183 {
 184     if( meshDict_.isDict("boundaryLayers") )
 185     {
 186         refineBoundaryLayers refLayers(mesh_);
 187
 188         refineBoundaryLayers::readSettings(meshDict_, refLayers);
 189
 190         refLayers.refineLayers();
 191
 192         labelLongList pointsInLayer;
 193         refLayers.pointsInBndLayer(pointsInLayer);
 194
 195         meshOptimizer mOpt(mesh_);
 196         mOpt.lockPoints(pointsInLayer);
 197         mOpt.untangleBoundaryLayer();
 198     }
 199 }
 200
 201 void voronoiMeshGenerator::optimiseFinalMesh()
 202 {
 203     //- untangle the surface if needed
 204     bool enforceConstraints(false);
 205     if( meshDict_.found("enforceGeometryConstraints") )
 206     {
 207         enforceConstraints =
 208             readBool(meshDict_.lookup("enforceGeometryConstraints"));
 209     }
 210
 211     if( true )
 212     {
 213         meshSurfaceEngine mse(mesh_);
 214         meshSurfaceOptimizer surfOpt(mse, *octreePtr_);
 215
 216         if( enforceConstraints )
 217             surfOpt.enforceConstraints();
 218
 219         surfOpt.optimizeSurface();
 220     }
 221
 222     deleteDemandDrivenData(octreePtr_);
 223
 224     //- final optimisation
 225     meshOptimizer optimizer(mesh_);
 226     if( enforceConstraints )
 227         optimizer.enforceConstraints();
 228     optimizer.optimizeMeshFV();
 229
 230     optimizer.optimizeLowQualityFaces();
 231     optimizer.optimizeBoundaryLayer(false);
 232     optimizer.untangleMeshFV();
 233
 234     mesh_.clearAddressingData();
 235
 236     if( modSurfacePtr_ )
 237     {
 238         polyMeshGenGeometryModification meshMod(mesh_, meshDict_);
 239
 240         //- revert the mesh into the original space
 241         meshMod.revertGeometryModification();
 242
 243         //- delete modified surface mesh
 244         deleteDemandDrivenData(modSurfacePtr_);
 245     }
 246
 247     # ifdef DEBUG
 248     mesh_.write();
 249     //::exit(0);
 250     # endif
 251 }
 252
 253 void voronoiMeshGenerator::projectSurfaceAfterBackScaling()
 254 {
 255     if( !meshDict_.found("anisotropicSources") )
 256         return;
 257
 258     deleteDemandDrivenData(octreePtr_);
 259     octreePtr_ = new meshOctree(*surfacePtr_);
 260
 261     meshOctreeCreator
 262     (
 263         *octreePtr_,
 264         meshDict_
 265     ).createOctreeWithRefinedBoundary(20, 30);
 266
 267     //- calculate mesh surface
 268     meshSurfaceEngine mse(mesh_);
 269
 270     //- pre-map mesh surface
 271     meshSurfaceMapper mapper(mse, *octreePtr_);
 272
 273     //- map mesh surface on the geometry surface
 274     mapper.mapVerticesOntoSurface();
 275
 276     optimiseFinalMesh();
 277 }
 278
 279 void voronoiMeshGenerator::replaceBoundaries()
 280 {
 281     renameBoundaryPatches rbp(mesh_, meshDict_);
 282
 283     # ifdef DEBUG
 284     mesh_.write();
 285     //::exit(0);
 286     # endif
 287 }
 288
 289 void voronoiMeshGenerator::renumberMesh()
 290 {
 291     polyMeshGenModifier(mesh_).renumberMesh();
 292
 293     # ifdef DEBUG
 294     mesh_.write();
 295     //::exit(0);
 296     # endif
 297 }
 298
 299 void voronoiMeshGenerator::generateMesh()
 300 {
 301     try
 302     {
 303         if( controller_.runCurrentStep("templateGeneration") )
 304         {
 305             createVoronoiMesh();
 306         }
 307
 308         if( controller_.runCurrentStep("surfaceTopology") )
 309         {
 310             surfacePreparation();
 311         }
 312
 313         if( controller_.runCurrentStep("surfaceProjection") )
 314         {
 315             mapMeshToSurface();
 316         }
 317
 318         if( controller_.runCurrentStep("patchAssignment") )
 319         {
 320             extractPatches();
 321         }
 322
 323         if( controller_.runCurrentStep("edgeExtraction") )
 324         {
 325             mapEdgesAndCorners();
 326
 327             optimiseMeshSurface();
 328         }
 329
 330         if( controller_.runCurrentStep("boundaryLayerGeneration") )
 331         {
 332             generateBoudaryLayers();
 333         }
 334
 335         if( controller_.runCurrentStep("meshOptimisation") )
 336         {
 337             optimiseFinalMesh();
 338
 339             projectSurfaceAfterBackScaling();
 340         }
 341
 342         if( controller_.runCurrentStep("boundaryLayerRefinement") )
 343         {
 344             refBoundaryLayers();
 345         }
 346
 347         renumberMesh();
 348
 349         replaceBoundaries();
 350     }
 351     catch(const std::string& message)
 352     {
 353         Info << message << endl;
 354     }
 355     catch(...)
 356     {
 357         WarningIn
 358         (
 359             "void voronoiMeshGenerator::generateMesh()"
 360         ) << "Meshing process terminated!" << endl;
 361     }
 362 }
 363
 364 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 365
 366 voronoiMeshGenerator::voronoiMeshGenerator(const Time& time)
 367 :
 368     runTime_(time),
 369     surfacePtr_(NULL),
 370     modSurfacePtr_(NULL),
 371     octreePtr_(NULL),
 372     pointRegionsPtr_(NULL),
 373     meshDict_
 374     (
 375         IOobject
 376         (
 377             "meshDict",
 378             runTime_.system(),
 379             runTime_,
 380             IOobject::MUST_READ,
 381             IOobject::NO_WRITE
 382         )
 383     ),
 384     mesh_(time),
 385     controller_(mesh_)
 386 {
 387     if( true )
 388         checkMeshDict cmd(meshDict_);
 389
 390     const fileName surfaceFile = meshDict_.lookup("surfaceFile");
 391
 392     surfacePtr_ = new triSurf(runTime_.path()/surfaceFile);
 393
 394     if( true )
 395     {
 396         //- save meta data with the mesh (surface mesh + its topology info)
 397         triSurfaceMetaData sMetaData(*surfacePtr_);
 398         const dictionary& surfMetaDict = sMetaData.metaData();
 399
 400         mesh_.metaData().add("surfaceFile", surfaceFile, true);
 401         mesh_.metaData().add("surfaceMeta", surfMetaDict, true);
 402     }
 403
 404     if( surfacePtr_->featureEdges().size() != 0 )
 405     {
 406         //- create surface patches based on the feature edges
 407         //- and update the meshDict based on the given data
 408         triSurfacePatchManipulator manipulator(*surfacePtr_);
 409
 410         const triSurf* surfaceWithPatches =
 411             manipulator.surfaceWithPatches(&meshDict_);
 412
 413         //- delete the old surface and assign the new one
 414         deleteDemandDrivenData(surfacePtr_);
 415         surfacePtr_ = surfaceWithPatches;
 416     }
 417
 418     if( meshDict_.found("anisotropicSources") )
 419     {
 420         surfaceMeshGeometryModification surfMod(*surfacePtr_, meshDict_);
 421
 422         modSurfacePtr_ = surfMod.modifyGeometry();
 423
 424         octreePtr_ = new meshOctree(*modSurfacePtr_);
 425     }
 426     else
 427     {
 428         octreePtr_ = new meshOctree(*surfacePtr_);
 429     }
 430
 431     meshOctreeCreator(*octreePtr_, meshDict_).createOctreeBoxes();
 432
 433     generateMesh();
 434 }
 435
 436 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 437
 438 voronoiMeshGenerator::~voronoiMeshGenerator()
 439 {
 440     deleteDemandDrivenData(surfacePtr_);
 441     deleteDemandDrivenData(modSurfacePtr_);
 442     deleteDemandDrivenData(octreePtr_);
 443     deleteDemandDrivenData(pointRegionsPtr_);
 444 }
 445
 446 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 447
 448 void voronoiMeshGenerator::writeMesh() const
 449 {
 450     mesh_.write();
 451 }
 452
 453 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 454
 455 } // End namespace Foam
 456
 457 // ************************************************************************* //