NEM::MSH::exoGeoMesh Class Reference

A concrete implementation of geoMeshBase representing an Exodus II mesh. More...

Detailed Description

Note that only the title, dimension, element blocks, element block properties, element block variables, node variables, global variables, node sets, and side sets (and the names of each of these fields) are read and stored in an exoGeoMesh class. Side set sides are ignored if the source element does not have the same dimensionality as the mesh.

Definition at line 56 of file exoGeoMesh.H.

Classes
struct	elemBlock
struct	nodeSet

Public Member Functions
vtkSmartPointer< vtkPolyData >	getSS ()
	exoGeoMesh ()
	Reads an EXODUS II file into an exoGeoMesh object. More...
	exoGeoMesh (const std::string &fileName, int timeStep=1)
	exoGeoMesh constructor from file. More...
	~exoGeoMesh () override
void	write (const std::string &fileName) override
	Write exoGeoMesh out to a file. More...
void	report (std::ostream &out) const override
	Write a summary of this exoGeoMesh to out. More...
void	reconstructGeo () override
	Construct the geometry from the mesh alone. More...
void	takeGeoMesh (geoMeshBase *otherGeoMesh) override
	Take the GeoMesh of another geoMeshBase. More...
const std::string &	getTitle () const
	Get the title of the exoGeoMesh (used for writing out to EXODUS II file) More...
void	setTitle (const std::string &title)
	Set the title of the exoGeoMesh (used for writing out to EXODUS II file) More...
int	getNumElemBlocks () const
	Get number of element blocks. More...
std::map< int, std::string >	getElemBlockNames () const
	Get all element block names. More...
const std::string &	getElemBlockName (int id) const
	Get the name of an element block (used for writing out to EXODUS II file) More...
void	setElemBlockName (int id, const std::string &name)
	Set the name of an element block (used for writing out to EXODUS II file) More...
std::vector< int >	getElemBlockIds () const
	Get all element block IDs. More...
int	getElemBlockId (vtkIdType cellIdx) const
	Get the element block ID of a cell. More...
std::vector< vtkIdType >	getElemBlock (int blockId) const
	Get (0-based) indices of the cells that are in a specific element block. More...
int	addElemBlock (vtkUnstructuredGrid *elements, const std::string &name="", float tol=1e-15f)
	Add a new element block to the mesh. More...
void	addCellsToBlock (vtkUnstructuredGrid *elements, int blockId, float tol=1e-15f)
	Add cells to an existing element block. More...
int	reassignCells (const std::vector< vtkIdType > &cells, int blockId=-1, const std::string &elemBlockName={})
	Reassign cells to a different element block. More...
bool	addElemBlockProperty (const std::string &propName)
	Add a property to element blocks (with default value 0 on all element blocks) More...
std::vector< std::string >	getElemBlockPropertyNames () const
	Get the names of all block properties. More...
int	getElemBlockProperty (const std::string &propName, int blockId) const
	Get the value of an element block property on a block. More...
void	setElemBlockProperty (const std::string &propName, int blockId, int value)
	Set the value of an element block property on a block. More...
int	getNumSideSets () const
	Get number of side sets. More...
const std::map< int, std::string > &	getSideSetNames () const
	Get all side set names. More...
const std::string &	getSideSetName (int id) const
	Get the name of a side set (used for writing out to EXODUS II file) More...
void	setSideSetName (int id, const std::string &name)
	Set the name of a side set (used for writing out to EXODUS II file) More...
std::vector< int >	getSideSetIds () const
	Get all side set IDs. More...
std::pair< std::vector< vtkIdType >, std::vector< int > >	getSideSet (int sideSetId) const
	Get sides in a side set. More...
int	addSideSet (const std::vector< vtkIdType > &elements, const std::vector< int > &sides, const std::string &name="")
	Add a new side set. More...
int	getNumNodeSets () const
	Get number of node sets. More...
std::map< int, std::string >	getNodeSetNames () const
	Get all node set names. More...
const std::string &	getNodeSetName (int id) const
	Get the name of a node set (used for writing out to EXODUS II file) More...
void	setNodeSetName (int id, const std::string &name)
	Set the name of a node set (used for writing out to EXODUS II file) More...
std::vector< int >	getNodeSetIds () const
	Get the IDs of all node sets. More...
const std::vector< vtkIdType > &	getNodeSet (int nodeSetId) const
	Get the nodes of a node set. More...
int	addNodeSet (const std::vector< vtkIdType > &nodes, const std::string &name="")
	Add a new node set. More...
const std::string &	getPhysGrpPropertyName () const
	Get the name of the element block property that maps element blocks to physical groups (if empty, each element block represents its own physical group) More...
void	setPhysGrpPropertyName (const std::string &physGrpName)
	Sets the name of the element block property that maps element blocks to physical groups (if empty, each element block represents its own physical group) More...
void	stitch (const exoGeoMesh &otherGM, float tol=1e-15f)
	Stitch another exoGeoMesh object onto this one. More...
void	scaleNodes (double scale)
	Scale point locations. More...
virtual void	mergeGeoMesh (geoMeshBase *otherGeoMesh)
	Merge mesh data from a new geoMesh to an existing geoMesh. More...
const std::string &	getGeoEntArrayName () const
	Get the name of the geometric entities array. More...
void	setGeoEntArrayName (const std::string &geoEntArrayName)
	Set the name of the geometric entities array. More...
double	getAngleThreshold () const
	Get the angle threshold used for surface classification. More...
void	setAngleThreshold (double angleThreshold)
	Set the angle threshold used for surface classification. More...
nemId_t	getNumberOfPoints () const
	Get the number of points in mesh. More...
nemId_t	getNumberOfCells () const
	Get the number of cells in mesh. More...
void	getPoint (nemId_t id, std::array< double, 3 > *x) const
	Get the coordinate of a point. More...
std::array< double, 3 >	getPoint (nemId_t id) const
	Get the coordinate of a point. More...
void	getCell (nemId_t cellId, vtkGenericCell *cell) const
	Get cell. More...
vtkCell *	getCell (nemId_t cellId) const
	Get cell. More...
void	getCellBounds (nemId_t cellId, std::array< double, 6 > *bounds) const
	Get cell bounds. More...
std::array< double, 6 >	getCellBounds (nemId_t cellId) const
	Get cell bounds. More...
VTKCellType	getCellType (nemId_t cellId) const
	Get VTK cell type. More...
void	getCellPoints (nemId_t cellId, vtkIdList *ptIds) const
	Get list of point ids defining specified cell. More...
void	getPointCells (nemId_t ptId, vtkIdList *cellIds) const
	Get list of cell ids using specified point. More...
void	getCellNeighbors (nemId_t cellId, vtkIdList *ptIds, vtkIdList *cellIds) const
	Get list of cells sharing points ptIds excluding cellId. More...
int	getNumberOfPointDataArrays () const
	Get number of arrays in the point data. More...
void	getPointDataArrayCopy (const std::string &arrayName, vtkAbstractArray *array, int *arrayIdx=nullptr) const
	Get copy of point data array by name. More...
vtkSmartPointer< vtkAbstractArray >	getPointDataArrayCopy (const std::string &arrayName, int *arrayIdx=nullptr) const
	Create and return a copy of point data array by name. More...
void	getPointDataArrayCopy (int arrayIdx, vtkAbstractArray *array) const
	Get copy of point data array by index. More...
vtkSmartPointer< vtkAbstractArray >	getPointDataArrayCopy (int arrayIdx) const
	Create and return a copy of point data array by index. More...
int	getNumberOfCellDataArrays () const
	Get number of arrays in the cell data. More...
void	getCellDataArrayCopy (const std::string &arrayName, vtkAbstractArray *array, int *arrayIdx=nullptr) const
	Get copy of cell data array by name. More...
vtkSmartPointer< vtkAbstractArray >	getCellDataArrayCopy (const std::string &arrayName, int *arrayIdx=nullptr) const
	Create and return a copy of cell data array by name. More...
void	getCellDataArrayCopy (int arrayIdx, vtkAbstractArray *array) const
	Get copy of cell data array by index. More...
vtkSmartPointer< vtkAbstractArray >	getCellDataArrayCopy (int arrayIdx) const
	Create and return a copy of cell data array by index. More...
int	getNumberOfFieldDataArrays () const
	Get number of arrays in the field data. More...
void	getFieldDataArrayCopy (const std::string &arrayName, vtkAbstractArray *array, int *arrayIdx=nullptr) const
	Get copy of field data array by name. More...
vtkSmartPointer< vtkAbstractArray >	getFieldDataArrayCopy (const std::string &arrayName, int *arrayIdx=nullptr) const
	Create and return a copy of field data array by name. More...
void	getFieldDataArrayCopy (int arrayIdx, vtkAbstractArray *array) const
	Get copy of field data array by index. More...
vtkSmartPointer< vtkAbstractArray >	getFieldDataArrayCopy (int arrayIdx) const
	Create and return a copy of field data array by index. More...

Static Public Member Functions
static exoGeoMesh *	New ()

Protected Member Functions
	exoGeoMesh (const vtkSmartPointer< vtkExodusIIReader > &reader)
	exoGeoMesh constructor from vtkExodusIIReader More...
int	setPointDataArray (vtkAbstractArray *array)
	Set point data. More...
int	setCellDataArray (vtkAbstractArray *array)
	Set cell data. More...
int	setFieldDataArray (vtkAbstractArray *array)
	Set field data. More...
void	unsetPointDataArray (int arrayIdx)
	Remove point data array by index. More...
void	unsetPointDataArray (const std::string &arrayName)
	Remove point data array by name. More...
void	unsetCellDataArray (int arrayIdx)
	Remove cell data array by index. More...
void	unsetCellDataArray (const std::string &arrayName)
	Remove cell data array by name. More...
void	unsetFieldDataArray (int arrayIdx)
	Remove field data array by index. More...
void	unsetFieldDataArray (const std::string &arrayName)
	Remove field data array by name. More...
const GeoMesh &	getGeoMesh () const
	Get the underlying geometry object. More...
void	setGeoMesh (const geoMeshBase::GeoMesh &geoMesh)
	Set the underlying geometry object. More...

Static Protected Attributes
static constexpr auto	GEO_ENT_DEFAULT_NAME = "GeoEnt"

Private Member Functions
void	resetElemBlocks ()
	Clears element block names, element block properties. More...
void	resetNodeSetPoints (vtkIdTypeArray *nodeMap=nullptr)
	Renumbers the nodes in all node sets based on nodeMap if provided. More...
void	setSideSetObjId ()
	Sets the (Exodus) side set IDs of each cell in the GeoMesh.sideSet by creating a side set for each pair (side entity, parent entity). More...
void	resetNative () override

Static Private Member Functions
static vtkSmartPointer< vtkExodusIIReader >	getExoReader (const std::string &fileName, int timeStep=1)
static GeoMesh	exoReader2GM (vtkSmartPointer< vtkExodusIIReader > reader)
static const char *	getExoIdArrName ()

Private Attributes
std::string	_title
std::map< int, elemBlock >	_elemBlocks
std::map< int, std::string >	_sideSetNames
std::map< int, nodeSet >	_nodeSets
std::set< std::string >	_elemBlockPropNames
std::string	_physGrpName

Inherits NEM::MSH::geoMeshBase.

Constructor & Destructor Documentation

exoGeoMesh() [1/3]

NEM::MSH::exoGeoMesh::exoGeoMesh

(

)

Parameters

fileName	Name of file to read. Empty string interpreted as creating new exoGeoMesh with empty mesh
timeStep	Time step (using EXODUS II indexing) to read

Returns

Pointer to a new exoGeoMesh object

Definition at line 257 of file exoGeoMesh.C.

Referenced by NEM::MSH::vtkStandardNewMacro().

: exoGeoMesh("") {}

exoGeoMesh() [2/3]

NEM::MSH::exoGeoMesh::exoGeoMesh ( const std::string &  fileName, int  timeStep = 1  )

explicit

Parameters

fileName	Name of EXODUS II file to read
timeStep	Time step (using EXODUS II indexing) to read

Definition at line 377 of file exoGeoMesh.C.

    : exoGeoMesh(getExoReader(fileName, timeStep)) {}

~exoGeoMesh()

NEM::MSH::exoGeoMesh::~exoGeoMesh ( )

override

Definition at line 380 of file exoGeoMesh.C.

{ std::cout << "exoGeoMesh destructed" << std::endl; }

exoGeoMesh() [3/3]

NEM::MSH::exoGeoMesh::exoGeoMesh ( const vtkSmartPointer< vtkExodusIIReader > &  reader )

explicitprotected

Note that side set side indices in the reader's output are ignored and are read from reader->GetFileName() instead. Element block properties are also read from the file separately.

Parameters

reader

Existing vtkExodusIIReader from which to create exoGeoMesh object. Update() should already have been called.

Definition at line 259 of file exoGeoMesh.C.

References _elemBlockPropNames, _elemBlocks, _nodeSets, _sideSetNames, _title, cellType, getExoIdArrName(), NEM::MSH::geoMeshBase::getGeoMesh(), NEM::MSH::geoMeshBase::GeoMesh::mesh, nodes, and nodeSets.

    : geoMeshBase(exoReader2GM(reader)) {
  if (reader && reader->GetOutput() &&
      reader->GetOutput()->GetNumberOfBlocks() == 8) {
    auto mbds = reader->GetOutput();
    _title = reader->GetTitle();
    auto elemBlocks = vtkMultiBlockDataSet::SafeDownCast(mbds->GetBlock(0));
    for (unsigned int i = 0; i < elemBlocks->GetNumberOfBlocks(); ++i) {
      std::string elemBlockName =
          elemBlocks->GetMetaData(i)->Get(vtkMultiBlockDataSet::NAME());
      auto elemBlock =
          vtkUnstructuredGrid::SafeDownCast(elemBlocks->GetBlock(i));
      int elemBlockId;
      VTKCellType cellType;
      if (elemBlock->GetNumberOfCells() > 0) {
        elemBlockId =
            vtkIntArray::FastDownCast(
                elemBlock->GetCellData()->GetAbstractArray(getExoIdArrName()))
                ->GetValue(0);
        cellType = static_cast<VTKCellType>(elemBlock->GetCellType(0));
      } else {
        elemBlockId =
            vtkIntArray::FastDownCast(
                elemBlock->GetFieldData()->GetAbstractArray("ElementBlockIds"))
                ->GetValue(0);
        cellType = VTK_EMPTY_CELL;
      }
      _elemBlocks[elemBlockId] = {elemBlockName, cellType, {}};
    }
    auto sideSets = vtkMultiBlockDataSet::SafeDownCast(mbds->GetBlock(4));
    if (sideSets->GetNumberOfBlocks() >= 1) {
      for (int i = 0; i < sideSets->GetNumberOfBlocks(); ++i) {
        auto sideSetName = reader->GetSideSetArrayName(i);
        auto sideSetId = reader->GetObjectId(vtkExodusIIReader::SIDE_SET, i);
        _sideSetNames[sideSetId] = sideSetName ? sideSetName : "";
      }
    }

    auto mesh = getGeoMesh().mesh;
    std::map<vtkIdType, vtkIdType> globalNodeId2meshIdx;
    auto globalNodeIdArr =
        vtkIdTypeArray::FastDownCast(mesh->GetPointData()->GetAbstractArray(
            reader->GetGlobalNodeIdArrayName()));
    for (vtkIdType i = 0; i < mesh->GetNumberOfPoints(); ++i) {
      globalNodeId2meshIdx[globalNodeIdArr->GetValue(i)] = i;
    }
    mesh->GetPointData()->RemoveArray(reader->GetGlobalNodeIdArrayName());
    mesh->GetPointData()->RemoveArray(reader->GetPedigreeNodeIdArrayName());
    auto nodeSets = vtkMultiBlockDataSet::SafeDownCast(mbds->GetBlock(7));
    for (unsigned int i = 0; i < nodeSets->GetNumberOfBlocks(); ++i) {
      std::string nodeSetName =
          nodeSets->GetMetaData(i)->Get(vtkMultiBlockDataSet::NAME());
      auto nodeSet = vtkUnstructuredGrid::SafeDownCast(nodeSets->GetBlock(i));
      auto nodeSetId =
          vtkIntArray::FastDownCast(
              nodeSet->GetCellData()->GetAbstractArray(getExoIdArrName()))
              ->GetValue(0);
      std::vector<vtkIdType> nodes;
      nodes.reserve(nodeSet->GetNumberOfCells());
      auto nodeSetGlobalNodeIdArr = vtkIdTypeArray::FastDownCast(
          nodeSet->GetPointData()->GetAbstractArray(
              reader->GetGlobalNodeIdArrayName()));
      for (vtkIdType j = 0; j < nodeSet->GetNumberOfCells(); ++j) {
        auto nodeGlobalId = nodeSetGlobalNodeIdArr->GetValue(
            nodeSet->GetCell(j)->GetPointId(0));
        auto find = globalNodeId2meshIdx.find(nodeGlobalId);
        if (find != globalNodeId2meshIdx.end()) {
          nodes.emplace_back(find->second);
        }
      }
      _nodeSets[nodeSetId] = {nodeSetName, nodes};
    }
    // Unfortunately the vtkExodusIIReader does not seem to support exodus
    // properties at the moment.
    int comp_ws = sizeof(double);
    int io_ws = 0;
    float version;
    auto exoid =
        ex_open(reader->GetFileName(), EX_READ, &comp_ws, &io_ws, &version);
    checkExodusErr(exoid, true);
    // We get the properties in order, so, just in case, we get the element
    // block ids in order
    std::vector<int> elemBlockIds;
    elemBlockIds.resize(_elemBlocks.size());
    auto err = ex_get_ids(exoid, EX_ELEM_BLOCK, elemBlockIds.data());
    checkExodusErr(err);
    int numProps = ex_inquire_int(exoid, EX_INQ_EB_PROP);
    std::vector<std::string> propNames;
    propNames.resize(numProps);
    std::vector<const char *> propNamesPtr;
    propNamesPtr.reserve(numProps);
    for (int i = 0; i < numProps; ++i) {
      propNames[i].resize(MAX_NAME_LENGTH);
      propNamesPtr.emplace_back(propNames[i].c_str());
    }
    err = ex_get_prop_names(exoid, EX_ELEM_BLOCK,
                            const_cast<char **>(propNamesPtr.data()));
    checkExodusErr(err);
    for (int i = 0; i < numProps; ++i) {
      if (strcmp(propNamesPtr[i], "ID") != 0) {
        std::vector<int> propVals;
        propVals.resize(_elemBlocks.size());
        err = ex_get_prop_array(exoid, EX_ELEM_BLOCK, propNamesPtr[i],
                                propVals.data());
        checkExodusErr(err);
        _elemBlockPropNames.insert(propNamesPtr[i]);
        for (std::size_t j = 0; j < _elemBlocks.size(); ++j) {
          _elemBlocks[elemBlockIds[j]].properties[propNamesPtr[i]] =
              propVals[j];
        }
      }
    }
    err = ex_close(exoid);
    checkExodusErr(err);
  }
  std::cout << "exoGeoMesh constructed" << std::endl;
}

Member Function Documentation

addCellsToBlock()

void NEM::MSH::exoGeoMesh::addCellsToBlock	(	vtkUnstructuredGrid *	elements,
		int	blockId,
		float	tol = 1e-15f
	)

Invalidates geometry, if any. PointData and CellData arrays are intersected.

Parameters

elements	vtkUnstructuredGrid of cells to add to the mesh. All cells should be of the same type as cells in the block given by blockId.
blockId	ID of existing element block
tol	Tolerance for merging points

Definition at line 938 of file exoGeoMesh.C.

References _elemBlocks, NEM::MSH::exoGeoMesh::elemBlock::cellType, NEM::MSH::geoMeshBase::GeoMesh::geo, getExoIdArrName(), NEM::MSH::geoMeshBase::getGeoMesh(), NEM::MSH::geoMeshBase::GeoMesh::link, mesh, NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::New(), resetNodeSetPoints(), NEM::MSH::geoMeshBase::setGeoMesh(), and NEM::MSH::geoMeshBase::GeoMesh::sideSet.

Referenced by addElemBlock().

                                            {
  if (elements && elements->GetNumberOfCells() > 0) {
    auto types = vtkSmartPointer<vtkCellTypes>::New();
    elements->GetCellTypes(types);
    if (types->GetNumberOfTypes() > 1) {
      std::cerr << "Single element block cannot have multiple cell types"
                << std::endl;
      exit(1);
    }
    auto elemBlock = _elemBlocks.find(blockId);
    if (getGeoMesh().mesh->GetNumberOfCells() == 0) {
      _elemBlocks.clear();
      std::cerr << "No existing element blocks." << std::endl;
      exit(1);
    }
    if (elemBlock == _elemBlocks.end()) {
      std::cerr << "No existing element block with id: " << blockId
                << std::endl;
      exit(1);
    }
    if (types->GetCellType(0) != elemBlock->second.cellType) {
      std::cerr
          << "Cell type does not match cell type of existing element block."
          << std::endl;
      exit(1);
    }
    vtkSmartPointer<vtkAbstractArray> oldBlockIdArr =
        elements->GetCellData()->GetAbstractArray(getExoIdArrName());
    if (oldBlockIdArr) {
      elements->GetCellData()->RemoveArray(getExoIdArrName());
    }
    auto mesh = getGeoMesh().mesh;
    auto newBlockIdArr = vtkSmartPointer<vtkIntArray>::Take(
        vtkIntArray::FastDownCast(mesh->GetCellData()
                                      ->GetAbstractArray(getExoIdArrName())
                                      ->NewInstance()));
    newBlockIdArr->SetName(getExoIdArrName());
    newBlockIdArr->SetNumberOfValues(elements->GetNumberOfCells());
    newBlockIdArr->FillComponent(0, blockId);
    elements->GetCellData()->AddArray(newBlockIdArr);
#ifdef HAVE_GMSH
    if (!getGeoMesh().geo.empty()) {
      gmsh::model::setCurrent(getGeoMesh().geo);
      gmsh::model::remove();
      setGeoMesh({mesh, "", "", getGeoMesh().sideSet});
    }
#endif
    auto newMesh = vtkSmartPointer<vtkUnstructuredGrid>::New();
    auto nodeMaps = mergeMeshes(mesh, elements, newMesh, tol);
    setGeoMesh(
        {newMesh, getGeoMesh().geo, getGeoMesh().link, getGeoMesh().sideSet});
    resetNodeSetPoints(nodeMaps.first);
    resetSideSetPoints(newMesh, getGeoMesh().sideSet.sides, nodeMaps.first);
    elements->GetCellData()->RemoveArray(getExoIdArrName());
    if (oldBlockIdArr) {
      elements->GetCellData()->AddArray(oldBlockIdArr);
    }
  } else {
    std::cerr << "No elements to add." << std::endl;
  }
}

addElemBlock()

int NEM::MSH::exoGeoMesh::addElemBlock	(	vtkUnstructuredGrid *	elements,
		const std::string &	name = "",
		float	tol = 1e-15f
	)

Invalidates geometry, if any. PointData and CellData arrays are intersected.

Parameters

elements	vtkUnstructuredGrid of cells to add to the mesh. All cells should be of same cell type.
name	Name of new element block
tol	Tolerance for merging points

Returns

The ID of the new element block.

Definition at line 901 of file exoGeoMesh.C.

References _elemBlocks, addCellsToBlock(), NEM::MSH::exoGeoMesh::elemBlock::cellType, NEM::MSH::geoMeshBase::getGeoMesh(), nemAux::leastUnusedKey(), mesh, NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::exoGeoMesh::elemBlock::name, NEM::MSH::New(), resetNative(), and NEM::MSH::geoMeshBase::setGeoMesh().

                                                               {
  if (elements && elements->GetNumberOfCells() > 0) {
    auto types = vtkSmartPointer<vtkCellTypes>::New();
    elements->GetCellTypes(types);
    if (types->GetNumberOfTypes() > 1) {
      std::cerr << "Single element block cannot have multiple cell types"
                << std::endl;
      return -1;
    }
    auto mesh = getGeoMesh().mesh;
    if (mesh->GetNumberOfCells() == 0) {
      mesh->DeepCopy(elements);
#ifdef HAVE_GMSH
      if (!getGeoMesh().geo.empty()) {
        gmsh::model::setCurrent(getGeoMesh().geo);
        gmsh::model::remove();
      }
#endif
      setGeoMesh({mesh, "", "", {}});
      resetNative();
      // Assumption that there is exactly one element block now.
      return _elemBlocks.begin()->first;
    } else {
      int newElemBlockId = nemAux::leastUnusedKey(_elemBlocks);
      auto &elemBlock = _elemBlocks[newElemBlockId];
      elemBlock.cellType = static_cast<VTKCellType>(types->GetCellType(0));
      elemBlock.name = name;
      addCellsToBlock(elements, newElemBlockId, tol);
      return newElemBlockId;
    }
  } else {
    std::cerr << "No elements to add." << std::endl;
    return -1;
  }
}

addElemBlockProperty()

bool NEM::MSH::exoGeoMesh::addElemBlockProperty

(

const std::string &

propName

)

Parameters

propName

Name of new property

Returns

Whether or not new property was added

Definition at line 1040 of file exoGeoMesh.C.

References _elemBlockPropNames, and NEM::MSH::geoMeshBase::getGeoMesh().

                                                               {
  if (getGeoMesh().mesh->GetNumberOfCells() == 0) {
    return false;
  }
  return _elemBlockPropNames.insert(propName).second;
}

addNodeSet()

int NEM::MSH::exoGeoMesh::addNodeSet	(	const std::vector< vtkIdType > &	nodes,
		const std::string &	name = ""
	)

Parameters

nodes	Node indices that should belong on the new node set (0-based indexing)
name	Name of new node set

Returns

ID of new node set

Definition at line 1257 of file exoGeoMesh.C.

References _nodeSets, NEM::MSH::geoMeshBase::getGeoMesh(), nemAux::leastUnusedKey(), and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                  {
  if (!nodes.empty()) {
    auto minmax = std::minmax_element(nodes.begin(), nodes.end());
    if (*minmax.first < 0) {
      std::cerr << "Unknown node " << *minmax.first << std::endl;
      return -1;
    } else if (*minmax.second >= getGeoMesh().mesh->GetNumberOfPoints()) {
      std::cerr << "Unknown node " << *minmax.second << std::endl;
      return -1;
    }
    auto newId = nemAux::leastUnusedKey(_nodeSets);
    _nodeSets[newId] = {name, nodes};
    return newId;
  }
  return -1;
}

addSideSet()

int NEM::MSH::exoGeoMesh::addSideSet	(	const std::vector< vtkIdType > &	elements,
		const std::vector< int > &	sides,
		const std::string &	name = ""
	)

Parameters

elements	The (0-based) index of the cells that each side comes from
sides	The index of the face/edge that of the side (according to VTK face/edge ordering)
name	Name of new side set

Returns

ID of new side set

Definition at line 1145 of file exoGeoMesh.C.

References _sideSetNames, NEM::MSH::geoMeshBase::GeoMesh::geo, getExoIdArrName(), NEM::MSH::geoMeshBase::SideSet::getGeoEntArr(), NEM::MSH::geoMeshBase::getGeoMesh(), nemAux::leastUnusedKey(), NEM::MSH::geoMeshBase::GeoMesh::link, NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::New(), NEM::MSH::geoMeshBase::setGeoMesh(), and NEM::MSH::geoMeshBase::GeoMesh::sideSet.

                                                  {
  if (!elements.empty() && elements.size() == sides.size()) {
    auto newId = nemAux::leastUnusedKey(_sideSetNames);
    auto gm = getGeoMesh();
    if (!gm.sideSet.sides) {
      auto sideSetPD = vtkSmartPointer<vtkPolyData>::New();
      sideSetPD->Allocate();
      sideSetPD->SetPoints(getGeoMesh().mesh->GetPoints());
      auto sideSetExoId = vtkSmartPointer<vtkIntArray>::New();
      sideSetExoId->SetName(getExoIdArrName());
      sideSetPD->GetCellData()->AddArray(sideSetExoId);
      auto sideSetEntities = vtkSmartPointer<vtkIntArray>::New();
      auto sideSetOrigCellId = vtkSmartPointer<vtkIdTypeArray>::New();
      sideSetOrigCellId->SetNumberOfComponents(2);
      auto sideSetCellFaceId = vtkSmartPointer<vtkIntArray>::New();
      sideSetCellFaceId->SetNumberOfComponents(2);
      setGeoMesh(
          {getGeoMesh().mesh,
           getGeoMesh().geo,
           getGeoMesh().link,
           {sideSetPD, sideSetEntities, sideSetOrigCellId, sideSetCellFaceId}});
    }
    auto sideSet = getGeoMesh().sideSet;
    auto sideSetExoId = vtkIntArray::FastDownCast(
        sideSet.sides->GetCellData()->GetAbstractArray(getExoIdArrName()));
    sideSetExoId->Resize(sideSet.sides->GetNumberOfCells() + elements.size());
    auto sideSetEntities = sideSet.getGeoEntArr();
    sideSetEntities->Resize(sideSet.sides->GetNumberOfCells() +
                            elements.size());
    auto sideSetOrigCellId = sideSet.getOrigCellArr();
    sideSetOrigCellId->Resize(sideSet.sides->GetNumberOfCells() +
                              elements.size());
    auto sideSetCellFaceId = sideSet.getCellFaceArr();
    sideSetCellFaceId->Resize(sideSet.sides->GetNumberOfCells() +
                              elements.size());

    auto mesh = getGeoMesh().mesh;
    auto elemIt = elements.begin();
    auto sidesIt = sides.begin();
    for (; elemIt != elements.end(); ++sidesIt, ++elemIt) {
      auto parent = mesh->GetCell(*elemIt);
      if (!parent) {
        std::cerr << "No cell found with index " << *elemIt << std::endl;
        continue;
      }
      auto side = parent->GetCellDimension() == 2 ? parent->GetEdge(*sidesIt)
                                                  : parent->GetFace(*sidesIt);
      sideSet.sides->InsertNextCell(side->GetCellType(), side->GetPointIds());
      sideSetExoId->InsertNextValue(newId);
      sideSetEntities->InsertNextValue(newId);
      sideSetOrigCellId->InsertNextTuple2(*elemIt, -1);
      sideSetCellFaceId->InsertNextTuple2(*sidesIt, -1);
    }

    _sideSetNames[newId] = name;
    return newId;
  }
  return -1;
}

exoReader2GM()

geoMeshBase::GeoMesh NEM::MSH::exoGeoMesh::exoReader2GM ( vtkSmartPointer< vtkExodusIIReader >  reader )

staticprivate

Definition at line 1472 of file exoGeoMesh.C.

References getExoIdArrName(), mesh, and NEM::MSH::New().

                                               {
  auto mesh = vtkSmartPointer<vtkUnstructuredGrid>::New();
  SideSet sideSet{};
  if (!reader) {
    return {mesh, "", "", {}};
  }

  auto mbds = reader->GetOutput();
  if (mbds->GetNumberOfBlocks() != 8) {
    std::cerr << "Malformed output of vtkExodusIIReader. Check that file "
                 "exists and is valid Exodus II file."
              << std::endl;
    exit(1);
  }
  // Map from "GlobalElementId", set by vtkExodusIIReader, to the index in
  // mesh, which becomes GeoMesh.mesh
  std::map<vtkIdType, vtkIdType> elemId2MeshIdx;
  if (reader->GetNumberOfElementsInFile() > 0) {
    auto exoElemBlocks = vtkMultiBlockDataSet::SafeDownCast(mbds->GetBlock(0));
    auto merge = vtkSmartPointer<mergeCells>::New();
    merge->SetUnstructuredGrid(mesh);
    merge->SetTotalNumberOfDataSets(exoElemBlocks->GetNumberOfBlocks());
    merge->SetTotalNumberOfPoints(reader->GetNumberOfNodes());
    merge->SetTotalNumberOfCells(reader->GetTotalNumberOfElements());
    merge->SetUseGlobalIds(1);
    merge->SetUseGlobalCellIds(1);
    auto it = vtkSmartPointer<vtkCompositeDataIterator>::Take(
        exoElemBlocks->NewIterator());
    for (it->InitTraversal(); !it->IsDoneWithTraversal(); it->GoToNextItem()) {
      merge->MergeDataSet(vtkDataSet::SafeDownCast(it->GetCurrentDataObject()));
    }
    merge->Finish();
    for (int i = mesh->GetCellData()->GetNumberOfArrays() - 1; i >= 0; --i) {
      if (mesh->GetCellData()->GetArray(i)->GetNumberOfTuples() !=
          mesh->GetNumberOfCells()) {
        mesh->GetCellData()->RemoveArray(i);
      }
    }
    for (int i = mesh->GetPointData()->GetNumberOfArrays() - 1; i >= 0; --i) {
      if (mesh->GetPointData()->GetArray(i)->GetNumberOfTuples() !=
          mesh->GetNumberOfPoints()) {
        mesh->GetPointData()->RemoveArray(i);
      }
    }
    auto globalElemIdArr = vtkIdTypeArray::FastDownCast(
        mesh->GetCellData()->GetArray(reader->GetGlobalElementIdArrayName()));
    for (vtkIdType i = 0; i < mesh->GetNumberOfCells(); ++i) {
      elemId2MeshIdx[globalElemIdArr->GetValue(i)] = i;
    }
    mesh->GetCellData()->RemoveArray(reader->GetPedigreeElementIdArrayName());
    mesh->GetCellData()->RemoveArray(reader->GetGlobalElementIdArrayName());
  }
  if (reader->GetNumberOfSideSetArrays() > 0 &&
      reader->GetDimensionality() >= 2) {
    auto sideSetPD = vtkSmartPointer<vtkPolyData>::New();
    sideSetPD->SetPoints(mesh->GetPoints());
    sideSetPD->Allocate();
    auto sideSetExoId = vtkSmartPointer<vtkIntArray>::New();
    sideSetExoId->SetName(getExoIdArrName());
    auto sideSetEntities = vtkSmartPointer<vtkIntArray>::New();
    auto sideSetOrigCellId = vtkSmartPointer<vtkIdTypeArray>::New();
    sideSetOrigCellId->SetNumberOfComponents(2);
    auto sideSetCellFaceId = vtkSmartPointer<vtkIntArray>::New();
    sideSetCellFaceId->SetNumberOfComponents(2);

    int comp_ws = sizeof(double);
    int io_ws = 0;
    float version;
    auto exoid =
        ex_open(reader->GetFileName(), EX_READ, &comp_ws, &io_ws, &version);
    checkExodusErr(exoid, true);

    auto exoSideSets = vtkMultiBlockDataSet::SafeDownCast(mbds->GetBlock(4));
    for (unsigned int i = 0; i < exoSideSets->GetNumberOfBlocks(); ++i) {
      auto exoSideSet =
          vtkUnstructuredGrid::SafeDownCast(exoSideSets->GetBlock(i));
      // vtkExodusIIReader sets the element id off by 1 compared to
      // GlobalElementId (see vtkExodusIIReader.cxx::832 in v7.1.0)
      auto sourceElemArr = vtkIdTypeArray::FastDownCast(
          exoSideSet->GetCellData()->GetAbstractArray(
              reader->GetSideSetSourceElementIdArrayName()));
      auto objectIdArr = exoSideSet->GetCellData()->GetArray(getExoIdArrName());
      // Because the element ids are off by 1 compared to GlobalElementId,
      // the side number is off because the wrong parent cell type is used to
      // convert Exodus side index to VTK side index. Thus we do not use
      // exoSideSet->GetCellData()->GetAbstractArray(
      //     reader->GetSideSetSourceElementSideArrayName());
      // and instead read from the file.
      // Here we rely on the assumption that vtkExodusIIReader does not change
      // the order of entries in the side set.
      std::vector<int> sourceSideVec;
      sourceSideVec.resize(exoSideSet->GetNumberOfCells());
      auto err = ex_get_set(
          exoid, EX_SIDE_SET,
          vtkIntArray::FastDownCast(
              exoSideSet->GetCellData()->GetAbstractArray(getExoIdArrName()))
              ->GetValue(0),
          nullptr, sourceSideVec.data());
      checkExodusErr(err);

      for (vtkIdType j = 0; j < exoSideSet->GetNumberOfCells(); ++j) {
        auto origCellId = elemId2MeshIdx.at(sourceElemArr->GetValue(j) + 1);
        auto parent = mesh->GetCell(origCellId);
        auto cellFaceId = exoSide2vtkSide(
            sourceSideVec[j], static_cast<VTKCellType>(parent->GetCellType()));
        if (reader->GetDimensionality() == parent->GetCellDimension()) {
          if (reader->GetDimensionality() == 2) {
            auto edge = parent->GetEdge(cellFaceId);
            sideSetPD->InsertNextCell(edge->GetCellType(), edge->GetPointIds());
          } else if (reader->GetDimensionality() == 3) {
            auto face = parent->GetFace(cellFaceId);
            sideSetPD->InsertNextCell(face->GetCellType(), face->GetPointIds());
          }
          sideSetExoId->InsertNextValue(
              static_cast<int>(objectIdArr->GetComponent(j, 0)));
          sideSetEntities->InsertNextValue(
              static_cast<int>(objectIdArr->GetComponent(j, 0)));
          sideSetOrigCellId->InsertNextTuple2(origCellId, -1);
          sideSetCellFaceId->InsertNextTuple2(cellFaceId, -1);
        }
      }
    }
    sideSetPD->GetCellData()->AddArray(sideSetExoId);
    sideSetPD->Squeeze();
    sideSet = {sideSetPD, sideSetEntities, sideSetOrigCellId,
               sideSetCellFaceId};
    auto err = ex_close(exoid);
    checkExodusErr(err);
  }
  return {mesh, "", "", sideSet};
}

getAngleThreshold()

double NEM::MSH::geoMeshBase::getAngleThreshold ( ) const

inlineinherited

Returns

angle threshold (in radians)

Definition at line 171 of file geoMeshBase.H.

{ return _angleThreshold; }

getCell() [1/2]

void NEM::MSH::geoMeshBase::getCell ( nemId_t  cellId, vtkGenericCell *  cell  ) const

inlineinherited

Parameters

cellId	cell id
cell	cell

Definition at line 214 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

                                                           {
    _geoMesh.mesh->GetCell(cellId, cell);
  }

getCell() [2/2]

vtkCell* NEM::MSH::geoMeshBase::getCell ( nemId_t  cellId ) const

inlineinherited

Parameters

cellId

cell id

Returns

cell

Definition at line 222 of file geoMeshBase.H.

                                         {
    return _geoMesh.mesh->GetCell(cellId);
  }

getCellBounds() [1/2]

void NEM::MSH::geoMeshBase::getCellBounds ( nemId_t  cellId, std::array< double, 6 > *  bounds  ) const

inlineinherited

Parameters

cellId	cell id
bounds	array of bounds as (x_min,x_max, y_min,y_max, z_min,z_max)

Definition at line 230 of file geoMeshBase.H.

                                                                        {
    _geoMesh.mesh->GetCellBounds(cellId, bounds->data());
  }

getCellBounds() [2/2]

std::array<double, 6> NEM::MSH::geoMeshBase::getCellBounds ( nemId_t  cellId ) const

inlineinherited

Parameters

cellId

cell id

Returns

array of bounds as (x_min,x_max, y_min,y_max, z_min,z_max)

Definition at line 238 of file geoMeshBase.H.

                                                          {
    std::array<double, 6> bounds{};
    getCellBounds(cellId, &bounds);
    return bounds;
  }

getCellDataArrayCopy() [1/4]

void NEM::MSH::geoMeshBase::getCellDataArrayCopy ( const std::string &  arrayName, vtkAbstractArray *  array, int *  arrayIdx = nullptr  ) const

inherited

Optionally, get array index.

Parameters

arrayName	array name
array	cell data array
arrayIdx	array index

Definition at line 180 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

Referenced by NEM::MSH::diffMesh().

                                                            {
  getArrCopy(_geoMesh.mesh->GetCellData(), arrayName, arrayIdx, array);
}

getCellDataArrayCopy() [2/4]

vtkSmartPointer< vtkAbstractArray > NEM::MSH::geoMeshBase::getCellDataArrayCopy ( const std::string &  arrayName, int *  arrayIdx = nullptr  ) const

inherited

Optionally, get array index.

Parameters

arrayName	array name
arrayIdx	array index

Returns

pointer to copy of array

Definition at line 186 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                     {
  return getArrCopy(_geoMesh.mesh->GetCellData(), arrayName, arrayIdx);
}

getCellDataArrayCopy() [3/4]

void NEM::MSH::geoMeshBase::getCellDataArrayCopy ( int  arrayIdx, vtkAbstractArray *  array  ) const

inherited

Parameters

arrayIdx	array index
array	cell data array

Definition at line 191 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                                      {
  getArrCopy(_geoMesh.mesh->GetCellData(), arrayIdx, array);
}

getCellDataArrayCopy() [4/4]

vtkSmartPointer< vtkAbstractArray > NEM::MSH::geoMeshBase::getCellDataArrayCopy ( int  arrayIdx ) const

inherited

Parameters

arrayIdx

array index

Returns

pointer to copy of array

Definition at line 196 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                        {
  return getArrCopy(_geoMesh.mesh->GetCellData(), arrayIdx);
}

getCellNeighbors()

void NEM::MSH::geoMeshBase::getCellNeighbors ( nemId_t  cellId, vtkIdList *  ptIds, vtkIdList *  cellIds  ) const

inlineinherited

Parameters

cellId	id of cell to exclude
ptIds	point id
cellIds	list of cell ids

Definition at line 273 of file geoMeshBase.H.

                                                  {
    _geoMesh.mesh->GetCellNeighbors(cellId, ptIds, cellIds);
  }

getCellPoints()

void NEM::MSH::geoMeshBase::getCellPoints ( nemId_t  cellId, vtkIdList *  ptIds  ) const

inlineinherited

Parameters

cellId	cell id
ptIds	list of point ids

Definition at line 256 of file geoMeshBase.H.

                                                             {
    _geoMesh.mesh->GetCellPoints(cellId, ptIds);
  }

getCellType()

VTKCellType NEM::MSH::geoMeshBase::getCellType ( nemId_t  cellId ) const

inlineinherited

Parameters

cellId

cell id

Returns

VTK cell type (see vtk documentation for specifics)

Definition at line 248 of file geoMeshBase.H.

                                                {
    return static_cast<VTKCellType>(_geoMesh.mesh->GetCellType(cellId));
  }

getElemBlock()

std::vector< vtkIdType > NEM::MSH::exoGeoMesh::getElemBlock

(

int

blockId

)

const

Parameters

blockId

ID of an element block

Returns

Indices of all cells that belong to blockID

Definition at line 869 of file exoGeoMesh.C.

References _elemBlocks, getExoIdArrName(), NEM::MSH::geoMeshBase::getGeoMesh(), and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                               {
  auto blockIt = _elemBlocks.find(blockId);
  if (blockIt == _elemBlocks.end()) {
    std::cerr << "No block found with id: " << blockId << std::endl;
    exit(1);
  }
  std::vector<vtkIdType> cellIdxList;
  auto elemBlockIdArr = vtkIntArray::FastDownCast(
      getGeoMesh().mesh->GetCellData()->GetAbstractArray(getExoIdArrName()));
  for (vtkIdType i = 0; i < getGeoMesh().mesh->GetNumberOfCells(); ++i) {
    if (elemBlockIdArr->GetValue(i) == blockId) {
      cellIdxList.emplace_back(i);
    }
  }
  return cellIdxList;
}

getElemBlockId()

int NEM::MSH::exoGeoMesh::getElemBlockId

(

vtkIdType

cellIdx

)

const

Parameters

cellIdx

0-based index of a cell

Returns

block ID that the cell belongs to; -1 if not found

Definition at line 886 of file exoGeoMesh.C.

References getExoIdArrName(), NEM::MSH::geoMeshBase::getGeoMesh(), and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                      {
  auto mesh = getGeoMesh().mesh;
  if (!mesh || mesh->GetNumberOfCells() == 0) {
    std::cerr << "Mesh is empty. No cells to find" << std::endl;
    return -1;
  }
  if (cellIdx < 0 || cellIdx >= mesh->GetNumberOfCells()) {
    std::cerr << "No cell found with index: " << cellIdx << std::endl;
    return -1;
  }
  auto elemBlockIdArr = vtkIntArray::FastDownCast(
      mesh->GetCellData()->GetAbstractArray(getExoIdArrName()));
  return elemBlockIdArr->GetValue(cellIdx);
}

getElemBlockIds()

std::vector< int > NEM::MSH::exoGeoMesh::getElemBlockIds

(

)

const

Returns

All element block IDs.

Definition at line 860 of file exoGeoMesh.C.

References _elemBlocks.

                                                 {
  std::vector<int> ids;
  ids.reserve(_elemBlocks.size());
  for (const auto &elemBlock : _elemBlocks) {
    ids.emplace_back(elemBlock.first);
  }
  return ids;
}

getElemBlockName()

const std::string & NEM::MSH::exoGeoMesh::getElemBlockName

(

int

id

)

const

Parameters

id	ID of the element block

Returns

reference to block name

Definition at line 840 of file exoGeoMesh.C.

References _elemBlocks.

                                                          {
  auto it = _elemBlocks.find(id);
  if (it == _elemBlocks.end()) {
    std::cerr << "No block found with id: " << id << std::endl;
    exit(1);
  } else {
    return it->second.name;
  }
}

getElemBlockNames()

std::map< int, std::string > NEM::MSH::exoGeoMesh::getElemBlockNames

(

)

const

Returns

element block names, indexed by ID

Definition at line 829 of file exoGeoMesh.C.

References _elemBlocks.

                                                           {
  std::map<int, std::string> names;
  std::transform(_elemBlocks.begin(), _elemBlocks.end(),
                 std::inserter(names, names.begin()),
                 [](const decltype(_elemBlocks)::value_type &block)
                     -> decltype(names)::value_type {
                   return {block.first, block.second.name};
                 });
  return names;
}

getElemBlockProperty()

int NEM::MSH::exoGeoMesh::getElemBlockProperty	(	const std::string &	propName,
		int	blockId
	)		const

Parameters

propName	Name of an element block property
blockId	ID of an element block

Returns

Value of a property on an element block

Definition at line 1053 of file exoGeoMesh.C.

References _elemBlockPropNames, and _elemBlocks.

Referenced by reconstructGeo(), and setPhysGrpPropertyName().

                                                        {
  if (_elemBlockPropNames.find(propName) == _elemBlockPropNames.end()) {
    std::cerr << "No property found with name: " << propName << std::endl;
    exit(1);
  }
  auto blockIt = _elemBlocks.find(blockId);
  if (blockIt == _elemBlocks.end()) {
    std::cerr << "No block found with id: " << blockId << std::endl;
    exit(1);
  } else {
    auto it = blockIt->second.properties.find(propName);
    if (it == blockIt->second.properties.end()) {
      return 0;
    } else {
      return it->second;
    }
  }
}

getElemBlockPropertyNames()

std::vector< std::string > NEM::MSH::exoGeoMesh::getElemBlockPropertyNames

(

)

const

Returns

Names of all element block properties

Definition at line 1047 of file exoGeoMesh.C.

References _elemBlockPropNames.

                                                                 {
  std::vector<std::string> names;
  names.assign(_elemBlockPropNames.begin(), _elemBlockPropNames.end());
  return names;
}

getExoIdArrName()

const char * NEM::MSH::exoGeoMesh::getExoIdArrName ( )

staticprivate

Definition at line 253 of file exoGeoMesh.C.

Referenced by addCellsToBlock(), addSideSet(), exoGeoMesh(), exoReader2GM(), getElemBlock(), getElemBlockId(), getSideSet(), reassignCells(), reconstructGeo(), resetElemBlocks(), resetNative(), setPhysGrpPropertyName(), setSideSetObjId(), stitch(), and write().

                                        {
  return vtkExodusIIReader::GetObjectIdArrayName();
}

getExoReader()

vtkSmartPointer< vtkExodusIIReader > NEM::MSH::exoGeoMesh::getExoReader ( const std::string &  fileName, int  timeStep = 1  )

staticprivate

Definition at line 1605 of file exoGeoMesh.C.

References NEM::MSH::New().

                                             {
  static constexpr std::array<vtkExodusIIReader::ObjectType, 8> objectTypes = {
      vtkExodusIIReader::ObjectType::ELEM_BLOCK_ELEM_CONN,
      vtkExodusIIReader::ObjectType::NODE_SET_CONN,
      vtkExodusIIReader::ObjectType::SIDE_SET_CONN,
      vtkExodusIIReader::ObjectType::NODAL,
      vtkExodusIIReader::ObjectType::GLOBAL,
      vtkExodusIIReader::ObjectType::ELEM_BLOCK,
      vtkExodusIIReader::ObjectType::NODE_SET,
      vtkExodusIIReader::ObjectType::SIDE_SET};
  if (fileName.empty()) {
    return nullptr;
  }
  auto reader = vtkSmartPointer<vtkExodusIIReader>::New();
  reader->SetFileName(fileName.c_str());
  // time steps are 1-indexed in Exodus
  reader->SetTimeStep(timeStep - 1);
  reader->UpdateInformation();
  for (const auto &objectType : objectTypes) {
    reader->SetAllArrayStatus(objectType, 1);
  }
  for (int i = 0; i < reader->GetNumberOfNodeMapArrays(); ++i) {
    reader->SetNodeMapArrayStatus(reader->GetNodeMapArrayName(i), 0);
  }
  for (int i = 0; i < reader->GetNumberOfElementMapArrays(); ++i) {
    reader->SetElementMapArrayStatus(reader->GetElementMapArrayName(i), 0);
  }
  reader->GenerateGlobalElementIdArrayOn();
  reader->GenerateGlobalNodeIdArrayOn();
  reader->Update();
  return reader;
}

getFieldDataArrayCopy() [1/4]

void NEM::MSH::geoMeshBase::getFieldDataArrayCopy ( const std::string &  arrayName, vtkAbstractArray *  array, int *  arrayIdx = nullptr  ) const

inherited

Optionally, get array index.

Parameters

arrayName	array name
array	field data array
arrayIdx	array index

Definition at line 201 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                             {
  getArrCopy(_geoMesh.mesh->GetFieldData(), arrayName, arrayIdx, array);
}

getFieldDataArrayCopy() [2/4]

vtkSmartPointer< vtkAbstractArray > NEM::MSH::geoMeshBase::getFieldDataArrayCopy ( const std::string &  arrayName, int *  arrayIdx = nullptr  ) const

inherited

Optionally, get array index.

Parameters

arrayName	array name
arrayIdx	array index

Returns

pointer to copy of array

Definition at line 207 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                     {
  return getArrCopy(_geoMesh.mesh->GetFieldData(), arrayName, arrayIdx);
}

getFieldDataArrayCopy() [3/4]

void NEM::MSH::geoMeshBase::getFieldDataArrayCopy ( int  arrayIdx, vtkAbstractArray *  array  ) const

inherited

Parameters

arrayIdx	array index
array	field data array

Definition at line 212 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                                       {
  getArrCopy(_geoMesh.mesh->GetFieldData(), arrayIdx, array);
}

getFieldDataArrayCopy() [4/4]

vtkSmartPointer< vtkAbstractArray > NEM::MSH::geoMeshBase::getFieldDataArrayCopy ( int  arrayIdx ) const

inherited

Parameters

arrayIdx

array index

Returns

pointer to copy of array

Definition at line 217 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                        {
  return getArrCopy(_geoMesh.mesh->GetFieldData(), arrayIdx);
}

getGeoEntArrayName()

const std::string& NEM::MSH::geoMeshBase::getGeoEntArrayName ( ) const

inlineinherited

Returns

name of geometric entities array

Definition at line 157 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

{ return _geoMesh.link; }

getGeoMesh()

const GeoMesh& NEM::MSH::geoMeshBase::getGeoMesh ( ) const

inlineprotectedinherited

Note

This is not a copy; Gmsh does not support cloning a model.

Definition at line 533 of file geoMeshBase.H.

Referenced by addCellsToBlock(), addElemBlock(), addElemBlockProperty(), addNodeSet(), addSideSet(), exoGeoMesh(), getElemBlock(), getElemBlockId(), getSideSet(), NEM::MSH::vtkGeoMesh::getVtkMesh(), NEM::MSH::inpGeoMesh::inpGeoMesh(), reassignCells(), NEM::MSH::oshGeoMesh::reconstructGeo(), reconstructGeo(), NEM::MSH::geoMeshBase::report(), resetElemBlocks(), NEM::MSH::smeshGeoMesh::resetNative(), NEM::MSH::gmshGeoMesh::resetNative(), NEM::MSH::inpGeoMesh::resetNative(), NEM::MSH::foamGeoMesh::resetNative(), NEM::MSH::oshGeoMesh::resetNative(), resetNative(), scaleNodes(), NEM::MSH::oshGeoMesh::setOshMesh(), setPhysGrpPropertyName(), setSideSetObjId(), stitch(), NEM::MSH::vtkGeoMesh::write(), NEM::MSH::gmshGeoMesh::write(), and write().

{ return _geoMesh; }

getNodeSet()

const std::vector< vtkIdType > & NEM::MSH::exoGeoMesh::getNodeSet

(

int

nodeSetId

)

const

Parameters

nodeSetId

ID of a node set

Returns

Vector of (0-based) node indices of the nodes in the node set.

Definition at line 1248 of file exoGeoMesh.C.

References _nodeSets.

                                                                      {
  auto it = _nodeSets.find(nodeSetId);
  if (it == _nodeSets.end()) {
    std::cerr << "No node set found with id: " << nodeSetId << std::endl;
    exit(1);
  }
  return it->second.nodes;
}

getNodeSetIds()

std::vector< int > NEM::MSH::exoGeoMesh::getNodeSetIds

(

)

const

Returns

All node set IDs

Definition at line 1239 of file exoGeoMesh.C.

References _nodeSets.

                                               {
  std::vector<int> ids;
  ids.reserve(_nodeSets.size());
  for (const auto &nodeSet : _nodeSets) {
    ids.emplace_back(nodeSet.first);
  }
  return ids;
}

getNodeSetName()

const std::string & NEM::MSH::exoGeoMesh::getNodeSetName

(

int

id

)

const

Parameters

id	ID of a node set

Returns

Reference to the name of a node set

Definition at line 1219 of file exoGeoMesh.C.

References _nodeSets.

                                                        {
  auto it = _nodeSets.find(id);
  if (it == _nodeSets.end()) {
    std::cerr << "No side set found with id: " << id << std::endl;
    exit(1);
  } else {
    return it->second.name;
  }
}

getNodeSetNames()

std::map< int, std::string > NEM::MSH::exoGeoMesh::getNodeSetNames

(

)

const

Returns

node set names, indexed by ID

Definition at line 1209 of file exoGeoMesh.C.

References _nodeSets.

                                                         {
  std::map<int, std::string> names;
  std::transform(_nodeSets.begin(), _nodeSets.end(),
                 std::inserter(names, names.begin()),
                 [](const std::pair<int, nodeSet> &set) {
                   return std::make_pair(set.first, set.second.name);
                 });
  return names;
}

getNumberOfCellDataArrays()

int NEM::MSH::geoMeshBase::getNumberOfCellDataArrays ( ) const

inlineinherited

Returns

number of arrays in the cell data

Definition at line 318 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

                                        {
    return _geoMesh.mesh->GetCellData()->GetNumberOfArrays();
  }

getNumberOfCells()

nemId_t NEM::MSH::geoMeshBase::getNumberOfCells ( ) const

inlineinherited

Returns

number of cells in mesh

Definition at line 190 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

{ return _geoMesh.mesh->GetNumberOfCells(); }

getNumberOfFieldDataArrays()

int NEM::MSH::geoMeshBase::getNumberOfFieldDataArrays ( ) const

inlineinherited

Returns

number of arrays in the field data

Definition at line 355 of file geoMeshBase.H.

                                         {
    return _geoMesh.mesh->GetFieldData()->GetNumberOfArrays();
  }

getNumberOfPointDataArrays()

int NEM::MSH::geoMeshBase::getNumberOfPointDataArrays ( ) const

inlineinherited

Returns

number of arrays in the point data

Definition at line 281 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

                                         {
    return _geoMesh.mesh->GetPointData()->GetNumberOfArrays();
  }

getNumberOfPoints()

nemId_t NEM::MSH::geoMeshBase::getNumberOfPoints ( ) const

inlineinherited

Returns

number of points in mesh

Definition at line 183 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

                                    {
    return _geoMesh.mesh->GetNumberOfPoints();
  }

getNumElemBlocks()

int NEM::MSH::exoGeoMesh::getNumElemBlocks

(

)

const

Returns

number of element blocks

Definition at line 827 of file exoGeoMesh.C.

References _elemBlocks.

{ return _elemBlocks.size(); }

getNumNodeSets()

int NEM::MSH::exoGeoMesh::getNumNodeSets

(

)

const

Returns

number of node sets

Definition at line 1207 of file exoGeoMesh.C.

References _nodeSets.

{ return _nodeSets.size(); }

getNumSideSets()

int NEM::MSH::exoGeoMesh::getNumSideSets

(

)

const

Returns

number of side sets

Definition at line 1088 of file exoGeoMesh.C.

References _sideSetNames.

{ return _sideSetNames.size(); }

getPhysGrpPropertyName()

const std::string & NEM::MSH::exoGeoMesh::getPhysGrpPropertyName

(

)

const

Returns

Name of element block property mapping element blocks to physical groups (or empty string if not set)

Definition at line 1275 of file exoGeoMesh.C.

References _physGrpName.

                                                          {
  return _physGrpName;
}

getPoint() [1/2]

void NEM::MSH::geoMeshBase::getPoint ( nemId_t  id, std::array< double, 3 > *  x  ) const

inlineinherited

Parameters

id	point id
x	array of coordinates as (x,y,z)

Definition at line 196 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

                                                          {
    _geoMesh.mesh->GetPoint(id, x->data());
  }

getPoint() [2/2]

std::array<double, 3> NEM::MSH::geoMeshBase::getPoint ( nemId_t  id ) const

inlineinherited

Parameters

id

point id

Returns

array of coordinates as (x,y,z)

Definition at line 204 of file geoMeshBase.H.

                                                 {
    std::array<double, 3> x{};
    getPoint(id, &x);
    return x;
  }

getPointCells()

void NEM::MSH::geoMeshBase::getPointCells ( nemId_t  ptId, vtkIdList *  cellIds  ) const

inlineinherited

Parameters

ptId	point id
cellIds	list of cell ids

Definition at line 264 of file geoMeshBase.H.

                                                             {
    _geoMesh.mesh->GetPointCells(ptId, cellIds);
  }

getPointDataArrayCopy() [1/4]

void NEM::MSH::geoMeshBase::getPointDataArrayCopy ( const std::string &  arrayName, vtkAbstractArray *  array, int *  arrayIdx = nullptr  ) const

inherited

Optionally, get array index.

Parameters

arrayName	array name
array	point data array
arrayIdx	array index

Definition at line 159 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

Referenced by NEM::MSH::diffMesh().

                                                             {
  getArrCopy(_geoMesh.mesh->GetPointData(), arrayName, arrayIdx, array);
}

getPointDataArrayCopy() [2/4]

vtkSmartPointer< vtkAbstractArray > NEM::MSH::geoMeshBase::getPointDataArrayCopy ( const std::string &  arrayName, int *  arrayIdx = nullptr  ) const

inherited

Optionally, get array index.

Parameters

arrayName	array name
arrayIdx	array index

Returns

pointer to copy of array

Definition at line 165 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                     {
  return getArrCopy(_geoMesh.mesh->GetPointData(), arrayName, arrayIdx);
}

getPointDataArrayCopy() [3/4]

void NEM::MSH::geoMeshBase::getPointDataArrayCopy ( int  arrayIdx, vtkAbstractArray *  array  ) const

inherited

Parameters

arrayIdx	array index
array	point data array

Definition at line 170 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                                       {
  getArrCopy(_geoMesh.mesh->GetPointData(), arrayIdx, array);
}

getPointDataArrayCopy() [4/4]

vtkSmartPointer< vtkAbstractArray > NEM::MSH::geoMeshBase::getPointDataArrayCopy ( int  arrayIdx ) const

inherited

Parameters

arrayIdx

array index

Returns

pointer to copy of array

Definition at line 175 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                        {
  return getArrCopy(_geoMesh.mesh->GetPointData(), arrayIdx);
}

getSideSet()

std::pair< std::vector< vtkIdType >, std::vector< int > > NEM::MSH::exoGeoMesh::getSideSet

(

int

sideSetId

)

const

Parameters

sideSetId

ID of a side set

Returns

Pair of vectors, first of which contains the (0-based) index of the cell the side belongs to and the second contains the side (according to VTK face/edge ordering)

Definition at line 1123 of file exoGeoMesh.C.

References _sideSetNames, getExoIdArrName(), and NEM::MSH::geoMeshBase::getGeoMesh().

                         {
  std::vector<vtkIdType> cellIdVec;
  std::vector<int> sideVec;
  if (_sideSetNames.find(sideSetId) == _sideSetNames.end()) {
    std::cerr << "No side set found with id: " << sideSetId << std::endl;
  }
  auto geoMesh = getGeoMesh();
  auto sideSet = geoMesh.sideSet;
  auto sideSetExoId = vtkIntArray::FastDownCast(
      sideSet.sides->GetCellData()->GetAbstractArray(getExoIdArrName()));
  auto sideSetOrigCellId = geoMesh.sideSet.getOrigCellArr();
  auto sideSetCellFaceId = geoMesh.sideSet.getCellFaceArr();
  for (vtkIdType i = 0; i < sideSet.sides->GetNumberOfCells(); ++i) {
    if (sideSetExoId->GetValue(i) == sideSetId) {
      cellIdVec.emplace_back(sideSetOrigCellId->GetTypedComponent(i, 0));
      sideVec.emplace_back(sideSetCellFaceId->GetTypedComponent(i, 0));
    }
  }
  return {cellIdVec, sideVec};
}

getSideSetIds()

std::vector< int > NEM::MSH::exoGeoMesh::getSideSetIds

(

)

const

Returns

All side set IDs.

Definition at line 1114 of file exoGeoMesh.C.

References _sideSetNames.

                                               {
  std::vector<int> ids;
  ids.reserve(_sideSetNames.size());
  for (const auto &sideSet : _sideSetNames) {
    ids.emplace_back(sideSet.first);
  }
  return ids;
}

getSideSetName()

const std::string & NEM::MSH::exoGeoMesh::getSideSetName

(

int

id

)

const

Parameters

id	ID of a side set

Returns

Reference to the name of a side set

Definition at line 1094 of file exoGeoMesh.C.

References _sideSetNames.

                                                        {
  auto it = _sideSetNames.find(id);
  if (it == _sideSetNames.end()) {
    std::cerr << "No side set found with id: " << id << std::endl;
    exit(1);
  } else {
    return it->second;
  }
}

getSideSetNames()

const std::map< int, std::string > & NEM::MSH::exoGeoMesh::getSideSetNames

(

)

const

Returns

side set names, indexed by ID

Definition at line 1090 of file exoGeoMesh.C.

References _sideSetNames.

                                                                 {
  return _sideSetNames;
}

getSS()

vtkSmartPointer<vtkPolyData> NEM::MSH::exoGeoMesh::getSS ( )

inline

Definition at line 58 of file exoGeoMesh.H.

References NEM::MSH::New(), nodes, NEM::MSH::Read(), and sides.

{ return getGeoMesh().sideSet.sides; }

getTitle()

const std::string & NEM::MSH::exoGeoMesh::getTitle

(

)

const

Returns

reference to title

Definition at line 823 of file exoGeoMesh.C.

References _title.

{ return _title; }

mergeGeoMesh()

void NEM::MSH::geoMeshBase::mergeGeoMesh ( geoMeshBase *  otherGeoMesh )

virtualinherited

Deletes the data from the new geoMesh pointer

Parameters

otherGeoMesh

A new geoMesh data to merge

Definition at line 113 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::New(), and NEM::MSH::geoMeshBase::resetNative().

                                                        {
  vtkSmartPointer<vtkAppendFilter> appendFilter =
      vtkSmartPointer<vtkAppendFilter>::New();
  appendFilter->AddInputData(_geoMesh.mesh);
  appendFilter->AddInputData(otherGeoMesh->_geoMesh.mesh);
  appendFilter->MergePointsOn();
  appendFilter->Update();
  _geoMesh.mesh = appendFilter->GetOutput();
  otherGeoMesh->_geoMesh = {
      vtkSmartPointer<vtkUnstructuredGrid>::New(), {}, {}, {}};
  otherGeoMesh->resetNative();
}

New()

static exoGeoMesh* NEM::MSH::exoGeoMesh::New ( )

static

Referenced by NEM::MSH::New(), and NEM::SRV::srvBase::RequestDataObject().

reassignCells()

int NEM::MSH::exoGeoMesh::reassignCells	(	const std::vector< vtkIdType > &	cells,
		int	blockId = -1,
		const std::string &	elemBlockName = {}
	)

Cells must all have same cell type. May result in empty blocks. Invalidates geometry, if any.

Parameters

cells	vector of cell indices
blockId	id of block to assign to; if not an existing block, one is created (if blockId is positive, the new block will have that ID; otherwise, one is chosen)
elemBlockName	if blockId is not an existing block, the name of the new block

Returns

element block that the cells were assigned to

Definition at line 1001 of file exoGeoMesh.C.

References _elemBlocks, cellType, getExoIdArrName(), NEM::MSH::geoMeshBase::getGeoMesh(), nemAux::leastUnusedKey(), mesh, NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::geoMeshBase::setGeoMesh(), and NEM::MSH::geoMeshBase::GeoMesh::sideSet.

                                                                           {
  if (!cells.empty()) {
    auto mesh = getGeoMesh().mesh;
    auto cellType =
        static_cast<VTKCellType>(mesh->GetCellType(cells.front()));
    for (const auto &cell : cells) {
      if (mesh->GetCellType(cell) != cellType) {
        std::cerr << "Single element block cannot have multiple cell types"
                  << std::endl;
        exit(1);
      }
    }
    auto elemBlockIt = _elemBlocks.find(blockId);
    if (elemBlockIt == _elemBlocks.end()) {
      if (blockId <= 0) {
        blockId = nemAux::leastUnusedKey(_elemBlocks);
      }
      _elemBlocks[blockId] = {elemBlockName, cellType, {}};
    }
    auto elemBlockIdArr = vtkIntArray::FastDownCast(
        mesh->GetCellData()->GetAbstractArray(getExoIdArrName()));
    for (const auto &cell : cells) {
      elemBlockIdArr->SetValue(cell, blockId);
    }
#ifdef HAVE_GMSH
    if (!getGeoMesh().geo.empty()) {
      gmsh::model::setCurrent(getGeoMesh().geo);
      gmsh::model::remove();
      setGeoMesh({mesh, "", "", getGeoMesh().sideSet});
    }
#endif
    return blockId;
  } else {
    std::cerr << "No cells to add." << std::endl;
    return -1;
  }
}

reconstructGeo()

void NEM::MSH::exoGeoMesh::reconstructGeo ( )

overridevirtual

Sets geometry, link, and side set. Does not alter the mesh. If physGrpName is not empty, then physical groups are set based on the property physGrpName for each element block. Otherwise, each element block represents its own physical group.

Reimplemented from NEM::MSH::geoMeshBase.

Definition at line 796 of file exoGeoMesh.C.

References _physGrpName, NEM::MSH::geoMeshBase::GeoMesh::geo, NEM::MSH::geoMeshBase::GEO_ENT_DEFAULT_NAME, getElemBlockProperty(), getExoIdArrName(), NEM::MSH::geoMeshBase::getGeoMesh(), NEM::MSH::geoMeshBase::GeoMesh::link, NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::New(), NEM::MSH::geoMeshBase::reconstructGeo(), NEM::MSH::geoMeshBase::setGeoMesh(), setSideSetObjId(), and NEM::MSH::geoMeshBase::GeoMesh::sideSet.

                                {
  std::string link =
      getGeoMesh().link.empty() ? GEO_ENT_DEFAULT_NAME : getGeoMesh().link;
  auto mesh = getGeoMesh().mesh;
  vtkSmartPointer<vtkDataArray> linkArr =
      mesh->GetCellData()->GetArray(link.c_str());
  if (!linkArr) {
    linkArr = vtkSmartPointer<vtkIntArray>::New();
    linkArr->SetName(link.c_str());
    linkArr->SetNumberOfTuples(mesh->GetNumberOfCells());
    mesh->GetCellData()->AddArray(linkArr);
  }
  auto elemBlockIdArr = vtkIntArray::FastDownCast(
      mesh->GetCellData()->GetAbstractArray(getExoIdArrName()));
  for (vtkIdType i = 0; i < mesh->GetNumberOfCells(); ++i) {
    auto physGroup = elemBlockIdArr->GetValue(i);
    if (!_physGrpName.empty()) {
      physGroup = getElemBlockProperty(_physGrpName, physGroup);
    }
    linkArr->SetComponent(i, 0, physGroup);
  }
  setGeoMesh({getGeoMesh().mesh, getGeoMesh().geo, link, getGeoMesh().sideSet});
  geoMeshBase::reconstructGeo();
  // Should now always have side set
  setSideSetObjId();
}

report()

void NEM::MSH::exoGeoMesh::report ( std::ostream &  out ) const

overridevirtual

Parameters

out	Stream to write summary to.

Implements NEM::MSH::geoMeshBase.

Definition at line 770 of file exoGeoMesh.C.

References _elemBlocks, _nodeSets, _sideSetNames, _title, and NEM::MSH::geoMeshBase::report().

                                             {
  geoMeshBase::report(out);
  out << "Title:\t" << _title << '\n';
  out << "Element Blocks:\t" << _elemBlocks.size() << '\n';
  out << "Side Sets:\t" << _sideSetNames.size() << '\n';
  out << "Node Sets:\t" << _nodeSets.size() << '\n';
}

resetElemBlocks()

void NEM::MSH::exoGeoMesh::resetElemBlocks ( )

private

Creates element blocks and sets the dimension based on the GeoMesh.

Definition at line 1667 of file exoGeoMesh.C.

References _elemBlockPropNames, _elemBlocks, _physGrpName, cellType, NEM::MSH::exoGeoMesh::elemBlock::cellType, getExoIdArrName(), NEM::MSH::geoMeshBase::getGeoMesh(), nemAux::leastUnusedKey(), NEM::MSH::geoMeshBase::GeoMesh::mesh, and NEM::MSH::exoGeoMesh::elemBlock::properties.

Referenced by resetNative().

                                 {
  _elemBlocks.clear();
  _elemBlockPropNames.clear();
  if (!_physGrpName.empty()) {
    _elemBlockPropNames.insert(_physGrpName);
  }
  std::map<std::pair<int, VTKCellType>, int> old2newElemBlock;
  auto mesh = getGeoMesh().mesh;
  auto elemBlockIds = vtkIntArray::SafeDownCast(
      mesh->GetCellData()->GetAbstractArray(getExoIdArrName()));
  vtkIdType i = 0;
  auto nextElemBlockId = nemAux::leastUnusedKey(_elemBlocks);
  for (auto it =
           vtkSmartPointer<vtkCellIterator>::Take(mesh->NewCellIterator());
       !it->IsDoneWithTraversal(); it->GoToNextCell()) {
    auto oldElemBlockId = elemBlockIds->GetValue(i);
    auto cellType = static_cast<VTKCellType>(it->GetCellType());
    auto inserted =
        old2newElemBlock.insert({{oldElemBlockId, cellType}, nextElemBlockId});
    if (inserted.second) {
      auto &elemBlock = _elemBlocks[nextElemBlockId];
      elemBlock.cellType = cellType;
      if (!_physGrpName.empty()) {
        elemBlock.properties[_physGrpName] = oldElemBlockId;
      }
      nextElemBlockId = nemAux::leastUnusedKey(_elemBlocks);
    }
    elemBlockIds->SetValue(i, inserted.first->second);
    ++i;
  }
}

resetNative()

void NEM::MSH::exoGeoMesh::resetNative ( )

overrideprivatevirtual

Implements NEM::MSH::geoMeshBase.

Definition at line 1639 of file exoGeoMesh.C.

References _nodeSets, _physGrpName, getExoIdArrName(), NEM::MSH::geoMeshBase::getGeoMesh(), NEM::MSH::geoMeshBase::GeoMesh::link, NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::New(), resetElemBlocks(), NEM::MSH::geoMeshBase::setGeoMesh(), and setSideSetObjId().

Referenced by addElemBlock().

                             {
  _nodeSets.clear();
  auto mesh = this->getGeoMesh().mesh;
  auto link = this->getGeoMesh().link;
  _physGrpName = link;
  if (!mesh->GetCellData()->HasArray(getExoIdArrName())) {
    auto elemBlockIdArr = vtkSmartPointer<vtkIntArray>::New();
    elemBlockIdArr->SetName(getExoIdArrName());
    auto linkArr = mesh->GetCellData()->GetArray(link.c_str());
    if (!link.empty() && linkArr) {
      elemBlockIdArr->Allocate(mesh->GetNumberOfCells());
      for (vtkIdType i = 0; i < mesh->GetNumberOfCells(); ++i) {
        elemBlockIdArr->InsertNextValue(
            static_cast<int>(linkArr->GetComponent(i, 0)));
      }
    } else {
      elemBlockIdArr->SetNumberOfValues(mesh->GetNumberOfCells());
      elemBlockIdArr->FillComponent(0, 1);
    }
    mesh->GetCellData()->AddArray(elemBlockIdArr);
  }
  resetElemBlocks();
  auto gm = getGeoMesh();
  gm.findSide2OrigCell();
  setGeoMesh(gm);
  setSideSetObjId();
}

resetNodeSetPoints()

void NEM::MSH::exoGeoMesh::resetNodeSetPoints ( vtkIdTypeArray *  nodeMap = nullptr )

private

Removes duplicate node ids within a node set.

Parameters

nodeMap

map from old to new node indices (can be many-to-one)

Definition at line 1699 of file exoGeoMesh.C.

References _nodeSets, and NEM::MSH::exoGeoMesh::nodeSet::nodes.

Referenced by addCellsToBlock(), stitch(), and write().

                                                           {
  for (auto &nodeSet : _nodeSets) {
    std::unordered_set<vtkIdType> set;
    for (const auto &node : nodeSet.second.nodes) {
      set.insert(nodeMap ? nodeMap->GetValue(node) : node);
    }
    nodeSet.second.nodes.assign(set.begin(), set.end());
  }
}

scaleNodes()

void NEM::MSH::exoGeoMesh::scaleNodes

(

double

scale

)

Does not change point data.

Parameters

scale

Multiplicative factor for point locations

Definition at line 1457 of file exoGeoMesh.C.

References NEM::MSH::geoMeshBase::GeoMesh::geo, NEM::MSH::geoMeshBase::getGeoMesh(), NEM::MSH::geoMeshBase::GeoMesh::link, mesh, NEM::MSH::New(), NEM::MSH::geoMeshBase::setGeoMesh(), NEM::MSH::geoMeshBase::SideSet::sides, and NEM::MSH::geoMeshBase::GeoMesh::sideSet.

                                        {
  auto transform = vtkSmartPointer<vtkTransform>::New();
  transform->Scale(scale, scale, scale);
  auto transformFilter = vtkSmartPointer<vtkTransformFilter>::New();
  transformFilter->SetTransform(transform);
  transformFilter->SetInputData(getGeoMesh().mesh);
  transformFilter->Update();
  auto mesh = vtkUnstructuredGrid::SafeDownCast(transformFilter->GetOutput());
  auto sideSet = getGeoMesh().sideSet;
  if (sideSet.sides) {
    sideSet.sides->SetPoints(mesh->GetPoints());
  }
  setGeoMesh({mesh, getGeoMesh().geo, getGeoMesh().link, getGeoMesh().sideSet});
}

setAngleThreshold()

void NEM::MSH::geoMeshBase::setAngleThreshold ( double  angleThreshold )

inlineinherited

Parameters

angleThreshold

(in radians)

Definition at line 176 of file geoMeshBase.H.

                                                {
    _angleThreshold = angleThreshold;
  }

setCellDataArray()

int NEM::MSH::geoMeshBase::setCellDataArray ( vtkAbstractArray *  array )

inlineprotectedinherited

Parameters

array

array pointer

Returns

array index

Definition at line 473 of file geoMeshBase.H.

                                                {
    return _geoMesh.mesh->GetCellData()->AddArray(array);
  }

setElemBlockName()

void NEM::MSH::exoGeoMesh::setElemBlockName	(	int	id,
		const std::string &	name
	)

Parameters

id	ID of the element block
name	new name of the element block

Definition at line 850 of file exoGeoMesh.C.

References _elemBlocks.

                                                               {
  auto it = _elemBlocks.find(id);
  if (it == _elemBlocks.end()) {
    std::cerr << "No block found with id: " << id << std::endl;
    exit(1);
  } else {
    it->second.name = name;
  }
}

setElemBlockProperty()

void NEM::MSH::exoGeoMesh::setElemBlockProperty	(	const std::string &	propName,
		int	blockId,
		int	value
	)

Parameters

propName	Name of an element block property
blockId	ID of an element block
value	Value of a property on an element block

Definition at line 1073 of file exoGeoMesh.C.

References _elemBlockPropNames, and _elemBlocks.

                                                 {
  if (_elemBlockPropNames.find(propName) == _elemBlockPropNames.end()) {
    std::cerr << "No property found with name: " << propName << std::endl;
    exit(1);
  }
  auto blockIt = _elemBlocks.find(blockId);
  if (blockIt == _elemBlocks.end()) {
    std::cerr << "No block found with id: " << blockId << std::endl;
    exit(1);
  } else {
    blockIt->second.properties[propName] = value;
  }
}

setFieldDataArray()

int NEM::MSH::geoMeshBase::setFieldDataArray ( vtkAbstractArray *  array )

inlineprotectedinherited

Parameters

array

array pointer

Returns

array index

Definition at line 481 of file geoMeshBase.H.

                                                 {
    return _geoMesh.mesh->GetFieldData()->AddArray(array);
  }

setGeoEntArrayName()

void NEM::MSH::geoMeshBase::setGeoEntArrayName ( const std::string &  geoEntArrayName )

inlineinherited

Parameters

geoEntArrayName

name of geometric entities array

Definition at line 162 of file geoMeshBase.H.

                                                            {
    auto a = _geoMesh.mesh->GetCellData()->GetArray(_geoMesh.link.c_str());
    if (a) a->SetName(geoEntArrayName.c_str());
    _geoMesh.link = geoEntArrayName;
  }

setGeoMesh()

void NEM::MSH::geoMeshBase::setGeoMesh ( const geoMeshBase::GeoMesh &  geoMesh )

inlineprotectedinherited

Parameters

geoMesh

a mesh and geometry

Definition at line 538 of file geoMeshBase.H.

References NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::geoMeshBase::SideSet::sides, and NEM::MSH::geoMeshBase::GeoMesh::sideSet.

Referenced by addCellsToBlock(), addElemBlock(), addSideSet(), reassignCells(), reconstructGeo(), NEM::MSH::gmshGeoMesh::resetNative(), resetNative(), scaleNodes(), NEM::MSH::foamGeoMesh::setFoamMesh(), NEM::MSH::oshGeoMesh::setOshMesh(), NEM::MSH::smeshGeoMesh::setSMeshMesh(), NEM::MSH::vtkGeoMesh::setVtkMesh(), stitch(), NEM::MSH::oshGeoMesh::takeGeoMesh(), and takeGeoMesh().

                                                     {
    assert(geoMesh.mesh->GetNumberOfCells() == 0 ||
           geoMesh.mesh->GetNumberOfPoints() == 0 ||
           geoMesh.sideSet.sides == nullptr ||
           geoMesh.sideSet.sides->GetPoints() == geoMesh.mesh->GetPoints());
    _geoMesh = geoMesh;
  }

setNodeSetName()

void NEM::MSH::exoGeoMesh::setNodeSetName	(	int	id,
		const std::string &	name
	)

Parameters

id	ID of a node set
name	New name of the node set

Definition at line 1229 of file exoGeoMesh.C.

References _nodeSets.

                                                             {
  auto it = _nodeSets.find(id);
  if (it == _nodeSets.end()) {
    std::cerr << "No side set found with id: " << id << std::endl;
    exit(1);
  } else {
    it->second.name = name;
  }
}

setPhysGrpPropertyName()

void NEM::MSH::exoGeoMesh::setPhysGrpPropertyName

(

const std::string &

physGrpName

)

Parameters

physGrpName

Name of element block property mapping element blocks to physical groups (use empty string to unset). Must be an existing element block property name.

Definition at line 1279 of file exoGeoMesh.C.

References _elemBlockPropNames, _physGrpName, getElemBlockProperty(), getExoIdArrName(), NEM::MSH::geoMeshBase::getGeoMesh(), NEM::MSH::geoMeshBase::GeoMesh::link, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                                    {
  if (_elemBlockPropNames.find(physGrpName) == _elemBlockPropNames.end()) {
    std::cerr << "No property found with name " << physGrpName << std::endl;
    return;
  }
  _physGrpName = physGrpName;
  auto link = getGeoMesh().link;
  if (!link.empty()) {
    auto mesh = getGeoMesh().mesh;
    auto elemBlockIdArr = vtkIntArray::FastDownCast(
        mesh->GetCellData()->GetAbstractArray(getExoIdArrName()));
    auto linkArr = mesh->GetCellData()->GetArray(link.c_str());
    if (linkArr) {
      for (vtkIdType i = 0; i < mesh->GetNumberOfCells(); ++i) {
        linkArr->SetComponent(
            i, 0,
            getElemBlockProperty(_physGrpName, elemBlockIdArr->GetValue(i)));
      }
    }
  }
}

setPointDataArray()

int NEM::MSH::geoMeshBase::setPointDataArray ( vtkAbstractArray *  array )

inlineprotectedinherited

Parameters

array

array pointer

Returns

array index

Definition at line 465 of file geoMeshBase.H.

                                                 {
    return _geoMesh.mesh->GetPointData()->AddArray(array);
  }

setSideSetName()

void NEM::MSH::exoGeoMesh::setSideSetName	(	int	id,
		const std::string &	name
	)

Parameters

id	ID of a side set
name	New name of the side set

Definition at line 1104 of file exoGeoMesh.C.

References _sideSetNames.

                                                             {
  auto it = _sideSetNames.find(id);
  if (it == _sideSetNames.end()) {
    std::cerr << "No side set found with id: " << id << std::endl;
    exit(1);
  } else {
    it->second = name;
  }
}

setSideSetObjId()

void NEM::MSH::exoGeoMesh::setSideSetObjId ( )

private

Definition at line 1709 of file exoGeoMesh.C.

References _sideSetNames, getExoIdArrName(), NEM::MSH::geoMeshBase::getGeoMesh(), and NEM::MSH::New().

Referenced by reconstructGeo(), and resetNative().

                                 {
  _sideSetNames.clear();
  auto gm = getGeoMesh();
  auto mesh = gm.mesh;
  auto link = gm.link;
  auto sideSet = gm.sideSet;
  if (sideSet.sides) {
    auto sideSetObjId = vtkIntArray::FastDownCast(
        sideSet.sides->GetCellData()->GetAbstractArray(getExoIdArrName()));
    if (sideSetObjId) {
      for (vtkIdType i = 0; i < sideSet.sides->GetNumberOfCells(); ++i) {
        _sideSetNames[sideSetObjId->GetValue(i)];
      }
    } else {
      sideSetObjId = vtkIntArray::New();
      sideSetObjId->SetName(getExoIdArrName());
      sideSetObjId->Allocate(sideSet.sides->GetNumberOfCells());
      sideSet.sides->GetCellData()->AddArray(sideSetObjId);
      auto sideSetEntities = gm.sideSet.getGeoEntArr();
      auto nameArr = sideSet.getSideSetNames();
      // Exodus II requires IDs to be positive, which is not always the case for
      // other mesh types, hence use of extra array
      std::map<int, int> geoEnt2ExoId;
      int nextSideSetId = 1;
      for (vtkIdType i = 0; i < sideSet.sides->GetNumberOfCells(); ++i) {
        int geoEnt = sideSetEntities->GetValue(i);
        // If geoEnt is not found in geoEnt2ExoID, call to operator[] to sets
        // geoEnt2ExoId[geoEnt] to 0 (which is used as sentinel value)
        auto &exoID = geoEnt2ExoId[geoEnt];
        if (exoID == 0) {
          exoID = nextSideSetId;
          auto emplaceIter = _sideSetNames.emplace(exoID, std::string{});
          if (emplaceIter.second && nameArr && geoEnt >= 0 &&
              geoEnt < nameArr->GetNumberOfValues()) {
            emplaceIter.first->second = nameArr->GetValue(geoEnt);
          }
          ++nextSideSetId;
        }
        sideSetObjId->InsertNextValue(exoID);
      }
      sideSetObjId->Delete();
    }
  }
}

setTitle()

void NEM::MSH::exoGeoMesh::setTitle

(

const std::string &

title

)

Parameters

title

new title to set

Definition at line 825 of file exoGeoMesh.C.

References _title.

{ _title = title; }

stitch()

void NEM::MSH::exoGeoMesh::stitch	(	const exoGeoMesh &	otherGM,
		float	tol = 1e-15f
	)

PointData and CellData arrays are intersected. Adds side sets and node sets if available. Element block properties from otherGM are copied if property also defined in this exoGeoMesh.

Parameters

otherGM	Other exoGeoMesh to addd to this one
tol	Tolerance for merging points

Definition at line 1301 of file exoGeoMesh.C.

References _elemBlockPropNames, _elemBlocks, _nodeSets, _sideSetNames, NEM::MSH::geoMeshBase::GeoMesh::geo, NEM::MSH::geoMeshBase::GeoMesh::getDimension(), getExoIdArrName(), NEM::MSH::geoMeshBase::SideSet::getGeoEntArr(), NEM::MSH::geoMeshBase::getGeoMesh(), nemAux::leastUnusedKey(), NEM::MSH::geoMeshBase::GeoMesh::link, mesh, NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::exoGeoMesh::nodeSet::name, NEM::MSH::New(), NEM::MSH::exoGeoMesh::nodeSet::nodes, resetNodeSetPoints(), NEM::MSH::geoMeshBase::setGeoMesh(), and NEM::MSH::geoMeshBase::GeoMesh::sideSet.

                                                            {
  auto mesh = this->getGeoMesh().mesh;
  if (mesh->GetNumberOfCells() == 0) {
    std::cerr << "Current mesh is empty. Cannot stitch onto empty mesh."
              << std::endl;
    exit(1);
  }
  if (this->getGeoMesh().getDimension() !=
      otherGM.getGeoMesh().getDimension()) {
    std::cerr << "Dimension of meshes does not match." << std::endl;
    exit(1);
  }
  auto numOrigCells = mesh->GetNumberOfCells();
  auto otherMesh = otherGM.getGeoMesh().mesh;
  std::map<int, int> old2newElemBlock;

  std::set<std::string> propsToCopy;
  std::set_intersection(_elemBlockPropNames.begin(), _elemBlockPropNames.end(),
                        otherGM._elemBlockPropNames.begin(),
                        otherGM._elemBlockPropNames.end(),
                        std::inserter(propsToCopy, propsToCopy.begin()));
  auto newBlockId = nemAux::leastUnusedKey(this->_elemBlocks);
  for (const auto &otherElemBlock : otherGM._elemBlocks) {
    old2newElemBlock[otherElemBlock.first] = newBlockId;
    auto &newElemBlock = this->_elemBlocks[newBlockId];
    newElemBlock.name = otherElemBlock.second.name;
    newElemBlock.cellType = otherElemBlock.second.cellType;
    for (const auto &property : propsToCopy) {
      auto it = otherElemBlock.second.properties.find(property);
      if (it != otherElemBlock.second.properties.end()) {
        newElemBlock.properties[property] = it->second;
      }
    }
    newBlockId = nemAux::leastUnusedKey(this->_elemBlocks, newBlockId);
  }
  auto oldOtherBlockIdArr =
      vtkSmartPointer<vtkIntArray>(vtkIntArray::FastDownCast(
          otherMesh->GetCellData()->GetAbstractArray(getExoIdArrName())));
  otherMesh->GetCellData()->RemoveArray(getExoIdArrName());
  auto newOtherBlockIdArr = vtkSmartPointer<vtkIntArray>::Take(
      vtkIntArray::FastDownCast(mesh->GetCellData()
                                    ->GetAbstractArray(getExoIdArrName())
                                    ->NewInstance()));
  newOtherBlockIdArr->SetName(getExoIdArrName());
  newOtherBlockIdArr->SetNumberOfValues(otherMesh->GetNumberOfCells());
  for (vtkIdType i = 0; i < otherMesh->GetNumberOfCells(); ++i) {
    newOtherBlockIdArr->SetComponent(
        i, 0, old2newElemBlock.at(oldOtherBlockIdArr->GetValue(i)));
  }
  otherMesh->GetCellData()->AddArray(newOtherBlockIdArr);

#ifdef HAVE_GMSH
  if (!this->getGeoMesh().geo.empty()) {
    gmsh::model::setCurrent(this->getGeoMesh().geo);
    gmsh::model::remove();
    mesh->GetCellData()->RemoveArray(this->getGeoMesh().link.c_str());
    this->setGeoMesh({mesh, "", "", this->getGeoMesh().sideSet});
  }
#endif
  auto newMesh = vtkSmartPointer<vtkUnstructuredGrid>::New();
  auto nodeMaps = mergeMeshes(mesh, otherMesh, newMesh, tol);
  resetNodeSetPoints(nodeMaps.first);
  if (!otherGM._nodeSets.empty()) {
    auto nextNodeSetId = nemAux::leastUnusedKey(_nodeSets);
    for (const auto &otherNodeSet : otherGM._nodeSets) {
      auto &nodeSet = _nodeSets[nextNodeSetId];
      nodeSet.name = otherNodeSet.second.name;
      nodeSet.nodes.reserve(otherNodeSet.second.nodes.size());
      std::transform(
          otherNodeSet.second.nodes.begin(), otherNodeSet.second.nodes.end(),
          std::back_inserter(nodeSet.nodes),
          [&nodeMaps](vtkIdType x) { return nodeMaps.second->GetValue(x); });
      nextNodeSetId = nemAux::leastUnusedKey(_nodeSets, nextNodeSetId);
    }
  }
  resetSideSetPoints(newMesh, getGeoMesh().sideSet.sides, nodeMaps.first);
  setGeoMesh(
      {newMesh, getGeoMesh().geo, getGeoMesh().link, getGeoMesh().sideSet});
  auto otherGeoMesh = otherGM.getGeoMesh();
  if (otherGeoMesh.sideSet.sides) {
    auto otherSideSet = otherGeoMesh.sideSet;
    auto otherExoIdArr = vtkIntArray::FastDownCast(
        otherSideSet.sides->GetCellData()->GetAbstractArray(getExoIdArrName()));
    auto otherEntitiesArr = otherGeoMesh.sideSet.getGeoEntArr();
    auto otherOrigCellIdArr = otherGeoMesh.sideSet.getOrigCellArr();
    auto otherCellFaceIdArr = otherGeoMesh.sideSet.getCellFaceArr();
    auto geoMesh = this->getGeoMesh();
    auto sideSet = geoMesh.sideSet;
    vtkSmartPointer<vtkIntArray> sideSetExoId;
    vtkSmartPointer<vtkIntArray> sideSetEntities;
    vtkSmartPointer<vtkIdTypeArray> sideSetOrigCellId;
    vtkSmartPointer<vtkIntArray> sideSetCellFaceId;
    if (sideSet.sides) {
      sideSetExoId = vtkIntArray::FastDownCast(
          sideSet.sides->GetCellData()->GetAbstractArray(getExoIdArrName()));
      sideSetEntities = geoMesh.sideSet.getGeoEntArr();
      sideSetOrigCellId = geoMesh.sideSet.getOrigCellArr();
      sideSetCellFaceId = geoMesh.sideSet.getCellFaceArr();
    } else {
      auto sideSetPD = vtkSmartPointer<vtkPolyData>::New();
      sideSetPD->Allocate(otherSideSet.sides);
      sideSetExoId = vtkSmartPointer<vtkIntArray>::New();
      sideSetExoId->SetName(getExoIdArrName());
      sideSetExoId->Allocate(otherSideSet.sides->GetNumberOfCells());
      sideSet.sides->GetCellData()->AddArray(sideSetExoId);
      sideSetEntities = vtkSmartPointer<vtkIntArray>::New();
      sideSetEntities->Allocate(otherSideSet.sides->GetNumberOfCells());
      sideSetOrigCellId = vtkSmartPointer<vtkIdTypeArray>::New();
      sideSetOrigCellId->SetNumberOfComponents(2);
      sideSetOrigCellId->Allocate(otherSideSet.sides->GetNumberOfCells());
      sideSetCellFaceId = vtkSmartPointer<vtkIntArray>::New();
      sideSetCellFaceId->SetNumberOfComponents(2);
      sideSetCellFaceId->Allocate(otherSideSet.sides->GetNumberOfCells());
      sideSet = {sideSetPD, sideSetEntities, sideSetOrigCellId,
                 sideSetCellFaceId};
      this->setGeoMesh({newMesh, this->getGeoMesh().geo,
                        this->getGeoMesh().link, sideSet});
    }
    std::map<int, int> old2newSideSet;
    auto newSideSetId = nemAux::leastUnusedKey(this->_sideSetNames);
    for (const auto &otherSet : otherGM._sideSetNames) {
      old2newSideSet[otherSet.first] = newSideSetId;
      this->_sideSetNames[newSideSetId] = otherSet.second;
      newSideSetId = nemAux::leastUnusedKey(this->_sideSetNames, newSideSetId);
    }
    std::map<int, int> old2newGeoEnt;
    for (vtkIdType i = 0; i < sideSet.sides->GetNumberOfCells(); ++i) {
      old2newGeoEnt[sideSetEntities->GetValue(i)] = -1;
    }
    int nextSideSetEntId = nemAux::leastUnusedKey(old2newGeoEnt);
    for (vtkIdType i = 0; i < otherSideSet.sides->GetNumberOfCells(); ++i) {
      auto origCellId = otherOrigCellIdArr->GetTypedComponent(i, 0) + numOrigCells;
      auto cellFaceId = otherCellFaceIdArr->GetTypedComponent(i, 0);
      auto parent = newMesh->GetCell(origCellId);
      auto side = parent->GetCellDimension() == 2 ? parent->GetEdge(cellFaceId)
                                                  : parent->GetFace(cellFaceId);
      sideSet.sides->InsertNextCell(side->GetCellType(), side->GetPointIds());
      int newEntId = otherEntitiesArr->GetValue(i);
      auto insertIter = old2newGeoEnt.insert({newEntId, nextSideSetEntId});
      if (insertIter.second || insertIter.first->second == -1) {
        if (insertIter.first->second == -1) {
          insertIter.first->second = nextSideSetEntId;
        }
        nextSideSetEntId =
            nemAux::leastUnusedKey(old2newGeoEnt, nextSideSetEntId);
      }
      sideSetExoId->InsertNextValue(old2newSideSet[otherExoIdArr->GetValue(i)]);
      sideSetEntities->InsertNextValue(insertIter.first->second);
      sideSetOrigCellId->InsertNextTuple2(origCellId, -1);
      sideSetCellFaceId->InsertNextTuple2(cellFaceId, -1);
    }
  }
  otherMesh->GetCellData()->RemoveArray(getExoIdArrName());
  otherMesh->GetCellData()->AddArray(oldOtherBlockIdArr);
}

takeGeoMesh()

void NEM::MSH::exoGeoMesh::takeGeoMesh ( geoMeshBase *  otherGeoMesh )

overridevirtual

Note that otherGeoMesh will be left with an empty mesh.

Parameters

otherGeoMesh

other geoMeshBase object; mesh will be left empty

Reimplemented from NEM::MSH::geoMeshBase.

Definition at line 778 of file exoGeoMesh.C.

References _elemBlockPropNames, _elemBlocks, _nodeSets, _physGrpName, _sideSetNames, _title, NEM::MSH::New(), NEM::MSH::geoMeshBase::setGeoMesh(), and NEM::MSH::geoMeshBase::takeGeoMesh().

                                                      {
  auto otherExoGM = dynamic_cast<exoGeoMesh *>(otherGeoMesh);
  if (otherExoGM) {
    setGeoMesh(otherExoGM->getGeoMesh());
    otherExoGM->setGeoMesh(
        {vtkSmartPointer<vtkUnstructuredGrid>::New(), {}, {}, {}});
    _title = std::move(otherExoGM->_title);
    _elemBlocks = std::move(otherExoGM->_elemBlocks);
    _sideSetNames = std::move(otherExoGM->_sideSetNames);
    _nodeSets = std::move(otherExoGM->_nodeSets);
    _elemBlockPropNames = std::move(otherExoGM->_elemBlockPropNames);
    _physGrpName = std::move(otherExoGM->_physGrpName);
    otherExoGM->resetNative();
  } else {
    geoMeshBase::takeGeoMesh(otherGeoMesh);
  }
}

unsetCellDataArray() [1/2]

void NEM::MSH::geoMeshBase::unsetCellDataArray ( int  arrayIdx )

inlineprotectedinherited

Parameters

arrayIdx

array index

Definition at line 503 of file geoMeshBase.H.

                                        {
    _geoMesh.mesh->GetCellData()->RemoveArray(arrayIdx);
  }

unsetCellDataArray() [2/2]

void NEM::MSH::geoMeshBase::unsetCellDataArray ( const std::string &  arrayName )

inlineprotectedinherited

Parameters

arrayName

array name

Definition at line 510 of file geoMeshBase.H.

                                                      {
    _geoMesh.mesh->GetCellData()->RemoveArray(arrayName.c_str());
  }

unsetFieldDataArray() [1/2]

void NEM::MSH::geoMeshBase::unsetFieldDataArray ( int  arrayIdx )

inlineprotectedinherited

Parameters

arrayIdx

array index

Definition at line 517 of file geoMeshBase.H.

                                         {
    _geoMesh.mesh->GetFieldData()->RemoveArray(arrayIdx);
  }

unsetFieldDataArray() [2/2]

void NEM::MSH::geoMeshBase::unsetFieldDataArray ( const std::string &  arrayName )

inlineprotectedinherited

Parameters

arrayName

array name

Definition at line 524 of file geoMeshBase.H.

                                                       {
    _geoMesh.mesh->GetFieldData()->RemoveArray(arrayName.c_str());
  }

unsetPointDataArray() [1/2]

void NEM::MSH::geoMeshBase::unsetPointDataArray ( int  arrayIdx )

inlineprotectedinherited

Parameters

arrayIdx

array index

Definition at line 489 of file geoMeshBase.H.

                                         {
    _geoMesh.mesh->GetPointData()->RemoveArray(arrayIdx);
  }

unsetPointDataArray() [2/2]

void NEM::MSH::geoMeshBase::unsetPointDataArray ( const std::string &  arrayName )

inlineprotectedinherited

Parameters

arrayName

array name

Definition at line 496 of file geoMeshBase.H.

                                                       {
    _geoMesh.mesh->GetPointData()->RemoveArray(arrayName.c_str());
  }

write()

void NEM::MSH::exoGeoMesh::write ( const std::string &  fileName )

overridevirtual

If fileName already exists, it is overwritten. If there are more than 900 side sets, they are concatenated, with a side set variable named "NEM_SIDE_SET_ID" added that contains the id of the side in this exoGeoMesh.

Parameters

fileName

Name of file. Must end in ".exo", ".e", ".gen", or ".g"

Implements NEM::MSH::geoMeshBase.

Definition at line 382 of file exoGeoMesh.C.

References _elemBlockPropNames, _elemBlocks, _nodeSets, _sideSetNames, _title, cellType, data, nemAux::find_ext(), getExoIdArrName(), NEM::MSH::geoMeshBase::getGeoMesh(), NEM::MSH::exoGeoMesh::nodeSet::name, nodes, NEM::MSH::exoGeoMesh::nodeSet::nodes, and resetNodeSetPoints().

                                                {
  std::string fileExt = nemAux::find_ext(fileName);
  if (fileExt == ".exo" || fileExt == ".e" || fileExt == ".gen" ||
      fileExt == ".g") {
    int comp_ws = sizeof(double);
    int io_ws = sizeof(double);
    int exoid = ex_create(fileName.c_str(), EX_CLOBBER, &comp_ws, &io_ws);
    checkExodusErr(exoid, true);

    auto geoMesh = this->getGeoMesh();
    auto mesh = geoMesh.mesh;
    auto sideSet = geoMesh.sideSet;
    if (!mesh || mesh->GetNumberOfCells() == 0) {
      std::cerr << "No mesh information to write." << std::endl;
      return;
    }

    // Make sure no empty element blocks
    std::map<int, std::vector<vtkIdType>> elemBlocks;
    {
      auto meshEntities = vtkIntArray::FastDownCast(
          mesh->GetCellData()->GetAbstractArray(getExoIdArrName()));
      for (const auto &elemBlock : _elemBlocks) {
        elemBlocks[elemBlock.first];
      }
      for (vtkIdType i = 0; i < mesh->GetNumberOfCells(); ++i) {
        auto entity = meshEntities->GetValue(i);
        elemBlocks.at(entity).emplace_back(i);
      }
      for (auto it = elemBlocks.begin(); it != elemBlocks.end();) {
        if (it->second.empty()) {
          it = elemBlocks.erase(it);
        } else {
          ++it;
        }
      }
    }

    // Get number of element block variables, nodal variables, and global
    // variables
    int numElemVars = 0;
    int numNodeVars = 0;
    int numGlobalVars = 0;
    std::vector<bool> cellDataWriteFlag;
    std::vector<bool> pointDataWriteFlag;
    std::vector<bool> fieldDataWriteFlag;
    int timeStep = 1;
    {
      // Cell Data
      auto globalIds = mesh->GetCellData()->GetGlobalIds();
      const char *globalIdName;
      if (globalIds) {
        globalIdName = globalIds->GetName();
      } else {
        globalIdName = "GlobalElementId";
      }
      auto pedigreeIds = mesh->GetCellData()->GetPedigreeIds();
      const char *pedgreeIdName;
      if (pedigreeIds) {
        pedgreeIdName = pedigreeIds->GetName();
      } else {
        pedgreeIdName = "PedigreeElementId";
      }
      auto numCells = mesh->GetNumberOfCells();
      cellDataWriteFlag.resize(mesh->GetCellData()->GetNumberOfArrays(), false);
      for (int i = 0; i < mesh->GetCellData()->GetNumberOfArrays(); ++i) {
        // Use GetArray instead of GetAbstractArray to filter for vtkDataArray
        auto arr = mesh->GetCellData()->GetArray(i);
        if (arr) {
          auto arrName = arr->GetName();
          if (strcmp(arrName, globalIdName) != 0 &&
              strcmp(arrName, pedgreeIdName) != 0 &&
              strcmp(arrName, getExoIdArrName()) != 0 &&
              arr->GetNumberOfTuples() == numCells) {
            auto numComponents = arr->GetNumberOfComponents();
            cellDataWriteFlag[i] = (numComponents > 0);
            numElemVars += numComponents;
          }
        }
      }
      // Point Data
      globalIds = mesh->GetPointData()->GetGlobalIds();
      if (globalIds) {
        globalIdName = globalIds->GetName();
      } else {
        globalIdName = "GlobalNodeId";
      }
      pedigreeIds = mesh->GetPointData()->GetPedigreeIds();
      if (pedigreeIds) {
        pedgreeIdName = pedigreeIds->GetName();
      } else {
        pedgreeIdName = "PedigreeNodeId";
      }
      auto numNodes = mesh->GetNumberOfPoints();
      pointDataWriteFlag.resize(mesh->GetPointData()->GetNumberOfArrays(),
                                false);
      for (int i = 0; i < mesh->GetPointData()->GetNumberOfArrays(); ++i) {
        // Use GetArray instead of GetAbstractArray to filter for vtkDataArray
        auto arr = mesh->GetPointData()->GetArray(i);
        if (arr) {
          auto arrName = arr->GetName();
          if (strcmp(arrName, globalIdName) != 0 &&
              strcmp(arrName, pedgreeIdName) != 0 &&
              arr->GetNumberOfTuples() == numNodes) {
            auto numComponents = arr->GetNumberOfComponents();
            pointDataWriteFlag[i] = (numComponents > 0);
            numNodeVars += numComponents;
          }
        }
      }
      // Field Data
      fieldDataWriteFlag.resize(mesh->GetFieldData()->GetNumberOfArrays(),
                                false);
      for (int i = 0; i < mesh->GetFieldData()->GetNumberOfArrays(); ++i) {
        // Use GetArray instead of GetAbstractArray to filter for vtkDataArray
        auto arr = mesh->GetFieldData()->GetArray(i);
        if (arr && arr->GetNumberOfTuples() == 1) {
          auto numComponents = arr->GetNumberOfComponents();
          fieldDataWriteFlag[i] = (numComponents > 0);
          numGlobalVars += numComponents;
        }
      }
    }

    // Have to make sure no empty side sets; might as well get the
    // indices now.
    std::map<int, std::vector<vtkIdType>> exoSideSets;
    if (sideSet.sides) {
      auto sideSetExoId = vtkIntArray::FastDownCast(
          sideSet.sides->GetCellData()->GetAbstractArray(getExoIdArrName()));
      for (vtkIdType i = 0; i < sideSet.sides->GetNumberOfCells(); ++i) {
        auto entity = sideSetExoId->GetValue(i);
        exoSideSets[entity].emplace_back(i);
      }
    }

    // Make sure no empty node sets and no duplicate nodes
    resetNodeSetPoints();
    int numNodeSets = std::accumulate(
        _nodeSets.begin(), _nodeSets.end(), 0,
        [](const int &a, const std::pair<const int, nodeSet> &b) {
          return a + (!b.second.nodes.empty());
        });

    auto err = ex_put_init(exoid, _title.c_str(), geoMesh.getDimension(),
                           mesh->GetNumberOfPoints(), mesh->GetNumberOfCells(),
                           elemBlocks.size(), numNodeSets, exoSideSets.size());
    checkExodusErr(err);
    if (numElemVars > 0) {
      err = ex_put_variable_param(exoid, EX_ELEM_BLOCK, numElemVars);
      checkExodusErr(err);
    }
    if (numNodeVars > 0) {
      err = ex_put_variable_param(exoid, EX_NODAL, numNodeVars);
      checkExodusErr(err);
    }
    if (numGlobalVars > 0) {
      err = ex_put_variable_param(exoid, EX_GLOBAL, numGlobalVars);
      checkExodusErr(err);
    }
    if (numElemVars > 0 || numNodeVars > 0 || numGlobalVars > 0) {
      double time = 0;
      err = ex_put_time(exoid, timeStep, &time);
      checkExodusErr(err);
    }

    std::vector<double> x_coord;
    std::vector<double> y_coord;
    std::vector<double> z_coord;
    x_coord.resize(mesh->GetNumberOfPoints(), 0);
    y_coord.resize(mesh->GetNumberOfPoints(), 0);
    z_coord.resize(mesh->GetNumberOfPoints(), 0);
    auto coord = mesh->GetPoints()->GetData();
    for (vtkIdType i = 0; i < mesh->GetNumberOfPoints(); ++i) {
      x_coord[i] = coord->GetComponent(i, 0);
      y_coord[i] = coord->GetComponent(i, 1);
      z_coord[i] = coord->GetComponent(i, 2);
    }
    err = ex_put_coord(exoid, x_coord.data(), y_coord.data(), z_coord.data());
    checkExodusErr(err);

    // map from index in mesh to implicit index in exodus output
    std::vector<vtkIdType> vtkIdMap(mesh->GetNumberOfCells(), -1);
    int lastElemIdx = 0;
    for (const auto &elemBlock : elemBlocks) {
      auto firstCell = mesh->GetCell(elemBlock.second[0]);
      auto cellType = static_cast<VTKCellType>(firstCell->GetCellType());
      err = ex_put_block(exoid, EX_ELEM_BLOCK, elemBlock.first,
                         vtkCellType2exoType(cellType), elemBlock.second.size(),
                         firstCell->GetNumberOfPoints(), 0, 0, 0);
      checkExodusErr(err);
      std::vector<int> conn;
      conn.reserve(elemBlock.second.size() * firstCell->GetNumberOfPoints());
      for (auto elem : elemBlock.second) {
        auto cell = mesh->GetCell(elem);
        vtkIdMap[elem] = ++lastElemIdx;
        for (int i = 0; i < cell->GetNumberOfPoints(); ++i) {
          // Exodus starts indexing from 1
          conn.emplace_back(cell->GetPointId(i) + 1);
        }
      }
      err = ex_put_conn(exoid, EX_ELEM_BLOCK, elemBlock.first, conn.data(),
                        nullptr, nullptr);
      checkExodusErr(err);
      if (!_elemBlocks.at(elemBlock.first).name.empty()) {
        err = ex_put_name(exoid, EX_ELEM_BLOCK, elemBlock.first,
                          _elemBlocks.at(elemBlock.first).name.c_str());
        checkExodusErr(err);
      }
    }

    if (sideSet.sides) {
      auto sideSetOrigCellId = geoMesh.sideSet.getOrigCellArr();
      auto sideSetCellFaceId = geoMesh.sideSet.getCellFaceArr();
      for (const auto &exoSideSet : exoSideSets) {
        err = ex_put_set_param(exoid, EX_SIDE_SET, exoSideSet.first,
                               exoSideSet.second.size(), 0);
        checkExodusErr(err);
        std::vector<int> sideSetElem, sideSetSide;
        sideSetElem.reserve(exoSideSet.second.size());
        sideSetSide.reserve(exoSideSet.second.size());
        for (auto sideIdx : exoSideSet.second) {
          auto parentCellIdx = sideSetOrigCellId->GetTypedComponent(sideIdx, 0);
          sideSetElem.emplace_back(vtkIdMap[parentCellIdx]);
          sideSetSide.emplace_back(
              vtkSide2exoSide(sideSetCellFaceId->GetTypedComponent(sideIdx, 0),
                              mesh->GetCell(parentCellIdx)->GetCellType()));
        }
        err = ex_put_set(exoid, EX_SIDE_SET, exoSideSet.first,
                         sideSetElem.data(), sideSetSide.data());
        checkExodusErr(err);
        auto foundName = _sideSetNames.find(exoSideSet.first);
        if (foundName != _sideSetNames.end()) {
          err = ex_put_name(exoid, EX_SIDE_SET, foundName->first,
                            foundName->second.c_str());
          checkExodusErr(err);
        }
      }
    }

    for (const auto &nodeSet : _nodeSets) {
      if (!nodeSet.second.nodes.empty()) {
        err = ex_put_set_param(exoid, EX_NODE_SET, nodeSet.first,
                               nodeSet.second.nodes.size(), 0);
        checkExodusErr(err);
        std::vector<int> nodes;  // Have to add 1
        nodes.reserve(nodeSet.second.nodes.size());
        std::transform(nodeSet.second.nodes.begin(), nodeSet.second.nodes.end(),
                       std::back_inserter(nodes), [](int x) { return x + 1; });
        err = ex_put_set(exoid, EX_NODE_SET, nodeSet.first, nodes.data(),
                         nullptr);
        checkExodusErr(err);
        if (!nodeSet.second.name.empty()) {
          err = ex_put_name(exoid, EX_NODE_SET, nodeSet.first,
                            nodeSet.second.name.c_str());
          checkExodusErr(err);
        }
      }
    }

    if (numElemVars > 0) {
      int var_index = 1;
      std::vector<double> vals(mesh->GetNumberOfCells());
      for (int i = 0; i < mesh->GetCellData()->GetNumberOfArrays(); ++i) {
        if (cellDataWriteFlag[i]) {
          auto arr = mesh->GetCellData()->GetArray(i);
          for (int j = 0; j < arr->GetNumberOfComponents(); ++j) {
            for (vtkIdType k = 0; k < mesh->GetNumberOfCells(); ++k) {
              vals[vtkIdMap[k] - 1] = arr->GetComponent(k, j);
            }
            auto name = getArrComponentName(arr, j);
            if (name.empty()) {
              name = "ElemBlockVar" + std::to_string(var_index);
            }
            err = ex_put_variable_name(exoid, EX_ELEM_BLOCK, var_index,
                                       name.c_str());
            checkExodusErr(err);
            std::size_t varOffset = 0;
            for (const auto &elemBlock : elemBlocks) {
              err = ex_put_var(exoid, timeStep, EX_ELEM_BLOCK, var_index,
                               elemBlock.first, elemBlock.second.size(),
                               vals.data() + varOffset);
              checkExodusErr(err);
              varOffset += elemBlock.second.size();
            }
            ++var_index;
          }
        }
      }
    }

    if (numNodeVars > 0) {
      int var_index = 1;
      std::vector<double> vals(mesh->GetNumberOfPoints());
      for (int i = 0; i < mesh->GetPointData()->GetNumberOfArrays(); ++i) {
        if (pointDataWriteFlag[i]) {
          auto arr = mesh->GetPointData()->GetArray(i);
          for (int j = 0; j < arr->GetNumberOfComponents(); ++j) {
            auto name = getArrComponentName(arr, j);
            if (name.empty()) {
              name = "NodalVar" + std::to_string(var_index);
            }
            err =
                ex_put_variable_name(exoid, EX_NODAL, var_index, name.c_str());
            checkExodusErr(err);
            for (vtkIdType k = 0; k < mesh->GetNumberOfPoints(); ++k) {
              vals[k] = arr->GetComponent(k, j);
            }
            err = ex_put_var(exoid, timeStep, EX_NODAL, var_index, 1,
                             mesh->GetNumberOfPoints(), vals.data());
            checkExodusErr(err);
            ++var_index;
          }
        }
      }
    }
    if (numGlobalVars > 0) {
      int var_index = 1;
      std::vector<double> vals;
      for (int i = 0; i < mesh->GetFieldData()->GetNumberOfArrays(); ++i) {
        if (fieldDataWriteFlag[i]) {
          auto arr = mesh->GetFieldData()->GetArray(i);
          for (int j = 0; j < arr->GetNumberOfComponents(); ++j) {
            vals.emplace_back(arr->GetComponent(0, j));
            auto name = getArrComponentName(arr, j);
            if (!name.empty()) {
              err = ex_put_variable_name(exoid, EX_GLOBAL, var_index,
                                         name.c_str());
              checkExodusErr(err);
            }
            ++var_index;
          }
        }
      }
      err = ex_put_var(exoid, timeStep, EX_GLOBAL, 1, 0, numGlobalVars,
                       vals.data());
      checkExodusErr(err);
    }

    if (!_elemBlockPropNames.empty()) {
      // Element block properties
      std::vector<const char *> propNames;
      propNames.reserve(_elemBlockPropNames.size());
      std::vector<std::vector<int>> propVals;
      propVals.resize(_elemBlockPropNames.size());
      for (const auto &elemBlockProp : _elemBlockPropNames) {
        propNames.emplace_back(elemBlockProp.c_str());
      }
      err = ex_put_prop_names(exoid, EX_ELEM_BLOCK, _elemBlockPropNames.size(),
                              const_cast<char **>(propNames.data()));
      checkExodusErr(err);
      // Use elemBlocks to verify non-empty
      auto nonEmptyIt = elemBlocks.begin();
      auto it = _elemBlocks.begin();
      while (nonEmptyIt != elemBlocks.end()) {
        if (it->first == nonEmptyIt->first) {
          std::size_t propValsIdx = 0;
          auto propNamesIt = propNames.begin();
          auto propValsIt = it->second.properties.begin();
          while (propNamesIt != propNames.end()) {
            if (propValsIt != it->second.properties.end() &&
                *propNamesIt == propValsIt->first) {
              propVals[propValsIdx].emplace_back(propValsIt->second);
              ++propValsIt;
            } else {
              propVals[propValsIdx].emplace_back(0);
            }
            ++propNamesIt;
            ++propValsIdx;
          }
          ++nonEmptyIt;
        }
        ++it;
      }
      for (std::size_t i = 0; i < propNames.size(); ++i) {
        err = ex_put_prop_array(exoid, EX_ELEM_BLOCK, propNames[i],
                                propVals[i].data());
        checkExodusErr(err);
      }
    }
    err = ex_close(exoid);
    checkExodusErr(err);
  } else {
    std::cerr << "For exoGeoMesh, " << fileExt
              << " format not currently supported." << std::endl;
  }
}

Member Data Documentation

_elemBlockPropNames

std::set<std::string> NEM::MSH::exoGeoMesh::_elemBlockPropNames

private

Definition at line 391 of file exoGeoMesh.H.

Referenced by addElemBlockProperty(), exoGeoMesh(), getElemBlockProperty(), getElemBlockPropertyNames(), resetElemBlocks(), setElemBlockProperty(), setPhysGrpPropertyName(), stitch(), takeGeoMesh(), and write().

_elemBlocks

std::map<int, elemBlock> NEM::MSH::exoGeoMesh::_elemBlocks

private

Definition at line 388 of file exoGeoMesh.H.

Referenced by addCellsToBlock(), addElemBlock(), exoGeoMesh(), getElemBlock(), getElemBlockIds(), getElemBlockName(), getElemBlockNames(), getElemBlockProperty(), getNumElemBlocks(), reassignCells(), report(), resetElemBlocks(), setElemBlockName(), setElemBlockProperty(), stitch(), takeGeoMesh(), and write().

_nodeSets

std::map<int, nodeSet> NEM::MSH::exoGeoMesh::_nodeSets

private

Definition at line 390 of file exoGeoMesh.H.

Referenced by addNodeSet(), exoGeoMesh(), getNodeSet(), getNodeSetIds(), getNodeSetName(), getNodeSetNames(), getNumNodeSets(), report(), resetNative(), resetNodeSetPoints(), setNodeSetName(), stitch(), takeGeoMesh(), and write().

_physGrpName

std::string NEM::MSH::exoGeoMesh::_physGrpName

private

Definition at line 392 of file exoGeoMesh.H.

Referenced by getPhysGrpPropertyName(), reconstructGeo(), resetElemBlocks(), resetNative(), setPhysGrpPropertyName(), and takeGeoMesh().

_sideSetNames

std::map<int, std::string> NEM::MSH::exoGeoMesh::_sideSetNames

private

Definition at line 389 of file exoGeoMesh.H.

Referenced by addSideSet(), exoGeoMesh(), getNumSideSets(), getSideSet(), getSideSetIds(), getSideSetName(), getSideSetNames(), report(), setSideSetName(), setSideSetObjId(), stitch(), takeGeoMesh(), and write().

_title

std::string NEM::MSH::exoGeoMesh::_title

private

Definition at line 387 of file exoGeoMesh.H.

Referenced by exoGeoMesh(), getTitle(), report(), setTitle(), takeGeoMesh(), and write().

GEO_ENT_DEFAULT_NAME

constexpr auto NEM::MSH::geoMeshBase::GEO_ENT_DEFAULT_NAME = "GeoEnt"

staticprotectedinherited

Definition at line 446 of file geoMeshBase.H.

Referenced by NEM::MSH::gmshGeoMesh::gmsh2GM(), NEM::MSH::inpGeoMesh::inp2GM(), NEM::MSH::oshGeoMesh::osh2GM(), reconstructGeo(), NEM::MSH::geoMeshBase::reconstructGeo(), and NEM::MSH::gmshGeoMesh::resetNative().

---

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

• exoGeoMesh.H
• exoGeoMesh.C