NEM::DRV::MeshGenDriver Class Reference

Detailed Description

Definition at line 38 of file MeshGenDriver.H.

Classes
struct	MeshGenFiles

Public Member Functions
virtual void	execute () const =0
	Run the workflow represented by the driver. More...

Static Public Member Functions
static std::unique_ptr< NemDriver >	readJSON (const jsoncons::json &inputjson)
	Factory method for all drivers. More...

Protected Member Functions
	MeshGenDriver ()=default

Private Member Functions
jsoncons::string_view	getProgramType () const override

Static Private Attributes
static constexpr const char *	programType = "Mesh Generation"

Inherits NEM::DRV::NemDriver.

Inherited by NEM::DRV::BlockMeshMeshGenDriver, NEM::DRV::CFMeshMeshGenDriver, NEM::DRV::GmshMeshGenDriver, NEM::DRV::NetgenMeshGenDriver, and NEM::DRV::SnappyMeshMeshGenDriver.

Constructor & Destructor Documentation

MeshGenDriver()

NEM::DRV::MeshGenDriver::MeshGenDriver ( )

protecteddefault

Definition at line 61 of file MeshGenDriver.C.

References cfmLclRefPatch::aditRefLvls, cfmPtchBndLyr::alwDiscont, NEM::GEN::TransfiniteBlock::axis, cfmPtchBndLyr::blNLyr, cfmPtchBndLyr::blThkRto, cfmLclRefPatch::cellSize, blockMeshParams::cellSize, blockMeshParams::cnvrtToMeters, NEM::GEN::TransfiniteBlock::coef, meshBase::Create(), meshGen::createMeshFromSTL(), meshBase::CreateShared(), cfmRenBndry::defName, cfmRenBndry::defType, shmLayers::expansionRatio, meshBase::exportGmshToVtk(), meshBase::exportVolToVtk(), shmFeatureEdgeRef::fileName, shmLayers::finalLayerThickness, nemAux::find_ext(), shmLayers::firstLyrThickness, snappymeshParams::geomFileName, meshGen::getDataSet(), meshGen::gmData, NEM::GEN::volSizeField::id, NEM::GEN::TransfiniteBlock::id, cfmPtchBndLyr::maxFrstLyrThk, shmRegionRefine::maxLvl, shmSurfRefine::maxLvl, shmFeatureEdgeRef::maxLvl, snappymeshParams::mergeTol, mesh, shmRegionRefine::minLvl, shmSurfRefine::minLvl, shmFeatureEdgeRef::minLvl, shmLayers::minThickness, shmRegionRefine::mode, cfmObjRef::name, NEM::MSH::New(), cfmRenBndry::newPatches, shmLayers::nSurfaceLayers, NEM::GEN::volSizeField::num_list_params, cfmObjRef::params, NEM::GEN::volSizeField::params, cfmLclRefPatch::patchName, cfmPtchBndLyr::patchName, shmLayers::patchName, shmSurfRefine::patchType, NEM::DRV::NemDriver::readJSON(), cfmLclRefPatch::refThickness, shmSTLDefinition::snappyPatchName, shmSTLDefinition::STLPatchName, NEM::GEN::volSizeField::strg_list_params, shmLayers::thickness, nemAux::trim_fname(), NEM::GEN::volSizeField::type, NEM::GEN::TransfiniteBlock::type, and NEM::GEN::TransfiniteBlock::vert.

                                                      {
  std::cout << "MeshGenDriver created" << std::endl;
  params = _params;

  meshGen *generator = nullptr;

  if (meshEngine == "netgen") {
#ifdef HAVE_NGEN
    generator = new netgenGen(dynamic_cast<netgenParams *>(params));
    std::string newname = nemAux::trim_fname(ifname, ".vol");
#else
    std::cerr << "NETGEN is not enabled during build."
              << " Build NEMoSys with ENABLE_NETGEN to use this method."
              << std::endl;
    exit(1);
#endif
  } else if (meshEngine == "gmsh") {
    generator =
        new NEM::GEN::gmshGen(dynamic_cast<NEM::GEN::gmshParams *>(params));
    std::string newname = nemAux::trim_fname(ifname, ".msh");
#ifdef HAVE_CFMSH
  } else if (meshEngine == "cfmesh") {
    generator = new cfmeshGen(dynamic_cast<cfmeshParams *>(params));
    std::string newname = nemAux::trim_fname(ifname, ".vtu");
  } else if (meshEngine == "snappyHexMesh") {
    generator = new snappymeshGen(dynamic_cast<snappymeshParams *>(params));
    std::string newname = nemAux::trim_fname(ifname, ".vtu");
  } else if (meshEngine == "blockMesh") {
    generator = new blockMeshGen(dynamic_cast<blockMeshParams *>(params));
    std::string newname = nemAux::trim_fname(ifname, ".vtu");
#endif
  } else {
    std::cerr << meshEngine << " is not a supported meshing engine"
              << std::endl;
    exit(1);
  }

  if (!generator) {
    std::cerr << "Meshing with engine " << meshEngine << " failed. Aborting."
              << std::endl;
    exit(1);
  }

  int status = generator->createMeshFromSTL(ifname.c_str());

  if (status) {
    std::cerr << "Mesh Engine " << meshEngine << " not recognized" << std::endl;
    exit(1);
  }

  // output file type
  std::string outputType = nemAux::find_ext(ofname);
  std::shared_ptr<meshBase> mesh;
  if (outputType == ".msh" && meshEngine == "gmsh") {
    // createMeshFromSTL (in this case) outputs a .msh file by default
    return;
  }

  // otherwise, resort to meshBase

  if (meshEngine == "netgen") {
    std::string newname = nemAux::trim_fname(ifname, ".vol");
    mesh = meshBase::CreateShared(meshBase::exportVolToVtk(newname));
  } else if (meshEngine == "gmsh") {
    std::string newname = nemAux::trim_fname(ifname, ".msh");
    // conversion from STL using gmsh engine writes a ".msh" file by default
    if (outputType == ".msh") return;
    mesh = meshBase::CreateShared(meshBase::exportGmshToVtk(newname));
  } else {
    // default
    std::string newname = nemAux::trim_fname(ifname, ".vtu");
    mesh = meshBase::CreateShared(
        meshBase::Create(generator->getDataSet(), newname));
  }

  if (meshEngine == "cfmesh" || meshEngine == "snappyHexMesh" ||
      meshEngine == "blockMesh") {
    geoMesh = NEM::MSH::New(ofname);
    geoMesh->takeGeoMesh(generator->gmData.get());
    geoMesh->write(ofname);
    geoMesh->Delete();
  } else {
    mesh->setFileName(ofname);
    mesh->report();
    mesh->write();
  }
}

Member Function Documentation

execute()

virtual void NEM::DRV::NemDriver::execute ( ) const

pure virtualinherited

Implemented in NEM::DRV::SurfacePackMeshDriver, NEM::DRV::VtkToPatranConversionDriver, NEM::DRV::HexPackMeshDriver, NEM::DRV::OmegahRefineDriver, NEM::DRV::AutoVerificationDriver, NEM::DRV::NucMeshDriver, NEM::DRV::OptimizeMeshQualDriver, NEM::DRV::ProteusDriver, NEM::DRV::GmshToExoConversionDriver, NEM::DRV::FoamRefineDriver, NEM::DRV::CheckMeshQualDriver, NEM::DRV::TransferDriver, NEM::DRV::ManipExoConversionDriver, NEM::DRV::SizeFieldRefineDriver, NEM::DRV::TemplateMeshDriver, NEM::DRV::VtkToPntConversionDriver, NEM::DRV::VtkToCobaltConversionDriver, NEM::DRV::Z2RefineDriver, NEM::DRV::UniformRefineDriver, NEM::DRV::VtkToFoamConversionDriver, NEM::DRV::NetgenMeshGenDriver, NEM::DRV::InputGenDriver, NEM::DRV::BlockMeshMeshGenDriver, NEM::DRV::CFMeshMeshGenDriver, NEM::DRV::GmshMeshGenDriver, NEM::DRV::SnappyMeshMeshGenDriver, NEM::DRV::RocPartCommGenDriver, NEM::DRV::GmshToVtkConversionDriver, NEM::DRV::SmartConversionDriver, NEM::DRV::VtkHexToTetConversionDriver, NEM::DRV::FoamToMshConversionDriver, and NEM::DRV::FoamToVtkConversionDriver.

getProgramType()

jsoncons::string_view NEM::DRV::MeshGenDriver::getProgramType ( ) const

overrideprivatevirtual

Implements NEM::DRV::NemDriver.

Definition at line 38 of file MeshGen/MeshGenDriver.C.

References programType.

                                                        {
  return programType;
}

readJSON()

std::unique_ptr< NemDriver > NEM::DRV::NemDriver::readJSON ( const jsoncons::json &  inputjson )

staticinherited

Parameters

inputjson

json input with "Program Type" key

Returns

pointer to base NemDriver class

Definition at line 37 of file NemDriver.C.

Referenced by MeshGenDriver().

                                                                          {
  return inputjson.as<std::unique_ptr<NemDriver>>();
}

Member Data Documentation

programType

constexpr const char* NEM::DRV::MeshGenDriver::programType = "Mesh Generation"

staticprivate

Definition at line 59 of file MeshGenDriver.H.

Referenced by getProgramType(), and NEM::DRV::JSON::gmshColorMapFromJSON().

---

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

• MeshGenDriver.H
• MeshGen/MeshGenDriver.C