vtkMesh Class Reference

Detailed Description

Definition at line 100 of file vtkMesh.H.

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

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

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

Inherits meshBase.

Constructor & Destructor Documentation

vtkMesh() [1/5]

vtkMesh::vtkMesh ( )

default

Referenced by vtkMesh().

vtkMesh() [2/5]

vtkMesh::vtkMesh ( const std::string &  fname )

explicit

Definition at line 169 of file vtkMesh.C.

References NEM::DRV::TransferDriver::CreateTransferObject(), meshBase::dataSet, meshBase::getNewArrayNames(), NEM::MSH::New(), meshBase::numCells, meshBase::numPoints, ReadALegacyVTKFile(), ReadDegenerateVTKFile(), meshBase::setFileName(), and vtkMesh().

                                       {
  bool degenerate(false);
  std::string extension = vtksys::SystemTools::GetFilenameLastExtension(fname);
  // Dispatch based on the file extension
  if (extension == ".vtu")
    dataSet.TakeReference(
        ReadAnXMLOrSTLFile<vtkXMLUnstructuredGridReader>(fname));
  else if (extension == ".vtp")
    dataSet.TakeReference(ReadAnXMLOrSTLFile<vtkXMLPolyDataReader>(fname));
  else if (extension == ".vts")
    dataSet.TakeReference(
        ReadAnXMLOrSTLFile<vtkXMLStructuredGridReader>(fname));
  else if (extension == ".vtr")
    dataSet.TakeReference(
        ReadAnXMLOrSTLFile<vtkXMLRectilinearGridReader>(fname));
  else if (extension == ".vti")
    dataSet.TakeReference(ReadAnXMLOrSTLFile<vtkXMLImageDataReader>(fname));
  else if (extension == ".stl")
    dataSet.TakeReference(ReadAnXMLOrSTLFile<vtkSTLReader>(fname));
  else if (extension == ".vtk") {
    // if vtk is produced by MFEM, it's probably degenerate (i.e. point
    // duplicity) in this case, we use a different reader to correct duplicity
    // and transfer the data attributes read by the regular legacy reader using
    // the transfer methods in meshBase
    std::ifstream meshStream(fname);
    if (!meshStream.good()) {
      std::cout << "Error opening file " << fname << std::endl;
      exit(1);
    }
    std::string line;
    getline(meshStream, line);
    getline(meshStream, line);
    meshStream.close();
    if (line.find("MFEM") != std::string::npos) {
      degenerate = true;
      dataSet = vtkDataSet::SafeDownCast(ReadDegenerateVTKFile(fname));
      setFileName(fname);
      numCells = dataSet->GetNumberOfCells();
      numPoints = dataSet->GetNumberOfPoints();
      vtkMesh *vtkMesh_tmp = new vtkMesh(
          vtkDataSet::SafeDownCast(ReadALegacyVTKFile(fname)), fname);
      // vtkMesh_tmp.transfer(this, "Consistent Interpolation");
      auto transfer = NEM::DRV::TransferDriver::CreateTransferObject(
          vtkMesh_tmp, this, "Consistent Interpolation");
      transfer->run(vtkMesh_tmp->getNewArrayNames());
      std::cout << "vtkMesh constructed" << std::endl;
    } else {
      // reading legacy formated vtk files
      vtkSmartPointer<vtkGenericDataObjectReader> reader =
          vtkSmartPointer<vtkGenericDataObjectReader>::New();
      // vtkSmartPointer<vtkDataSetReader> reader =
      //     vtkSmartPointer<vtkDataSetReader>::New();
      reader->SetFileName(fname.c_str());
      reader->Update();
      reader->GetOutput()->Register(reader);
      // obtaining dataset
      dataSet.TakeReference(vtkDataSet::SafeDownCast(reader->GetOutput()));
    }
  } else {
    std::cerr << "Unknown extension: " << extension << std::endl;
    exit(1);
  }

  if (!dataSet) {
    std::cout << "Error populating dataSet" << std::endl;
    exit(1);
  }

  if (!degenerate) {
    setFileName(fname);
    std::cout << "vtkMesh constructed" << std::endl;
    numCells = dataSet->GetNumberOfCells();
    numPoints = dataSet->GetNumberOfPoints();
  }
}

vtkMesh() [3/5]

vtkMesh::vtkMesh	(	const std::string &	fname1,
		const std::string &	fname2
	)

Definition at line 245 of file vtkMesh.C.

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

                                                                 {
  std::string ext_in = vtksys::SystemTools::GetFilenameLastExtension(fname1);
  std::string ext_out = vtksys::SystemTools::GetFilenameLastExtension(fname2);

  // sanity check
  if (!(ext_in == ".vtu" && ext_out == ".stl")) {
    std::cerr
        << "vtkMesh: Currently only support conversion between vtu and stl."
        << std::endl;
    exit(1);
  }

  vtkSmartPointer<vtkXMLUnstructuredGridReader> reader =
      vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
  reader->SetFileName(fname1.c_str());
  reader->Update();
  reader->GetOutput()->Register(reader);

  // obtaining dataset
  dataSet.TakeReference(vtkDataSet::SafeDownCast(reader->GetOutput()));
  if (!dataSet) {
    std::cout << "Error populating dataSet" << std::endl;
    exit(1);
  }
  setFileName(fname1);
  std::cout << "vtkMesh constructed" << std::endl;
  numCells = dataSet->GetNumberOfCells();
  numPoints = dataSet->GetNumberOfPoints();

  // skinn to the surface
  vtkSmartPointer<vtkDataSetSurfaceFilter> surfFilt =
      vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
  surfFilt->SetInputConnection(reader->GetOutputPort());
  surfFilt->Update();

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

  // write to stl file
  vtkSmartPointer<vtkSTLWriter> stlWriter =
      vtkSmartPointer<vtkSTLWriter>::New();
  stlWriter->SetFileName(fname2.c_str());
  stlWriter->SetInputConnection(triFilt->GetOutputPort());
  stlWriter->Write();
}

vtkMesh() [4/5]

vtkMesh::vtkMesh	(	vtkSmartPointer< vtkDataSet >	dataSet_tmp,
		const std::string &	fname
	)

Definition at line 99 of file vtkMesh.C.

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

                                         {
  if (dataSet_tmp) {
    dataSet = dataSet_tmp;
    filename = fname;
    numCells = dataSet->GetNumberOfCells();
    numPoints = dataSet->GetNumberOfPoints();
    std::cout << "vtkMesh constructed" << std::endl;
  } else {
    std::cerr << "Nothing to copy!" << std::endl;
    exit(1);
  }
}

vtkMesh() [5/5]

vtkMesh::vtkMesh	(	const std::vector< double > &	xCrds,
		const std::vector< double > &	yCrds,
		const std::vector< double > &	zCrds,
		const std::vector< nemId_t > &	elemConn,
		int	cellType,
		const std::string &	newname
	)

Definition at line 113 of file vtkMesh.C.

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

                                           {
  if (!(xCrds.size() == yCrds.size() && xCrds.size() == zCrds.size())) {
    std::cerr << "Length of coordinate arrays must match!" << std::endl;
    exit(1);
  }

  // point to be pushed into dataSet
  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
  // declare vtk dataset
  vtkSmartPointer<vtkUnstructuredGrid> dataSet_tmp =
      vtkSmartPointer<vtkUnstructuredGrid>::New();
  numPoints = xCrds.size();
  // allocate size for vtk point container
  points->SetNumberOfPoints(numPoints);
  for (nemId_t i = 0; i < numPoints; ++i)
    points->SetPoint(i, xCrds[i], yCrds[i], zCrds[i]);

  // add points to vtk mesh data structure
  dataSet_tmp->SetPoints(points);
  switch (cellType) {
    case VTK_TETRA: {
      numCells = elemConn.size() / 4;
      dataSet_tmp->Allocate(numCells);
      for (nemId_t i = 0; i < numCells; ++i) {
        vtkSmartPointer<vtkIdList> elmConn = vtkSmartPointer<vtkIdList>::New();
        elmConn->SetNumberOfIds(4);
        for (nemId_t j = 0; j < 4; ++j) elmConn->SetId(j, elemConn[i * 4 + j]);
        dataSet_tmp->InsertNextCell(VTK_TETRA, elmConn);
      }
      break;
    }
    case VTK_TRIANGLE: {
      numCells = elemConn.size() / 3;
      dataSet_tmp->Allocate(numCells);
      for (nemId_t i = 0; i < numCells; ++i) {
        vtkSmartPointer<vtkIdList> elmConn = vtkSmartPointer<vtkIdList>::New();
        elmConn->SetNumberOfIds(3);
        for (nemId_t j = 0; j < 3; ++j) elmConn->SetId(j, elemConn[i * 3 + j]);
        dataSet_tmp->InsertNextCell(VTK_TRIANGLE, elmConn);
      }
      break;
    }
    default: {
      std::cout << "Unknown element type " << cellType << std::endl;
      exit(1);
    }
  }
  filename = newname;
  dataSet = dataSet_tmp;
  std::cout << "vtkMesh constructed" << std::endl;
}

~vtkMesh()

vtkMesh::~vtkMesh ( )

inlineoverride

Definition at line 119 of file vtkMesh.H.

{ std::cout << "vtkMesh destroyed" << std::endl; }

Member Function Documentation

buildStaticCellLocator()

vtkSmartPointer< vtkStaticCellLocator > meshBase::buildStaticCellLocator ( )

inherited

Returns

<>

Definition at line 1640 of file meshBase.C.

References NEM::MSH::New().

Referenced by meshBase::writeCobalt().

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

buildStaticPointLocator()

vtkSmartPointer< vtkStaticPointLocator > meshBase::buildStaticPointLocator ( )

inherited

Returns

<>

Definition at line 1648 of file meshBase.C.

References NEM::MSH::New().

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

checkMesh()

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

inherited

Parameters

ofname

<>

Definition at line 1657 of file meshBase.C.

References MeshQuality::checkMesh().

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

convertHexToTetVTK()

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

inherited

Parameters

meshdataSet

Input hexahedral mesh dataset

Definition at line 1826 of file meshBase.C.

References NEM::MSH::New().

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

  dataSet = triFilter->GetOutput();
}

convertQuads()

meshBase * meshBase::convertQuads ( )

inherited

Definition at line 1769 of file meshBase.C.

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

Referenced by proteusHdf5::proteusHdf5().

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

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

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

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

    vtkDataSetNoQuads->InsertNextCell(VTK_TRIANGLE, triList2);
  }

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

Create() [1/3]

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

staticinherited

This method calls the other factory methods based on extension.

Parameters

fname

name of mesh file

Returns

<>

Caller must delete object after use.

Definition at line 78 of file meshBase.C.

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

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

Create() [2/3]

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

staticinherited

Caller must delete object after use.

Parameters

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

Returns

<>

Definition at line 112 of file meshBase.C.

                                                     {
  return new vtkMesh(other, newname);
}

Create() [3/3]

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

staticinherited

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

Parameters

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

Returns

<>

Caller must delete object after use.

Definition at line 120 of file meshBase.C.

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

CreateShared() [1/4]

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

staticinherited

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

Parameters

fname

name of mesh file

Returns

<>

Definition at line 171 of file meshBase.C.

References meshBase::Create(), and mesh.

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

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

CreateShared() [2/4]

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

staticinherited

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

Parameters

mesh	the existing meshbase

Returns

<>

(be careful with this one!)

Definition at line 154 of file meshBase.C.

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

CreateShared() [3/4]

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

staticinherited

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

Parameters

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

Returns

<>

Definition at line 162 of file meshBase.C.

References meshBase::Create(), and mesh.

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

CreateShared() [4/4]

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

staticinherited

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

Parameters

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

Returns

<>

Definition at line 179 of file meshBase.C.

References meshBase::Create(), and mesh.

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

CreateUnique() [1/4]

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

staticinherited

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

Parameters

fname

name of mesh file

Returns

<>

Definition at line 190 of file meshBase.C.

References meshBase::Create().

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

CreateUnique() [2/4]

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

staticinherited

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

Parameters

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

Returns

<>

Definition at line 130 of file meshBase.C.

References meshBase::Create().

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

CreateUnique() [3/4]

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

staticinherited

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

Parameters

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

Returns

<>

Definition at line 140 of file meshBase.C.

References meshBase::Create().

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

CreateUnique() [4/4]

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

staticinherited

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

Parameters

mesh	the existing meshbase

Returns

<>

Definition at line 147 of file meshBase.C.

References mesh.

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

exportExoToVtk()

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

staticinherited

exports exodusII to vtk format

Parameters

fname

name of mesh file

Returns

<>

Definition at line 918 of file meshBase.C.

References meshBase::dataSet, NEM::MSH::EXOMesh::e2vEMap(), NEM::MSH::EXOMesh::elmTypeNum(), NEM::MSH::New(), meshBase::numCells, meshBase::numPoints, points, meshBase::setFileName(), 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, setCellDataArray(), and 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 > vtkMesh::extractSurface ( )

overridevirtual

Returns

the surface mesh for this mesh.

Implements meshBase.

Definition at line 847 of file vtkMesh.C.

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

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

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

  return triFilt->GetOutput();
}

generateSizeField()

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

inherited

Parameters

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

Definition at line 396 of file meshBase.C.

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

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

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

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

overridevirtual

Parameters

id	The id of the cell.

Returns

point indices and respective coordinates

Implements meshBase.

Definition at line 706 of file vtkMesh.C.

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

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

getCellCenter()

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

overridevirtual

Parameters

cellID

<>

Returns

<>

Implements meshBase.

Definition at line 874 of file vtkMesh.C.

References getCellVec().

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

  for (const auto &i : cell) center = center + i;
  return 1. / cell.size() * center;
}

getCellDataArray() [1/2]

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

overridevirtual

Parameters

name	<>
data	<>

Reimplemented from meshBase.

Definition at line 960 of file vtkMesh.C.

References meshBase::dataSet.

                                                        {
  int idx;
  vtkSmartPointer<vtkDataArray> cd =
      dataSet->GetCellData()->GetArray(name.c_str(), idx);
  if (idx != -1) {
    if (cd->GetNumberOfComponents() > 1) {
      std::cerr << __func__
                << " is only suitable for scalar data, i.e. 1 component"
                << std::endl;
      exit(1);
    }
    data.resize(cd->GetNumberOfTuples());
    double x[1];
    for (nemId_t i = 0; i < cd->GetNumberOfTuples(); ++i) {
      cd->GetTuple(i, x);
      data[i] = x[0];
    }
  } else {
    std::cerr << "could not find data with name " << name << std::endl;
    exit(1);
  }
}

getCellDataArray() [2/2]

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

overridevirtual

Parameters

arrayId	<>
data	<>

Reimplemented from meshBase.

Definition at line 984 of file vtkMesh.C.

References meshBase::dataSet.

                                                                   {
  if (arrayId < dataSet->GetCellData()->GetNumberOfArrays()) {
    vtkSmartPointer<vtkDataArray> cd =
        dataSet->GetCellData()->GetArray(arrayId);
    if (cd->GetNumberOfComponents() > 1) {
      std::cerr << __func__
                << " is only suitable for scalar data, i.e. 1 component"
                << std::endl;
      exit(1);
    }
    data.resize(cd->GetNumberOfTuples());
    double x[1];
    for (nemId_t i = 0; i < cd->GetNumberOfTuples(); ++i) {
      cd->GetTuple(i, x);
      data[i] = x[0];
    }
  } else {
    std::cerr << "arrayId exceeds number of cell data arrays " << std::endl;
    exit(1);
  }
}

getCellDataIdx()

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

overridevirtual

Parameters

name

<>

Returns

<>

Reimplemented from meshBase.

Definition at line 953 of file vtkMesh.C.

References meshBase::dataSet.

                                                 {
  // check physical group exist and obtain id
  int idx;
  dataSet->GetCellData()->GetArray(name.c_str(), idx);
  return idx;
}

getCellLengths()

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

overridevirtual

Returns

<>

Implements meshBase.

Definition at line 864 of file vtkMesh.C.

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

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

  return result;
}

getCellType()

int vtkMesh::getCellType ( ) const

overridevirtual

Returns

<>

Implements meshBase.

Definition at line 883 of file vtkMesh.C.

References meshBase::dataSet.

{ return dataSet->GetCellType(0); }

getCellVec()

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

overridevirtual

Parameters

id	The id of the cell.

Returns

vector of coords of cell

Implements meshBase.

Definition at line 724 of file vtkMesh.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();
    nemId_t num_ids = point_ids->GetNumberOfIds();
    cell.resize(num_ids);
    for (nemId_t 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 > vtkMesh::getConnectivities ( ) const

overridevirtual

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 768 of file vtkMesh.C.

References meshBase::dataSet.

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

getDataSet()

vtkSmartPointer<vtkDataSet> meshBase::getDataSet ( ) const

inlineinherited

Returns

this mesh's dataSet

Definition at line 308 of file meshBase.H.

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

{ return dataSet; }

getFileName()

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

inlineinherited

Returns

The current value of the private variable "filename"

Definition at line 680 of file meshBase.H.

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

{ return filename; }

getGlobToPartCellMap()

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

inlineinherited

Note

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

Definition at line 571 of file meshBase.H.

References globToPartCellMap.

                                                  {
    return globToPartCellMap;
  }

getGlobToPartNodeMap()

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

inlineinherited

Note

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

Definition at line 563 of file meshBase.H.

References globToPartNodeMap.

                                                  {
    return globToPartNodeMap;
  }

getMetadata()

vtkSmartPointer<vtkModelMetadata> meshBase::getMetadata ( )

inlineinherited

Definition at line 443 of file meshBase.H.

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

{ return metadata; }

getNewArrayNames()

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

inlineinherited

Definition at line 698 of file meshBase.H.

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

{ return newArrayNames; }

getNumberOfCells()

nemId_t meshBase::getNumberOfCells ( ) const

inlineinherited

Returns

The number of cells.

Definition at line 550 of file meshBase.H.

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

{ return numCells; }

getNumberOfPoints()

nemId_t meshBase::getNumberOfPoints ( ) const

inlineinherited

Returns

The number of points.

Definition at line 545 of file meshBase.H.

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

{ return numPoints; }

getPartToGlobCellMap()

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

inlineinherited

Note

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

Definition at line 587 of file meshBase.H.

References partToGlobCellMap.

                                                  {
    return partToGlobCellMap;
  }

getPartToGlobNodeMap()

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

inlineinherited

Note

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

Definition at line 579 of file meshBase.H.

References partToGlobNodeMap.

                                                  {
    return partToGlobNodeMap;
  }

getPoint()

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

overridevirtual

Parameters

id	The id of the point.

Returns

<>

Implements meshBase.

Definition at line 683 of file vtkMesh.C.

References meshBase::dataSet.

Referenced by getCell(), and getCellVec().

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

getPointDataArray() [1/2]

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

overridevirtual

assumes data is not allocated prior to calling

Parameters

name	<>
data	<>

Reimplemented from meshBase.

Definition at line 907 of file vtkMesh.C.

References meshBase::dataSet.

                                                         {
  int idx;
  vtkSmartPointer<vtkDataArray> pd =
      dataSet->GetPointData()->GetArray(name.c_str(), idx);
  if (idx != -1) {
    if (pd->GetNumberOfComponents() > 1) {
      std::cerr << __func__
                << " is only suitable for scalar data, i.e. 1 component"
                << std::endl;
      exit(1);
    }
    data.resize(pd->GetNumberOfTuples());
    double x[1];
    for (nemId_t i = 0; i < pd->GetNumberOfTuples(); ++i) {
      pd->GetTuple(i, x);
      data[i] = x[0];
    }
  } else {
    std::cerr << "could not find data with name " << name << std::endl;
    exit(1);
  }
}

getPointDataArray() [2/2]

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

overridevirtual

assumes data is not allocated prior to calling

Parameters

arrayId	<>
data	<>

Reimplemented from meshBase.

Definition at line 931 of file vtkMesh.C.

References meshBase::dataSet.

                                                                    {
  if (arrayId < dataSet->GetPointData()->GetNumberOfArrays()) {
    vtkSmartPointer<vtkDataArray> pd =
        dataSet->GetPointData()->GetArray(arrayId);
    if (pd->GetNumberOfComponents() > 1) {
      std::cerr << __func__
                << " is only suitable for scalar data, i.e. 1 component"
                << std::endl;
      exit(1);
    }
    data.resize(pd->GetNumberOfTuples());
    double x[1];
    for (nemId_t i = 0; i < pd->GetNumberOfTuples(); ++i) {
      pd->GetTuple(i, x);
      data[i] = x[0];
    }
  } else {
    std::cerr << "arrayId exceeds number of point data arrays " << std::endl;
    exit(1);
  }
}

getVertCrds()

std::vector< std::vector< double > > vtkMesh::getVertCrds ( ) const

overridevirtual

Returns

<>

Implements meshBase.

Definition at line 691 of file vtkMesh.C.

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

                                                        {
  std::vector<std::vector<double>> comp_crds(3);
  for (int i = 0; i < 3; ++i) comp_crds[i].resize(numPoints);

  double coords[3];
  for (nemId_t i = 0; i < numPoints; ++i) {
    dataSet->GetPoint(i, coords);
    comp_crds[0][i] = coords[0];
    comp_crds[1][i] = coords[1];
    comp_crds[2][i] = coords[2];
  }
  return comp_crds;
}

inspectEdges()

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

overridevirtual

Parameters

ofname

<>

Implements meshBase.

Definition at line 742 of file vtkMesh.C.

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

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

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

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

integrateOverMesh()

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

inherited

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

Parameters

arrayIDs

<>

Returns

total integral for each datum is returned

Definition at line 387 of file meshBase.C.

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

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

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

IsArrayName()

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

inherited

check for named array in vtk

Parameters

pointOrCell

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

Returns

<>

Definition at line 267 of file meshBase.C.

Referenced by meshBase::writeCobalt().

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

merge()

void vtkMesh::merge

(

vtkSmartPointer< vtkDataSet >

dataSet_new

)

Definition at line 1053 of file vtkMesh.C.

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

                                                           {
  vtkSmartPointer<vtkAppendFilter> appendFilter =
      vtkSmartPointer<vtkAppendFilter>::New();
  appendFilter->AddInputData(dataSet);
  appendFilter->AddInputData(dataSet_new);
  appendFilter->MergePointsOn();
  appendFilter->Update();
  dataSet = appendFilter->GetOutput();

  numCells = dataSet->GetNumberOfCells();
  numPoints = dataSet->GetNumberOfPoints();
}

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

inlineoverridevirtual

Parameters

fname

name of mesh file

Implements meshBase.

Definition at line 124 of file vtkMesh.H.

References meshBase::extractSurface(), meshBase::getCell(), meshBase::getCellCenter(), meshBase::getCellLengths(), meshBase::getCellType(), meshBase::getCellVec(), meshBase::getConnectivities(), meshBase::getPoint(), meshBase::getVertCrds(), meshBase::inspectEdges(), and meshBase::report().

{}

refineMesh() [1/5]

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

inherited

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

Parameters

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

instead of "uniform"

Definition at line 1565 of file meshBase.C.

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

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

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

refineMesh() [2/5]

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

inherited

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

Parameters

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

instead of "uniform"

Definition at line 1599 of file meshBase.C.

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

refineMesh() [3/5]

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

inherited

Parameters

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

Definition at line 1631 of file meshBase.C.

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

refineMesh() [4/5]

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

inherited

Parameters

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

Definition at line 1583 of file meshBase.C.

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

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

refineMesh() [5/5]

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

inherited

Parameters

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

Definition at line 1616 of file meshBase.C.

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

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

report()

void vtkMesh::report ( ) const

overridevirtual

Reimplemented from meshBase.

Definition at line 780 of file vtkMesh.C.

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

Referenced by NEM::GEO::rocPack::createCohesiveElements(), and NEM::DRV::FoamToVtkConversionDriver::execute().

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

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

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

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

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

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

  // Now check for field data
  if (dataSet->GetFieldData()) {
    std::cout << " contains field data with "
              << dataSet->GetFieldData()->GetNumberOfArrays() << " arrays."
              << std::endl;
    for (int i = 0; i < dataSet->GetFieldData()->GetNumberOfArrays(); ++i) {
      std::cout << "\tArray " << i << " is named "
                << dataSet->GetFieldData()->GetArray(i)->GetName();
      vtkDataArray *da = dataSet->GetFieldData()->GetArray(i);
      std::cout << " with " << da->GetNumberOfTuples() << " values. "
                << std::endl;
    }
  }
}

setCellDataArray() [1/2]

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

overridevirtual

Parameters

name	<>
data	<>

Reimplemented from meshBase.

Definition at line 1007 of file vtkMesh.C.

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

Referenced by NEM::GEO::rocPack::createCohesiveElements(), and meshBase::exportGmshToVtk().

                                                                         {
  vtkSmartPointer<vtkDoubleArray> da = vtkSmartPointer<vtkDoubleArray>::New();
  da->SetName(name.c_str());
  da->SetNumberOfComponents(data[0].size());
  for (nemId_t i = 0; i < numCells; i++) da->InsertNextTuple(data[i].data());
  dataSet->GetCellData()->AddArray(da);
  // dataSet->GetCellData()->SetActiveScalars(name);
  // dataSet->GetCellData()->SetScalars(da);
}

setCellDataArray() [2/2]

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

overridevirtual

Parameters

name	<>
data	<>

Reimplemented from meshBase.

Definition at line 1018 of file vtkMesh.C.

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

                                                              {
  vtkSmartPointer<vtkDoubleArray> da = vtkSmartPointer<vtkDoubleArray>::New();
  da->SetName(name.c_str());
  da->SetNumberOfComponents(1);
  for (nemId_t i = 0; i < numCells; i++) da->InsertNextTuple1(data[i]);
  dataSet->GetCellData()->AddArray(da);
  // dataSet->GetCellData()->SetActiveScalars(name);
  // dataSet->GetCellData()->SetScalars(da);
}

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

{ 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]

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

overridevirtual

Parameters

name	<>
data	<>

Reimplemented from meshBase.

Definition at line 896 of file vtkMesh.C.

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

Referenced by meshBase::exportGmshToVtk().

                                                                          {
  vtkSmartPointer<vtkDoubleArray> da = vtkSmartPointer<vtkDoubleArray>::New();
  da->SetName(name.c_str());
  da->SetNumberOfComponents(data[0].size());
  for (nemId_t i = 0; i < numPoints; i++) da->InsertNextTuple(data[i].data());
  dataSet->GetPointData()->AddArray(da);
  // dataSet->GetPointData()->SetActiveScalars(name);
  // dataSet->GetPointData()->SetScalars(da);
}

setPointDataArray() [2/2]

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

overridevirtual

Parameters

name	<>
data	<>

Reimplemented from meshBase.

Definition at line 886 of file vtkMesh.C.

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

                                                               {
  vtkSmartPointer<vtkDoubleArray> da = vtkSmartPointer<vtkDoubleArray>::New();
  da->SetName(name.c_str());
  da->SetNumberOfComponents(1);
  for (nemId_t i = 0; i < numPoints; i++) da->InsertNextTuple1(data[i]);
  dataSet->GetPointData()->AddArray(da);
}

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]

void vtkMesh::unsetCellDataArray ( int  arrayID )

overridevirtual

Parameters

arrayID

<>

Reimplemented from meshBase.

Definition at line 1039 of file vtkMesh.C.

References meshBase::dataSet.

                                            {
  dataSet->GetCellData()->RemoveArray(arrayID);
}

unsetCellDataArray() [2/2]

void vtkMesh::unsetCellDataArray ( const std::string &  name )

overridevirtual

Parameters

name

<>

Reimplemented from meshBase.

Definition at line 1043 of file vtkMesh.C.

References meshBase::dataSet.

                                                      {
  dataSet->GetCellData()->RemoveArray(name.c_str());
}

unsetFieldDataArray()

void vtkMesh::unsetFieldDataArray ( const std::string &  name )

overridevirtual

Parameters

name

<>

Reimplemented from meshBase.

Definition at line 1048 of file vtkMesh.C.

References meshBase::dataSet.

                                                       {
  dataSet->GetFieldData()->RemoveArray(name.c_str());
}

unsetPointDataArray() [1/2]

void vtkMesh::unsetPointDataArray ( int  arrayID )

overridevirtual

Parameters

arrayID

<>

Reimplemented from meshBase.

Definition at line 1030 of file vtkMesh.C.

References meshBase::dataSet.

                                             {
  dataSet->GetPointData()->RemoveArray(arrayID);
}

unsetPointDataArray() [2/2]

void vtkMesh::unsetPointDataArray ( const std::string &  name )

overridevirtual

Parameters

name

<>

Reimplemented from meshBase.

Definition at line 1034 of file vtkMesh.C.

References meshBase::dataSet.

                                                       {
  dataSet->GetPointData()->RemoveArray(name.c_str());
}

write() [1/2]

void vtkMesh::write ( ) const

inlineoverridevirtual

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

Reimplemented from meshBase.

Definition at line 152 of file vtkMesh.H.

References data, meshBase::getCellDataArray(), meshBase::getCellDataIdx(), meshBase::getPointDataArray(), meshBase::setCellDataArray(), meshBase::setPointDataArray(), meshBase::unsetCellDataArray(), meshBase::unsetFieldDataArray(), meshBase::unsetPointDataArray(), and meshBase::write().

Referenced by NEM::GEO::rocPack::createCohesiveElements(), NEM::DRV::FoamToVtkConversionDriver::execute(), and meshBase::exportExoToVtk().

{ meshBase::write(); }

write() [2/2]

void vtkMesh::write ( const std::string &  fname ) const

overridevirtual

Parameters

fname

The name of the file to write to

Implements meshBase.

Definition at line 71 of file vtkMesh.C.

References meshBase::dataSet, nemAux::find_ext(), and nemAux::trim_fname().

                                                {
  if (!dataSet) {
    std::cout << "No dataSet to write!" << std::endl;
    exit(1);
  }

  std::string extension = nemAux::find_ext(fname);

  if (extension == ".vtp")
    writeVTFile<vtkXMLPolyDataWriter>(fname, dataSet);
  else if (extension == ".vts")
    writeVTFile<vtkXMLStructuredGridWriter>(fname, dataSet);
  else if (extension == ".vtr")
    writeVTFile<vtkXMLRectilinearGridWriter>(fname, dataSet);
  else if (extension == ".vti")
    writeVTFile<vtkXMLImageDataWriter>(fname, dataSet);
  else if (extension == ".stl")
    writeVTFile<vtkSTLWriter>(fname, dataSet);  // ascii stl
  else if (extension == ".vtk")
    writeVTFile<vtkUnstructuredGridWriter>(fname,
                                           dataSet);  // legacy vtk writer
  else {
    std::string fname_tmp = nemAux::trim_fname(fname, ".vtu");
    // default is vtu
    writeVTFile<vtkXMLUnstructuredGridWriter>(fname_tmp, dataSet);
  }
}

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

filename

std::string meshBase::filename

protectedinherited

Definition at line 726 of file meshBase.H.

Referenced by FOAM::foamMesh::report(), report(), and 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(), getCell(), meshSrch::getCellVec(), FOAM::foamMesh::getCellVec(), getCellVec(), merge(), ReadALegacyVTKFile(), ReadDegenerateVTKFile(), readLegacyVTKCells(), FOAM::foamMesh::report(), report(), setCellDataArray(), 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(), getVertCrds(), merge(), ReadALegacyVTKFile(), ReadDegenerateVTKFile(), readLegacyVTKPoints(), FOAM::foamMesh::report(), report(), setPointDataArray(), 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.

---

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

• vtkMesh.H
• vtkMesh.C