Detailed Description

Definition at line 37 of file FoamToVtkConversionDriver.H.

Classes
struct	Opts

Public Types
using	Files = DriverOutFile

Public Member Functions
	FoamToVtkConversionDriver (Files file)

const Files &	getFiles () const

void	setFiles (Files file)

void	execute () const override
	Run the workflow represented by the driver. More...

Static Public Member Functions
static void	genExo (std::vector< meshBase *> meshes, const std::string &fname)

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

Static Protected Member Functions
static void	genExo (meshBase mb, NEM::MSH::EXOMesh::exoMesh em, const int &ndeIdOffset, const int &elmIdOffset, int &ins, int &ieb, int &iss, std::string mshName, const bool &usePhys, int &ndeIdOffset_local, int &elmIdOffset_local, const bool &makeFreeSurfSS, const bool &splitTopBotSS, std::vector< std::string > sideSetNames)

static void	procExo (const jsoncons::json &ppJson, const std::string &fname, NEM::MSH::EXOMesh::exoMesh *em)

static void	freeSurfaceSideSet (const meshBase mb, NEM::MSH::EXOMesh::exoMesh em, int elmIdOffset, std::map< int, int > v2e_elemID_map, bool splitTopBotSS, std::vector< std::string > sideSetNames)
	Creates side set(s) for the free surface, exterior surface, during conversion. More...

Private Member Functions
	FoamToVtkConversionDriver ()

const Opts &	getOpts () const

Private Attributes
Files	file_

Inherits NEM::DRV::ConversionDriver.

Member Typedef Documentation

◆ Files

using NEM::DRV::FoamToVtkConversionDriver::Files = DriverOutFile

Definition at line 39 of file FoamToVtkConversionDriver.H.

Constructor & Destructor Documentation

◆ FoamToVtkConversionDriver() [1/2]

NEM::DRV::FoamToVtkConversionDriver::FoamToVtkConversionDriver ( Files file )

explicit

Definition at line 37 of file FoamToVtkConversionDriver.C.

38 : file_(std::move(file)) {}

NEM::DRV::FoamToVtkConversionDriver::file_

Files file_

Definition: FoamToVtkConversionDriver.H:52

◆ FoamToVtkConversionDriver() [2/2]

NEM::DRV::FoamToVtkConversionDriver::FoamToVtkConversionDriver ( )

private

Definition at line 40 of file FoamToVtkConversionDriver.C.

41 : FoamToVtkConversionDriver(Files{{}}) {}

NEM::DRV::FoamToVtkConversionDriver::FoamToVtkConversionDriver

FoamToVtkConversionDriver()

Definition: FoamToVtkConversionDriver.C:40

NEM::DRV::FoamToVtkConversionDriver::Files

DriverOutFile Files

Definition: FoamToVtkConversionDriver.H:39

Member Function Documentation

◆ execute()

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

overridevirtual

Implements NEM::DRV::NemDriver.

Definition at line 52 of file FoamToVtkConversionDriver.C.

References file_, meshBase::getDataSet(), NEM::DRV::DriverOutFile::outputFile, meshBase::read(), vtkMesh::report(), and vtkMesh::write().

                                               {
   meshBase *fm = new FOAM::foamMesh();
   fm->read("NULL");
   // TODO: Fix report and write methods for the foamMesh class
   // std::cout << "Variable values is = " << srcmsh << std::endl;
   vtkMesh *vm = new vtkMesh(fm->getDataSet(), this->file_.outputFile);
   vm->report();
   vm->write();
   delete vm;
   delete fm;
 }

◆ freeSurfaceSideSet()

void NEM::DRV::ConversionDriver::freeSurfaceSideSet	(	const meshBase *	mb,
		NEM::MSH::EXOMesh::exoMesh *	em,
		int	elmIdOffset,
		std::map< int, int >	v2e_elemID_map,
		bool	splitTopBotSS,
		std::vector< std::string >	sideSetNames
	)

staticprotectedinherited

Parameters

mb	Meshbase object
em	ExoMesh object
elmIdOffset	Exodus element ID offset
v2e_elemID_map	VTK to EXO element ID map
splitTopBotSS	Boolean to split the side set into three side sets
sideSetNames	The list of name(s) for the side set(s)

Definition at line 287 of file ConversionDriver.C.

References NEM::MSH::EXOMesh::exoMesh::addSdeSet(), NEM::MSH::EXOMesh::sdeSetType::elmIdOffset, NEM::MSH::EXOMesh::sdeSetType::elmIds, meshBase::getDataSet(), NEM::MSH::EXOMesh::exoMesh::getDimension(), NEM::MSH::EXOMesh::sdeSetType::id, NEM::MSH::EXOMesh::sdeSetType::name, NEM::MSH::New(), NEM::MSH::EXOMesh::sdeSetType::nSde, and NEM::MSH::EXOMesh::sdeSetType::sdeIds.

Referenced by NEM::DRV::ConversionDriver::genExo().

                                        {
   std::cout << "Creating side set from free surface." << std::endl;
 
   std::vector<std::pair<int, int>> freeSurfCellEdge;
   std::vector<std::pair<int, int>> hexFreeSurfCellFace;
   std::vector<std::pair<int, int>> wedgeFreeSurfCellFace;
   std::vector<std::pair<int, int>> tetraFreeSurfCellFace;
   std::vector<int> elementIds1, elementIds2, elementIds3, sideIds1, sideIds2,
       sideIds3;
   std::vector<std::vector<int>> splitElemIds, splitSideIds;
 
   // Maps for VTK to EXO face id conversion for hex and wedge
   std::map<int, int> v2e_hexFace_map = {{1, 4}, {2, 2}, {3, 1},
                                         {4, 3}, {5, 5}, {6, 6}};
   std::map<int, int> v2e_wedgeFace_map = {
       {1, 4}, {2, 5}, {3, 1}, {4, 2}, {5, 3}};
   std::map<int, int> v2e_tetraFace_map = {{1, 1}, {2, 2}, {3, 3}, {4, 4}};
 
   // acquiring dataset
   vtkSmartPointer<vtkDataSet> ds = mb->getDataSet();
   if (!ds) {
     std::cerr << "No dataset is associated to the meshbase." << std::endl;
     throw;
   }
   bool tetWarning = false;
   // loop through cells and obtain different quantities needed
   int nCl = ds->GetNumberOfCells();
   for (int cell_i = 0; cell_i < nCl; cell_i++) {
     vtkCell *vc = ds->GetCell(cell_i);
     if (vc->GetCellDimension() == 2) {
       // for 2D cells
       int ne = vc->GetNumberOfEdges();
       for (int edge_i = 0; edge_i < ne; edge_i++) {
         vtkCell *ve = vc->GetEdge(edge_i);
         vtkIdList *pidl = ve->GetPointIds();
 
         std::pair<int, int> adjPair;
 
         // getting neighbour list
         vtkSmartPointer<vtkIdList> cidl = vtkSmartPointer<vtkIdList>::New();
         ds->GetCellNeighbors(cell_i, pidl, cidl);
         if (cidl->GetNumberOfIds() == 0) {
           adjPair.first = cell_i;
           adjPair.second = edge_i + 1;
           freeSurfCellEdge.push_back(adjPair);
         }
       }
     } else if (vc->GetCellDimension() == 3) {
       // for 3D cells
       int nfc = vc->GetNumberOfFaces();
       for (int face_i = 0; face_i < nfc; face_i++) {
         vtkCell *vf = vc->GetFace(face_i);
         vtkIdList *facePoints = vf->GetPointIds();
 
         std::pair<int, int> adjPair;
 
         // getting neighbour list
         vtkSmartPointer<vtkIdList> cidl = vtkSmartPointer<vtkIdList>::New();
         ds->GetCellNeighbors(cell_i, facePoints, cidl);
         if (cidl->GetNumberOfIds() == 0) {
           adjPair.first = cell_i;
           adjPair.second = face_i + 1;
           if (nfc == 6) hexFreeSurfCellFace.push_back(adjPair);
           if (nfc == 5) wedgeFreeSurfCellFace.push_back(adjPair);
           if (nfc == 4) {
             tetraFreeSurfCellFace.push_back(adjPair);
             if (splitTopBotSS && tetWarning == false) {
               std::cerr
                   << "Warning: Tetrahedral element found on free surface.\n"
                   << "         Cannot split top and bottom into separate side "
                      "sets.\n"
                   << "         Creating single side set." << std::endl;
               splitTopBotSS = false;
               tetWarning = true;
             }
           }
         }
       }
     }
   }
 
   if (em->getDimension() == 3) {
     // Iterate through *freeSurfCellFace to make lists of elements/faces
     // Hexahedra
     for (int i = 0; i < hexFreeSurfCellFace.size(); i++) {
       int exoId = v2e_elemID_map[hexFreeSurfCellFace[i].first];
       int sId = v2e_hexFace_map[hexFreeSurfCellFace[i].second];
 
       if (splitTopBotSS) {
         if (sId == 5) {
           // Top
           elementIds2.push_back(exoId);
           sideIds2.push_back(sId);
         } else if (sId == 6) {
           // Bottom
           elementIds3.push_back(exoId);
           sideIds3.push_back(sId);
         } else {
           elementIds1.push_back(exoId);
           sideIds1.push_back(sId);
         }
       } else {
         elementIds1.push_back(exoId);
         sideIds1.push_back(sId);
       }
     }
     // Wedges
     for (int i = 0; i < wedgeFreeSurfCellFace.size(); i++) {
       int exoId = v2e_elemID_map[wedgeFreeSurfCellFace[i].first];
       int sId = v2e_wedgeFace_map[wedgeFreeSurfCellFace[i].second];
 
       if (splitTopBotSS) {
         if (sId == 4) {
           // Top
           elementIds2.push_back(exoId);
           sideIds2.push_back(sId);
         } else if (sId == 5) {
           // Bottom
           elementIds3.push_back(exoId);
           sideIds3.push_back(sId);
         } else {
           elementIds1.push_back(exoId);
           sideIds1.push_back(sId);
         }
       } else {
         elementIds1.push_back(exoId);
         sideIds1.push_back(sId);
       }
     }
     // Tetrahedra
     for (int i = 0; i < tetraFreeSurfCellFace.size(); i++) {
       int exoId = v2e_elemID_map[tetraFreeSurfCellFace[i].first];
       int sId = v2e_tetraFace_map[tetraFreeSurfCellFace[i].second];
       elementIds1.push_back(exoId);
       sideIds1.push_back(sId);
     }
   }
 
   if (em->getDimension() == 2) {
     // Iterate through freeSurfCellEdge to make lists of elements/faces
     for (int i = 0; i < freeSurfCellEdge.size(); i++) {
       // map from VTK element id to EXO element id
       int exoId = v2e_elemID_map[freeSurfCellEdge[i].first];
       elementIds1.push_back(exoId);
       sideIds1.push_back(freeSurfCellEdge[i].second);
     }
   }
 
   if (splitTopBotSS && em->getDimension() == 3) {
     splitElemIds = {elementIds1, elementIds2, elementIds3};
     splitSideIds = {sideIds1, sideIds2, sideIds3};
   } else {
     splitElemIds = {elementIds1};
     splitSideIds = {sideIds1};
   }
 
   for (int i = 0; i < splitElemIds.size(); ++i) {
     NEM::MSH::EXOMesh::sdeSetType ss;
 
     // TODO: fix names, still not working correctly
     if (sideSetNames.size() == 1 && splitElemIds.size() == 1) {
       ss.name = sideSetNames[i];
     }
     if (sideSetNames.size() == 0) {
       std::cout << "side set names size is zero" << std::endl;
       ss.name = "side_set_000000" + std::to_string(i + 1);
     }
     if (sideSetNames.size() > 0 && sideSetNames.size() < 3 && splitTopBotSS) {
       std::cerr << "Error: Expected 3 'Side Set Names', found "
                 << sideSetNames.size() << std::endl;
       exit(1);
     }
     if (sideSetNames.size() == 3) {
       ss.name = sideSetNames[i];
     }
 
     // ss.id = ++iss;
     ss.id = i + 1;
     ss.nSde = (int)splitSideIds[i].size();
     ss.elmIds = splitElemIds[i];
     ss.sdeIds = splitSideIds[i];
     ss.elmIdOffset = elmIdOffset;
     em->addSdeSet(ss);
   }
 }

◆ genExo() [1/2]

void NEM::DRV::ConversionDriver::genExo	(	std::vector< meshBase *>	meshes,
		const std::string &	fname
	)

staticinherited

Definition at line 236 of file ConversionDriver.C.

Referenced by NEM::DRV::GmshToExoConversionDriver::execute(), and proteusHdf5::proteusHdf5().

                                                       {
   bool usePhys = false;
   bool makeFreeSurfSS = false;
   bool splitTopBotSS = false;
   std::vector<std::string> sideSetNames;
 
   std::cout << "Warning: this method does not support physical groups."
             << std::endl;
   std::cout << "Warning: this method does not support post-processing."
             << std::endl;
 
   int nMsh = meshes.size();
 
   // sanity check
   if (nMsh == 0) {
     std::cerr << "Error: At least one mesh should be provided!\n";
     exit(-1);
   }
 
   // starting conversion operation
   auto em = new NEM::MSH::EXOMesh::exoMesh(fname);
 
   // reading meshes
   int ndeIdOffset = 0;
   int elmIdOffset = 0;
   int ins = 0;
   int ieb = 0;
   int iss = 0;
   int ndeIdOffset_local = 0;
   int elmIdOffset_local = 0;
 
   std::string mshName;
 
   for (auto itrMsh = meshes.begin(); itrMsh != meshes.end(); itrMsh++) {
     mshName = (*itrMsh)->getFileName();
     genExo(*itrMsh, em, ndeIdOffset, elmIdOffset, ins, ieb, iss, mshName,
            usePhys, ndeIdOffset_local, elmIdOffset_local, makeFreeSurfSS,
            splitTopBotSS, sideSetNames);
   }
 
   // writing the file
   em->write();
   em->report();
 
   em->mergeNodes();
 
   // clean up
   delete em;
 }

◆ genExo() [2/2]

void NEM::DRV::ConversionDriver::genExo	(	meshBase *	mb,
		NEM::MSH::EXOMesh::exoMesh *	em,
		const int &	ndeIdOffset,
		const int &	elmIdOffset,
		int &	ins,
		int &	ieb,
		int &	iss,
		std::string	mshName,
		const bool &	usePhys,
		int &	ndeIdOffset_local,
		int &	elmIdOffset_local,
		const bool &	makeFreeSurfSS,
		const bool &	splitTopBotSS,
		std::vector< std::string >	sideSetNames
	)

staticprotectedinherited

Definition at line 54 of file ConversionDriver.C.

                                                                  {
   // add nodes to database
   for (nemId_t iNde = 0; iNde < mb->getNumberOfPoints(); ++iNde)
     em->addNde(mb->getPoint(iNde));
 
   // node coordinate to one nodeSet
   NEM::MSH::EXOMesh::ndeSetType ns;
   ns.id = ++ins;
   ns.nNde = mb->getNumberOfPoints();
   ns.name = mshName;
   ns.ndeIdOffset = ndeIdOffset;
   for (int iNde = 0; iNde < ns.nNde; iNde++) {
     ns.ndeIds.emplace_back(iNde + 1);
   }
   em->addNdeSet(ns);
   ndeIdOffset_local += ns.nNde;
 
   // add element blocks
 
   // Element bucket where they will be sorted.
   // Outer layer: Specifies grouping, such as physical groups. The 0th index
   // is reserved for elements without a group.
   // Inner layer: Sorted by element type. The 0th index is reserved for
   // unsupported elements. The current support respects the ordering of the
   // NEM::MSH::EXOMesh::elementType enum:
   //     OTHER, TRIANGLE, QUAD, TETRA, HEX
   std::map<int, std::map<NEM::MSH::EXOMesh::elementType, std::vector<int>>>
       elmBucket;
   // map for VTK to EXO element ids
   std::map<int, int> v2e_elemID_map;
 
   std::vector<double> grpIds(mb->getNumberOfCells(), 0.0);
   if (usePhys) mb->getCellDataArray("PhysGrpId", grpIds);
 
   bool is3D = false;
   // Loop through all elements
   for (int iElm = 0; iElm < mb->getNumberOfCells(); iElm++) {
     VTKCellType vtkType =
         static_cast<VTKCellType>(mb->getDataSet()->GetCellType(iElm));
     NEM::MSH::EXOMesh::elementType exoType =
         NEM::MSH::EXOMesh::v2eEMap(vtkType);
 
     // set the dimension of Exo database based on present elements
     if (!is3D) {
       if (exoType == NEM::MSH::EXOMesh::elementType::TETRA ||
           exoType == NEM::MSH::EXOMesh::elementType::WEDGE ||
           exoType == NEM::MSH::EXOMesh::elementType::HEX) {
         is3D = true;
         em->setDimension(3);
       }
     }
 
     elmBucket[static_cast<int>(grpIds[iElm])][exoType].emplace_back(iElm);
   }
 
   // sanity check
   int numUnsupported = 0;
   for (const auto &elmGroup : elmBucket)
     if (elmGroup.second.count(NEM::MSH::EXOMesh::elementType::OTHER) != 0)
       numUnsupported +=
           elmGroup.second.at(NEM::MSH::EXOMesh::elementType::OTHER).size();
   if (numUnsupported > 0) {
     std::cerr << "WARNING: Detected " << numUnsupported
               << " unsupported elements.\n";
     throw;
   }
 
   // for each group and supported type, if existent, add an element block
   for (const auto &elmGroup : elmBucket) {
     for (const auto &elmIds : elmGroup.second) {
       if (elmIds.second.empty()) continue;  // skip if empty
 
       NEM::MSH::EXOMesh::elmBlkType eb;
       eb.id = ++ieb;
       eb.ndeIdOffset = ndeIdOffset;
       eb.nElm = elmIds.second.size();
 
       // populate VTK to EXO element id map for side set implementation
       for (int i = 0; i < elmIds.second.size(); ++i) {
         int vtkId = elmIds.second[i];
         int exoId = i + elmIdOffset_local + 1;
         v2e_elemID_map.insert(std::pair<int, int>(vtkId, exoId));
       }
 
       if (usePhys)
         eb.name = mshName + "_PhysGrp_" + std::to_string(ieb);
       else
         eb.name = mshName + "_" + std::to_string(ieb);
 
       switch (elmIds.first) {
         case NEM::MSH::EXOMesh::elementType::TRIANGLE:
           std::cout << "Number of triangular elements = " << eb.nElm << "\n";
           eb.ndePerElm = 3;
           eb.eTpe = NEM::MSH::EXOMesh::elementType::TRIANGLE;
           break;
         case NEM::MSH::EXOMesh::elementType::QUAD:
           std::cout << "Number of quadrilateral elements = " << eb.nElm << "\n";
           eb.ndePerElm = 4;
           eb.eTpe = NEM::MSH::EXOMesh::elementType::QUAD;
           break;
         case NEM::MSH::EXOMesh::elementType::TETRA:
           std::cout << "Number of tetrahedral elements = " << eb.nElm << "\n";
           eb.ndePerElm = 4;
           eb.eTpe = NEM::MSH::EXOMesh::elementType::TETRA;
           break;
         case NEM::MSH::EXOMesh::elementType::HEX:
           std::cout << "Number of hexahedral elements = " << eb.nElm << "\n";
           eb.ndePerElm = 8;
           eb.eTpe = NEM::MSH::EXOMesh::elementType::HEX;
           break;
         case NEM::MSH::EXOMesh::elementType::WEDGE:
           std::cout << "Number of wedge elements = " << eb.nElm << "\n";
           eb.ndePerElm = 6;
           eb.eTpe = NEM::MSH::EXOMesh::elementType::WEDGE;
           break;
         case NEM::MSH::EXOMesh::elementType::OTHER:
         default:
           std::cerr << "WARNING: Processing unsupported element. Previous "
                        "sanity check failed!\n";
           throw;
       }
 
       eb.conn.reserve(eb.nElm * eb.ndePerElm);
       vtkIdList *nids = vtkIdList::New();
       for (const auto &iElm : elmIds.second) {
         mb->getDataSet()->GetCellPoints(iElm, nids);
         for (int in = 0; in < eb.ndePerElm; ++in) {
           // offset node ids by 1
           eb.conn.emplace_back(nids->GetId(in) + 1);
         }
       }
 
       // DEBUG
       // std::cout << "Min node index = "
       //           << *min_element(eb.conn.begin(), eb.conn.end()) << "\n"
       //           << "Max node index = "
       //           << *max_element(eb.conn.begin(), eb.conn.end()) << "\n";
       // std::cout << "Starting node offset = " << ndeIdOffset << std::endl;
 
       em->addElmBlk(eb);
       elmIdOffset_local += eb.nElm;
     }
   }
 
   // add side set of the external surface(s) (free surface)
   if (makeFreeSurfSS) {
     freeSurfaceSideSet(mb, em, elmIdOffset, v2e_elemID_map, splitTopBotSS,
                        sideSetNames);
   }
 
   // add side sets
   if (mb->getMetadata()) {
     // get side set metadata
     vtkSmartPointer<vtkModelMetadata> metadata = mb->getMetadata();
     vtkSmartPointer<vtkStringArray> sdeSetNames = metadata->GetSideSetNames();
     int *sdeSetElmLst = metadata->GetSideSetElementList();
     int *sdeSetSdeLst = metadata->GetSideSetSideList();
     int *sdeSetSze = metadata->GetSideSetSize();
 
     for (int iSS = 0; iSS < metadata->GetNumberOfSideSets(); iSS++) {
       NEM::MSH::EXOMesh::sdeSetType ss;
       ss.id = ++iss;
       ss.name = sdeSetNames->GetValue(iSS);
       ss.nSde = sdeSetSze[iSS];
       ss.elmIds.assign(sdeSetElmLst, sdeSetElmLst + sdeSetSze[iSS]);
       ss.sdeIds.assign(sdeSetSdeLst, sdeSetSdeLst + sdeSetSze[iSS]);
       ss.elmIdOffset = elmIdOffset;
       em->addSdeSet(ss);
 
       // Advance pointer for reading next side set.
       sdeSetElmLst += sdeSetSze[iSS];
       sdeSetSdeLst += sdeSetSze[iSS];
     }
   }
 }

◆ getFiles()

const FoamToVtkConversionDriver::Files & NEM::DRV::FoamToVtkConversionDriver::getFiles ( ) const

Definition at line 43 of file FoamToVtkConversionDriver.C.

References file_.

       {
   return file_;
 }

◆ getOpts()

const FoamToVtkConversionDriver::Opts & NEM::DRV::FoamToVtkConversionDriver::getOpts ( ) const

private

Definition at line 64 of file FoamToVtkConversionDriver.C.

           {
   static constexpr Opts opts{};
   return opts;
 }

◆ procExo()

void NEM::DRV::ConversionDriver::procExo	(	const jsoncons::json &	ppJson,
		const std::string &	fname,
		NEM::MSH::EXOMesh::exoMesh *	em
	)

staticprotectedinherited

Definition at line 476 of file ConversionDriver.C.

References NEM::MSH::EXOMesh::exoMesh::addElmBlkByElmIdLst(), NEM::MSH::EXOMesh::exoMesh::addNdeSetByNdeIdLst(), meshSrch::chkDuplElm(), meshSrch::Create(), meshBase::Create(), meshSrch::FindCellsInSphere(), meshSrch::FindCellsInTriSrf(), meshSrch::FindCellsWithinBounds(), meshSrch::FindPntsOnEdge(), meshSrch::FindPntsOnTriSrf(), NEM::MSH::EXOMesh::exoMesh::getElmBlkNames(), NEM::MSH::EXOMesh::exoMesh::lstElmInBlk(), NEM::MSH::EXOMesh::exoMesh::mergeNodes(), NEM::MSH::EXOMesh::exoMesh::removeElmBlkByName(), NEM::MSH::EXOMesh::exoMesh::scaleNodes(), and NEM::MSH::EXOMesh::exoMesh::snapNdeCrdsZero().

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

                                                          {
   // converting to mesh base for geometric inquiry
   meshBase *mb = meshBase::Create(fname);
 
   // performing requested operation
   std::string opr = ppJson.get_with_default("Operation", "");
   if (opr == "Material Assignment") {
     meshSrch *ms = meshSrch::Create(mb);
     // gathering information about all zones
     // if densities are defined, materials with higher density will be
     // prioritized
     bool appDen = ppJson.get_with_default("Apply Density", false);
 
     std::map<std::pair<double, std::string>, std::set<int>> zoneGeom;
 
     // loop over all zones
     for (const auto &zone : ppJson["Zones"].array_range()) {
       // assuming first element is zone information keyed by zone name
       // that we do not care about yet
       std::string matName = zone[0].get_with_default("Material Name", "N/A");
       std::string shape = zone[0].get_with_default("Shape", "N/A");
       std::cout << "Processing zone: " << zone.object_range().begin()->key()
                 << "  Material: " << matName << "  Shape: " << shape;
 
       double density = 1.0;  // Default density is 1.0
       if (appDen) {
         density = zone[0].get_with_default("Density", 1.0);
         std::cout << "  Density: " << density;
       }
       std::cout << std::endl;
 
       std::vector<nemId_t> lst;
       if (shape == "Box") {
         // Box shape. Requires 3-vector of Min and Max in x, y, and z, resp.
         std::vector<double> bb;
         bb.push_back(zone[0]["Params"]["Min"][0].as<double>());
         bb.push_back(zone[0]["Params"]["Max"][0].as<double>());
         bb.push_back(zone[0]["Params"]["Min"][1].as<double>());
         bb.push_back(zone[0]["Params"]["Max"][1].as<double>());
         bb.push_back(zone[0]["Params"]["Min"][2].as<double>());
         bb.push_back(zone[0]["Params"]["Max"][2].as<double>());
 
         ms->FindCellsWithinBounds(bb, lst, true);
       } else if (shape == "STL") {
         // STL shape. Only supports Tri surface.
         // Node Coordinates are given as 3-vector in an array.
         // Connectivities are given as 3-vectors in an array.
         // Tris are 0-indexed.
         std::vector<std::vector<double>> crds;
         std::vector<std::vector<vtkIdType>> conns;
         for (const auto &crd :
              zone[0]["Params"]["Node Coordinates"].array_range())
           crds.push_back(crd.as<std::vector<double>>());
         for (const auto &conn :
              zone[0]["Params"]["Connectivities"].array_range())
           conns.push_back(conn.as<std::vector<vtkIdType>>());
 
         ms->FindCellsInTriSrf(crds, conns, lst);
       } else if (shape == "Sphere") {
         // Sphere shape.
         // Center is a 3-vector in an array.
         // Radius is a double.
         std::vector<double> center =
             zone[0]["Params"]["Center"].as<std::vector<double>>();
         auto radius = zone[0]["Params"]["Radius"].as<double>();
 
         ms->FindCellsInSphere(center, radius, lst);
       } else {
         std::cerr << "WARNING: Skipping unknown zone shape: " << shape
                   << std::endl;
         continue;
       }
 
       if (zone[0].contains("Only From Block")) {
         std::string blkName = zone[0]["Only From Block"].as<std::string>();
 
         std::vector<std::string> elmBlkNames = em->getElmBlkNames();
         auto elmBlkName =
             std::find(elmBlkNames.begin(), elmBlkNames.end(), blkName);
         if (elmBlkName == elmBlkNames.end()) {
           std::cerr << "WARNING: Only From Block " << blkName
                     << " matches no available blocks. Continuing with no "
                        "restriction.\n";
         } else {
           std::vector<int> lst_int(lst.begin(), lst.end());
           bool allIn = false;
           lst_int = em->lstElmInBlk(
               std::distance(elmBlkNames.begin(), elmBlkName), lst_int, allIn);
           lst.assign(lst_int.begin(), lst_int.end());
         }
       }
       zoneGeom[{1.0 / density, matName}].insert(lst.begin(), lst.end());
     }
 
     if (appDen)
       std::cout << "Applying material zones based on density ordering"
                 << std::endl;
 
     // adjusting exodus database accordingly
     for (const auto &zone : zoneGeom) {
       // zone is ((density, material name), ids)
       std::vector<int> elmLst;
       std::cout << "Manipulating ExodusDB for " << zone.first.second
                 << std::endl;
       elmLst.insert(elmLst.end(), zone.second.begin(), zone.second.end());
       em->addElmBlkByElmIdLst(zone.first.second, elmLst);
     }
   } else if (opr == "Check Duplicate Elements") {
     std::cout << "Checking for existence of duplicate elements ... ";
     meshSrch *ms = meshSrch::Create(mb);
     bool ret = ms->chkDuplElm();
     if (ret) {
       std::cerr << " The exodus database contains duplicate elements."
                 << std::endl;
       exit(-1);
     } else {
       std::cout << "False" << std::endl;
     }
   } else if (opr == "Remove Block") {
     std::string blkName = ppJson.get_with_default("Block Name", "");
     std::cout << "Removing Block " << blkName << std::endl;
     em->removeElmBlkByName(blkName);
   } else if (opr == "Snap Node Coords To Zero") {
     double tol = ppJson.get_with_default("Tolerance", 0.0);
     std::cout << "Snapping nodal coordinates to zero using tolerance: " << tol
               << std::endl;
     em->snapNdeCrdsZero(tol);
   } else if (opr == "Boundary Condition Assignment") {
     // For EP16 boundary conditions are simply translated to node sets. Node
     // sets may have shared nodes. In that case a node the order of nodeset
     // matter. A later node set supersedes an earlier one.
     meshSrch *ms = meshSrch::Create(mb);
 
     // gathering information about all boundary node sets
     jsoncons::json bcs = ppJson["Condition"];
     for (const auto &bc : bcs.array_range()) {
       std::set<nemId_t> pntIds;
 
       // identify node ids on each boundary
       std::string bcName = bc["Name"].as<std::string>();
       std::string bcTyp = bc["Boundary Type"].as<std::string>();
       if (bcTyp == "Faces") {
         std::vector<double> srfCrd;
         std::vector<nemId_t> srfConn;
         jsoncons::json nc = bc["Params"]["Node Coordinates"];
         for (const auto &crds : nc.array_range())
           for (const auto &cmp : crds.array_range())
             srfCrd.push_back(cmp.as<double>());
         jsoncons::json conn = bc["Params"]["Connectivities"];
         for (const auto &tri : conn.array_range())
           for (const auto &idx : tri.array_range())
             srfConn.push_back(idx.as<nemId_t>());
         ms->FindPntsOnTriSrf(srfCrd, srfConn, pntIds);
         std::cout << "Number of points residing on the boundary " << bcName
                   << " is " << pntIds.size() << std::endl;
       } else if (bcTyp == "Edges") {
         std::vector<double> edgeCrd;
         jsoncons::json ncs = bc["Params"]["Start"];
         for (const auto &crds : ncs.array_range())
           for (const auto &cmp : crds.array_range())
             edgeCrd.push_back(cmp.as<double>());
         jsoncons::json nce = bc["Params"]["End"];
         for (const auto &crds : nce.array_range())
           for (const auto &cmp : crds.array_range())
             edgeCrd.push_back(cmp.as<double>());
         ms->FindPntsOnEdge(edgeCrd, pntIds);
         std::cout << "Number of points residing on the boundary " << bcName
                   << " is " << pntIds.size() << std::endl;
       } else {
         std::cerr << "Warning: unsupported boundary type " << bcTyp
                   << std::endl;
       }
 
       // register node set in Exodus II database
       if (!pntIds.empty()) {
         std::vector<int> nv;
         std::copy(pntIds.begin(), pntIds.end(), std::back_inserter(nv));
         em->addNdeSetByNdeIdLst(bcName, nv);
       }
     }
   } else if (opr == "Merge Nodes") {
     em->mergeNodes();
   } else if (opr == "Mesh Scaling") {
     em->scaleNodes(ppJson["Scale"].as<double>());
   } else {
     std::cerr << "Unknown operation requested: " << opr << std::endl;
   }
 }

◆ 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::FoamToVtkConversionDriver::setFiles ( Files file )

Definition at line 48 of file FoamToVtkConversionDriver.C.

References file_.

                                                    {
   this->file_ = std::move(file);
 }

Member Data Documentation

◆ file_

Files NEM::DRV::FoamToVtkConversionDriver::file_

private

Definition at line 52 of file FoamToVtkConversionDriver.H.

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

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

Detailed Description

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Protected Member Functions

Private Member Functions

Private Attributes

Member Typedef Documentation

◆ Files

Constructor & Destructor Documentation

◆ FoamToVtkConversionDriver() [1/2]

◆ FoamToVtkConversionDriver() [2/2]

Member Function Documentation

◆ execute()

◆ freeSurfaceSideSet()

◆ genExo() [1/2]

◆ genExo() [2/2]

◆ getFiles()

◆ getOpts()

◆ procExo()

◆ readJSON()

◆ setFiles()

Member Data Documentation

◆ file_