FOAM::foamMesh Class Reference

foamMesh class contains methods for reading and writing mesh in OpenFOAM polyMesh format. More...

Detailed Description

It also overrides certain methods of meshBase for decomposing OpenFOAM polyMesh into VTK unstructured database to facilitate convertion to and from OpenFOAM mesh to different mesh formats through ConversionDriver.

Definition at line 49 of file foamMesh.H.

Public Member Functions
	foamMesh (bool readDB=false)
	foamMesh default constructor. More...
	foamMesh (std::shared_ptr< meshBase > fullMesh)
	foamMesh alternate constructor. More...
	~foamMesh () override
	foamMesh standard destructor More...
void	report () const override
	generate a report of the mesh More...
void	read (const std::string &fname) override
	general purpose mesh information read method More...
void	readAMR (const Foam::Time &runTime)
	Reads fvMesh for adaptive mesh refinement process. More...
std::vector< double >	getPoint (nemId_t id) const override
	get point with id More...
std::vector< std::vector< double > >	getVertCrds () const override
	get 3 vecs with x,y and z coords More...
std::map< nemId_t, std::vector< double > >	getCell (nemId_t id) const override
	get cell with id : returns point indices and respective coordinates More...
std::vector< std::vector< double > >	getCellVec (nemId_t id) const override
	get cell points ids and their coordinates More...
std::vector< double >	getCellLengths () const override
	get diameter of circumsphere of each cell More...
std::vector< double >	getCellCenter (nemId_t cellID) const override
	get center of a cell More...
int	getCellType () const override
	get cell type as an integer. More...
void	inspectEdges (const std::string &ofname) const override
	get edge lengths of dataSet More...
std::vector< nemId_t >	getConnectivities () const override
	get vtk cell connectivities in terms of point ids More...
void	write (const std::string &fname) const override
	write the mesh to file named fname More...
vtkSmartPointer< vtkDataSet >	extractSurface () override
	Extracts foam mesh surface using VTK data set. More...
vtkSmartPointer< vtkDataSet >	getDataSet () const
	get this meshes' dataSet More...
virtual void	setPointDataArray (const std::string &name, const std::vector< std::vector< double >> &data)
	register data to dataSet's point data More...
virtual void	setPointDataArray (const std::string &name, const std::vector< double > &data)
	register data to dataSet's point data More...
virtual void	setCellDataArray (const std::string &name, const std::vector< std::vector< double >> &data)
	register data to dataSet's cell data More...
virtual void	setCellDataArray (const std::string &name, const std::vector< double > &data)
	register data to dataSet's cell data More...
virtual void	getPointDataArray (const std::string &name, std::vector< double > &data)
	get scalar point or cell data array. More...
virtual void	getPointDataArray (int arrayId, std::vector< double > &data)
	get scalar point or cell data array. More...
virtual int	getCellDataIdx (const std::string &name)
	<> More...
virtual void	getCellDataArray (const std::string &name, std::vector< double > &data)
	<> More...
virtual void	getCellDataArray (int arrayId, std::vector< double > &data)
	<> More...
virtual void	unsetPointDataArray (int arrayID)
	delete array with id from dataSet's point data More...
virtual void	unsetPointDataArray (const std::string &name)
	<> More...
virtual void	unsetCellDataArray (int arrayID)
	delete array with id from dataSet's cell data More...
virtual void	unsetCellDataArray (const std::string &name)
	<> More...
virtual void	unsetFieldDataArray (const std::string &name)
	delete array with id from dataSet's field data More...
vtkSmartPointer< vtkStaticCellLocator >	buildStaticCellLocator ()
	build locators for efficient search operations More...
vtkSmartPointer< vtkStaticPointLocator >	buildStaticPointLocator ()
	build thread-safe point locator for efficient search operations More...
void	setMetadata (vtkSmartPointer< vtkModelMetadata > _metadata)
vtkSmartPointer< vtkModelMetadata >	getMetadata ()
std::vector< std::vector< double > >	integrateOverMesh (const std::vector< int > &arrayIDs)
	integrate arrays in arrayIDs over the mesh. More...
void	generateSizeField (const std::string &method, int arrayID, double dev_mlt, bool maxIsmin, double sizeFactor=1.0, int order=1)
	generate size field based on method and given a point data array. More...
int	IsArrayName (const std::string &name, bool pointOrCell=false) const
	check for named array in vtk and return its integer id. More...
void	refineMesh (const std::string &method, int arrayID, double dev_mult, bool maxIsmin, double edge_scale, const std::string &ofname, bool transferData, double sizeFactor=1., bool constrainBoundary=false)
	perform sizefield-based h-refinement. More...
void	refineMesh (const std::string &method, const std::string &arrayName, double dev_mult, bool maxIsmin, double edge_scale, const std::string &ofname, bool transferData, double sizeFactor=1.)
	perform sizefield-based h-refinement. More...
void	refineMesh (const std::string &method, double edge_scale, const std::string &ofname, bool transferData, bool constrainBoundary=false)
	added for uniform refinement by driver More...
void	refineMesh (const std::string &method, int arrayID, int order, const std::string &ofname, bool transferData)
	<> More...
void	refineMesh (const std::string &method, const std::string &arrayName, int order, const std::string &ofname, bool transferData)
	<> More...
nemId_t	getNumberOfPoints () const
	return the number of points More...
nemId_t	getNumberOfCells () const
	return the number of cells More...
void	checkMesh (const std::string &ofname) const
	<> More...
std::map< nemId_t, nemId_t >	getGlobToPartNodeMap ()
	global to local mapping of nodes More...
std::map< nemId_t, nemId_t >	getGlobToPartCellMap ()
	global to local mapping of cells More...
std::map< nemId_t, nemId_t >	getPartToGlobNodeMap ()
	local to global mapping of nodes More...
std::map< nemId_t, nemId_t >	getPartToGlobCellMap ()
	local to global mapping of cells More...
virtual void	write () const
	write the mesh to file named after the private var 'filename'. More...
void	writeMSH (std::ofstream &outputStream)
	convert to gmsh format without data More...
void	writeMSH (const std::string &fname)
	convert to gmsh format without data More...
void	writeMSH (std::ofstream &outputStream, const std::string &pointOrCell, int arrayID)
	convert to gmsh format with specified point or cell data More...
void	writeMSH (const std::string &fname, const std::string &pointOrCell, int arrayID)
	convert to gmsh format without data More...
void	writeMSH (std::ofstream &outputStream, const std::string &pointOrCell, int arrayID, bool onlyVol)
	convert to gmsh format with specified point or cell data for only volume elements (USE ONLY FOR MADLIB STUFF) More...
void	writeMSH (const std::string &fname, const std::string &pointOrCell, int arrayID, bool onlyVol)
	convert to gmsh format with specified point or cell data for only volume elements (USE ONLY FOR MADLIB STUFF) More...
void	writeCobalt (meshBase *surfWithPatch, const std::string &mapFile, std::ofstream &outputStream)
	surfWithPatch must have patchNo array More...
void	writeCobalt (meshBase *surfWithPatch, const std::string &mapFile, const std::string &ofname)
	surfWithPatch must have patchNo array More...
void	setFileName (const std::string &fname)
	set the file name. More...
const std::string &	getFileName () const
	get the current file name More...
void	setCheckQuality (bool x)
	set whether to check quality of transfer by back-transfer and rmse More...
void	setContBool (bool x)
	set weighted averaging/smoothing for cell data transfer (default is off) More...
meshBase *	convertQuads ()
std::vector< std::string >	getNewArrayNames ()
	get new array names for use in transfer More...
std::vector< int >	getArrayIDs (std::vector< std::string > arrayNames, bool fromPointArrays=false)
	given array names, return corresponding ids More...
void	convertHexToTetVTK (vtkSmartPointer< vtkDataSet > meshdataSet)
	Converts given hexahedral VTK dataset into tetrahedral mesh and stores it into dataSet variable. More...

Static Public Member Functions
static meshBase *	Create (const std::string &fname)
	Construct vtkMesh from filename. More...
static meshBase *	Create (vtkSmartPointer< vtkDataSet > other, const std::string &newname)
	Construct from existing vtkDataSet and assign newname as filename. More...
static meshBase *	Create (const std::vector< double > &xCrds, const std::vector< double > &yCrds, const std::vector< double > &zCrds, const std::vector< nemId_t > &elmConn, const int cellType, const std::string &newname)
	create from coordinates and connectivities. More...
static std::shared_ptr< meshBase >	CreateShared (const std::string &fname)
	Create shared ptr from fname. More...
static std::shared_ptr< meshBase >	CreateShared (meshBase *mesh)
	Create shared ptr from existing meshbase. More...
static std::shared_ptr< meshBase >	CreateShared (vtkSmartPointer< vtkDataSet > other, const std::string &newname)
	Create shared ptr from existing vtkDataset and assign newname as filename. More...
static std::shared_ptr< meshBase >	CreateShared (const std::vector< double > &xCrds, const std::vector< double > &yCrds, const std::vector< double > &zCrds, const std::vector< nemId_t > &elmConn, int cellType, const std::string &newname)
	Version of raw data mesh creation for memory managed shared_ptr instance. More...
static std::unique_ptr< meshBase >	CreateUnique (const std::string &fname)
	create unique ptr from fname More...
static std::unique_ptr< meshBase >	CreateUnique (const std::vector< double > &xCrds, const std::vector< double > &yCrds, const std::vector< double > &zCrds, const std::vector< nemId_t > &elmConn, int cellType, const std::string &newname)
	version of raw data mesh creation for memory managed unique ptr instance More...
static std::unique_ptr< meshBase >	CreateUnique (vtkSmartPointer< vtkDataSet > other, const std::string &newname)
	construct from existing vtkDataSet and assign newname as filename More...
static std::unique_ptr< meshBase >	CreateUnique (meshBase *mesh)
	construct from existing meshbase object More...
static meshBase *	exportGmshToVtk (const std::string &fname)
	construct vtkMesh from gmsh msh file (called in Create methods) More...
static meshBase *	exportVolToVtk (const std::string &fname)
	construct vtkMesh from netgen vol file (called in Create methods) More...
static meshBase *	exportPntToVtk (const std::string &fname)
	construct vtkMesh from netgen vol file (called in Create methods) More...
static meshBase *	exportExoToVtk (const std::string &fname)
	construct vtkMesh from exodusII files More...
static meshBase *	stitchMB (const std::vector< meshBase *> &mbObjs)
	stitch together several meshBases More...
static std::shared_ptr< meshBase >	stitchMB (const std::vector< std::shared_ptr< meshBase >> &_mbObjs)
	stitch together several meshBase More...
static std::vector< std::shared_ptr< meshBase > >	partition (const meshBase *mbObj, int numPartitions)
	mesh partitioning (with METIS) More...
static meshBase *	extractSelectedCells (meshBase *mesh, const std::vector< nemId_t > &cellIds)
	extract subset of mesh given list of cell ids and return meshBase obj More...
static meshBase *	extractSelectedCells (vtkSmartPointer< vtkDataSet > mesh, vtkSmartPointer< vtkIdTypeArray > cellIds)
	helper wrapped by function above More...

Protected Attributes
nemId_t	numPoints
	number of points in mesh More...
nemId_t	numCells
	number of cells in mesh More...
vtkSmartPointer< vtkDataSet >	dataSet
	mesh points, topology and data More...
std::string	filename
	name of mesh file More...
bool	checkQuality
	check transfer quality when on More...
bool	continuous
	switch on / off weighted averaging for cell data transfer (default is off) More...
std::vector< std::string >	newArrayNames
	new names to set for transferred data More...
std::map< nemId_t, nemId_t >	globToPartNodeMap
	map between global and local node idx in partition for distributed data sets More...
std::map< nemId_t, nemId_t >	globToPartCellMap
	map between global and local cell idx in partition More...
std::map< nemId_t, nemId_t >	partToGlobNodeMap
	map between local and global node idx in partition More...
std::map< nemId_t, nemId_t >	partToGlobCellMap
	map between local and global cell idx in partition More...
vtkSmartPointer< vtkModelMetadata >	metadata

Private Member Functions
void	genMshDB ()
	Return a polyMesh Object. More...
void	createFoamDicts ()
	Created necessary dictionaries for OpenFOAM runtime environment. More...

Private Attributes
Foam::argList *	_args
Foam::Time *	_runTime
Foam::fvMesh *	_fmesh
std::shared_ptr< meshBase >	_volMB
	Shared meshBase pointer for foamMesh constructor and some methods. More...

Inherits meshBase.

Constructor & Destructor Documentation

foamMesh() [1/2]

FOAM::foamMesh::foamMesh ( bool  readDB = false )

explicit

Initializes OpenFOAM environment.

Parameters

readDB

If true, reads mesh database from current location. (default is false)

Definition at line 63 of file foamMesh.C.

References _args, _runTime, and read().

                              {
  // initialize openfoam
  int argc = 1;
  char **argv = new char *[2];
  argv[0] = new char[100];
  strcpy(argv[0], "NONE");
  _args = new Foam::argList(argc, argv);
  Foam::Info << "Create time\n" << Foam::endl;
  _runTime = new Foam::Time(Foam::Time::controlDictName, *_args);
  Foam::argList::noParallel();

  // reading mesh database from current location
  if (readDB) read("");
}

foamMesh() [2/2]

FOAM::foamMesh::foamMesh

(

std::shared_ptr< meshBase >

fullMesh

)

Assigns incoming meshBase mesh to internal pointer for manipulation. Creates necessary foam dictionaries for runtime environment.

Parameters

fullMesh

meshBase shared pointer for mesh database.

Definition at line 78 of file foamMesh.C.

References _volMB, and createFoamDicts().

                                                   {
  _volMB = fullMesh;
  createFoamDicts();
}

~foamMesh()

FOAM::foamMesh::~foamMesh ( )

override

Definition at line 83 of file foamMesh.C.

References _args, _fmesh, and _runTime.

                    {
  if (_args) {
    delete _args;
    _args = nullptr;
  }
  if (_runTime) {
    delete _runTime;
    _runTime = nullptr;
  }
  if (_fmesh) {
    delete _fmesh;
    _fmesh = nullptr;
  }
  std::cout << "foamMesh destroyed" << std::endl;
}

Member Function Documentation

buildStaticCellLocator()

vtkSmartPointer< vtkStaticCellLocator > meshBase::buildStaticCellLocator ( )

inherited

Returns

<>

Definition at line 1640 of file meshBase.C.

References NEM::MSH::New().

Referenced by meshBase::writeCobalt().

                                                                       {
  vtkSmartPointer<vtkStaticCellLocator> cellLocator =
      vtkSmartPointer<vtkStaticCellLocator>::New();
  cellLocator->SetDataSet(dataSet);
  cellLocator->BuildLocator();
  return cellLocator;
}

buildStaticPointLocator()

vtkSmartPointer< vtkStaticPointLocator > meshBase::buildStaticPointLocator ( )

inherited

Returns

<>

Definition at line 1648 of file meshBase.C.

References NEM::MSH::New().

                                                                         {
  auto pointLocator = vtkSmartPointer<vtkStaticPointLocator>::New();
  pointLocator->SetDataSet(dataSet);
  pointLocator->BuildLocator();
  return pointLocator;
}

checkMesh()

void meshBase::checkMesh ( const std::string &  ofname ) const

inherited

Parameters

ofname

<>

Definition at line 1657 of file meshBase.C.

References MeshQuality::checkMesh().

                                                      {
  std::unique_ptr<MeshQuality> qualCheck =
      std::unique_ptr<MeshQuality>(new MeshQuality(this));
  qualCheck->checkMesh(ofname);
}

convertHexToTetVTK()

void meshBase::convertHexToTetVTK ( vtkSmartPointer< vtkDataSet >  meshdataSet )

inherited

Parameters

meshdataSet

Input hexahedral mesh dataset

Definition at line 1826 of file meshBase.C.

References NEM::MSH::New().

                                                                         {
  vtkSmartPointer<vtkDataSetTriangleFilter> triFilter =
      vtkSmartPointer<vtkDataSetTriangleFilter>::New();
  triFilter->SetInputData(meshdataSet);
  triFilter->Update();

  dataSet = triFilter->GetOutput();
}

convertQuads()

meshBase * meshBase::convertQuads ( )

inherited

Definition at line 1769 of file meshBase.C.

References NEM::MSH::New(), and points.

Referenced by proteusHdf5::proteusHdf5().

                                 {
  // Create new dataset
  vtkSmartPointer<vtkUnstructuredGrid> vtkDataSetNoQuads =
      vtkSmartPointer<vtkUnstructuredGrid>::New();
  // Accumulate vector of ID lists for quads removed
  std::vector<std::vector<int>> removedQuadIds;
  // Set points
  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
  points->SetNumberOfPoints(this->getDataSet()->GetNumberOfPoints());
  double pt[3];
  for (int iPoint = 0; iPoint < this->getDataSet()->GetNumberOfPoints();
       iPoint++) {
    this->getDataSet()->GetPoint(iPoint, pt);
    points->SetPoint(iPoint, pt[0], pt[1], pt[2]);
  }
  vtkDataSetNoQuads->SetPoints(points);

  // loop through elements and remove quads by splitting into tris
  for (int iCell = 0; iCell < this->getDataSet()->GetNumberOfCells(); iCell++) {
    // is quad?
    if (this->getDataSet()->GetCell(iCell)->GetCellType() == VTK_QUAD) {
      vtkSmartPointer<vtkIdList> elmIds =
          this->getDataSet()->GetCell(iCell)->GetPointIds();
      std::vector<int> elmIdsVec = {static_cast<int>(elmIds->GetId(0)),
                                    static_cast<int>(elmIds->GetId(1)),
                                    static_cast<int>(elmIds->GetId(2)),
                                    static_cast<int>(elmIds->GetId(3))};
      removedQuadIds.push_back(elmIdsVec);
    }
    // only add non-quads to vtkdataset
    else {
      vtkDataSetNoQuads->InsertNextCell(
          this->getDataSet()->GetCell(iCell)->GetCellType(),
          this->getDataSet()->GetCell(iCell)->GetPointIds());
    }
  }

  // Add in new tris based on accumulated quad Ids
  for (auto elemItr = removedQuadIds.begin(); elemItr != removedQuadIds.end();
       elemItr++) {
    vtkSmartPointer<vtkIdList> triList1 = vtkSmartPointer<vtkIdList>::New();
    triList1->InsertNextId((*elemItr)[0]);
    triList1->InsertNextId((*elemItr)[1]);
    triList1->InsertNextId((*elemItr)[2]);
    vtkDataSetNoQuads->InsertNextCell(VTK_TRIANGLE, triList1);

    vtkSmartPointer<vtkIdList> triList2 = vtkSmartPointer<vtkIdList>::New();
    triList2->InsertNextId((*elemItr)[0]);
    triList2->InsertNextId((*elemItr)[2]);
    triList2->InsertNextId((*elemItr)[3]);

    vtkDataSetNoQuads->InsertNextCell(VTK_TRIANGLE, triList2);
  }

  return Create(vtkDataSetNoQuads, "removedQuads.vtu");
}

Create() [1/3]

meshBase * meshBase::Create ( const std::string &  fname )

staticinherited

This method calls the other factory methods based on extension.

Parameters

fname

name of mesh file

Returns

<>

Caller must delete object after use.

Definition at line 78 of file meshBase.C.

Referenced by OrderOfAccuracy::computeMeshWithResolution(), NEM::GEO::rocPack::createCohesiveElements(), meshBase::CreateShared(), meshBase::CreateUnique(), NEM::DRV::BlockMeshMeshGenDriver::execute(), NEM::DRV::SnappyMeshMeshGenDriver::execute(), NEM::DRV::VtkToPntConversionDriver::execute(), NEM::DRV::TransferDriver::execute(), NEM::DRV::CheckMeshQualDriver::execute(), NEM::DRV::GmshToExoConversionDriver::execute(), hdf5Reader::exportToMeshBase(), meshBase::extractSelectedCells(), NEM::DRV::MeshGenDriver::MeshGenDriver(), NEM::DRV::ConversionDriver::procExo(), proteusHdf5::proteusHdf5(), and meshBase::stitchMB().

                                                 {
  if (fname.find(".vt") != std::string::npos ||
      fname.find(".stl") != std::string::npos) {
    auto *vtkmesh = new vtkMesh(fname);
    vtkmesh->setFileName(fname);
    return vtkmesh;
  } else if (fname.find(".msh") != std::string::npos) {
    std::cout << "Detected file in GMSH format" << std::endl;
    std::cout << "Exporting to VTK ...." << std::endl;
    return exportGmshToVtk(fname);
  } else if (fname.find(".vol") != std::string::npos) {
    std::cout << "Detected file in Netgen .vol format" << std::endl;
    std::cout << "Exporting to VTK ...." << std::endl;
    return exportVolToVtk(fname);
  } else if (fname.find(".pntmesh") != std::string::npos) {
    std::cout << "Detected file in PNTmesh format" << std::endl;
    std::cout << "Processing the file ...." << std::endl;
    return exportPntToVtk(fname);
  } else if (fname.find(".g") != std::string::npos ||
             fname.find(".exo") != std::string::npos ||
             fname.find(".e") != std::string::npos) {
    std::cout << "Detected file in Exodus II format" << std::endl;
    std::cout << "Processing the file ...." << std::endl;
    return exportExoToVtk(fname);
  } else {
    std::cout << "mesh files with extension "
              << fname.substr(fname.find_last_of('.')) << " are not supported!"
              << std::endl;
    exit(1);
  }
}

Create() [2/3]

meshBase * meshBase::Create ( vtkSmartPointer< vtkDataSet >  other, const std::string &  newname  )

staticinherited

Caller must delete object after use.

Parameters

other	The vtkDataSet used to construct the mesh
fname	name of mesh file

Returns

<>

Definition at line 112 of file meshBase.C.

                                                     {
  return new vtkMesh(other, newname);
}

Create() [3/3]

meshBase * meshBase::Create ( const std::vector< double > &  xCrds, const std::vector< double > &  yCrds, const std::vector< double > &  zCrds, const std::vector< nemId_t > &  elmConn, const int  cellType, const std::string &  newname  )

staticinherited

Use of this is only valid when mesh has one cell type.

Parameters

xCrds	<>
yCrds	<>
zCrds	<>
elmConn	<>
cellType	one of the vtkCellType enums. Currently, only VTK_TETRA and VTK_TRIANGLE are supported.
newname	name of mesh file

Returns

<>

Caller must delete object after use.

Definition at line 120 of file meshBase.C.

                                                                         {
  return new vtkMesh(xCrds, yCrds, zCrds, elmConn, cellType, newname);
}

createFoamDicts()

void FOAM::foamMesh::createFoamDicts ( )

private

Definition at line 357 of file foamMesh.C.

Referenced by foamMesh().

                               {
  // fvSchemesDict

  // creating a base system directory
  const char dir_path[] = "./system";
  boost::filesystem::path dir(dir_path);
  try {
    boost::filesystem::create_directory(dir);
  } catch (boost::filesystem::filesystem_error &e) {
    std::cerr << "Problem in creating system directory for the cfMesh"
              << "\n";
    std::cerr << e.what() << std::endl;
    throw;
  }

  std::ofstream contDict;
  contDict.open(std::string(dir_path) + "/fvSchemes");
  std::string contText =
      "\
/*--------------------------------*- C++ -*----------------------------------*\n\
| =========                 |                                                |\n\
| \\\\      /  F ield         | NEMoSys: Mesh Conversion interface             |\n\
|  \\\\    /   O peration     |                                                |\n\
|   \\\\  /    A nd           |                                                |\n\
|    \\\\/     M anipulation  |                                                |\n\
\\*---------------------------------------------------------------------------*/\n\
\n\
FoamFile\n\
{\n\
    version   2.0;\n\
    format    ascii;\n\
    class     dictionary;\n\
    object    fvSchemes;\n\
}\n\n\
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //\n\n\
gradSchemes\n\
{\n\
    default         Gauss linear;\n\
    grad(p)         Gauss linear;\n\
}\n\
\n\
divSchemes\n\
{\n\
    default         none;\n\
    div(phi,U)      Gauss linear;\n\
}\n\
\n\
laplacianSchemes\n\
{\n\
    default         none;\n\
    laplacian(nu,U) Gauss linear corrected;\n\
    laplacian((1|A(U)),p) Gauss linear corrected;\n\
}\n\
// ************************************************************************* //";
  contDict << contText;
  contDict.close();

  // fvSolutionDict

  std::ofstream contDict2;
  contDict2.open(std::string(dir_path) + "/fvSolution");
  std::string contText2 =
      "\
/*--------------------------------*- C++ -*----------------------------------*\n\
| =========                 |                                                |\n\
| \\\\      /  F ield         | NEMoSys: Mesh Conversion interface             |\n\
|  \\\\    /   O peration     |                                                |\n\
|   \\\\  /    A nd           |                                                |\n\
|    \\\\/     M anipulation  |                                                |\n\
\\*---------------------------------------------------------------------------*/\n\
\n\
FoamFile\n\
{\n\
    version   2.0;\n\
    format    ascii;\n\
    class     dictionary;\n\
    object    fvSolution;\n\
}\n\n\
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //\n\n\
\n\
// ************************************************************************* //";
  contDict2 << contText2;
  contDict2.close();

  // ControlDict

  std::ofstream contDict3;
  contDict3.open(std::string(dir_path) + "/controlDict");
  std::string contText3 =
      "\
/*--------------------------------*- C++ -*----------------------------------*\n\
| =========                 |                                                |\n\
| \\\\      /  F ield         | NEMoSys: Mesh Conversion interface             |\n\
|  \\\\    /   O peration     |                                                |\n\
|   \\\\  /    A nd           |                                                |\n\
|    \\\\/     M anipulation  |                                                |\n\
\\*---------------------------------------------------------------------------*/\n\
\n\
FoamFile\n\
{\n\
    version   2.0;\n\
    format    ascii;\n\
    class     dictionary;\n\
    location  \"system\";\n\
    object    controlDict;\n\
}\n\n\
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //\n\n\
deltaT  1;\n\n\
startTime 0;\n\n\
writeInterval 1;\n\n\
// ************************************************************************* //";
  contDict3 << contText3;
  contDict3.close();
}

CreateShared() [1/4]

std::shared_ptr< meshBase > meshBase::CreateShared ( const std::string &  fname )

staticinherited

Memory is managed by shared pointer, so do not call delete after use.

Parameters

fname

name of mesh file

Returns

<>

Definition at line 171 of file meshBase.C.

References meshBase::Create(), and mesh.

Referenced by COBALT::cobalt::cobalt(), NEM::DRV::VtkHexToTetConversionDriver::execute(), NEM::DRV::BlockMeshMeshGenDriver::execute(), NEM::DRV::SnappyMeshMeshGenDriver::execute(), NEM::DRV::GmshMeshGenDriver::execute(), NEM::DRV::NetgenMeshGenDriver::execute(), NEM::DRV::VtkToFoamConversionDriver::execute(), NEM::DRV::UniformRefineDriver::execute(), NEM::DRV::VtkToCobaltConversionDriver::execute(), NEM::DRV::Z2RefineDriver::execute(), NEM::DRV::SizeFieldRefineDriver::execute(), NEM::DRV::FoamRefineDriver::execute(), NEM::DRV::AutoVerificationDriver::execute(), NEM::DRV::VtkToPatranConversionDriver::execute(), meshStitcher::initSurfCgObj(), meshStitcher::initVolCgObj(), NEM::DRV::MeshGenDriver::MeshGenDriver(), meshBase::partition(), PATRAN::patran::patran(), and meshBase::stitchMB().

                                                                     {
  std::shared_ptr<meshBase> mesh;
  mesh.reset(meshBase::Create(fname));
  return mesh;
}

CreateShared() [2/4]

std::shared_ptr< meshBase > meshBase::CreateShared ( meshBase *  mesh )

staticinherited

Memory is managed by shared pointer, so do not call delete after use.

Parameters

mesh	the existing meshbase

Returns

<>

(be careful with this one!)

Definition at line 154 of file meshBase.C.

                                                             {
  std::shared_ptr<meshBase> sharedMesh;
  sharedMesh.reset(mesh);
  return sharedMesh;
}

CreateShared() [3/4]

std::shared_ptr< meshBase > meshBase::CreateShared ( vtkSmartPointer< vtkDataSet >  other, const std::string &  newname  )

staticinherited

Memory is managed by shared pointer, so do not call delete after use.

Parameters

other	The vtkDataSet used to construct the mesh
fname	name of mesh file

Returns

<>

Definition at line 162 of file meshBase.C.

References meshBase::Create(), and mesh.

                                                                 {
  std::shared_ptr<meshBase> mesh;
  mesh.reset(meshBase::Create(other, newname));
  return mesh;
}

CreateShared() [4/4]

std::shared_ptr< meshBase > meshBase::CreateShared ( const std::vector< double > &  xCrds, const std::vector< double > &  yCrds, const std::vector< double > &  zCrds, const std::vector< nemId_t > &  elmConn, int  cellType, const std::string &  newname  )

staticinherited

Memory is managed by shared pointer, so do not call delete after use.

Parameters

xCrds	<>
yCrds	<>
zCrds	<>
elmConn	<>
cellType	one of the vtkCellType enums. Currently, only VTK_TETRA and VTK_TRIANGLE are supported.
fname	name of mesh file

Returns

<>

Definition at line 179 of file meshBase.C.

References meshBase::Create(), and mesh.

                                                  {
  std::shared_ptr<meshBase> mesh;
  mesh.reset(meshBase::Create(xCrds, yCrds, zCrds, elmConn, cellType, newname));
  return mesh;
}

CreateUnique() [1/4]

std::unique_ptr< meshBase > meshBase::CreateUnique ( const std::string &  fname )

staticinherited

Memory is managed by shared pointer, so do not call delete after use.

Parameters

fname

name of mesh file

Returns

<>

Definition at line 190 of file meshBase.C.

References meshBase::Create().

                                                                     {
  return std::unique_ptr<meshBase>(meshBase::Create(fname));
}

CreateUnique() [2/4]

std::unique_ptr< meshBase > meshBase::CreateUnique ( const std::vector< double > &  xCrds, const std::vector< double > &  yCrds, const std::vector< double > &  zCrds, const std::vector< nemId_t > &  elmConn, int  cellType, const std::string &  newname  )

staticinherited

Memory is managed by shared pointer, so do not call delete after use.

Parameters

xCrds	<>
yCrds	<>
zCrds	<>
elmConn	<>
cellType	one of the vtkCellType enums. Currently, only VTK_TETRA and VTK_TRIANGLE are supported.
fname	name of mesh file

Returns

<>

Definition at line 130 of file meshBase.C.

References meshBase::Create().

                                                  {
  return std::unique_ptr<meshBase>(
      meshBase::Create(xCrds, yCrds, zCrds, elmConn, cellType, newname));
}

CreateUnique() [3/4]

std::unique_ptr< meshBase > meshBase::CreateUnique ( vtkSmartPointer< vtkDataSet >  other, const std::string &  newname  )

staticinherited

Memory is managed by shared pointer, so do not call delete after use.

Parameters

other	The vtkDataSet used to construct the mesh
fname	name of mesh file

Returns

<>

Definition at line 140 of file meshBase.C.

References meshBase::Create().

                                                                 {
  return std::unique_ptr<meshBase>(meshBase::Create(other, newname));
}

CreateUnique() [4/4]

std::unique_ptr< meshBase > meshBase::CreateUnique ( meshBase *  mesh )

staticinherited

Memory is managed by shared pointer, so do not call delete after use.

Parameters

mesh	the existing meshbase

Returns

<>

Definition at line 147 of file meshBase.C.

References mesh.

                                                             {
  return std::unique_ptr<meshBase>(mesh);
}

exportExoToVtk()

meshBase * meshBase::exportExoToVtk ( const std::string &  fname )

staticinherited

exports exodusII to vtk format

Parameters

fname

name of mesh file

Returns

<>

Definition at line 918 of file meshBase.C.

References meshBase::dataSet, NEM::MSH::EXOMesh::e2vEMap(), NEM::MSH::EXOMesh::elmTypeNum(), NEM::MSH::New(), meshBase::numCells, meshBase::numPoints, points, meshBase::setFileName(), vtkMesh::write(), and NEM::MSH::EXOMesh::wrnErrMsg().

                                                         {
  // opening the file
  int CPU_word_size, IO_word_size;
  int fid, _exErr;
  float version;
  CPU_word_size = sizeof(float);
  IO_word_size = 0;
  _exErr = 0;

  /* open EXODUS II files */
  fid =
      ex_open(fname.c_str(), EX_READ, &CPU_word_size, &IO_word_size, &version);
  NEM::MSH::EXOMesh::wrnErrMsg(_exErr, "Problem opening file " + fname + "\n");

  // declare points to be pushed into dataSet_tmp
  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();

  // declare dataSet_tmp which will be associated to output vtkMesh
  vtkSmartPointer<vtkUnstructuredGrid> dataSet_tmp =
      vtkSmartPointer<vtkUnstructuredGrid>::New();

  int numPoints;
  int numVolCells;
  int numElmBlk;
  int numNdeSet;
  int numSideSet;

  // parameter inquiry from Exodus file
  int num_props;
  float fdum;
  char cdum;
  _exErr = ex_inquire(fid, EX_INQ_API_VERS, &num_props, &fdum, &cdum);
  NEM::MSH::EXOMesh::wrnErrMsg(_exErr, "Problem reading file contents.\n");
  std::cout << "Exodus II API version is " << fdum << std::endl;

  _exErr = ex_inquire(fid, EX_INQ_DB_VERS, &num_props, &fdum, &cdum);
  NEM::MSH::EXOMesh::wrnErrMsg(_exErr, "Problem reading file contents.\n");
  std::cout << "Exodus II Database version is " << fdum << std::endl;

  _exErr = ex_inquire(fid, EX_INQ_DIM, &num_props, &fdum, &cdum);
  NEM::MSH::EXOMesh::wrnErrMsg(_exErr, "Problem reading file contents.\n");
  std::cout << "Number of coordinate dimensions is " << num_props << std::endl;
  if (num_props != 3)
    NEM::MSH::EXOMesh::wrnErrMsg(-1, "Only 3D mesh data is supported!\n");

  _exErr = ex_inquire(fid, EX_INQ_NODES, &num_props, &fdum, &cdum);
  NEM::MSH::EXOMesh::wrnErrMsg(_exErr, "Problem reading file contents.\n");
  numPoints = num_props;
  std::cout << "Number of points " << numPoints << std::endl;

  _exErr = ex_inquire(fid, EX_INQ_ELEM, &num_props, &fdum, &cdum);
  NEM::MSH::EXOMesh::wrnErrMsg(_exErr, "Problem reading file contents.\n");
  numVolCells = num_props;
  std::cout << "Number of elements " << numVolCells << std::endl;

  _exErr = ex_inquire(fid, EX_INQ_ELEM_BLK, &num_props, &fdum, &cdum);
  NEM::MSH::EXOMesh::wrnErrMsg(_exErr, "Problem reading file contents.\n");
  numElmBlk = num_props;
  std::cout << "Number of element blocks " << numElmBlk << std::endl;

  _exErr = ex_inquire(fid, EX_INQ_NODE_SETS, &num_props, &fdum, &cdum);
  NEM::MSH::EXOMesh::wrnErrMsg(_exErr, "Problem reading file contents.\n");
  numNdeSet = num_props;
  std::cout << "Number of node sets " << numNdeSet << std::endl;

  _exErr = ex_inquire(fid, EX_INQ_SIDE_SETS, &num_props, &fdum, &cdum);
  NEM::MSH::EXOMesh::wrnErrMsg(_exErr, "Problem reading file contents.\n");
  numSideSet = num_props;
  std::cout << "Number of side sets " << numSideSet << std::endl;

  // nodal coordinates
  std::vector<float> x, y, z;
  x.resize(numPoints, 0);
  y.resize(numPoints, 0);
  z.resize(numPoints, 0);
  _exErr = ex_get_coord(fid, &x[0], &y[0], &z[0]);
  NEM::MSH::EXOMesh::wrnErrMsg(_exErr, "Problem reading nodal coordinates.\n");

  // allocate memory for points
  points->SetNumberOfPoints(numPoints);
  for (int i = 0; i < numPoints; ++i) {
    std::vector<double> pt = {x[i], y[i], z[i]};
    points->SetPoint(i, &pt[0]);
  }
  // inserting point array into dataSet_tmp
  dataSet_tmp->SetPoints(points);

  // Connectivities
  // allocating space for cell connectivities
  dataSet_tmp->Allocate(numVolCells);

  // VTK int array for block IDs
  vtkSmartPointer<vtkIntArray> blocks = vtkSmartPointer<vtkIntArray>::New();
  blocks->SetNumberOfValues(numVolCells);
  blocks->SetName("BlockId");

  int count = 0;
  // read element blocks
  for (int iEB = 1; iEB <= numElmBlk; iEB++) {
    int num_el_in_blk, num_nod_per_el, num_attr /*, *connect*/;
    // float *attrib;
    char elem_type[MAX_STR_LENGTH + 1];
    // read element block parameters
    _exErr = ex_get_elem_block(fid, iEB, elem_type, &num_el_in_blk,
                               &num_nod_per_el, &num_attr);
    NEM::MSH::EXOMesh::wrnErrMsg(_exErr,
                                 "Problem reading element block parameters.\n");
    // read element connectivity
    std::vector<int> conn;
    conn.resize(num_el_in_blk * num_nod_per_el, 0);
    _exErr = ex_get_elem_conn(fid, iEB, &conn[0]);
    NEM::MSH::EXOMesh::wrnErrMsg(
        _exErr, "Problem reading element block connectivities.\n");
    // read element block attributes
    // std::vector<float> attr;
    // attr.resize(0.,num_el_in_blk*num_nod_per_el);
    //_exErr = ex_get_elem_attr (fid, iEB, &attrib[0]);
    // EXOMesh::wrnErrMsg(_exErr, "Problem reading element block
    // attributes.\n");

    for (int iEl = 0; iEl < num_el_in_blk; ++iEl) {
      vtkSmartPointer<vtkIdList> vtkcellIds = vtkSmartPointer<vtkIdList>::New();
      VTKCellType vct =
          NEM::MSH::EXOMesh::e2vEMap(NEM::MSH::EXOMesh::elmTypeNum(elem_type));
      for (int jc = iEl * num_nod_per_el; jc < (iEl + 1) * num_nod_per_el;
           jc++) {
        // insert connectivities for cell into cellIds container
        vtkcellIds->InsertNextId(conn[jc] - 1);
      }
      // insert connectivities
      dataSet_tmp->InsertNextCell(vct, vtkcellIds);

      vtkIdType i = count;
      blocks->SetValue(i, iEB);
      count++;
    }
  }
  // std::cout << "Trimmed name = " << nemAux::trim_fname(fname, ".vtu")
  //          << std::endl;

  vtkMesh *vtkmesh = new vtkMesh();
  vtkmesh->dataSet = dataSet_tmp;
  vtkmesh->numCells = vtkmesh->dataSet->GetNumberOfCells();
  vtkmesh->numPoints = vtkmesh->dataSet->GetNumberOfPoints();

  vtkmesh->dataSet->GetCellData()->AddArray(blocks);

  vtkmesh->setFileName("vtkWithIds.vtu");
  vtkmesh->write();
  std::cout << "vtkMesh constructed" << std::endl;

  // closing the file
  _exErr = ex_close(fid);
  NEM::MSH::EXOMesh::wrnErrMsg(_exErr, "Problem closing the exodusII file.");

  return vtkmesh;
}

exportGmshToVtk()

meshBase * meshBase::exportGmshToVtk ( const std::string &  fname )

staticinherited

Parameters

fname

name of mesh file

Returns

<>

Definition at line 409 of file meshBase.C.

References data, meshBase::dataSet, id, NEM::MSH::New(), meshBase::numCells, meshBase::numPoints, points, vtkMesh::setCellDataArray(), and vtkMesh::setPointDataArray().

Referenced by NEM::DRV::GmshToVtkConversionDriver::execute(), NEM::DRV::GmshMeshGenDriver::execute(), NEM::GEO::rocPack::geomToVTK(), NEM::DRV::MeshGenDriver::MeshGenDriver(), and NEM::ADP::Refine::run().

                                                          {
  std::ifstream meshStream(fname);
  if (!meshStream.good()) {
    std::cout << "Error opening file " << fname << std::endl;
    exit(1);
  }

  bool warning = true;

  std::string line;
  int numPoints = 0, numCells = 0, numPhysGrps = 0;
  bool fndPhyGrp = false;
  std::vector<int> physGrpDims;
  std::map<int, std::string> physGrpIdName;
  std::vector<std::vector<std::vector<double>>> pointData;
  std::vector<std::vector<std::vector<double>>> cellData;
  std::vector<std::vector<double>> cellPhysGrpIds;
  std::vector<std::string> pointDataNames;
  std::vector<std::string> cellDataNames;
  std::vector<std::string> fieldDataNames;
  std::vector<std::string> fieldData;

  // declare points to be pushed into dataSet_tmp
  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
  points->SetDataTypeToDouble();
  // declare dataSet_tmp which will be associated to output vtkMesh
  vtkSmartPointer<vtkUnstructuredGrid> dataSet_tmp =
      vtkSmartPointer<vtkUnstructuredGrid>::New();
  // map to hold true index of points (gmsh allows non-contiguous ordering)
  std::map<int, int> trueIndex;

  while (getline(meshStream, line)) {
    if (line.find("$PhysicalNames") != -1) {
      fndPhyGrp = true;
      getline(meshStream, line);
      std::stringstream ss(line);
      ss >> numPhysGrps;
      std::cout << "Found " << numPhysGrps << " physical groups!\n";
      for (int i = 0; i < numPhysGrps; ++i) {
        int grpDim, grpId;
        std::string grpName;
        getline(meshStream, line);
        std::stringstream ss(line);
        ss >> grpDim >> grpId >> grpName;
        grpName.erase(std::remove(grpName.begin(), grpName.end(), '\"'),
                      grpName.end());
        /*std::cout << "Group Dim = " << grpDim
                    << "\nGroup Id = " << grpId
                    << "\nGroup Name = " << grpName
                    << std::endl;*/
        physGrpDims.push_back(grpDim);
        physGrpIdName[grpId] = grpName;
      }
    }

    if (line.find("$Nodes") != -1) {
      getline(meshStream, line);
      std::stringstream ss(line);
      ss >> numPoints;
      int id;
      double x, y, z;
      // allocate memory for points
      points->SetNumberOfPoints(numPoints);
      for (int i = 0; i < numPoints; ++i) {
        getline(meshStream, line);
        std::stringstream ss(line);
        ss >> id >> std::setprecision(16) >> x >> y >> z;
        double point[3];
        point[0] = x;
        point[1] = y;
        point[2] = z;
        // insert point i
        points->SetPoint(i, point);
        trueIndex.insert(std::pair<int, int>(id, i));
      }
      // inserting point array into dataSet_tmp
      dataSet_tmp->SetPoints(points);
    }

    if (line.find("$Elements") != -1) {
      getline(meshStream, line);
      // std::cout << "line = " << line << std::endl;
      std::stringstream ss(line);
      ss >> numCells;
      int id, type, numTags;
      // double tmp2[1];
      // allocate space for cell connectivities
      dataSet_tmp->Allocate(numCells);
      for (int i = 0; i < numCells; ++i) {
        getline(meshStream, line);
        std::stringstream ss(line);
        ss >> id >> type >> numTags;
        vtkSmartPointer<vtkIdList> vtkCellIds =
            vtkSmartPointer<vtkIdList>::New();
        if (type == 2) {
          int tmp;
          if (!fndPhyGrp) {
            for (int j = 0; j < numTags; ++j) ss >> tmp;
          } else {
            std::vector<double> physGrpId(1);
            ss >> physGrpId[0];
            cellPhysGrpIds.push_back(physGrpId);
            for (int j = 0; j < numTags - 1; ++j) ss >> tmp;
          }
          for (int j = 0; j < 3; ++j) {
            ss >> tmp;
            // insert connectivities for cell into cellIds container
            vtkCellIds->InsertNextId(trueIndex[tmp]);  //-1);
          }
          // insert connectivities for triangle elements into dataSet
          dataSet_tmp->InsertNextCell(VTK_TRIANGLE, vtkCellIds);
        } else if (type == 4) {
          int tmp;
          if (!fndPhyGrp) {
            for (int j = 0; j < numTags; ++j) ss >> tmp;
          } else {
            std::vector<double> physGrpId(1);
            ss >> physGrpId[0];
            cellPhysGrpIds.push_back(physGrpId);
            for (int j = 0; j < numTags - 1; ++j) ss >> tmp;
          }
          for (int j = 0; j < 4; ++j) {
            ss >> tmp;
            // insert connectivities for cell into cellIds container
            vtkCellIds->InsertNextId(trueIndex[tmp]);  //-1);
          }
          // insert connectivities for tet elements into dataSet
          dataSet_tmp->InsertNextCell(VTK_TETRA, vtkCellIds);
        } else if (type == 3) {
          int tmp;
          if (!fndPhyGrp) {
            for (int j = 0; j < numTags; ++j) ss >> tmp;
          } else {
            std::vector<double> physGrpId(1);
            ss >> physGrpId[0];
            cellPhysGrpIds.push_back(physGrpId);
            for (int j = 0; j < numTags - 1; ++j) ss >> tmp;
          }
          for (int j = 0; j < 4; ++j) {
            ss >> tmp;
            // insert connectivities for cell into cellIds container
            vtkCellIds->InsertNextId(trueIndex[tmp]);  //-1);
          }
          // insert connectivities for tet elements into dataSet
          dataSet_tmp->InsertNextCell(VTK_QUAD, vtkCellIds);
        } else if (type == 5) {
          int tmp;
          if (!fndPhyGrp) {
            for (int j = 0; j < numTags; ++j) ss >> tmp;
          } else {
            std::vector<double> physGrpId(1);
            ss >> physGrpId[0];
            cellPhysGrpIds.push_back(physGrpId);
            for (int j = 0; j < numTags - 1; ++j) ss >> tmp;
          }
          for (int j = 0; j < 8; ++j) {
            ss >> tmp;
            // insert connectivities for cell into cellIds container
            vtkCellIds->InsertNextId(trueIndex[tmp]);  //-1);
          }
          // insert connectivities for hex elements into dataSet
          dataSet_tmp->InsertNextCell(VTK_HEXAHEDRON, vtkCellIds);
        } else if (type == 6) {
          int tmp;
          if (!fndPhyGrp) {
            for (int j = 0; j < numTags; ++j) ss >> tmp;
          } else {
            std::vector<double> physGrpId(1);
            ss >> physGrpId[0];
            cellPhysGrpIds.push_back(physGrpId);
            for (int j = 0; j < numTags - 1; ++j) ss >> tmp;
          }
          for (int j = 0; j < 6; ++j) {
            ss >> tmp;
            // insert connectivities for cell into cellIds container
            vtkCellIds->InsertNextId(trueIndex[tmp]);  //-1);
          }
          // insert connectivities for wedge/prism elements into dataSet
          dataSet_tmp->InsertNextCell(VTK_WEDGE, vtkCellIds);
        } else if (type == 11) {
          int tmp;
          if (!fndPhyGrp) {
            for (int j = 0; j < numTags; ++j) ss >> tmp;
          } else {
            std::vector<double> physGrpId(1);
            ss >> physGrpId[0];
            cellPhysGrpIds.push_back(physGrpId);
            for (int j = 0; j < numTags - 1; ++j) ss >> tmp;
          }
          for (int j = 0; j < 10; ++j) {
            ss >> tmp;
            // insert connectivities for cell into cellIds container
            vtkCellIds->InsertNextId(trueIndex[tmp]);  //-1);
          }
          // insert connectivities for tet elements into dataSet
          dataSet_tmp->InsertNextCell(VTK_QUADRATIC_TETRA, vtkCellIds);
        } else {
          if (warning) {
            std::cout
                << "Warning: Only triangular, quadrilateral, "
                   "tetrahedral, hexahedral, wedge, and quadratic tetrahedral"
                   "elements are supported, "
                << "everything else is ignored! " << std::endl;
            warning = false;
            // exit(1);
          }
        }
      }
    }

    if (line.find("$NodeData") != -1) {
      std::vector<std::vector<double>> currPointData;
      getline(meshStream, line);  // moving to num_string_tags
      std::stringstream ss(line);
      int num_string_tags;
      ss >> num_string_tags;
      std::string dataname;
      for (int i = 0; i < num_string_tags; ++i) {
        getline(meshStream, line);  // get string tag
        if (i == 0) {
          std::stringstream ss(line);
          ss >> dataname;
        }
      }
      dataname.erase(std::remove(dataname.begin(), dataname.end(), '\"'),
                     dataname.end());
      pointDataNames.push_back(dataname);
      getline(meshStream, line);  // moving to num_real_tags
      std::stringstream ss1(line);
      int num_real_tags;
      ss1 >> num_real_tags;
      for (int i = 0; i < num_real_tags; ++i) getline(meshStream, line);

      getline(meshStream, line);  // moving to num_int_tags
      std::stringstream ss2(line);
      int num_int_tags;
      ss2 >> num_int_tags;
      int dt, dim, numFields, tmp;
      for (int i = 0; i < num_int_tags; ++i) {
        getline(meshStream, line);  // get int tag
        std::stringstream ss(line);
        if (i == 0)
          ss >> dt;
        else if (i == 1)
          ss >> dim;
        else if (i == 2)
          ss >> numFields;
        else
          ss >> tmp;
      }
      for (int i = 0; i < numFields; ++i) {
        std::vector<double> data(dim);
        int id;
        double val;
        getline(meshStream, line);
        std::stringstream ss(line);
        ss >> id;
        for (int j = 0; j < dim; ++j) {
          ss >> val;
          data[j] = val;
        }
        currPointData.push_back(data);
      }
      pointData.push_back(currPointData);
    }

    if (line.find("$ElementData") != -1) {
      std::vector<std::vector<double>> currCellData;
      getline(meshStream, line);  // moving to num_string_tags
      std::stringstream ss(line);
      int num_string_tags;
      ss >> num_string_tags;
      std::string dataname;
      for (int i = 0; i < num_string_tags; ++i) {
        getline(meshStream, line);  // get string tag
        if (i == 0) {
          std::stringstream ss(line);
          ss >> dataname;
        }
      }
      dataname.erase(std::remove(dataname.begin(), dataname.end(), '\"'),
                     dataname.end());
      cellDataNames.push_back(dataname);
      getline(meshStream, line);  // moving to num_real_tags
      std::stringstream ss1(line);
      int num_real_tags;
      ss1 >> num_real_tags;
      for (int i = 0; i < num_real_tags; ++i) getline(meshStream, line);

      getline(meshStream, line);  // moving to num_int_tags
      std::stringstream ss2(line);
      int num_int_tags;
      ss2 >> num_int_tags;
      int dt, dim, numFields, tmp;
      for (int i = 0; i < num_int_tags; ++i) {
        getline(meshStream, line);  // get int tag
        std::stringstream ss(line);
        if (i == 0)
          ss >> dt;
        else if (i == 1)
          ss >> dim;
        else if (i == 2)
          ss >> numFields;
        else
          ss >> tmp;
      }
      for (int i = 0; i < numFields; ++i) {
        std::vector<double> data(dim);
        int id;
        double val;
        getline(meshStream, line);
        std::stringstream ss(line);
        ss >> id;
        for (int j = 0; j < dim; ++j) {
          ss >> val;
          data[j] = val;
        }
        currCellData.push_back(data);
      }
      cellData.push_back(currCellData);
    }
  }

  if (fndPhyGrp) {
    cellDataNames.push_back("PhysGrpId");
    cellData.push_back(cellPhysGrpIds);
  }

  vtkMesh *vtkmesh = new vtkMesh();
  // vtkmesh->dataSet = dataSet_tmp->NewInstance();
  // vtkmesh->dataSet->DeepCopy(dataSet_tmp);
  vtkmesh->dataSet = dataSet_tmp;
  vtkmesh->numCells = vtkmesh->dataSet->GetNumberOfCells();
  if (numCells == 0) std::cerr << "Warning: No cells were found in the mesh!\n";
  vtkmesh->numPoints = vtkmesh->dataSet->GetNumberOfPoints();
  if (numPoints == 0)
    std::cerr << "Warning: No points were found in the mesh!\n";

  if (numPoints > 0) {
    for (int i = 0; i < pointData.size(); ++i)
      vtkmesh->setPointDataArray(&(pointDataNames[i])[0u], pointData[i]);
  }

  if (numCells > 0) {
    for (int i = 0; i < cellData.size(); ++i)
      vtkmesh->setCellDataArray(&(cellDataNames[i])[0u], cellData[i]);
  }

  // vtkmesh->setFileName(nemAux::trim_fname(fname, ".vtu"));
  // vtkmesh->write();
  std::cout << "vtkMesh constructed" << std::endl;

  return vtkmesh;
}

exportPntToVtk()

meshBase * meshBase::exportPntToVtk ( const std::string &  fname )

staticinherited

exports pntMesh to vtk format

Parameters

fname

name of mesh file

Returns

<>

Definition at line 848 of file meshBase.C.

References meshBase::dataSet, PNTMesh::pntMesh::getElmConn(), PNTMesh::pntMesh::getElmOrder(), PNTMesh::pntMesh::getElmType(), PNTMesh::pntMesh::getNumberOfCells(), PNTMesh::pntMesh::getNumberOfPoints(), PNTMesh::pntMesh::getPointCrd(), PNTMesh::pntMesh::getVtkCellTag(), NEM::MSH::New(), meshBase::numCells, meshBase::numPoints, points, meshBase::setFileName(), and nemAux::trim_fname().

                                                         {
  PNTMesh::pntMesh *pMesh;
  pMesh = new PNTMesh::pntMesh(fname);

  vtkMesh *vtkmesh = new vtkMesh();

  /*
  if (!pMesh->isCompatible())
  {
    std::cerr << "Mesh contains unsupported element types.\n";
    std::cerr << "Only 3-Node TRIs and 4-Node TETs are supported.\n";
    vtkmesh->numCells = 0;
    vtkmesh->numPoints = 0;
    return vtkmesh;
  }
  */

  // declare points to be pushed into dataSet_tmp
  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
  // declare dataSet_tmp which will be associated to output vtkMesh
  vtkSmartPointer<vtkUnstructuredGrid> dataSet_tmp =
      vtkSmartPointer<vtkUnstructuredGrid>::New();

  int numPoints = pMesh->getNumberOfPoints();
  int numVolCells = pMesh->getNumberOfCells();

  // allocate memory for points
  points->SetNumberOfPoints(numPoints);
  for (int i = 0; i < numPoints; ++i) {
    std::vector<double> point;
    point = pMesh->getPointCrd(i);
    // insert point i
    points->SetPoint(i, &point[0]);
  }
  // inserting point array into dataSet_tmp
  dataSet_tmp->SetPoints(points);

  // allocating space for cell connectivities
  dataSet_tmp->Allocate(numVolCells);
  for (int i = 0; i < numVolCells; ++i) {
    std::cout << "Element " << i << std::endl;
    vtkSmartPointer<vtkIdList> vtkcellIds = vtkSmartPointer<vtkIdList>::New();
    std::vector<int> conn;
    VTKCellType vct =
        pMesh->getVtkCellTag(pMesh->getElmType(i), pMesh->getElmOrder(i));
    conn = pMesh->getElmConn(i, vct);
    for (int j = 0; j < conn.size(); ++j) {
      // insert connectivies for cell into cellIds container
      vtkcellIds->InsertNextId(conn[j]);
    }
    // insert connectivies
    dataSet_tmp->InsertNextCell(vct, vtkcellIds);
  }

  vtkmesh->dataSet = dataSet_tmp;
  vtkmesh->numCells = vtkmesh->dataSet->GetNumberOfCells();
  vtkmesh->numPoints = vtkmesh->dataSet->GetNumberOfPoints();

  //
  std::cout << "Trimmed name = " << nemAux::trim_fname(fname, ".vtu")
            << std::endl;
  vtkmesh->setFileName(nemAux::trim_fname(fname, ".vtu"));
  // vtkmesh->write();
  std::cout << "vtkMesh constructed" << std::endl;

  return vtkmesh;
}

exportVolToVtk()

meshBase * meshBase::exportVolToVtk ( const std::string &  fname )

staticinherited

Parameters

fname

name of mesh file

Returns

<>

Definition at line 766 of file meshBase.C.

References meshBase::dataSet, NEM::MSH::New(), meshBase::numCells, meshBase::numPoints, points, meshBase::setFileName(), and nemAux::trim_fname().

Referenced by NEM::DRV::NetgenMeshGenDriver::execute(), and NEM::DRV::MeshGenDriver::MeshGenDriver().

                                                         {
#ifdef HAVE_NGEN
  nglib::Ng_Mesh *Ngmesh;
  nglib::Ng_Init();
  Ngmesh = nglib::Ng_NewMesh();

  int status = nglib::Ng_MergeMesh(Ngmesh, &fname[0u]);
  if (status) {
    std::cout << "Error: NetGen Returned: " << status << std::endl;
    std::cout << "Could not load " << fname << " into netgen" << std::endl;
    exit(1);
  }

  // declare points to be pushed into dataSet_tmp
  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
  // declare dataSet_tmp which will be associated to output vtkMesh
  vtkSmartPointer<vtkUnstructuredGrid> dataSet_tmp =
      vtkSmartPointer<vtkUnstructuredGrid>::New();
  int numNgPoints = nglib::Ng_GetNP(Ngmesh);
  int numSurfCells = nglib::Ng_GetNSE(Ngmesh);
  int numVolCells = nglib::Ng_GetNE(Ngmesh);

  // allocate memory for points
  points->SetNumberOfPoints(numNgPoints);
  for (int i = 1; i <= numNgPoints; ++i) {
    double point[3];
    nglib::Ng_GetPoint(Ngmesh, i, point);
    // insert point i
    points->SetPoint(i - 1, point);
  }
  // inserting point array into dataSet_tmp
  dataSet_tmp->SetPoints(points);

  // allocating space for cell connectivities
  dataSet_tmp->Allocate(numSurfCells + numVolCells);

  for (int i = 1; i <= numSurfCells; ++i) {
    vtkSmartPointer<vtkIdList> vtkcellIds = vtkSmartPointer<vtkIdList>::New();
    int tri[3];
    nglib::Ng_GetSurfaceElement(Ngmesh, i, tri);
    for (int j = 0; j < 3; ++j) {
      // insert connectivies for cell into cellIds container
      vtkcellIds->InsertNextId(tri[j] - 1);
    }
    // insert connectivies for triangle elements into dataSet
    dataSet_tmp->InsertNextCell(VTK_TRIANGLE, vtkcellIds);
  }

  for (int i = 1; i <= numVolCells; ++i) {
    vtkSmartPointer<vtkIdList> vtkcellIds = vtkSmartPointer<vtkIdList>::New();
    int tet[4];
    nglib::Ng_GetVolumeElement(Ngmesh, i, tet);
    for (int j = 0; j < 4; ++j) {
      // insert connectivies for cell into cellIds container
      vtkcellIds->InsertNextId(tet[j] - 1);
    }
    // insert connectivies for triangle elements into dataSet
    dataSet_tmp->InsertNextCell(VTK_TETRA, vtkcellIds);
  }

  vtkMesh *vtkmesh = new vtkMesh();
  // vtkmesh->dataSet = dataSet_tmp->NewInstance();//
  // vtkmesh->dataSet->DeepCopy(dataSet_tmp);//vtkDataSet::SafeDownCast(dataSet_tmp));
  vtkmesh->dataSet = dataSet_tmp;
  vtkmesh->numCells = vtkmesh->dataSet->GetNumberOfCells();
  vtkmesh->numPoints = vtkmesh->dataSet->GetNumberOfPoints();

  vtkmesh->setFileName(nemAux::trim_fname(fname, ".vtu"));
  std::cout << "vtkMesh constructed" << std::endl;

  if (Ngmesh) nglib::Ng_DeleteMesh(Ngmesh);
  nglib::Ng_Exit();
  return vtkmesh;
#else
  std::cerr << "ENABLE_NETGEN is not used during build."
            << " Build with ENABLE_NETGEN to use this function." << std::endl;
  exit(1);
#endif
}

extractSelectedCells() [1/2]

meshBase * meshBase::extractSelectedCells ( meshBase *  mesh, const std::vector< nemId_t > &  cellIds  )

staticinherited

Parameters

mesh	The meshBase object to extract the subset from.
cellIds	<>

Returns

meshBase object representing the subset

Definition at line 226 of file meshBase.C.

References meshBase::getDataSet(), and NEM::MSH::New().

                                                                            {
  vtkSmartPointer<vtkIdTypeArray> selectionIds =
      vtkSmartPointer<vtkIdTypeArray>::New();
  selectionIds->SetNumberOfComponents(1);
  for (const auto &cellId : cellIds) {
    selectionIds->InsertNextValue(cellId);
  }
  return extractSelectedCells(mesh->getDataSet(), selectionIds);
}

extractSelectedCells() [2/2]

meshBase * meshBase::extractSelectedCells ( vtkSmartPointer< vtkDataSet >  mesh, vtkSmartPointer< vtkIdTypeArray >  cellIds  )

staticinherited

Parameters

mesh	The meshBase object to extract the subset from.
cellIds	<>

Returns

meshBase object representing the subset

Definition at line 239 of file meshBase.C.

References meshBase::Create(), and NEM::MSH::New().

                                                                               {
  vtkSmartPointer<vtkSelectionNode> selectionNode =
      vtkSmartPointer<vtkSelectionNode>::New();
  selectionNode->SetFieldType(vtkSelectionNode::CELL);
  selectionNode->SetContentType(vtkSelectionNode::INDICES);
  selectionNode->SetSelectionList(cellIds);
  // create the selection
  vtkSmartPointer<vtkSelection> selection =
      vtkSmartPointer<vtkSelection>::New();
  selection->AddNode(selectionNode);
  // creating extractor
  vtkSmartPointer<vtkExtractSelection> extractSelection =
      vtkSmartPointer<vtkExtractSelection>::New();
  // set stitch surf as input on first port
  extractSelection->SetInputData(0, mesh);
  // set selectionNode as input on second port
  extractSelection->SetInputData(1, selection);
  extractSelection->Update();
  vtkSmartPointer<vtkDataSet> extractedCellMesh =
      vtkDataSet::SafeDownCast(extractSelection->GetOutput());
  meshBase *selectedCellMesh =
      meshBase::Create(extractedCellMesh, "extracted.vtu");
  return selectedCellMesh;
}

extractSurface()

vtkSmartPointer< vtkDataSet > FOAM::foamMesh::extractSurface ( )

overridevirtual

Implements meshBase.

Definition at line 340 of file foamMesh.C.

References meshBase::dataSet, and NEM::MSH::New().

                                                     {
  // extract surface polygons
  vtkSmartPointer<vtkDataSetSurfaceFilter> surfFilt =
      vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
  surfFilt->SetInputData(dataSet);
  surfFilt->Update();

  // triangulate the surface
  vtkSmartPointer<vtkTriangleFilter> triFilt =
      vtkSmartPointer<vtkTriangleFilter>::New();
  triFilt->SetInputData(surfFilt->GetOutput());
  triFilt->Update();

  return triFilt->GetOutput();
}

generateSizeField()

void meshBase::generateSizeField ( const std::string &  method, int  arrayID, double  dev_mlt, bool  maxIsmin, double  sizeFactor = 1.0, int  order = 1  )

inherited

Parameters

method	(e.g., "gradient", "value", "error estimator")
arrayID	<>
dev_mlt	used to determine which cells to consider for refinement
maxIsmin	used to determine which cells to consider for refinement
sizeFactor	<>
order	<>

Definition at line 396 of file meshBase.C.

References NEM::ADP::SizeFieldBase::computeSizeField(), NEM::ADP::SizeFieldBase::CreateUnique(), and NEM::ADP::SizeFieldBase::setSizeFactor().

Referenced by NEM::ADP::Refine::Refine().

                                                               {
  std::cout << "Size Factor = " << sizeFactor << std::endl;
  std::unique_ptr<NEM::ADP::SizeFieldBase> sfobj =
      NEM::ADP::SizeFieldBase::CreateUnique(dataSet, method, arrayID, dev_mult,
                                            maxIsmin, sizeFactor, order);
  sfobj->setSizeFactor(sizeFactor);
  sfobj->computeSizeField(dataSet->GetPointData()->GetArray(arrayID));
}

genMshDB()

void FOAM::foamMesh::genMshDB ( )

private

Decomposes OpenFOAM mesh into VTK unstructured dataset.

Definition at line 136 of file foamMesh.C.

References _fmesh, meshBase::dataSet, meshBase::numCells, and meshBase::numPoints.

Referenced by read(), and readAMR().

                        {
  // creating equivalent vtk topology from fvMesh
  // by default polyhedral cells will be decomposed to
  // tets and pyramids. Additional points will be added
  // to underlying fvMesh.
  std::cout << "Performing topological decomposition.\n";
  auto objVfoam = Foam::vtk::vtuAdaptor();
  dataSet = objVfoam.internal(*_fmesh);

  // Obtaining the mesh data and generating requested output file
  numPoints = dataSet->GetNumberOfPoints();
  numCells = dataSet->GetNumberOfCells();
  std::cout << "Number of points " << numPoints << std::endl;
  std::cout << "Number of cells " << numCells << std::endl;
}

getArrayIDs()

std::vector< int > meshBase::getArrayIDs ( std::vector< std::string >  arrayNames, bool  fromPointArrays = false  )

inherited

Definition at line 1835 of file meshBase.C.

References id.

                                                             {
  std::vector<int> arrayIDs(arrayNames.size());
  for (int i = 0; i < arrayNames.size(); ++i) {
    int id = IsArrayName(arrayNames[i], fromPointArrays);
    if (id == -1) {
      std::cerr << "Array " << arrayNames[i]
                << " not found in set of data arrays." << std::endl;
      exit(1);
    }
    arrayIDs[i] = id;
  }
  return arrayIDs;
}

getCell()

std::map< nemId_t, std::vector< double > > FOAM::foamMesh::getCell ( nemId_t  id ) const

overridevirtual

Parameters

id	VTK cell ID

Returns

a map of cell ID to its bounding point IDs.

Implements meshBase.

Definition at line 175 of file foamMesh.C.

References meshBase::dataSet, getPoint(), NEM::MSH::New(), and meshBase::numCells.

                                                                     {
  if (id < numCells) {
    std::map<nemId_t, std::vector<double>> cell;
    vtkSmartPointer<vtkIdList> point_ids = vtkSmartPointer<vtkIdList>::New();
    point_ids = dataSet->GetCell(id)->GetPointIds();
    vtkIdType num_ids = point_ids->GetNumberOfIds();
    for (vtkIdType i = 0; i < num_ids; ++i) {
      nemId_t pntId = point_ids->GetId(i);
      std::vector<double> coord = getPoint(pntId);
      cell.insert(std::pair<nemId_t, std::vector<double>>(pntId, coord));
    }

    return cell;
  } else {
    std::cerr << "Cell ID is out of range!" << std::endl;
    exit(1);
  }
}

getCellCenter()

std::vector< double > FOAM::foamMesh::getCellCenter ( nemId_t  cellID ) const

overridevirtual

Parameters

cellID

VTK cell ID

Returns

Vector of cell center coordinates.

Implements meshBase.

Definition at line 327 of file foamMesh.C.

References getCellVec().

                                                              {
  std::vector<double> center(3, 0.0);
  std::vector<std::vector<double>> cell = getCellVec(cellID);

  using nemAux::operator*;  // for vector multiplication.
  using nemAux::operator+;  // for vector addition.
  for (int i = 0; i < cell.size(); ++i) { center = center + cell[i]; }
  return (1. / cell.size()) * center;
}

getCellDataArray() [1/2]

virtual void meshBase::getCellDataArray ( const std::string &  name, std::vector< double > &  data  )

inlinevirtualinherited

Parameters

name	<>
data	<>

Reimplemented in vtkMesh.

Definition at line 369 of file meshBase.H.

Referenced by NEM::GEO::rocPack::createCohesiveElements(), NEM::DRV::ConversionDriver::genExo(), cgnsAnalyzer::overwriteSolData(), and vtkMesh::write().

                                                         {}

getCellDataArray() [2/2]

virtual void meshBase::getCellDataArray ( int  arrayId, std::vector< double > &  data  )

inlinevirtualinherited

Parameters

arrayId	<>
data	<>

Reimplemented in vtkMesh.

Definition at line 376 of file meshBase.H.

{}

getCellDataIdx()

virtual int meshBase::getCellDataIdx ( const std::string &  name )

inlinevirtualinherited

Parameters

name

<>

Returns

<>

Reimplemented in vtkMesh, and meshSrch.

Definition at line 363 of file meshBase.H.

Referenced by vtkMesh::write().

{ return 0; }

getCellLengths()

std::vector< double > FOAM::foamMesh::getCellLengths ( ) const

overridevirtual

Returns

Vector of diameter of circumsphere of each cell

Implements meshBase.

Definition at line 317 of file foamMesh.C.

References meshBase::dataSet, and meshBase::getNumberOfCells().

                                                 {
  std::vector<double> result;
  result.resize(getNumberOfCells());
  for (nemId_t i = 0; i < getNumberOfCells(); ++i) {
    result[i] = std::sqrt(dataSet->GetCell(i)->GetLength2());
  }
  return result;
}

getCellType()

int FOAM::foamMesh::getCellType ( ) const

overridevirtual

assumes all elements are the same type

Implements meshBase.

Definition at line 338 of file foamMesh.C.

References meshBase::dataSet.

{ return dataSet->GetCellType(0); }

getCellVec()

std::vector< std::vector< double > > FOAM::foamMesh::getCellVec ( nemId_t  id ) const

overridevirtual

Parameters

id	VTK cell ID

Returns

Vector of cell point ids with their coordinates.

Implements meshBase.

Definition at line 194 of file foamMesh.C.

References meshBase::dataSet, getPoint(), NEM::MSH::New(), and meshBase::numCells.

Referenced by getCellCenter().

                                                                  {
  if (id < numCells) {
    std::vector<std::vector<double>> cell;
    vtkSmartPointer<vtkIdList> point_ids = vtkSmartPointer<vtkIdList>::New();
    point_ids = dataSet->GetCell(id)->GetPointIds();
    vtkIdType num_ids = point_ids->GetNumberOfIds();
    cell.resize(num_ids);
    for (vtkIdType i = 0; i < num_ids; ++i) {
      nemId_t pntId = point_ids->GetId(i);
      cell[i] = getPoint(pntId);
    }
    return cell;
  } else {
    std::cerr << "Cell ID is out of range!" << std::endl;
    exit(1);
  }
}

getConnectivities()

std::vector< nemId_t > FOAM::foamMesh::getConnectivities ( ) const

overridevirtual

Returns

Vector of points

Implements meshBase.

Definition at line 238 of file foamMesh.C.

References meshBase::dataSet.

                                                     {
  std::vector<nemId_t> connectivities;
  vtkSmartPointer<vtkCellIterator> it =
      vtkSmartPointer<vtkCellIterator>::Take(dataSet->NewCellIterator());
  for (it->InitTraversal(); !it->IsDoneWithTraversal(); it->GoToNextCell()) {
    vtkSmartPointer<vtkIdList> pointIds = it->GetPointIds();
    for (vtkIdType i = 0; i < pointIds->GetNumberOfIds(); ++i) {
      connectivities.push_back(pointIds->GetId(i));
    }
  }
  return connectivities;
}

getDataSet()

vtkSmartPointer<vtkDataSet> meshBase::getDataSet ( ) const

inlineinherited

Returns

this mesh's dataSet

Definition at line 308 of file meshBase.H.

Referenced by MeshQuality::checkMesh(), OrderOfAccuracy::computeDiff(), OrderOfAccuracy::computeRichardsonExtrapolation(), ConservativeVolumeTransfer::ConservativeVolumeTransfer(), ConservativeVolumeTransfer::constructSupermesh(), NEM::GEO::rocPack::createCohesiveElements(), diffMesh(), NEM::DRV::FoamToVtkConversionDriver::execute(), meshBase::extractSelectedCells(), FETransfer::FETransfer(), NEM::DRV::ConversionDriver::freeSurfaceSideSet(), NEM::DRV::ConversionDriver::genExo(), proteusHdf5::get2dCellNodeOrder(), proteusHdf5::getBoundarySideSets(), gmshMesh::gmshMesh(), NEM::ADP::Refine::initAdaptive(), meshPartitioner::meshPartitioner(), MeshQuality::MeshQuality(), OrderOfAccuracy::OrderOfAccuracy(), PNTMesh::pntMesh::pntMesh(), PNTMesh::pntMesh::pntPopulate(), FETransfer::run(), TransferBase::transferCellData(), FETransfer::transferCellData(), ConservativeSurfaceTransfer::transferPointData(), FETransfer::transferPointData(), TransferBase::transferPointData(), meshBase::writeCobalt(), and ConservativeSurfaceTransfer::writeOverlay().

{ return dataSet; }

getFileName()

const std::string& meshBase::getFileName ( ) const

inlineinherited

Returns

The current value of the private variable "filename"

Definition at line 680 of file meshBase.H.

Referenced by MeshQuality::checkMesh(), and meshBase::partition().

{ return filename; }

getGlobToPartCellMap()

std::map<nemId_t, nemId_t> meshBase::getGlobToPartCellMap ( )

inlineinherited

Note

These are only generated if mesh is one of the partitions returned from a call to meshBase::partition

Definition at line 571 of file meshBase.H.

References globToPartCellMap.

                                                  {
    return globToPartCellMap;
  }

getGlobToPartNodeMap()

std::map<nemId_t, nemId_t> meshBase::getGlobToPartNodeMap ( )

inlineinherited

Note

These are only generated if mesh is one of the partitions returned from a call to meshBase::partition

Definition at line 563 of file meshBase.H.

References globToPartNodeMap.

                                                  {
    return globToPartNodeMap;
  }

getMetadata()

vtkSmartPointer<vtkModelMetadata> meshBase::getMetadata ( )

inlineinherited

Definition at line 443 of file meshBase.H.

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

{ return metadata; }

getNewArrayNames()

std::vector<std::string> meshBase::getNewArrayNames ( )

inlineinherited

Definition at line 698 of file meshBase.H.

Referenced by OrderOfAccuracy::computeRichardsonExtrapolation(), NEM::ADP::Refine::run(), and vtkMesh::vtkMesh().

{ return newArrayNames; }

getNumberOfCells()

nemId_t meshBase::getNumberOfCells ( ) const

inlineinherited

Returns

The number of cells.

Definition at line 550 of file meshBase.H.

Referenced by MeshQuality::checkMesh(), meshSrch::chkDuplElm(), NEM::GEO::rocPack::createCohesiveElements(), diffMesh(), meshSrch::FindCellsInPolyData(), NEM::DRV::ConversionDriver::genExo(), getCellLengths(), vtkMesh::getCellLengths(), meshPartitioner::meshPartitioner(), PNTMesh::pntMesh::pntMesh(), FETransfer::transferCellData(), and meshBase::writeCobalt().

{ return numCells; }

getNumberOfPoints()

nemId_t meshBase::getNumberOfPoints ( ) const

inlineinherited

Returns

The number of points.

Definition at line 545 of file meshBase.H.

Referenced by OrderOfAccuracy::computeDiff(), OrderOfAccuracy::computeRichardsonExtrapolation(), diffMesh(), meshSrch::FindPntsOnEdge(), meshSrch::FindPntsOnTriSrf(), NEM::DRV::ConversionDriver::genExo(), NEM::GEO::rocPack::geomToVTK(), meshPartitioner::meshPartitioner(), OrderOfAccuracy::OrderOfAccuracy(), PNTMesh::pntMesh::pntMesh(), FETransfer::transferCellData(), and FETransfer::transferPointData().

{ return numPoints; }

getPartToGlobCellMap()

std::map<nemId_t, nemId_t> meshBase::getPartToGlobCellMap ( )

inlineinherited

Note

These are only generated if mesh is one of the partitions returned from a call to meshBase::partition

Definition at line 587 of file meshBase.H.

References partToGlobCellMap.

                                                  {
    return partToGlobCellMap;
  }

getPartToGlobNodeMap()

std::map<nemId_t, nemId_t> meshBase::getPartToGlobNodeMap ( )

inlineinherited

Note

These are only generated if mesh is one of the partitions returned from a call to meshBase::partition

Definition at line 579 of file meshBase.H.

References partToGlobNodeMap.

                                                  {
    return partToGlobNodeMap;
  }

getPoint()

std::vector< double > FOAM::foamMesh::getPoint ( nemId_t  id ) const

overridevirtual

Parameters

id	VTK Point ID

Returns

Vector of point coordinates <X, Y, Z>

Implements meshBase.

Definition at line 153 of file foamMesh.C.

References meshBase::dataSet.

Referenced by getCell(), and getCellVec().

                                                     {
  double coords[3];
  dataSet->GetPoint(id, coords);
  std::vector<double> result(coords, coords + 3);
  return result;
}

getPointDataArray() [1/2]

virtual void meshBase::getPointDataArray ( const std::string &  name, std::vector< double > &  data  )

inlinevirtualinherited

assumes data is not allocated prior to calling

Parameters

name	<>
data	<>

Reimplemented in vtkMesh.

Definition at line 349 of file meshBase.H.

Referenced by cgnsAnalyzer::overwriteSolData(), and vtkMesh::write().

                                                          {}

getPointDataArray() [2/2]

virtual void meshBase::getPointDataArray ( int  arrayId, std::vector< double > &  data  )

inlinevirtualinherited

assumes data is not allocated prior to calling

Parameters

arrayId	<>
data	<>

Reimplemented in vtkMesh.

Definition at line 357 of file meshBase.H.

{}

getVertCrds()

std::vector< std::vector< double > > FOAM::foamMesh::getVertCrds ( ) const

overridevirtual

Returns

Vector with all vertices coordinates in mesh <vertices><X,Y,Z>

Implements meshBase.

Definition at line 161 of file foamMesh.C.

References meshBase::dataSet, and meshBase::numPoints.

                                                         {
  std::vector<std::vector<double>> comp_crds(3);
  for (int i = 0; i < 3; ++i) { comp_crds[i].resize(numPoints); }
  double coords[3];
  for (int i = 0; i < numPoints; ++i) {
    dataSet->GetPoint(i, coords);
    comp_crds[0][i] = coords[0];
    comp_crds[1][i] = coords[1];
    comp_crds[2][i] = coords[2];
  }
  return comp_crds;
}

inspectEdges()

void FOAM::foamMesh::inspectEdges ( const std::string &  ofname ) const

overridevirtual

Parameters

ofname

Output file name

Implements meshBase.

Definition at line 212 of file foamMesh.C.

References meshBase::dataSet, NEM::MSH::New(), and points.

                                                         {
  std::ofstream outputStream(ofname);
  if (!outputStream.good()) {
    std::cerr << "error opening " << ofname << std::endl;
    exit(1);
  }

  vtkSmartPointer<vtkExtractEdges> extractEdges =
      vtkSmartPointer<vtkExtractEdges>::New();
  extractEdges->SetInputData(dataSet);
  extractEdges->Update();

  vtkSmartPointer<vtkGenericCell> genCell =
      vtkSmartPointer<vtkGenericCell>::New();
  for (int i = 0; i < extractEdges->GetOutput()->GetNumberOfCells(); ++i) {
    extractEdges->GetOutput()->GetCell(i, genCell);
    vtkPoints *points = genCell->GetPoints();
    double p1[3], p2[3];
    points->GetPoint(0, p1);
    points->GetPoint(1, p2);
    double len = std::sqrt(pow(p1[0] - p2[0], 2) + pow(p1[1] - p2[1], 2) +
                           pow(p1[2] - p2[2], 2));
    outputStream << len << std::endl;
  }
}

integrateOverMesh()

std::vector< std::vector< double > > meshBase::integrateOverMesh ( const std::vector< int > &  arrayIDs )

inherited

integrated data is available per cell as vtk cell data after operation

Parameters

arrayIDs

<>

Returns

total integral for each datum is returned

Definition at line 387 of file meshBase.C.

References GaussCubature::CreateUnique(), and GaussCubature::integrateOverAllCells().

Referenced by OrderOfAccuracy::computeDiff(), OrderOfAccuracy::computeGCI_21(), and OrderOfAccuracy::computeGCI_32().

                                    {
  std::unique_ptr<GaussCubature> cubature =
      GaussCubature::CreateUnique(dataSet, arrayIDs);
  return cubature->integrateOverAllCells();
}

IsArrayName()

int meshBase::IsArrayName ( const std::string &  name, bool  pointOrCell = false  ) const

inherited

check for named array in vtk

Parameters

pointOrCell

boolean that tells the method whether to transfer point (False) or cell (True) data.

Returns

<>

Definition at line 267 of file meshBase.C.

Referenced by meshBase::writeCobalt().

                                                        {
  if (!pointOrCell) {
    vtkPointData *pd = dataSet->GetPointData();
    if (pd->GetNumberOfArrays()) {
      for (int i = 0; i < pd->GetNumberOfArrays(); ++i) {
        if (name == (pd->GetArrayName(i) ? pd->GetArrayName(i) : "NULL")) {
          return i;
        }
      }
    }
  } else {
    vtkCellData *cd = dataSet->GetCellData();
    if (cd->GetNumberOfArrays()) {
      for (int i = 0; i < cd->GetNumberOfArrays(); ++i) {
        if (name == (cd->GetArrayName(i) ? cd->GetArrayName(i) : "Null")) {
          return i;
        }
      }
    }
  }
  return -1;
}

partition()

std::vector< std::shared_ptr< meshBase > > meshBase::partition ( const meshBase *  mbObj, int  numPartitions  )

staticinherited

partition mesh into numPartition pieces (static fcn)

Parameters

mbObj	The meshBase object to partition.
numPartitions	The number of partitions to partition the mesh into

Returns

<>

Memory is managed by shared pointer, so do not call delete after use.

Definition at line 295 of file meshBase.C.

References meshBase::CreateShared(), meshBase::getFileName(), meshBase::getVertCrds(), globalNodeIds, NEM::MSH::New(), partToGlobCellMap, partToGlobNodeMap, and nemAux::trim_fname().

                                                    {
  // construct partitioner with meshBase object
  auto *mPart = new meshPartitioner(mbObj);
  if (mPart->partition(numPartitions)) {
    exit(1);
  }
  // initialize vector of meshBase partitions
  std::vector<std::shared_ptr<meshBase>> mbParts(numPartitions);
  for (int i = 0; i < numPartitions; ++i) {
    // define coordinates
    std::vector<std::vector<double>> comp_crds(mbObj->getVertCrds());
    // get partition connectivity and zero index it
    std::vector<int> vtkConn_int(mPart->getConns(i));
    std::vector<nemId_t> vtkConn(vtkConn_int.begin(), vtkConn_int.end());
    for (auto &&it : vtkConn) it -= 1;

    std::string basename(nemAux::trim_fname(mbObj->getFileName(), ""));
    basename += std::to_string(i);
    basename += ".vtu";
    // construct meshBase partition from coordinates and connectivities
    // from partitioner
    mbParts[i] = meshBase::CreateShared(
        mPart->getCrds(i, comp_crds[0]), mPart->getCrds(i, comp_crds[1]),
        mPart->getCrds(i, comp_crds[2]), vtkConn, VTK_TETRA, basename);
    // add partition id to node and cell data of mbPart
    vtkSmartPointer<vtkIntArray> nodePartitionIds =
        vtkSmartPointer<vtkIntArray>::New();
    nodePartitionIds->SetName("NodePartitionIds");
    nodePartitionIds->SetNumberOfComponents(1);
    nodePartitionIds->SetNumberOfTuples(mbParts[i]->getNumberOfPoints());
    nodePartitionIds->FillComponent(0, i);
    mbParts[i]->getDataSet()->GetPointData()->AddArray(nodePartitionIds);

    vtkSmartPointer<vtkIntArray> cellPartitionIds =
        vtkSmartPointer<vtkIntArray>::New();
    cellPartitionIds->SetName("CellPartitionIds");
    cellPartitionIds->SetNumberOfComponents(1);
    cellPartitionIds->SetNumberOfTuples(mbParts[i]->getNumberOfCells());
    cellPartitionIds->FillComponent(0, i);
    mbParts[i]->getDataSet()->GetCellData()->AddArray(cellPartitionIds);

    // add global node index array to partition
    std::map<int, int> partToGlobNodeMap(mPart->getPartToGlobNodeMap(i));
    vtkSmartPointer<vtkIdTypeArray> globalNodeIds =
        vtkSmartPointer<vtkIdTypeArray>::New();
    globalNodeIds->SetName("GlobalNodeIds");
    globalNodeIds->SetNumberOfComponents(1);
    globalNodeIds->SetNumberOfTuples(mbParts[i]->getNumberOfPoints());
    globalNodeIds->SetNumberOfValues(mbParts[i]->getNumberOfPoints());
    auto it = partToGlobNodeMap.begin();
    int idx = 0;
    while (it != partToGlobNodeMap.end()) {
      int globidx = it->second - 1;
      int locidx = it->first - 1;
      globalNodeIds->SetTuple1(idx, globidx);
      mbParts[i]->globToPartNodeMap[globidx] = locidx;
      mbParts[i]->partToGlobNodeMap[locidx] = globidx;
      ++idx;
      ++it;
    }
    mbParts[i]->getDataSet()->GetPointData()->AddArray(globalNodeIds);
    // add global cell index array to partition
    std::map<int, int> partToGlobCellMap(mPart->getPartToGlobElmMap(i));
    // vtkSmartPointer<vtkIdTypeArray> globalCellIds =
    // vtkSmartPointer<vtkIdTypeArray>::New();
    // globalCellIds->SetName("GlobalCellIds");
    // globalCellIds->SetNumberOfComponents(1);
    // globalCellIds->SetNumberOfTuples(mbPart->getNumberOfCells());
    // globalCellIds->SetNumberOfValues(mbPart->getNumberOfCells());
    it = partToGlobCellMap.begin();
    idx = 0;
    while (it != partToGlobCellMap.end()) {
      int globidx = it->second - 1;
      int locidx = it->first - 1;
      //    globalCellIds->SetTuple1(idx,globidx);
      mbParts[i]->globToPartCellMap[globidx] = locidx;
      mbParts[i]->partToGlobCellMap[locidx] = globidx;
      ++idx;
      ++it;
    }
    // mbPart->getDataSet()->GetCellData()->AddArray(globalCellIds);
    mbParts[i]->write();
    // mbParts[i] = mbPart;
  }
  delete mPart;
  mPart = nullptr;
  return mbParts;
}

read()

void FOAM::foamMesh::read ( const std::string &  fname )

overridevirtual

Parameters

fname

File name to read the mesh from.

Implements meshBase.

Definition at line 99 of file foamMesh.C.

References _args, _fmesh, _runTime, and genMshDB().

Referenced by foamMesh().

                                          {
  // openFOAM's mesh information is distributed through
  // multiple files therefore fname is meaningless
  // this implementation reads current working directory
  // and finds mesh data files automatically if they exist
  // TODO: Error out when information are not existing

  _fmesh = nullptr;

  // reading mesh database and converting
  Foam::word regionName;
  if (_args->readIfPresent("region", regionName)) {
    Foam::Info << "Create mesh " << regionName
               << " for time = " << _runTime->timeName() << Foam::nl
               << Foam::endl;
  } else {
    if (fname == "domain1")
      regionName = "domain1";
    else if (fname == "domain0")
      regionName = "domain0";
    else if (fname == "domain2")
      regionName = "domain2";
    else if (fname == "domain100")
      regionName = "domain100";
    else {
      regionName = Foam::fvMesh::defaultRegion;
      Foam::Info << "Create mesh for time = " << _runTime->timeName()
                 << Foam::nl << Foam::endl;
    }
  }

  _fmesh = new Foam::fvMesh(Foam::IOobject(
      regionName, _runTime->timeName(), *_runTime, Foam::IOobject::MUST_READ));

  genMshDB();
}

readAMR()

void FOAM::foamMesh::readAMR

(

const Foam::Time &

runTime

)

Parameters

runTime

OpenFOAM Time class object

Definition at line 567 of file foamMesh.C.

References _fmesh, and genMshDB().

                                              {
  _fmesh = new Foam::fvMesh(Foam::IOobject(Foam::fvMesh::defaultRegion,
                                           runTime.timeName(), runTime,
                                           Foam::IOobject::MUST_READ));

  genMshDB();
}

refineMesh() [1/5]

void meshBase::refineMesh ( const std::string &  method, int  arrayID, double  dev_mult, bool  maxIsmin, double  edge_scale, const std::string &  ofname, bool  transferData, double  sizeFactor = 1., bool  constrainBoundary = false  )

inherited

edge_scale is for uniform refinement and is ignored in calls where method is "gradient", "value", etc.

Parameters

method	<>
arrayID	<>
dev_mult	<>
maxIsmin	<>
edge_scale	<>
ofname	<>
transferData	<>
sizeFactor	<>

instead of "uniform"

Definition at line 1565 of file meshBase.C.

References NEM::ADP::Refine::run().

Referenced by OrderOfAccuracy::computeMeshWithResolution(), and proteusHdf5::proteusHdf5().

                                                                     {
#ifdef HAVE_GMSH
  std::unique_ptr<NEM::ADP::Refine> refineobj =
      std::unique_ptr<NEM::ADP::Refine>(
          new NEM::ADP::Refine(this, method, arrayID, dev_mult, maxIsmin,
                               edge_scale, ofname, sizeFactor));
  refineobj->run(transferData, constrainBoundary);
#else
  std::cerr << "Cannot use meshBase::refineMesh without Gmsh. Please configure "
               "with ENABLE_GMSH=ON.\n";
#endif
}

refineMesh() [2/5]

void meshBase::refineMesh ( const std::string &  method, const std::string &  arrayName, double  dev_mult, bool  maxIsmin, double  edge_scale, const std::string &  ofname, bool  transferData, double  sizeFactor = 1.  )

inherited

edge_scale is for uniform refinement and is ignored in calls where method is "gradient", "value", etc.

Parameters

method	<>
arrayName	<>
dev_mult	<>
maxIsmin	<>
edge_scale	<>
ofname	<>
transferData	<>
sizeFactor	<>

instead of "uniform"

Definition at line 1599 of file meshBase.C.

                                             {
  int arrayID = IsArrayName(arrayName);
  if (arrayID == -1) {
    std::cout << "Array " << arrayName
              << " not found in set of point data arrays" << std::endl;
    exit(1);
  }
  refineMesh(method, arrayID, dev_mult, maxIsmin, edge_scale, ofname,
             transferData, sizeFactor);
}

refineMesh() [3/5]

void meshBase::refineMesh ( const std::string &  method, double  edge_scale, const std::string &  ofname, bool  transferData, bool  constrainBoundary = false  )

inherited

Parameters

method	<>
edge_scale	<>
ofname	<>
transferData	<>

Definition at line 1631 of file meshBase.C.

                                                  {
  refineMesh(method, 0, 0, false, edge_scale, ofname, transferData, 1.0,
             constrainBoundary);
}

refineMesh() [4/5]

void meshBase::refineMesh ( const std::string &  method, int  arrayID, int  order, const std::string &  ofname, bool  transferData  )

inherited

Parameters

method	<>
arrayID	<>
order	<>
ofname	<>
transferData	<>

Definition at line 1583 of file meshBase.C.

References NEM::ADP::Refine::run().

                                                                      {
#ifdef HAVE_GMSH
  std::unique_ptr<NEM::ADP::Refine> refineobj =
      std::unique_ptr<NEM::ADP::Refine>(new NEM::ADP::Refine(
          this, method, arrayID, 0.0, false, 0.0, ofname, 1.0, _order));
  refineobj->run(transferData);
#else
  std::cerr << "Cannot use meshBase::refineMesh without Gmsh. Please configure "
               "with ENABLE_GMSH=ON.\n";
#endif
}

refineMesh() [5/5]

void meshBase::refineMesh ( const std::string &  method, const std::string &  arrayName, int  order, const std::string &  ofname, bool  transferData  )

inherited

Parameters

method	<>
arrayName	<>
order	<>
ofname	<>
transferData	<>

Definition at line 1616 of file meshBase.C.

                                                                      {
  int arrayID = IsArrayName(arrayName);
  if (arrayID == -1) {
    std::cout << "Array " << arrayName
              << " not found in set of point data arrays" << std::endl;
    exit(1);
  }

  refineMesh(method, arrayID, order, ofname, transferData);
}

report()

void FOAM::foamMesh::report ( ) const

overridevirtual

Reimplemented from meshBase.

Definition at line 251 of file foamMesh.C.

References meshBase::dataSet, meshBase::filename, meshBase::numCells, and meshBase::numPoints.

                            {
  if (!dataSet) {
    std::cout << "dataSet has not been populated!" << std::endl;
    exit(1);
  }

  using CellContainer = std::map<int, int>;
  // Generate a report
  std::cout << "Processing the dataset generated from " << filename << std::endl
            << " dataSet contains a " << dataSet->GetClassName() << " that has "
            << numCells << " cells"
            << " and " << numPoints << " points." << std::endl;

  CellContainer cellMap;
  for (int i = 0; i < numCells; i++) { cellMap[dataSet->GetCellType(i)]++; }

  CellContainer::const_iterator it = cellMap.begin();
  while (it != cellMap.end()) {
    std::cout << "\tCell type "
              << vtkCellTypes::GetClassNameFromTypeId(it->first) << " occurs "
              << it->second << " times." << std::endl;
    ++it;
  }

  // Now check for point data
  vtkPointData *pd = dataSet->GetPointData();
  if (pd) {
    std::cout << " contains point data with " << pd->GetNumberOfArrays()
              << " arrays." << std::endl;
    for (int i = 0; i < pd->GetNumberOfArrays(); i++) {
      std::cout << "\tArray " << i << " is named "
                << (pd->GetArrayName(i) ? pd->GetArrayName(i) : "NULL");
      vtkDataArray *da = pd->GetArray(i);
      std::cout << " with " << da->GetNumberOfTuples() << " values. "
                << std::endl;
    }
  }
  // Now check for cell data
  vtkCellData *cd = dataSet->GetCellData();
  if (cd) {
    std::cout << " contains cell data with " << cd->GetNumberOfArrays()
              << " arrays." << std::endl;
    for (int i = 0; i < cd->GetNumberOfArrays(); i++) {
      std::cout << "\tArray " << i << " is named "
                << (cd->GetArrayName(i) ? cd->GetArrayName(i) : "NULL");
      vtkDataArray *da = cd->GetArray(i);
      std::cout << " with " << da->GetNumberOfTuples() << " values. "
                << std::endl;
    }
  }
  // Now check for field data
  if (dataSet->GetFieldData()) {
    std::cout << " contains field data with "
              << dataSet->GetFieldData()->GetNumberOfArrays() << " arrays."
              << std::endl;
    for (int i = 0; i < dataSet->GetFieldData()->GetNumberOfArrays(); i++) {
      std::cout << "\tArray " << i << " is named "
                << dataSet->GetFieldData()->GetArray(i)->GetName();
      vtkDataArray *da = dataSet->GetFieldData()->GetArray(i);
      std::cout << " with " << da->GetNumberOfTuples() << " values. "
                << std::endl;
    }
  }
}

setCellDataArray() [1/2]

virtual void meshBase::setCellDataArray ( const std::string &  name, const std::vector< std::vector< double >> &  data  )

inlinevirtualinherited

Parameters

name	<>
data	<>

Reimplemented in vtkMesh.

Definition at line 334 of file meshBase.H.

Referenced by hdf5Reader::setFields(), and vtkMesh::write().

                                                                          {}

setCellDataArray() [2/2]

virtual void meshBase::setCellDataArray ( const std::string &  name, const std::vector< double > &  data  )

inlinevirtualinherited

Parameters

name	<>
data	<>

Reimplemented in vtkMesh.

Definition at line 341 of file meshBase.H.

                                                               {}

setCheckQuality()

void meshBase::setCheckQuality ( bool  x )

inlineinherited

Parameters

x

<>

Definition at line 685 of file meshBase.H.

{ checkQuality = x; }

setContBool()

void meshBase::setContBool ( bool  x )

inlineinherited

Parameters

x

<>

Definition at line 691 of file meshBase.H.

{ continuous = x; }

setFileName()

void meshBase::setFileName ( const std::string &  fname )

inlineinherited

This will allow vtk to dispatch appropriate writers based on the extension and whether it is supported by vtk.

Parameters

fname

The name to set the private variable "filename" to

Definition at line 675 of file meshBase.H.

Referenced by meshBase::exportExoToVtk(), meshBase::exportPntToVtk(), meshBase::exportVolToVtk(), NEM::ADP::Refine::run(), and vtkMesh::vtkMesh().

{ filename = fname; }

setMetadata()

void meshBase::setMetadata ( vtkSmartPointer< vtkModelMetadata >  _metadata )

inlineinherited

Definition at line 440 of file meshBase.H.

Referenced by proteusHdf5::proteusHdf5().

                                                                {
    metadata = _metadata;
  }

setPointDataArray() [1/2]

virtual void meshBase::setPointDataArray ( const std::string &  name, const std::vector< std::vector< double >> &  data  )

inlinevirtualinherited

Parameters

name	<>
data	<>

Reimplemented in vtkMesh.

Definition at line 319 of file meshBase.H.

Referenced by hdf5Reader::setFields(), and vtkMesh::write().

                                                                           {
  }

setPointDataArray() [2/2]

virtual void meshBase::setPointDataArray ( const std::string &  name, const std::vector< double > &  data  )

inlinevirtualinherited

Parameters

name	<>
data	<>

Reimplemented in vtkMesh.

Definition at line 327 of file meshBase.H.

                                                                {}

stitchMB() [1/2]

meshBase * meshBase::stitchMB ( const std::vector< meshBase *> &  mbObjs )

staticinherited

Caller must delete object after use.

Parameters

mbObjs

a vector of meshBase objects to stich together

Returns

<>

Definition at line 196 of file meshBase.C.

References meshBase::Create(), and NEM::MSH::New().

Referenced by meshBase::stitchMB().

                                                                {
  if (!mbObjs.empty()) {
    vtkSmartPointer<vtkAppendFilter> appender =
        vtkSmartPointer<vtkAppendFilter>::New();
    appender->MergePointsOn();
    for (int i = 0; i < mbObjs.size(); ++i) {
      appender->AddInputData(mbObjs[i]->getDataSet());
    }
    appender->Update();
    return meshBase::Create(appender->GetOutput(), "stitched.vtu");
  } else {
    std::cerr << "Nothing to stitch!" << std::endl;
    exit(1);
  }
}

stitchMB() [2/2]

std::shared_ptr< meshBase > meshBase::stitchMB ( const std::vector< std::shared_ptr< meshBase >> &  _mbObjs )

staticinherited

This is the shared pointer version of stitchMB.

Parameters

mbObjs

a vector of meshBase objects to stich together

Returns

<>

Memory is managed by shared pointer, so do not call delete after use.

Definition at line 215 of file meshBase.C.

References meshBase::CreateShared(), and meshBase::stitchMB().

                                                       {
  std::vector<meshBase *> mbObjs(_mbObjs.size());
  for (int i = 0; i < mbObjs.size(); ++i) {
    mbObjs[i] = _mbObjs[i].get();
  }
  return meshBase::CreateShared(meshBase::stitchMB(mbObjs));
}

unsetCellDataArray() [1/2]

virtual void meshBase::unsetCellDataArray ( int  arrayID )

inlinevirtualinherited

Parameters

arrayID

<>

Reimplemented in vtkMesh.

Definition at line 391 of file meshBase.H.

Referenced by NEM::ADP::Refine::initAdaptive(), FETransfer::transferCellData(), and vtkMesh::write().

{}

unsetCellDataArray() [2/2]

virtual void meshBase::unsetCellDataArray ( const std::string &  name )

inlinevirtualinherited

Parameters

name

<>

Reimplemented in vtkMesh.

Definition at line 396 of file meshBase.H.

{}

unsetFieldDataArray()

virtual void meshBase::unsetFieldDataArray ( const std::string &  name )

inlinevirtualinherited

Parameters

name

<>

Reimplemented in vtkMesh.

Definition at line 401 of file meshBase.H.

Referenced by vtkMesh::write().

{}

unsetPointDataArray() [1/2]

virtual void meshBase::unsetPointDataArray ( int  arrayID )

inlinevirtualinherited

Parameters

arrayID

<>

Reimplemented in vtkMesh.

Definition at line 381 of file meshBase.H.

Referenced by FETransfer::transferPointData(), and vtkMesh::write().

{}

unsetPointDataArray() [2/2]

virtual void meshBase::unsetPointDataArray ( const std::string &  name )

inlinevirtualinherited

Parameters

name

<>

Reimplemented in vtkMesh.

Definition at line 386 of file meshBase.H.

{}

write() [1/2]

void FOAM::foamMesh::write ( const std::string &  fname ) const

overridevirtual

Parameters

fname

Output mesh file name (filename.extension)

Implements meshBase.

Definition at line 473 of file foamMesh.C.

References _volMB, mesh, NEM::MSH::New(), meshBase::numCells, and meshBase::numPoints.

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

                                                 {
  int argc = 1;
  char **argv = new char *[2];
  argv[0] = new char[100];
  strcpy(argv[0], "NONE");
  Foam::argList args(argc, argv);
  Foam::Info << "Create time\n" << Foam::endl;
  Foam::argList::noParallel();

  Foam::Time runTime(Foam::Time::controlDictName, Foam::fileName("."),
                     Foam::fileName("."));

  // Fetches VTK dataset from VTU/VTK files
  vtkSmartPointer<vtkDataSet> vtkDS = _volMB->getDataSet();

  int numPoints = vtkDS->GetNumberOfPoints();
  int numCells = vtkDS->GetNumberOfCells();

  // Gets all point numbers and coordinates
  std::vector<std::vector<double>> verticeZZ;
  verticeZZ.resize(numPoints);
  for (int ipt = 0; ipt < numPoints; ipt++) {
    std::vector<double> getPt = std::vector<double>(3);
    vtkDS->GetPoint(ipt, &getPt[0]);
    verticeZZ[ipt].resize(3);
    verticeZZ[ipt][0] = getPt[0];
    verticeZZ[ipt][1] = getPt[1];
    verticeZZ[ipt][2] = getPt[2];
  }

  // Gets Ids for cells
  std::vector<std::vector<int>> cellIdZZ;
  cellIdZZ.resize(numCells);

  // Foam point data container
  Foam::pointField pointData(numPoints);

  // Gets celltypes for all cells in mesh
  std::vector<int> typeCell;
  typeCell.resize(numCells);

  // Foam cell data container
  Foam::cellShapeList cellShapeData(numCells);

  for (int i = 0; i < numPoints; i++) {
    pointData[i] =
        Foam::vector(verticeZZ[i][0], verticeZZ[i][1], verticeZZ[i][2]);
  }

  for (int i = 0; i < numCells; i++) {
    vtkIdList *ptIds = vtkIdList::New();
    vtkDS->GetCellPoints(i, ptIds);
    int numIds = ptIds->GetNumberOfIds();
    cellIdZZ[i].resize(numIds);
    for (int j = 0; j < numIds; j++) { cellIdZZ[i][j] = ptIds->GetId(j); }

    Foam::labelList meshPoints(numIds);

    for (int k = 0; k < numIds; k++) { meshPoints[k] = cellIdZZ[i][k]; }

    typeCell[i] = vtkDS->GetCellType(i);

    if (typeCell[i] == 12) {
      cellShapeData[i] = Foam::cellShape("hex", meshPoints, true);
    } else if (typeCell[i] == 14) {
      cellShapeData[i] = Foam::cellShape("pyr", meshPoints, true);
    } else if (typeCell[i] == 10) {
      cellShapeData[i] = Foam::cellShape("tet", meshPoints, true);
    } else {
      std::cerr << "Only Hexahedral, Tetrahedral,"
                << " and Pyramid cells are supported for VTK->FOAM!"
                << std::endl;
      throw;
    }
  }

  Foam::polyMesh mesh(Foam::IOobject(Foam::polyMesh::defaultRegion,
                                     runTime.constant(), runTime),
                      std::move(pointData),       // Vertices
                      cellShapeData,              // Cell shape and points
                      Foam::faceListList(),       // Boundary faces
                      Foam::wordList(),           // Boundary Patch Names
                      Foam::wordList(),           // Boundary Patch Type
                      "defaultPatch",             // Default Patch Name
                      Foam::polyPatch::typeName,  // Default Patch Type
                      Foam::wordList()  // Boundary Patch Physical Type
  );
  // ****************************************************************** //

  std::cout << "Writing mesh for time 0" << std::endl;

  mesh.write();
}

write() [2/2]

virtual void meshBase::write ( ) const

inlinevirtualinherited

The file extension of the private var "filename" determines the format of the output file

Reimplemented in vtkMesh.

Definition at line 598 of file meshBase.H.

References meshBase::write().

Referenced by MeshQuality::checkMesh(), OrderOfAccuracy::computeMeshWithResolution(), NEM::DRV::GmshToVtkConversionDriver::execute(), NEM::DRV::GmshToExoConversionDriver::execute(), NEM::GEO::rocPack::geomToVTK(), proteusHdf5::proteusHdf5(), meshSrch::read(), NEM::ADP::Refine::run(), vtkMesh::write(), meshBase::write(), and hdf5Reader::writeVTK().

{ write(filename); }

writeCobalt() [1/2]

void meshBase::writeCobalt ( meshBase *  surfWithPatch, const std::string &  mapFile, std::ofstream &  outputStream  )

inherited

for rocstar restart hack through rflupart/prep

Parameters

surfWithPatch	<>
mapFile	<>
outputStream	<>

Definition at line 1407 of file meshBase.C.

References meshBase::buildStaticCellLocator(), meshBase::getDataSet(), meshBase::getNumberOfCells(), meshBase::IsArrayName(), NEM::MSH::New(), and writePatchMap().

                                                      {
  if (!surfWithPatches) {
    std::cout << "surface mesh is empty!" << std::endl;
    exit(1);
  }
  if (surfWithPatches->IsArrayName("patchNo", 1) == -1) {
    std::cout << "surface mesh must have patchNo cell array" << std::endl;
    exit(1);
  }
  vtkSmartPointer<vtkIdList> facePtIds;
  vtkSmartPointer<vtkIdList> sharedCellPtIds =
      vtkSmartPointer<vtkIdList>::New();
  vtkSmartPointer<vtkGenericCell> genCell1 =
      vtkSmartPointer<vtkGenericCell>::New();
  vtkSmartPointer<vtkGenericCell> genCell2 =
      vtkSmartPointer<vtkGenericCell>::New();
  std::map<std::vector<nemId_t>, std::pair<nemId_t, nemId_t>,
           sortNemId_tVec_compare>
      faceMap;
  // building cell locator for looking up patch number in remeshed surface mesh
  vtkSmartPointer<vtkStaticCellLocator> surfCellLocator =
      surfWithPatches->buildStaticCellLocator();
  // maximum number of vertices per face (to be found in proceeding loop)
  int nVerticesPerFaceMax = 0;
  // maximum number of faces per cell (to be found in proceeding loop)
  int nFacesPerCellMax = 0;

  for (nemId_t i = 0; i < this->getNumberOfCells(); ++i) {
    // get cell i
    dataSet->GetCell(i, genCell1);
    // get faces, find cells sharing it. if no cell shares it,
    // use the locator of the surfWithPatches to find the patch number
    int numFaces = genCell1->GetNumberOfFaces();
    nFacesPerCellMax =
        (nFacesPerCellMax < numFaces ? numFaces : nFacesPerCellMax);
    for (int j = 0; j < numFaces; ++j) {
      vtkCell *face = genCell1->GetFace(j);
      // bool shared = false;
      vtkIdType numVerts = face->GetNumberOfPoints();
      nVerticesPerFaceMax =
          (nVerticesPerFaceMax < numVerts ? numVerts : nVerticesPerFaceMax);
      facePtIds = face->GetPointIds();
      dataSet->GetCellNeighbors(i, facePtIds, sharedCellPtIds);
      std::vector<nemId_t> facePntIds(numVerts);
      for (vtkIdType k = 0; k < numVerts; ++k) {
        facePntIds[k] = face->GetPointId(k) + 1;
      }
      // std::cout << "sharedCellPtIds->GetNumberOfIds() = " <<
      // sharedCellPtIds->GetNumberOfIds() << std::endl;
      if (sharedCellPtIds->GetNumberOfIds()) {
        faceMap.insert(
            std::pair<std::vector<nemId_t>, std::pair<nemId_t, nemId_t>>(
                facePntIds,
                std::make_pair(i + 1, sharedCellPtIds->GetId(0) + 1)));
      } else {
        double p1[3], p2[3], p3[3];
        face->GetPoints()->GetPoint(0, p1);
        face->GetPoints()->GetPoint(1, p2);
        face->GetPoints()->GetPoint(2, p3);
        double faceCenter[3];
        for (vtkIdType k = 0; k < numVerts; ++k) {
          faceCenter[k] = (p1[k] + p2[k] + p3[k]) / 3.0;
        }
        vtkIdType closestCellId;
        int subId;
        double minDist2;
        double closestPoint[3];
        // find closest point and closest cell to faceCenter
        surfCellLocator->FindClosestPoint(faceCenter, closestPoint, genCell2,
                                          closestCellId, subId, minDist2);
        double patchNo[1];
        surfWithPatches->getDataSet()
            ->GetCellData()
            ->GetArray("patchNo")
            ->GetTuple(closestCellId, patchNo);
        faceMap.insert(
            std::pair<std::vector<nemId_t>, std::pair<nemId_t, nemId_t>>(
                facePntIds, std::make_pair(i + 1, -1 * patchNo[0])));
      }
    }
  }

  std::map<int, int> patchMap;
  for (int i = 0; i < surfWithPatches->getNumberOfCells(); ++i) {
    double patchNo[1];
    surfWithPatches->getDataSet()->GetCellData()->GetArray("patchNo")->GetTuple(
        i, patchNo);
    patchMap.insert(std::pair<int, int>(patchNo[0], i));
  }

  // write patch mapping file
  writePatchMap(mapFile, patchMap);
  // write cobalt file
  outputStream << 3 << "   " << 1 << "  " << patchMap.size() << std::endl;
  outputStream << this->getNumberOfPoints() << " " << faceMap.size() << " "
               << this->getNumberOfCells() << " " << nVerticesPerFaceMax << " "
               << nFacesPerCellMax << std::endl;
  for (int i = 0; i < this->getNumberOfPoints(); ++i) {
    std::vector<double> pnt(this->getPoint(i));
    outputStream << std::setw(21) << std::fixed << std::setprecision(15)
                 << pnt[0] << "   " << pnt[1] << "   " << pnt[2] << std::endl;
  }

  auto it = faceMap.begin();
  while (it != faceMap.end()) {
    outputStream << it->first.size() << " ";
    auto faceIdIter = it->first.begin();
    while (faceIdIter != it->first.end()) {
      outputStream << *faceIdIter << " ";
      ++faceIdIter;
    }
    outputStream << it->second.first << " " << it->second.second << std::endl;
    ++it;
  }
}

writeCobalt() [2/2]

void meshBase::writeCobalt ( meshBase *  surfWithPatch, const std::string &  mapFile, const std::string &  ofname  )

inherited

for rocstar restart hack through rflupart/prep

Parameters

surfWithPatch	<>
mapFile	<>
ofname	<>

Definition at line 1527 of file meshBase.C.

                                                    {
  std::ofstream outputStream(ofname);
  if (!outputStream.good()) {
    std::cout << "Cannot open file " << ofname << std::endl;
    exit(1);
  }
  writeCobalt(surfWithPatches, mapFile, outputStream);
}

writeMSH() [1/6]

void meshBase::writeMSH ( std::ofstream &  outputStream )

inherited

Parameters

outputStream

<>

Definition at line 1078 of file meshBase.C.

Referenced by NEM::ADP::Refine::initAdaptive().

                                                 {
  if (!outputStream.good()) {
    std::cout << "Output file stream is bad" << std::endl;
    exit(1);
  }

  if (!dataSet) {
    std::cout << "No data to write" << std::endl;
    exit(1);
  }
  // ---------  writing gmsh header ----------- //
  outputStream << "$MeshFormat" << std::endl
               << "2.2 0 8" << std::endl
               << "$EndMeshFormat" << std::endl;

  // -------- ensure all cell types are tri/tet or below -------------- //
  int type_id;
  for (int i = 0; i < numCells; i++) {
    type_id = dataSet->GetCellType(i);
    if (!(type_id == 3 || type_id == 5 || type_id == 10 || type_id == 9)) {
      std::cout << "Error: Only tetrahedral, triangular, and quadrilateral"
                << " meshes can be written to gmsh format" << std::endl;
      exit(3);
    }
  }

  // ------------------------ write point coords -------------------------- //
  outputStream << "$Nodes" << std::endl << numPoints << std::endl;
  for (int i = 0; i < numPoints; ++i) {
    std::vector<double> pntcrds = getPoint(i);
    outputStream << i + 1 << " " << pntcrds[0] << " " << pntcrds[1] << " "
                 << pntcrds[2] << " " << std::endl;
  }
  outputStream << "$EndNodes" << std::endl;

  // ------------- write element type and connectivity --------------------- //
  outputStream << "$Elements" << std::endl << numCells << std::endl;
  for (int i = 0; i < numCells; ++i) {
    vtkIdList *point_ids = dataSet->GetCell(i)->GetPointIds();
    int numComponent = point_ids->GetNumberOfIds();
    type_id = dataSet->GetCell(i)->GetCellType();
    outputStream << i + 1 << " ";
    switch (numComponent) {
      case 2: {
        outputStream << 1 << " " << 2 << " " << 1 << " " << 1 << " ";
        break;
      }
      case 3: {
        outputStream << 2 << " " << 2 << " " << 1 << " " << 1 << " ";
        break;
      }
      case 4: {
        if (type_id == 10)  // tetra
        {
          outputStream << 4 << " " << 2 << " " << 1 << " " << 1 << " ";
          break;
        } else if (type_id == 9)  // quad
        {
          outputStream << 3 << " " << 2 << " " << 1 << " " << 1 << " ";
          break;
        } else
        {
          std::cerr << "Cells with 4 components must be tet or quad."
                    << std::endl;
          exit(1);
        }
      }

      default: {
        std::cerr << "Components in cell should be <= 4" << std::endl;
        exit(1);
      }
    }
    for (int j = 0; j < numComponent; ++j)
      outputStream << point_ids->GetId(j) + 1 << " ";
    outputStream << std::endl;
  }
  outputStream << "$EndElements" << std::endl;
}

writeMSH() [2/6]

void meshBase::writeMSH ( const std::string &  fname )

inherited

Parameters

fname

The name of the file to write to

Definition at line 1549 of file meshBase.C.

                                              {
  std::ofstream outputStream(fname.c_str());
  writeMSH(outputStream);
}

writeMSH() [3/6]

void meshBase::writeMSH ( std::ofstream &  outputStream, const std::string &  pointOrCell, int  arrayID  )

inherited

Parameters

outputStream	<>
pointOrCell	<>
arrayID	<>

Definition at line 1160 of file meshBase.C.

References data.

                                                                   {
  // write points and cells
  writeMSH(outputStream);

  if (!outputStream.good()) {
    std::cout << "Output file stream is bad" << std::endl;
    exit(1);
  }

  if (!pointOrCell.compare("point")) {
    // ---------------------------- write point data -------------------------
    // //
    vtkPointData *pointData = dataSet->GetPointData();
    if (pointData) {
      int numArr = pointData->GetNumberOfArrays();
      if (arrayID >= numArr) {
        std::cout << "ERROR: arrayID is out of bounds" << std::endl;
        std::cout << "There are " << numArr << " point data arrays"
                  << std::endl;
        exit(1);
      } else if (numArr < 1) {
        std::cout << "no point data found" << std::endl;
        exit(1);
      }
      vtkDataArray *da = pointData->GetArray(arrayID);
      if (da) {
        int numComponent = da->GetNumberOfComponents();
        int numTuple = da->GetNumberOfTuples();
        std::string tmpname = "PointArray";
        tmpname += std::to_string(arrayID);
        outputStream << "$NodeData" << std::endl
                     << 1 << std::endl  // 1 string tag
                     << "\""
                     << (pointData->GetArrayName(arrayID)
                             ? pointData->GetArrayName(arrayID)
                             : tmpname)  // name of view
                     << "\"" << std::endl
                     << 0 << std::endl  // 0 real tag
                     << 3 << std::endl  // 3 int tags (dt index, dim of field,
                                        // number of fields)
                     << 0 << std::endl  // dt index
                     << numComponent << std::endl  // dim of field
                     << numTuple << std::endl;     // number of fields
        for (int j = 0; j < numTuple; ++j) {
          double *data = da->GetTuple(j);
          outputStream << j + 1 << " ";
          for (int k = 0; k < numComponent; ++k) {
            outputStream << data[k] << " ";
          }
          outputStream << std::endl;
        }
        outputStream << "$EndNodeData" << std::endl;
      }
    }
  } else if (!pointOrCell.compare("cell")) {
    // -------------------------- write cell data ----------------------------
    // //

    vtkCellData *cellData = dataSet->GetCellData();
    if (cellData) {
      int numArr = cellData->GetNumberOfArrays();
      if (arrayID >= numArr) {
        std::cout << "ERROR: arrayID is out of bounds" << std::endl;
        std::cout << "There are " << numArr << " cell data arrays" << std::endl;
        exit(1);
      } else if (numArr < 1) {
        std::cout << "no cell data found" << std::endl;
        exit(1);
      }
      vtkDataArray *da = cellData->GetArray(arrayID);
      if (da) {
        int numComponent = da->GetNumberOfComponents();
        int numTuple = da->GetNumberOfTuples();
        std::string tmpname = "CellArray";
        tmpname += std::to_string(arrayID);
        outputStream << "$ElementData" << std::endl
                     << 1 << std::endl  // 1 string tag
                     << "\""
                     << (cellData->GetArrayName(arrayID)
                             ? cellData->GetArrayName(arrayID)
                             : tmpname)  // name of view
                     << "\"" << std::endl
                     << 0 << std::endl  // 0 real tag
                     << 3 << std::endl  // 3 int tags (dt index, dim of field,
                                        // number of fields)
                     << 0 << std::endl  // dt index
                     << numComponent << std::endl  // dim of field
                     << numTuple << std::endl;     // number of fields
        for (int j = 0; j < numTuple; ++j) {
          double *data = da->GetTuple(j);
          outputStream << j + 1 << " ";
          for (int k = 0; k < numComponent; ++k) {
            outputStream << data[k] << " ";
          }
          outputStream << std::endl;
        }
        outputStream << "$EndElementData" << std::endl;
      }
    }
  }
}

writeMSH() [4/6]

void meshBase::writeMSH ( const std::string &  fname, const std::string &  pointOrCell, int  arrayID  )

inherited

Parameters

fname	The name of the file to write to
pointOrCell	<>
arrayID	<>

Definition at line 1556 of file meshBase.C.

                                                                   {
  std::ofstream outputStream(fname.c_str());
  writeMSH(outputStream, pointOrCell, arrayID);
}

writeMSH() [5/6]

void meshBase::writeMSH ( std::ofstream &  outputStream, const std::string &  pointOrCell, int  arrayID, bool  onlyVol  )

inherited

convert to gmsh format with specified point or cell data for

Parameters

outputStream	<>
pointOrCell	<>
arrayID	<>
onlyVol	<>

Definition at line 1265 of file meshBase.C.

References data.

                                      {
  if (!outputStream.good()) {
    std::cout << "Output file stream is bad" << std::endl;
    exit(1);
  }

  if (!dataSet) {
    std::cout << "No data to write" << std::endl;
    exit(2);
  }
  // ---------  writing gmsh header ----------- //
  outputStream << "$MeshFormat" << std::endl
               << "2.2 0 8" << std::endl
               << "$EndMeshFormat" << std::endl;

  // ---- get number of points and number of elements ---- //
  getNumberOfCells();
  getNumberOfPoints();

  // -------- ensure all cell types are tri/tet or below -------------- //
  int num_bad = 0;
  for (int i = 0; i < numCells; i++) {
    int type_id = dataSet->GetCellType(i);
    if (!(type_id == 3 || type_id == 5 || type_id == 10 || type_id == 9)) {
      std::cout << "Error: Only tetrahedral, triangular, and quadrilateral"
                << " meshes can be written to gmsh format" << std::endl;
      exit(3);
    }
    if (!(type_id == 10)) num_bad += 1;
  }

  // ------------------------ write point coords -------------------------- //
  outputStream << "$Nodes" << std::endl << numPoints << std::endl;
  for (int i = 0; i < numPoints; ++i) {
    std::vector<double> pntcrds = getPoint(i);
    outputStream << i + 1 << " ";
    outputStream << std::setprecision(16) << pntcrds[0] << " " << pntcrds[1]
                 << " " << pntcrds[2] << " " << std::endl;
  }
  outputStream << "$EndNodes" << std::endl;

  // ------------- write element type and connectivity --------------------- //
  outputStream << "$Elements" << std::endl << numCells - num_bad << std::endl;
  // int k = 0;
  for (int i = 0; i < numCells; ++i) {
    vtkIdList *point_ids = dataSet->GetCell(i)->GetPointIds();
    int numComponent = point_ids->GetNumberOfIds();
    int type_id = dataSet->GetCellType(i);
    if (type_id == 10) {
      outputStream << i + 1 << " ";
      switch (numComponent) {
        case 2: {
          break;
        }
        case 3: {
          outputStream << 2 << " " << 2 << " " << 1 << " " << 1 << " ";
          break;
        }
        case 4: {
          outputStream << 4 << " " << 2 << " " << 1 << " " << 1 << " ";
          break;
        }

        default: {
          std::cerr << "Components in cell should be less than 4" << std::endl;
          exit(1);
        }
      }
      for (int j = 0; j < numComponent; ++j)
        outputStream << point_ids->GetId(j) + 1 << " ";
      outputStream << std::endl;
      // k+=1;
    }
  }
  outputStream << "$EndElements" << std::endl;
  // -------------------------- write cell data ---------------------------- //
  vtkCellData *cellData = dataSet->GetCellData();
  vtkDataArray *da = cellData->GetArray(arrayID);
  if (da) {
    std::string tmpname = "CellArray";
    tmpname += std::to_string(arrayID);
    outputStream
        << "$ElementData" << std::endl
        << 1 << std::endl  // 1 string tag
        << "\""
        << (cellData->GetArrayName(arrayID) ? cellData->GetArrayName(arrayID)
                                            : tmpname)  // name of view
        << "\"" << std::endl
        << 0 << std::endl  // 0 real tag
        << 3
        << std::endl  // 3 int tags (dt index, dim of field, number of fields)
        << 0 << std::endl                    // dt index
        << 1 << std::endl                    // dim of field
        << numCells - num_bad << std::endl;  // number of fields
    for (int j = 0; j < numCells; ++j) {
      int type_id = dataSet->GetCellType(j);
      if (type_id == 10) {
        double *data = da->GetTuple(j);
        outputStream << j + 1 << " ";
        outputStream << data[0] << " ";
        outputStream << std::endl;
      }
    }
    outputStream << "$EndElementData" << std::endl;
  }
}

writeMSH() [6/6]

void meshBase::writeMSH ( const std::string &  fname, const std::string &  pointOrCell, int  arrayID, bool  onlyVol  )

inherited

Parameters

fname	The name of the file to write to
pointOrCell	<>
arrayID	<>
onlyVol	<>

Definition at line 1540 of file meshBase.C.

                                      {
  std::ofstream outputStream(fname.c_str());
  writeMSH(outputStream, pointOrCell, arrayID, onlyVol);
}

Member Data Documentation

_args

Foam::argList* FOAM::foamMesh::_args

private

Definition at line 180 of file foamMesh.H.

Referenced by foamMesh(), read(), and ~foamMesh().

_fmesh

Foam::fvMesh* FOAM::foamMesh::_fmesh

private

Definition at line 182 of file foamMesh.H.

Referenced by genMshDB(), read(), readAMR(), and ~foamMesh().

_runTime

Foam::Time* FOAM::foamMesh::_runTime

private

Definition at line 181 of file foamMesh.H.

Referenced by foamMesh(), read(), and ~foamMesh().

_volMB

std::shared_ptr<meshBase> FOAM::foamMesh::_volMB

private

Definition at line 188 of file foamMesh.H.

Referenced by foamMesh(), and write().

checkQuality

bool meshBase::checkQuality

protectedinherited

Definition at line 730 of file meshBase.H.

continuous

bool meshBase::continuous

protectedinherited

Definition at line 735 of file meshBase.H.

dataSet

vtkSmartPointer<vtkDataSet> meshBase::dataSet

protectedinherited

Definition at line 722 of file meshBase.H.

Referenced by meshSrch::buildCellLocator(), meshSrch::chkDuplElm(), meshBase::exportExoToVtk(), meshBase::exportGmshToVtk(), meshBase::exportPntToVtk(), meshBase::exportVolToVtk(), vtkMesh::extractSurface(), extractSurface(), meshSrch::FindCellsInPolyData(), genMshDB(), getCell(), vtkMesh::getCell(), vtkMesh::getCellDataArray(), vtkMesh::getCellDataIdx(), getCellLengths(), vtkMesh::getCellLengths(), getCellType(), vtkMesh::getCellType(), meshSrch::getCellVec(), getCellVec(), vtkMesh::getCellVec(), vtkMesh::getConnectivities(), getConnectivities(), meshSrch::getPoint(), getPoint(), vtkMesh::getPoint(), vtkMesh::getPointDataArray(), getVertCrds(), vtkMesh::getVertCrds(), inspectEdges(), vtkMesh::inspectEdges(), vtkMesh::merge(), report(), vtkMesh::report(), vtkMesh::setCellDataArray(), vtkMesh::setPointDataArray(), vtkMesh::unsetCellDataArray(), vtkMesh::unsetFieldDataArray(), vtkMesh::unsetPointDataArray(), vtkMesh::vtkMesh(), and vtkMesh::write().

filename

std::string meshBase::filename

protectedinherited

Definition at line 726 of file meshBase.H.

Referenced by report(), vtkMesh::report(), and vtkMesh::vtkMesh().

globToPartCellMap

std::map<nemId_t, nemId_t> meshBase::globToPartCellMap

protectedinherited

Definition at line 750 of file meshBase.H.

globToPartNodeMap

std::map<nemId_t, nemId_t> meshBase::globToPartNodeMap

protectedinherited

Only populated for mesh resulting from call to meshBase::partition

Definition at line 746 of file meshBase.H.

metadata

vtkSmartPointer<vtkModelMetadata> meshBase::metadata

protectedinherited

Definition at line 760 of file meshBase.H.

newArrayNames

std::vector<std::string> meshBase::newArrayNames

protectedinherited

Definition at line 739 of file meshBase.H.

numCells

nemId_t meshBase::numCells

protectedinherited

Definition at line 718 of file meshBase.H.

Referenced by meshBase::exportExoToVtk(), meshBase::exportGmshToVtk(), meshBase::exportPntToVtk(), meshBase::exportVolToVtk(), genMshDB(), getCell(), vtkMesh::getCell(), meshSrch::getCellVec(), getCellVec(), vtkMesh::getCellVec(), vtkMesh::merge(), ReadALegacyVTKFile(), ReadDegenerateVTKFile(), readLegacyVTKCells(), report(), vtkMesh::report(), vtkMesh::setCellDataArray(), vtkMesh::vtkMesh(), and write().

numPoints

nemId_t meshBase::numPoints

protectedinherited

Definition at line 714 of file meshBase.H.

Referenced by meshBase::exportExoToVtk(), meshBase::exportGmshToVtk(), meshBase::exportPntToVtk(), meshBase::exportVolToVtk(), genMshDB(), getVertCrds(), vtkMesh::getVertCrds(), vtkMesh::merge(), ReadALegacyVTKFile(), ReadDegenerateVTKFile(), readLegacyVTKPoints(), report(), vtkMesh::report(), vtkMesh::setPointDataArray(), vtkMesh::vtkMesh(), and write().

partToGlobCellMap

std::map<nemId_t, nemId_t> meshBase::partToGlobCellMap

protectedinherited

Definition at line 758 of file meshBase.H.

partToGlobNodeMap

std::map<nemId_t, nemId_t> meshBase::partToGlobNodeMap

protectedinherited

Definition at line 754 of file meshBase.H.

---

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

• foamMesh.H
• foamMesh.C