NEM::DRV::HexPackMeshDriver Class Reference

Detailed Description

Hexahedral meshing pipeline creates different objects for different meshing engines in NEMoSys, as well as objects of mesh manipulation utilities to complete the meshing workflow.

• Geometry generation using RocPack output file.
• Generation of STL file for workflow downstream.
• Generation of background mesh for snappyHexMesh
• Snapping of pack surfaces onto background volume mesh to create conformal

interfaces.

• Splitting multiple pack regions into different cellZones (volumes).
• Merging all different volumes into two different foam mesh (1.

Packs, 2. Surrounding)

• Creating patch for Packs and Surrounding regions.
• Conversion of foam mesh to VTK.
• Provides mesh quality statistics to users in a text file.

Definition at line 59 of file HexPackMeshDriver.H.

Classes
struct	Files
struct	Opts

Public Member Functions
	HexPackMeshDriver (Files files, Opts opts)
const Files &	getFiles () const
void	setFiles (Files files)
const Opts &	getOpts () const
void	setOpts (Opts opts)
void	execute () const override
	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...

Private Member Functions
	HexPackMeshDriver ()

Private Attributes
Files	files_
Opts	opts_

Inherits NEM::DRV::PackMeshDriver.

Constructor & Destructor Documentation

HexPackMeshDriver() [1/2]

NEM::DRV::HexPackMeshDriver::HexPackMeshDriver	(	Files	files,
		Opts	opts
	)

Definition at line 67 of file HexPackMeshDriver.C.

    : files_(std::move(files)), opts_(std::move(opts)) {}

HexPackMeshDriver() [2/2]

NEM::DRV::HexPackMeshDriver::HexPackMeshDriver ( )

private

Definition at line 70 of file HexPackMeshDriver.C.

    : HexPackMeshDriver({{}, {}, {}, {}}, {}) {}

Member Function Documentation

execute()

void NEM::DRV::HexPackMeshDriver::execute ( ) const

overridevirtual

Implements NEM::DRV::NemDriver.

Definition at line 142 of file HexPackMeshDriver.C.

References NEM::DRV::HexPackMeshDriver::Opts::bmParams, bmBox::coordsBox, MeshManipulationFoamParams::createPatchParams, files_, NEM::DRV::HexPackMeshDriver::Files::getInputFile(), NEM::DRV::HexPackMeshDriver::Files::isInputRocpackFile(), blockMeshParams::isPackMesh, snappymeshParams::isPackMesh, NEM::DRV::HexPackMeshDriver::Opts::locAdjust, MeshManipulationFoamParams::mergeMeshesParams, mesh, NEM::DRV::HexPackMeshDriver::Opts::mmfCreatePatchParams, NEM::DRV::HexPackMeshDriver::Opts::mmfMergeParams, NEM::MSH::New(), opts_, NEM::DRV::HexPackMeshDriver::Files::outCombinedFile, MeshManipulationFoamParams::SurfaceSplitByManifold::pckRegionNames, NEM::MSH::Read(), NEM::DRV::HexPackMeshDriver::Opts::smParams, and MeshManipulationFoamParams::surfSplitParams.

                                      {
  // Makes sure that constant and triSurface directories are present.
  // If directories are already present, it will not do anything.
  const char dir_path[] = "./constant";
  boost::filesystem::path dir(dir_path);
  try {
    boost::filesystem::create_directory(dir);
  } catch (boost::filesystem::filesystem_error &e) {
    std::cerr << "Problem in creating triSurface directory"
              << "for the snappyHexMesh"
              << "\n";
    std::cerr << e.what() << std::endl;
    throw;
  }

  const char dir_path1[] = "./constant/triSurface";
  boost::filesystem::path dir1(dir_path1);
  try {
    boost::filesystem::create_directory(dir1);
  } catch (boost::filesystem::filesystem_error &e) {
    std::cerr << "Problem in creating triSurface directory"
              << "for the snappyHexMesh"
              << "\n";
    std::cerr << e.what() << std::endl;
    throw;
  }

  // This object has access to all MeshManipulation utilities.
  MeshManipulationFoamParams mmfParams;  // should outlive objMsh
  mmfParams.mergeMeshesParams = this->opts_.mmfMergeParams;
  mmfParams.createPatchParams = this->opts_.mmfCreatePatchParams;
  auto objMsh = std::unique_ptr<MeshManipulationFoam>(
      new MeshManipulationFoam(&mmfParams));
  const char *nameFile = "a";  // Dummy name for input

  // A rocpack method that creates stl and then moves it to triSurface using
  // boost.
  if (this->files_.isInputRocpackFile()) {
#ifdef HAVE_GMSH
    std::string hexOutSTL = this->files_.getInputFile() + ".stl";
    auto objrocPck = std::unique_ptr<NEM::GEO::rocPack>(
        new NEM::GEO::rocPack(this->files_.getInputFile(), hexOutSTL));

    objrocPck->removeBoundaryVolumes();
    objrocPck->rocPack2Surf();

    // const std::string dir_path11 = hexOutSTL;
    boost::filesystem::path dir11(hexOutSTL);

    const std::string dir_path2 =
        "./constant/triSurface/" + this->files_.getInputFile() + ".stl";
    boost::filesystem::path dir2(dir_path2);

    boost::filesystem::copy_file(
        dir11, dir2, boost::filesystem::copy_option::overwrite_if_exists);
#else
    std::cerr << "Cannot process rocPack input file without gmsh.\n";
    std::exit(1);
#endif
  } else {
    const std::string dir_path11 = this->files_.getInputFile();
    boost::filesystem::path dir11(dir_path11);

    const std::string dir_path2 =
        "./constant/triSurface/" + this->files_.getInputFile();
    boost::filesystem::path dir2(dir_path2);

    boost::filesystem::copy_file(
        dir11, dir2, boost::filesystem::copy_option::overwrite_if_exists);
  }

  // blockMesh utility takes user input for surrounding box region and
  // generates mesh block in constant/polyMesh folder. It will overwrite the
  // previous mesh created by CfMesh. This mesh will be used as background mesh
  // by snappyHexMesh later.
  auto bmParamsCopy = this->opts_.bmParams;  // should outlive objBM
  bmParamsCopy.isPackMesh = true;
  auto objBM = std::unique_ptr<blockMeshGen>(new blockMeshGen(&bmParamsCopy));
  objBM->createMeshFromSTL(nameFile);

  // Updating location for next process
  auto adjust = this->opts_.locAdjust >= 0. ? this->opts_.locAdjust : 0.;
  auto smParamsCopy = this->opts_.smParams;  // should outlive objSHM
  smParamsCopy.isPackMesh = true;
  smParamsCopy.castMeshControls.locMesh[0] =
      std::dynamic_pointer_cast<bmBox>(bmParamsCopy.shape)->coordsBox.first[0] +
      0.001 + adjust;
  smParamsCopy.castMeshControls.locMesh[1] =
      std::dynamic_pointer_cast<bmBox>(bmParamsCopy.shape)->coordsBox.first[1] +
      0.001 + adjust;
  smParamsCopy.castMeshControls.locMesh[2] =
      std::dynamic_pointer_cast<bmBox>(bmParamsCopy.shape)->coordsBox.first[2] +
      0.001 + adjust;

  // snappyHexMesh reads background mesh created using blockMesh and takes
  // surface file from foamToSurface utility to snap pack surface onto back-
  // ground mesh and creates different cellZones (i.e different solids). These
  // interfaces between pack and surrounding regions are completely conformal
  // due to snappyHexMesh's unique snapping abilities.
  auto objSHM =
      std::unique_ptr<snappymeshGen>(new snappymeshGen(&smParamsCopy));
  objSHM->createMeshFromSTL(nameFile);

  // splitMeshRegions reads mesh from constant/polyMesh directory and splits
  // mesh into separate regions. Each region will represent one solid. It will
  // write bunch of domain.* directories inside constant/ and system/ folders.
  // This function does a random walking around mesh to identify different
  // regions and in that process, while naming all domains as domain.*
  // in constant folder, it skips one number for the disconnected region it
  // encounters first. This number is taken out to provide as input to merge
  // mesh.
  std::pair<std::vector<int>, std::vector<std::string>> dirStat =
      objMsh->splitMshRegions();

  std::string surroundingRegion = dirStat.second[0];
  mmfParams.surfSplitParams.pckRegionNames = dirStat.second;

  /*std::pair<std::vector<int>, std::string> dirStat =
  objMsh->splitMshRegions(); int skippedDir = dirStat.first[0]; int totalRegs =
  dirStat.first[1] - 1; std::string surroundingRegion = dirStat.second;
  */

  // *************** Merge meshes using geoMeshBase and write
  // *******************// packRegNames is a vector containing all names of pack
  // regions
  mmfParams.surfSplitParams.pckRegionNames.erase(
      mmfParams.surfSplitParams.pckRegionNames.begin());
  std::vector<std::string> packRegNames =
      mmfParams.surfSplitParams.pckRegionNames;

  // FoamGeoMesh
  auto fgm_ = NEM::MSH::Read(surroundingRegion + ".foam");
  auto mesh = NEM::MSH::New(this->files_.outCombinedFile);
  mesh->takeGeoMesh(fgm_);

  for (auto &packRegName : packRegNames) {
    auto fgm_loop = NEM::MSH::Read(packRegName + ".foam");
    mesh->mergeGeoMesh(fgm_loop);
  }

  mesh->write(this->files_.outCombinedFile);

  mesh->Delete();
  fgm_->Delete();

  // *************** Merge meshes using meshBase and write *******************//

  //  bool readDB = false;
  //  // Create surrounding region database
  //  meshBase *fm = new FOAM::foamMesh(readDB);
  //  fm->read(surroundingRegion);
  //  std::vector<double> physId = std::vector<double>(fm->getNumberOfCells(),
  //  0); auto *vm = new vtkMesh(fm->getDataSet(),
  //  this->files_.outCombinedFile); vm->setCellDataArray("PhysGrpId", physId);
  //
  //  // Loop through all pack particles and merge their databases into main
  //  // database
  //  for (int i = 0; i < (int) packRegNames.size(); i++) {
  //    fm->read(packRegNames[i]);
  //    std::vector<double> physIdLoop =
  //        std::vector<double>(fm->getNumberOfCells(), i + 1);
  //    auto *vm2 =
  //        new vtkMesh(fm->getDataSet(), "pack" + std::to_string(i) + ".vtu");
  //    vm2->setCellDataArray("PhysGrpId", physIdLoop);
  //    // vm2->write();
  //    vm->merge(vm2->getDataSet());
  //  }
  //
  //  // Write mesh and clean up objects
  //  vm->report();
  //  vm->write();
  //  delete vm;
  //  delete fm;

  // *************** Merge meshes using OF and write ************************ //
  // Use this method for writing pack and surrounding meshes separately. This
  // uses mergeMeshes method from "src/MeshManipulation/MeshManipulationFoam.C".
  // It also writes merged mesh at the end. Use this as a replacement for the
  // method directly above (Merge meshes using meshBase).

  // mergeMeshes will read master domain (defined by user) from constant folder
  // and start merging other domain to it untill all slave domains are attached
  // to master domain. It loops through all domains in sequential manner and
  // skips the missing domain.* (also skipped by splitMeshRegions) to avoid
  // runtime error.
  // std::cout << "Total # of domains are = " << totalRegs << std::endl;
  // if (totalRegs == 1) {
  //   // Nothing
  // } else {
  //   objMsh->mergeMeshes(skippedDir, totalRegs);
  // }

  // // Reads current mesh and write it to separate VTK/VTU files
  // // Reads and converts pack mesh
  // bool readDB = false;
  // std::string regNme;
  // if (skippedDir == 1)
  //   regNme = "domain2";
  // else
  //   regNme = "domain1";

  // if (totalRegs == 1) regNme = _snappyparams->singleSolidPatch;

  // meshBase *fm = new FOAM::foamMesh(readDB);
  // fm->read(regNme);
  // vtkMesh *vm2 = new vtkMesh(fm->getDataSet(), ofname_pack);
  // std::vector<double> physIdPack
  //   = std::vector<double>(fm->getNumberOfCells(),1);
  // vm2->setCellDataArray("PhysGrpId",physIdPack);
  // vm2->write();

  // // Reads and converts surronding mesh
  // regNme = surroundingRegion;

  // if (totalRegs == 1) regNme = surroundingRegion;
  // meshBase *fm2 = new FOAM::foamMesh(readDB);
  // fm2->read(regNme);
  // std::vector<double> physIdSurrounding
  //   = std::vector<double>(fm2->getNumberOfCells(),0);
  // vtkMesh *vm3 = new vtkMesh(fm2->getDataSet(), ofname_surrndng);
  // vm3->setCellDataArray("PhysGrpId",physIdSurrounding);
  // vm3->write();

  // // Merge meshes and write
  // vtkMesh *vm = new vtkMesh(vm2->getDataSet(),ofname_merged);
  // vm->merge(vm3->getDataSet());
  // vm->report();
  // vm->write();
  // if (vm) delete vm;
  // if (fm) delete fm;
  // if (vm2) delete vm2;
  // if (fm2) delete fm2;
  // if (vm3) delete vm3;

  // // Outputs useful mesh quality parameters for users
  // std::string SurroundingName = "surroundingMeshQuality";
  // std::string Surroundingmesh = "geom_surrounding_mesh.vtu";
  // std::string PackName = "packMeshQuality";
  // std::string Packmesh = "geom_pack_mesh.vtu";
  // MeshQualityDriver *objSurrQ =
  //     new MeshQualityDriver(Surroundingmesh, SurroundingName);
  // MeshQualityDriver *objPackQ = new MeshQualityDriver(Packmesh, PackName);
  // if (objSurrQ) delete objSurrQ;
  // if (objPackQ) delete objPackQ;
  // *************** Merge meshes using OF and write ************************ //

  // End of workflow
}

getFiles()

const HexPackMeshDriver::Files & NEM::DRV::HexPackMeshDriver::getFiles

(

)

const

Definition at line 73 of file HexPackMeshDriver.C.

References files_.

Referenced by setOpts().

                                                                {
  return files_;
}

getOpts()

const HexPackMeshDriver::Opts & NEM::DRV::HexPackMeshDriver::getOpts

(

)

const

Definition at line 90 of file HexPackMeshDriver.C.

References opts_.

                                                              {
  return opts_;
}

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 NEM::DRV::MeshGenDriver::MeshGenDriver().

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

setFiles()

void NEM::DRV::HexPackMeshDriver::setFiles

(

Files

files

)

Definition at line 77 of file HexPackMeshDriver.C.

References NEM::DRV::HexPackMeshDriver::Opts::bmParams, files_, snappymeshParams::geomFileName, NEM::DRV::HexPackMeshDriver::Files::getInputFile(), NEM::DRV::HexPackMeshDriver::Files::isInputRocpackFile(), opts_, blockMeshParams::shape, and NEM::DRV::HexPackMeshDriver::Opts::smParams.

                                            {
  const auto stlFile = files.isInputRocpackFile()
                           ? files.getInputFile() + ".stl"
                           : files.getInputFile();
  this->opts_.smParams.geomFileName = stlFile;
  if (auto box = dynamic_cast<bmBox *>(this->opts_.bmParams.shape.get())) {
    if (box->autoGenerate.has_value()) {
      box->autoGenerate.value().packFileName = stlFile;
    }
  }
  this->files_ = std::move(files);
}

setOpts()

void NEM::DRV::HexPackMeshDriver::setOpts

(

Opts

opts

)

Definition at line 94 of file HexPackMeshDriver.C.

References MeshManipulationFoamParams::MergeMeshes::addCasePath, NEM::DRV::HexPackMeshDriver::Opts::bmParams, snappymeshParams::geomFileName, getFiles(), NEM::DRV::HexPackMeshDriver::Files::getInputFile(), NEM::DRV::HexPackMeshDriver::Files::isInputRocpackFile(), MeshManipulationFoamParams::MergeMeshes::masterCasePath, NEM::DRV::HexPackMeshDriver::Opts::mmfCreatePatchParams, NEM::DRV::HexPackMeshDriver::Opts::mmfMergeParams, opts_, MeshManipulationFoamParams::CreatePatch::packsName, MeshManipulationFoamParams::CreatePatch::packsPatchType, blockMeshParams::shape, NEM::DRV::HexPackMeshDriver::Opts::smParams, MeshManipulationFoamParams::CreatePatch::srrndngPatchType, and MeshManipulationFoamParams::CreatePatch::surroundingName.

                                         {
  const auto stlFile = getFiles().isInputRocpackFile()
                           ? getFiles().getInputFile() + ".stl"
                           : getFiles().getInputFile();
  if (auto box = dynamic_cast<bmBox *>(opts.bmParams.shape.get())) {
    if (box->autoGenerate.has_value()) {
      if (!box->autoGenerate.value().packFileName.empty()) {
        std::cerr
            << "opts.bmParams.shape.autoGenerate.packFileName is ignored. "
               "Using getFiles().getInputFile() for geometry file"
            << std::endl;
      }
      box->autoGenerate.value().packFileName = stlFile;
    }
  } else {
    std::cerr << "HexPackMeshDriver only accepts box shape for blockmesh.\n";
    exit(1);
  }

  if (!opts.smParams.geomFileName.empty()) {
    std::cerr << "opts.smParams.geomFileName is ignored. Using "
                 "getFiles().getInputFile() for geometry file"
              << std::endl;
  }
  opts.smParams.geomFileName = stlFile;

  // Default values specific to this driver
  if (opts.mmfMergeParams.masterCasePath.empty()) {
    opts.mmfMergeParams.masterCasePath = ".";
  }
  if (opts.mmfMergeParams.addCasePath.empty()) {
    opts.mmfMergeParams.addCasePath = ".";
  }
  if (opts.mmfCreatePatchParams.surroundingName.empty()) {
    opts.mmfCreatePatchParams.surroundingName = "Soil";
  }
  if (opts.mmfCreatePatchParams.packsName.empty()) {
    opts.mmfCreatePatchParams.packsName = "Rocks";
  }
  if (opts.mmfCreatePatchParams.srrndngPatchType.empty()) {
    opts.mmfCreatePatchParams.srrndngPatchType = "wall";
  }
  if (opts.mmfCreatePatchParams.packsPatchType.empty()) {
    opts.mmfCreatePatchParams.packsPatchType = "wall";
  }
  this->opts_ = std::move(opts);
}

Member Data Documentation

files_

Files NEM::DRV::HexPackMeshDriver::files_

private

Definition at line 119 of file HexPackMeshDriver.H.

Referenced by execute(), getFiles(), and setFiles().

opts_

Opts NEM::DRV::HexPackMeshDriver::opts_

private

Definition at line 120 of file HexPackMeshDriver.H.

Referenced by execute(), getOpts(), setFiles(), and setOpts().

---

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

• HexPackMeshDriver.H
• HexPackMeshDriver.C