cfmeshGen Class Reference

Detailed Description

Definition at line 42 of file cfmeshGen.H.

Public Member Functions
	cfmeshGen ()
	cfmeshGen (cfmeshParams *params)
	~cfmeshGen () override
int	createMeshFromSTL (const char *fname) override
vtkSmartPointer< vtkDataSet >	getDataSet () const

Public Attributes
std::unique_ptr< NEM::MSH::geoMeshBase >	gmData

Protected Attributes
vtkSmartPointer< vtkDataSet >	dataSet

Private Member Functions
void	initialize ()
void	createMshDict (const bool &write)
int	surfaceFeatureEdgeDetect ()
int	improveMeshQuality ()

Private Attributes
bool	defaults
std::string	caseName {"_cfmesh"}
cfmeshParams *	params_
std::unique_ptr< Foam::dictionary >	controlDict_
std::unique_ptr< Foam::dictionary >	fvSchemes_
std::unique_ptr< Foam::dictionary >	fvSolution_
std::unique_ptr< Foam::Time >	runTime_
std::unique_ptr< Foam::fvMesh >	fmesh_
std::unique_ptr< Foam::dictionary >	meshDict_

Inherits meshGen.

Constructor & Destructor Documentation

cfmeshGen() [1/2]

cfmeshGen::cfmeshGen

(

)

Definition at line 55 of file cfmeshGen.C.

References defaults, initialize(), and params_.

                     {
  // default meshing parameters
  params_ = new cfmeshParams();
  defaults = true;

  // Initialization tasks
  initialize();
}

cfmeshGen() [2/2]

cfmeshGen::cfmeshGen ( cfmeshParams *  params )

explicit

Definition at line 64 of file cfmeshGen.C.

References initialize().

                                         : defaults(false), params_(params) {
  // Initialization tasks
  initialize();
}

~cfmeshGen()

cfmeshGen::~cfmeshGen ( )

override

Definition at line 69 of file cfmeshGen.C.

{}

Member Function Documentation

createMeshFromSTL()

int cfmeshGen::createMeshFromSTL ( const char *  fname )

overridevirtual

Implements meshGen.

Definition at line 99 of file cfmeshGen.C.

References fmesh_, cfmeshParams::generator, meshGen::gmData, improveMeshQuality(), cfmeshParams::improveMeshQuality, cfmeshParams::isPackMesh, params_, NEM::MSH::Read(), and runTime_.

Referenced by NEM::DRV::CFMeshMeshGenDriver::execute().

                                                  {
  bool writeMsh;
  if (params_->isPackMesh)
    writeMsh = true;
  else
    writeMsh = false;

  // mesh generation and I/O
  Foam::Info << "Generating mesh with cfMesh engine" << Foam::endl;
  if (params_->generator == "cartesian2D") {
    Foam::Module::cartesian2DMeshGenerator cmg(*runTime_);
    std::cout << "ExecutionTime = " << runTime_->elapsedCpuTime() << " s\n"
              << "ClockTime = " << runTime_->elapsedClockTime() << " s"
              << std::endl;
    cmg.writeMesh();
  } else if (params_->generator == "tetMesh") {
    Foam::Module::tetMeshGenerator tmg(*runTime_);
    std::cout << "ExecutionTime = " << runTime_->elapsedCpuTime() << " s\n"
              << "ClockTime = " << runTime_->elapsedClockTime() << " s"
              << std::endl;
    tmg.writeMesh();

    // post-processing steps
    if (params_->improveMeshQuality.has_value()) improveMeshQuality();
  } else if (params_->generator == "cartesian3D") {
    Foam::Module::cartesianMeshGenerator cmg(*runTime_);
    std::cout << "ExecutionTime = " << runTime_->elapsedCpuTime() << " s\n"
              << "ClockTime = " << runTime_->elapsedClockTime() << " s"
              << std::endl;
    cmg.writeMesh();
  } else if (params_->generator == "polyMesh") {
    Foam::Module::voronoiMeshGenerator pmg(*runTime_);
    std::cout << "ExecutionTime = " << runTime_->elapsedCpuTime() << " s\n"
              << "ClockTime = " << runTime_->elapsedClockTime() << " s"
              << std::endl;
    pmg.writeMesh();
  } else {
    std::cerr << (params_->generator)
              << " is not a supported mesh generator.\n";
    throw;
  }

  // Create foamGeoMesh
  if (writeMsh) {
    gmData.reset();
    gmData = std::unique_ptr<NEM::MSH::geoMeshBase>(NEM::MSH::Read(".foam"));
  } else {
    auto fgm_ = std::unique_ptr<NEM::MSH::foamGeoMesh>(
        new NEM::MSH::foamGeoMesh(fmesh_.get(), ""));
    gmData = std::unique_ptr<NEM::MSH::geoMeshBase>(
        dynamic_cast<NEM::MSH::geoMeshBase *>(fgm_.get()));
    return 0;
  }

  return 0;
}

createMshDict()

void cfmeshGen::createMshDict ( const bool &  write )

private

Definition at line 241 of file cfmeshGen.C.

References cfmeshParams::alwDiscDomains, cfmeshParams::bndryCellSize, cfmeshParams::bndryCellSizeRefThk, cfmeshParams::boundaryLayers, cfmeshParams::chkGluMsh, cfmeshParams::geomFilePath, cfmeshParams::keepCellIB, cfmeshParams::maxCellSize, meshDict_, cfmeshParams::minCellSize, cfmeshParams::objRefLst, params_, cfmeshParams::refPatches, and cfmeshParams::renBndry.

Referenced by initialize().

                                               {
  meshDict_ =
      std::unique_ptr<Foam::dictionary>(new Foam::dictionary("meshDict"));

  Foam::dictionary fmfle("FoamFile");
  fmfle.add("version", "2.0");
  fmfle.add("format", "ascii");
  fmfle.add("class", "dictionary");
  fmfle.add("location", "\"system\"");
  fmfle.add("object", "meshDict");
  meshDict_->add("FoamFile", fmfle);

  if ((params_->maxCellSize) > 0)
    meshDict_->add("maxCellSize", params_->maxCellSize);

  if ((params_->minCellSize) > 0)
    meshDict_->add("minCellSize", params_->minCellSize);

  if ((params_->bndryCellSize) > 0)
    meshDict_->add("boundaryCellSize", params_->bndryCellSize);

  if ((params_->bndryCellSizeRefThk) > 0)
    meshDict_->add("boundaryCellSizeRefinementThickness",
                   params_->bndryCellSizeRefThk);

  if (params_->keepCellIB) meshDict_->add("keepCellsIntersectingBoundary", "1");

  if (params_->chkGluMsh) meshDict_->add("checkForGluedMesh", "1");

  if ((params_->alwDiscDomains)) meshDict_->add("allowDisconnectedDomains", 1);

  meshDict_->add("surfaceFile", params_->geomFilePath);

  // boundary layer
  if (params_->boundaryLayers.has_value()) {
    const auto &boundaryLayer = params_->boundaryLayers.value();
    Foam::dictionary boundaryLayrs("boundaryLayers");
    boundaryLayrs.add("nLayers", boundaryLayer.blNLyr);
    boundaryLayrs.add("thicknessRatio", boundaryLayer.blThkRto);
    if (boundaryLayer.maxFrstLyrThk > 0.0)
      boundaryLayrs.add("maxFirstLayerThickness", boundaryLayer.maxFrstLyrThk);

    if (boundaryLayer.alwDiscont) boundaryLayrs.add("allowDiscontinuity", 1);

    // boundary layer patches
    if (!boundaryLayer.blPatches.empty()) {
      Foam::dictionary patchBoundaryLayers("patchBoundaryLayers");
      for (auto pt = (boundaryLayer.blPatches).begin();
           pt != (boundaryLayer.blPatches).end(); pt++) {
        Foam::dictionary tmpDict1(pt->patchName);
        if (pt->alwDiscont) tmpDict1.add("allowDiscontinuity", 1);
        if ((pt->maxFrstLyrThk) > 0)
          tmpDict1.add("maxFirstLayerThickness", pt->maxFrstLyrThk);
        if ((pt->blNLyr) > 0) tmpDict1.add("nLayers", pt->blNLyr);
        if ((pt->blThkRto) > 0) tmpDict1.add("thicknessRatio", pt->blThkRto);
        patchBoundaryLayers.add(Foam::word("\"" + pt->patchName + "\""),
                                tmpDict1);
      }
      boundaryLayrs.add("patchBoundaryLayers", patchBoundaryLayers);
    }
    meshDict_->add("boundaryLayers", boundaryLayrs);
  }

  // object refinements
  Foam::dictionary objectRefinements("objectRefinements");
  if (!params_->objRefLst.empty()) {
    for (auto ref = (params_->objRefLst).begin();
         ref != (params_->objRefLst).end(); ref++) {
      Foam::dictionary tmpDict1(ref->name);
      for (auto prm = (ref->params).begin(); prm != (ref->params).end();
           prm++) {
        tmpDict1.add(Foam::word(prm->first), Foam::word(prm->second));
      }
      objectRefinements.add(Foam::word(ref->name), tmpDict1);
    }
    meshDict_->add("objectRefinements", objectRefinements);
  }

  // local refinement
  Foam::dictionary localRefinement("localRefinement");
  if (!params_->refPatches.empty()) {
    for (auto pt = (params_->refPatches).begin();
         pt != (params_->refPatches).end(); pt++) {
      Foam::dictionary tmpDict1(pt->patchName);
      if ((pt->aditRefLvls) > 0)
        tmpDict1.add("additionalRefinementLevels", pt->aditRefLvls);
      if ((pt->refThickness) > 0)
        tmpDict1.add("refinementThickness", pt->refThickness);
      if ((pt->cellSize) > 0) tmpDict1.add("cellSize", pt->cellSize);
      localRefinement.add(Foam::word("\"" + pt->patchName + "\""), tmpDict1);
    }
    meshDict_->add("localRefinement", localRefinement);
  }

  // rename boundaries
  Foam::dictionary renameBoundary("renameBoundary");
  if (params_->renBndry.has_value()) {
    const auto &renBndry = params_->renBndry.value();
    renameBoundary.add("defaultName", Foam::word((renBndry).defName));
    renameBoundary.add("defaultType", Foam::word((renBndry).defType));

    Foam::dictionary tmpDict1("newPatchNames");

    for (auto pt = (renBndry).newPatches.begin();
         pt != (renBndry).newPatches.end(); pt++) {
      Foam::dictionary tmpDict2(pt->name);
      tmpDict2.add("newName", Foam::word(pt->newName));
      tmpDict2.add("type", Foam::word(pt->newType));
      tmpDict1.add(Foam::word("\"" + pt->name + "\""), tmpDict2);
    }
    renameBoundary.add("newPatchNames", tmpDict1);
    meshDict_->add("renameBoundary", renameBoundary);
  }

  if (write) {
    // Write meshDict
    Foam::fileName cfmeshDict_ = "system/meshDict";
    Foam::OFstream outcfmeshDict_(cfmeshDict_);
    Foam::IOobject::writeBanner(outcfmeshDict_);
    meshDict_->write(outcfmeshDict_, false);
  }
}

getDataSet()

vtkSmartPointer<vtkDataSet> meshGen::getDataSet ( ) const

inlineinherited

Definition at line 53 of file meshGen.H.

Referenced by NEM::DRV::MeshGenDriver::MeshGenDriver().

{ return dataSet; }

improveMeshQuality()

int cfmeshGen::improveMeshQuality ( )

private

Definition at line 194 of file cfmeshGen.C.

References cfmeshParams::improveMeshQuality, params_, and runTime_.

Referenced by createMeshFromSTL().

                                  {
  std::cout << "Performing mesh quality improvements.\n";

  //- load the mesh from disk
  Foam::Module::polyMeshGen pmg(*runTime_);
  pmg.read();

  //- construct the smoother
  Foam::Module::meshOptimizer mOpt(pmg);

  const auto &meshQual = params_->improveMeshQuality.value();

  if ((meshQual.qltConCelSet) != "none") {
    //- lock cells in constrainedCellSet
    mOpt.lockCellsInSubset((meshQual.qltConCelSet));

    //- find boundary faces which shall be locked
    Foam::Module::labelLongList lockedBndFaces, selectedCells;

    const Foam::label sId = pmg.cellSubsetIndex((meshQual.qltConCelSet));
    pmg.cellsInSubset(sId, selectedCells);

    Foam::boolList activeCell(pmg.cells().size(), false);
    for (int iCl = 0; iCl < selectedCells.size(); iCl++)
      activeCell[selectedCells[iCl]] = true;
  }

  //- clear geometry information before volume smoothing
  pmg.clearAddressingData();

  //- perform optimisation using the laplace smoother and
  mOpt.optimizeMeshFV((meshQual.qltNLop), (meshQual.qltNLop),
                      (meshQual.qltNItr), (meshQual.qltNSrfItr));

  //- perform optimisation of worst quality faces
  mOpt.optimizeMeshFVBestQuality((meshQual.qltNLop), (meshQual.qltQltThr));

  //- check the mesh again and untangl bad regions if any of them exist
  mOpt.untangleMeshFV((meshQual.qltNLop), (meshQual.qltNItr),
                      (meshQual.qltNSrfItr));

  std::cout << "Finished optimization cycle\n";
  pmg.write();

  return 0;
}

initialize()

void cfmeshGen::initialize ( )

private

Definition at line 71 of file cfmeshGen.C.

References controlDict_, createMshDict(), fvSchemes_, fvSolution_, cfmeshParams::isPackMesh, params_, runTime_, cfmeshParams::srfEdge, and surfaceFeatureEdgeDetect().

Referenced by cfmeshGen().

                           {
  // surface feature edge treatment
  if (params_->srfEdge.has_value())
    if (surfaceFeatureEdgeDetect()) {
      std::cerr << "A problem occured during edge detection step!\n";
      throw;
    }

  // create dictionaries needed in memory
  bool writeDicts;
  if (params_->isPackMesh)
    writeDicts = true;
  else
    writeDicts = false;
  std::unique_ptr<getDicts> initFoam;
  initFoam = std::unique_ptr<getDicts>(new getDicts());
  controlDict_ = initFoam->createControlDict(writeDicts);
  fvSchemes_ = initFoam->createFvSchemes(writeDicts);
  fvSolution_ = initFoam->createFvSolution(writeDicts);
  createMshDict(writeDicts);

  runTime_ =
      std::unique_ptr<Foam::Time>(new Foam::Time(controlDict_.get(), ".", "."));

  //- 2d cartesian mesher cannot be run in parallel
  Foam::argList::noParallel();
}

surfaceFeatureEdgeDetect()

int cfmeshGen::surfaceFeatureEdgeDetect ( )

private

Definition at line 156 of file cfmeshGen.C.

References caseName, cfmeshParams::geomFilePath, params_, and cfmeshParams::srfEdge.

Referenced by initialize().

                                        {
  std::cout << "Performing surface feature edge detection.\n";
  std::string of = "./" + caseName + "_feature.ftr";
  Foam::fileName inFileName(params_->geomFilePath);
  Foam::fileName outFileName(of);

  if (outFileName == inFileName) {
    std::cerr << "Output file " << outFileName
              << " would overwrite the input file.\n";
    throw;
  }

  double tol = params_->srfEdge.value().srfEdgAng;
  std::cout << "Using " << tol << " deg angle\n";

  Foam::Module::triSurf originalSurface(inFileName);

  Foam::Module::triSurfaceDetectFeatureEdges edgeDetector(originalSurface, tol);
  edgeDetector.detectFeatureEdges();

  if (outFileName.ext() == "fms" || outFileName.ext() == "FMS") {
    std::cout << "Writing : " << outFileName << std::endl;
    originalSurface.writeSurface(outFileName);
  } else {
    Foam::Module::triSurfacePatchManipulator manipulator(originalSurface);
    const Foam::Module::triSurf *newSurfPtr = manipulator.surfaceWithPatches();

    std::cout << "Writing : " << outFileName << std::endl;
    newSurfPtr->writeSurface(outFileName);
    delete newSurfPtr;
  }

  // change cad input file
  params_->geomFilePath = of;

  return 0;
}

Member Data Documentation

caseName

std::string cfmeshGen::caseName {"_cfmesh"}

private

Definition at line 70 of file cfmeshGen.H.

Referenced by surfaceFeatureEdgeDetect().

controlDict_

std::unique_ptr<Foam::dictionary> cfmeshGen::controlDict_

private

Definition at line 75 of file cfmeshGen.H.

Referenced by initialize().

dataSet

vtkSmartPointer<vtkDataSet> meshGen::dataSet

protectedinherited

Definition at line 57 of file meshGen.H.

defaults

bool cfmeshGen::defaults

private

Definition at line 69 of file cfmeshGen.H.

Referenced by cfmeshGen().

fmesh_

std::unique_ptr<Foam::fvMesh> cfmeshGen::fmesh_

private

Definition at line 79 of file cfmeshGen.H.

Referenced by createMeshFromSTL().

fvSchemes_

std::unique_ptr<Foam::dictionary> cfmeshGen::fvSchemes_

private

Definition at line 76 of file cfmeshGen.H.

Referenced by initialize().

fvSolution_

std::unique_ptr<Foam::dictionary> cfmeshGen::fvSolution_

private

Definition at line 77 of file cfmeshGen.H.

Referenced by initialize().

gmData

std::unique_ptr<NEM::MSH::geoMeshBase> meshGen::gmData

inherited

Definition at line 54 of file meshGen.H.

Referenced by createMeshFromSTL(), snappymeshGen::createMeshFromSTL(), blockMeshGen::createMeshFromSTL(), and NEM::DRV::MeshGenDriver::MeshGenDriver().

meshDict_

std::unique_ptr<Foam::dictionary> cfmeshGen::meshDict_

private

Definition at line 80 of file cfmeshGen.H.

Referenced by createMshDict().

params_

cfmeshParams* cfmeshGen::params_

private

Definition at line 71 of file cfmeshGen.H.

Referenced by cfmeshGen(), createMeshFromSTL(), createMshDict(), improveMeshQuality(), initialize(), and surfaceFeatureEdgeDetect().

runTime_

std::unique_ptr<Foam::Time> cfmeshGen::runTime_

private

Definition at line 78 of file cfmeshGen.H.

Referenced by createMeshFromSTL(), improveMeshQuality(), and initialize().

---

The documentation for this class was generated from the following files:

• cfmeshGen.H
• cfmeshGen.C