meshSrch Class Reference

Detailed Description

Definition at line 39 of file meshSrch.H.

Public Member Functions
	meshSrch ()=delete
	meshSrch (meshBase *mb)
	~meshSrch () override=default
std::vector< std::vector< double > >	getCellVec (nemId_t id) const override
	get vector of coords of cell with id More...
std::vector< double >	getPoint (nemId_t id) const override
	get point with id 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 assumes all elements are the same type 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 More...
int	getCellDataIdx (const std::string &name) override
	<> More...
std::vector< double >	getCellLengths () const override
	get diameter of circumsphere of each cell More...
std::vector< nemId_t >	getConnectivities () const override
	get connectivities. More...
bool	chkDuplElm () const
void	FindPntsOnTriSrf (const std::vector< double > &crds, const std::vector< nemId_t > &conn, std::set< nemId_t > &ids, double tol=0.1e-15) const
void	FindPntsOnEdge (std::vector< double > &crds, std::set< nemId_t > &ids, double tol=0.1e-15) const
void	FindCellsInPolyData (vtkPolyData *polyData, std::vector< nemId_t > &ids, bool query3Donly=true, double tol=0.1e-15) const
void	FindCellsWithinBounds (std::vector< double > &bb, std::vector< nemId_t > &ids, bool fulImrsd=true)
void	FindCellsInTriSrf (const std::vector< std::vector< double >> &crds, const std::vector< std::vector< vtkIdType >> &conns, std::vector< nemId_t > &ids, bool query3Donly=true, double tol=0.1e-15) const
void	FindCellsInSphere (const std::vector< double > &center, double radius, std::vector< nemId_t > &ids, bool query3Donly=true, double tol=0.1e-15) const
void	inspectEdges (const std::string &ofname) const override
	get edge lengths of dataSet More...
vtkSmartPointer< vtkDataSet >	extractSurface () override
	extract the surface mesh More...
void	read (const std::string &fname=std::string()) override
	abstract read method reserved for derived classes More...
void	write (const std::string &fname) const override
	write the mesh to file named fname 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 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...
virtual void	report () const
	generate a report of the mesh 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 meshSrch *	Create (meshBase *mb)
static std::shared_ptr< meshSrch >	CreateShared (meshBase *mb)
static std::unique_ptr< meshSrch >	CreateUnique (meshBase *mb)
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 (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 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	buildCellLocator ()

Private Attributes
bool	upd_vcl
vtkSmartPointer< vtkCellLocator >	vcl

Inherits meshBase.

Constructor & Destructor Documentation

meshSrch() [1/2]

meshSrch::meshSrch ( )

delete

meshSrch() [2/2]

meshSrch::meshSrch ( meshBase *  mb )

inlineexplicit

Definition at line 43 of file meshSrch.H.

: meshBase(*mb), upd_vcl(true) {}

~meshSrch()

meshSrch::~meshSrch ( )

overridedefault

Member Function Documentation

buildCellLocator()

void meshSrch::buildCellLocator ( )

private

Definition at line 83 of file meshSrch.C.

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

Referenced by FindCellsWithinBounds().

                                {
  if (upd_vcl) {
    // Create the tree
    vcl = vtkSmartPointer<vtkCellLocator>::New();
    vcl->SetDataSet(dataSet);
    vcl->BuildLocator();
    upd_vcl = false;
  }
}

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);
}

chkDuplElm()

bool meshSrch::chkDuplElm

(

)

const

Definition at line 212 of file meshSrch.C.

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

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

                                {
  std::set<std::vector<nemId_t>> ids;
  for (nemId_t ic = 0; ic < getNumberOfCells(); ic++) {
    std::vector<nemId_t> cid;
    vtkSmartPointer<vtkIdList> idl = vtkSmartPointer<vtkIdList>::New();
    idl = dataSet->GetCell(ic)->GetPointIds();
    for (vtkIdType id = 0; id < idl->GetNumberOfIds(); id++)
      cid.push_back(idl->GetId(id));
    std::pair<std::set<std::vector<nemId_t>>::iterator, bool> ret;
    ret = ids.insert(cid);
    if (!ret.second) return true;
  }
  return false;
}

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/4]

static meshSrch* meshSrch::Create ( meshBase *  mb )

inlinestatic

Definition at line 45 of file meshSrch.H.

Referenced by CreateShared(), CreateUnique(), and NEM::DRV::ConversionDriver::procExo().

                                        {
    auto *ms = new meshSrch(mb);
    return ms;
  }

Create() [2/4]

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() [3/4]

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() [4/4]

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);
}

CreateShared() [1/4]

static std::shared_ptr<meshSrch> meshSrch::CreateShared ( meshBase *  mb )

inlinestatic

Definition at line 50 of file meshSrch.H.

References Create().

                                                            {
    std::shared_ptr<meshSrch> ms;
    ms.reset(meshSrch::Create(mb));
    return ms;
  }

CreateShared() [2/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::SnappyMeshMeshGenDriver::execute(), NEM::DRV::GmshMeshGenDriver::execute(), NEM::DRV::BlockMeshMeshGenDriver::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() [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]

static std::unique_ptr<meshSrch> meshSrch::CreateUnique ( meshBase *  mb )

inlinestatic

Definition at line 56 of file meshSrch.H.

References Create(), meshBase::getCellCenter(), meshBase::getCellVec(), and meshBase::getPoint().

                                                            {
    return std::unique_ptr<meshSrch>(meshSrch::Create(mb));
  }

CreateUnique() [2/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() [3/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() [4/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));
}

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> meshSrch::extractSurface ( )

inlineoverridevirtual

Returns

the surface mesh for this mesh.

Implements meshBase.

Definition at line 125 of file meshSrch.H.

                                                        {
    return vtkSmartPointer<vtkDataSet>();
  }

FindCellsInPolyData()

void meshSrch::FindCellsInPolyData	(	vtkPolyData *	polyData,
		std::vector< nemId_t > &	ids,
		bool	query3Donly = true,
		double	tol = 0.1e-15
	)		const

Definition at line 227 of file meshSrch.C.

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

Referenced by FindCellsInSphere(), and FindCellsInTriSrf().

                                                     {
  // pass dataSet through vtkCellCenters filter
  vtkSmartPointer<vtkCellCenters> cc = vtkSmartPointer<vtkCellCenters>::New();

  cc->SetInputData(dataSet);

  // create vtkSelectEnclosedPoints
  vtkSmartPointer<vtkSelectEnclosedPoints> sep =
      vtkSmartPointer<vtkSelectEnclosedPoints>::New();

  sep->SetInputConnection(cc->GetOutputPort());

  sep->SetSurfaceData(polyData);
  // sep->CheckSurfaceOn();

  sep->SetTolerance(tol);

  sep->Update();

  for (nemId_t id = 0; id < getNumberOfCells(); ++id)
    if (sep->IsInside(id)) {
      if (query3Donly && dataSet->GetCell(id)->GetCellDimension() != 3)
        continue;
      ids.emplace_back(id);
    }
}

FindCellsInSphere()

void meshSrch::FindCellsInSphere	(	const std::vector< double > &	center,
		double	radius,
		std::vector< nemId_t > &	ids,
		bool	query3Donly = true,
		double	tol = 0.1e-15
	)		const

Definition at line 280 of file meshSrch.C.

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

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

                                                                     {
  // create vtkSphere using center and radius
  vtkSmartPointer<vtkSphereSource> ss = vtkSmartPointer<vtkSphereSource>::New();
  ss->SetRadius(radius);
  ss->SetCenter(center[0], center[1], center[2]);

  ss->Update();

  FindCellsInPolyData(ss->GetOutput(), ids, query3Donly, tol);
}

FindCellsInTriSrf()

void meshSrch::FindCellsInTriSrf	(	const std::vector< std::vector< double >> &	crds,
		const std::vector< std::vector< vtkIdType >> &	conns,
		std::vector< nemId_t > &	ids,
		bool	query3Donly = true,
		double	tol = 0.1e-15
	)		const

Definition at line 256 of file meshSrch.C.

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

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

                                        {
  // create vtkPolyData using crds and conns
  vtkSmartPointer<vtkPoints> pnts = vtkSmartPointer<vtkPoints>::New();
  vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
  vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();

  for (const auto &crd : crds) pnts->InsertNextPoint(crd.data());
  for (const auto &conn : conns)
    polys->InsertNextCell(conn.size(), conn.data());
  polyData->SetPoints(pnts);
  polyData->SetPolys(polys);

  // DEBUG: Write polyData to STL
  //  vtkSmartPointer<vtkSTLWriter> stlw = vtkSmartPointer<vtkSTLWriter>::New();
  //  stlw->SetInputData(polyData);
  //  stlw->SetFileName("polydata.stl");
  //  stlw->Write();

  FindCellsInPolyData(polyData, ids, query3Donly, tol);
}

FindCellsWithinBounds()

void meshSrch::FindCellsWithinBounds	(	std::vector< double > &	bb,
		std::vector< nemId_t > &	ids,
		bool	fulImrsd = true
	)

Definition at line 93 of file meshSrch.C.

References buildCellLocator(), getCellCenter(), nemAux::isInBBox(), NEM::MSH::New(), and vcl.

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

                                                                             {
  // finding all intersecting cells
  buildCellLocator();
  vtkSmartPointer<vtkIdList> idl = vtkSmartPointer<vtkIdList>::New();
  vcl->FindCellsWithinBounds(bb.data(), idl);
  std::cout << "Found " << idl->GetNumberOfIds() << " cells." << std::endl;
  std::vector<nemId_t> aids;
  for (vtkIdType idx = 0; idx < idl->GetNumberOfIds(); idx++)
    aids.push_back(idl->GetId(idx));
  // removing cells centered out of the bounding box
  int nr = 0;
  if (fulImrsd) {
    for (const auto &aid : aids)
      if (!nemAux::isInBBox(getCellCenter(aid), bb)) {
        nr++;
        continue;
      } else {
        ids.push_back(aid);
      }
    std::cout << "Remove " << nr << " cells from the list." << std::endl;
  } else {
    ids = aids;
  }
}

FindPntsOnEdge()

void meshSrch::FindPntsOnEdge	(	std::vector< double > &	crds,
		std::set< nemId_t > &	ids,
		double	tol = 0.1e-15
	)		const

Definition at line 167 of file meshSrch.C.

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

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

                                                {
  // create polyData
  vtkSmartPointer<vtkPoints> pnts = vtkSmartPointer<vtkPoints>::New();
  for (std::size_t iPnt = 0; iPnt < crds.size() / 3; iPnt++)
    pnts->InsertNextPoint(crds[iPnt * 3], crds[iPnt * 3 + 1],
                          crds[iPnt * 3 + 2]);
  vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
  polys->InsertNextCell(2);
  polys->InsertCellPoint(0);
  polys->InsertCellPoint(1);
  vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
  polyData->SetPoints(pnts);
  polyData->SetPolys(polys);

  // Write the file
  // vtkSmartPointer<vtkXMLPolyDataWriter> writer
  //    = vtkSmartPointer<vtkXMLPolyDataWriter>::New();
  // writer->SetFileName("edge.vtp");
  // writer->SetInputData(polyData);
  // Optional - set the mode. The default is binary.
  ////writer->SetDataModeToBinary();
  // writer->SetDataModeToAscii();
  // writer->Write();

  // find nodes residing on the edge
  // create cell locator
  vtkSmartPointer<vtkCellLocator> cellLocator =
      vtkSmartPointer<vtkCellLocator>::New();
  cellLocator->SetDataSet(polyData);
  cellLocator->BuildLocator();

  double closestPoint[3];
  double closestPointDist2;
  vtkIdType cellId;
  int subId;
  for (nemId_t iPt = 0; iPt < getNumberOfPoints(); iPt++) {
    std::vector<double> pnt = getPoint(iPt);
    cellLocator->FindClosestPoint(pnt.data(), closestPoint, cellId, subId,
                                  closestPointDist2);
    if (closestPointDist2 < tol) ids.insert(iPt + 1);
  }
}

FindPntsOnTriSrf()

void meshSrch::FindPntsOnTriSrf	(	const std::vector< double > &	crds,
		const std::vector< nemId_t > &	conn,
		std::set< nemId_t > &	ids,
		double	tol = 0.1e-15
	)		const

Definition at line 119 of file meshSrch.C.

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

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

                                                                        {
  // create polyData
  vtkSmartPointer<vtkPoints> pnts = vtkSmartPointer<vtkPoints>::New();
  for (std::size_t iPnt = 0; iPnt < crds.size() / 3; iPnt++)
    pnts->InsertNextPoint(crds[iPnt * 3], crds[iPnt * 3 + 1],
                          crds[iPnt * 3 + 2]);
  vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
  for (std::size_t iCel = 0; iCel < conn.size() / 3; iCel++) {
    polys->InsertNextCell(3);
    polys->InsertCellPoint(conn[iCel * 3]);
    polys->InsertCellPoint(conn[iCel * 3 + 1]);
    polys->InsertCellPoint(conn[iCel * 3 + 2]);
  }
  vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
  polyData->SetPoints(pnts);
  polyData->SetPolys(polys);

  // Write the file
  // vtkSmartPointer<vtkXMLPolyDataWriter> writer
  //    = vtkSmartPointer<vtkXMLPolyDataWriter>::New();
  // writer->SetFileName("test.vtp");
  // writer->SetInputData(polyData);
  // Optional - set the mode. The default is binary.
  ////writer->SetDataModeToBinary();
  // writer->SetDataModeToAscii();
  // writer->Write();

  // find nodes residing on the trisurf
  // create cell locator
  vtkSmartPointer<vtkCellLocator> cellLocator =
      vtkSmartPointer<vtkCellLocator>::New();
  cellLocator->SetDataSet(polyData);
  cellLocator->BuildLocator();

  double closestPoint[3];
  double closestPointDist2;
  vtkIdType cellId;
  int subId;
  for (nemId_t iPt = 0; iPt < getNumberOfPoints(); iPt++) {
    std::vector<double> pnt = getPoint(iPt);
    cellLocator->FindClosestPoint(pnt.data(), closestPoint, cellId, subId,
                                  closestPointDist2);
    if (closestPointDist2 < tol) ids.insert(iPt + 1);
  }
}

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));
}

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> > meshSrch::getCell ( nemId_t  id ) const

inlineoverridevirtual

Parameters

id	The id of the cell.

Returns

point indices and respective coordinates

Implements meshBase.

Definition at line 72 of file meshSrch.H.

                                                                        {
    return std::map<nemId_t, std::vector<double>>();
  }

getCellCenter()

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

overridevirtual

Parameters

cellID

<>

Returns

<>

Implements meshBase.

Definition at line 75 of file meshSrch.C.

References getCellVec().

Referenced by FindCellsWithinBounds().

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

  for (const auto &i : cell) center = center + i;
  return (1.0 / static_cast<double>(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()

int meshSrch::getCellDataIdx ( const std::string &  name )

inlineoverridevirtual

Parameters

name

<>

Returns

<>

Reimplemented from meshBase.

Definition at line 75 of file meshSrch.H.

{ return 0; }

getCellLengths()

std::vector<double> meshSrch::getCellLengths ( ) const

inlineoverridevirtual

Returns

<>

Implements meshBase.

Definition at line 76 of file meshSrch.H.

                                                    {
    return std::vector<double>();
  }

getCellType()

int meshSrch::getCellType ( ) const

inlineoverridevirtual

Returns

<>

Implements meshBase.

Definition at line 68 of file meshSrch.H.

{ return 0; }

getCellVec()

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

overridevirtual

Parameters

id	The id of the cell.

Returns

vector of coords of cell

Implements meshBase.

Definition at line 56 of file meshSrch.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> meshSrch::getConnectivities ( ) const

inlineoverridevirtual

This is only safe to use if mesh has cells of the same type or you have information on the number of cells of each type and the order in which they appear (for look up in resulting vector)

Returns

<>

Implements meshBase.

Definition at line 79 of file meshSrch.H.

                                                        {
    return std::vector<nemId_t>();
  }

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(), chkDuplElm(), NEM::GEO::rocPack::createCohesiveElements(), diffMesh(), FindCellsInPolyData(), NEM::DRV::ConversionDriver::genExo(), FOAM::foamMesh::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(), FindPntsOnEdge(), 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 > meshSrch::getPoint ( nemId_t  id ) const

overridevirtual

Parameters

id	The id of the point.

Returns

<>

Implements meshBase.

Definition at line 48 of file meshSrch.C.

References meshBase::dataSet.

Referenced by FindPntsOnEdge(), FindPntsOnTriSrf(), 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> > meshSrch::getVertCrds ( ) const

inlineoverridevirtual

Returns

<>

Implements meshBase.

Definition at line 69 of file meshSrch.H.

                                                            {
    return std::vector<std::vector<double>>();
  }

inspectEdges()

void meshSrch::inspectEdges ( const std::string &  ofname ) const

inlineoverridevirtual

Parameters

ofname

<>

Implements meshBase.

Definition at line 124 of file meshSrch.H.

{}

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 meshSrch::read ( const std::string &  fname = std::string() )

inlineoverridevirtual

Parameters

fname

name of mesh file

Implements meshBase.

Definition at line 129 of file meshSrch.H.

References meshBase::write().

{}

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()

virtual void meshBase::report ( ) const

inlinevirtualinherited

Reimplemented in vtkMesh, FOAM::foamMesh, and gmshMesh.

Definition at line 540 of file meshBase.H.

Referenced by NEM::DRV::GmshToVtkConversionDriver::execute(), vtkMesh::read(), gmshMesh::report(), and NEM::ADP::Refine::run().

{};

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 meshSrch::write ( const std::string &  fname ) const

inlineoverridevirtual

Parameters

fname

The name of the file to write to

Implements meshBase.

Definition at line 131 of file meshSrch.H.

{}

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(), 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

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 buildCellLocator(), chkDuplElm(), meshBase::exportExoToVtk(), meshBase::exportGmshToVtk(), meshBase::exportPntToVtk(), meshBase::exportVolToVtk(), vtkMesh::extractSurface(), FOAM::foamMesh::extractSurface(), FindCellsInPolyData(), FOAM::foamMesh::genMshDB(), FOAM::foamMesh::getCell(), vtkMesh::getCell(), vtkMesh::getCellDataArray(), vtkMesh::getCellDataIdx(), FOAM::foamMesh::getCellLengths(), vtkMesh::getCellLengths(), FOAM::foamMesh::getCellType(), vtkMesh::getCellType(), getCellVec(), FOAM::foamMesh::getCellVec(), vtkMesh::getCellVec(), vtkMesh::getConnectivities(), FOAM::foamMesh::getConnectivities(), getPoint(), FOAM::foamMesh::getPoint(), vtkMesh::getPoint(), vtkMesh::getPointDataArray(), FOAM::foamMesh::getVertCrds(), vtkMesh::getVertCrds(), FOAM::foamMesh::inspectEdges(), vtkMesh::inspectEdges(), vtkMesh::merge(), FOAM::foamMesh::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 FOAM::foamMesh::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(), FOAM::foamMesh::genMshDB(), FOAM::foamMesh::getCell(), vtkMesh::getCell(), getCellVec(), FOAM::foamMesh::getCellVec(), vtkMesh::getCellVec(), vtkMesh::merge(), ReadALegacyVTKFile(), ReadDegenerateVTKFile(), readLegacyVTKCells(), FOAM::foamMesh::report(), vtkMesh::report(), vtkMesh::setCellDataArray(), vtkMesh::vtkMesh(), and FOAM::foamMesh::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(), FOAM::foamMesh::genMshDB(), FOAM::foamMesh::getVertCrds(), vtkMesh::getVertCrds(), vtkMesh::merge(), ReadALegacyVTKFile(), ReadDegenerateVTKFile(), readLegacyVTKPoints(), FOAM::foamMesh::report(), vtkMesh::report(), vtkMesh::setPointDataArray(), vtkMesh::vtkMesh(), and FOAM::foamMesh::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.

upd_vcl

bool meshSrch::upd_vcl

private

Definition at line 138 of file meshSrch.H.

Referenced by buildCellLocator().

vcl

vtkSmartPointer<vtkCellLocator> meshSrch::vcl

private

Definition at line 139 of file meshSrch.H.

Referenced by buildCellLocator(), and FindCellsWithinBounds().

---

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

• meshSrch.H
• meshSrch.C