NEM::MSH::oshGeoMesh Class Reference

A concrete implementation of geoMeshBase representing a Omega_h::Mesh. More...

Detailed Description

Definition at line 79 of file oshGeoMesh.H.

Public Member Functions
	oshGeoMesh ()
	Create a oshGeoMesh from a file. More...
	oshGeoMesh (Omega_h::Mesh *oshMesh, Omega_h::Library *lib=nullptr)
	Construct a oshGeoMesh from an existing Omega_h::Mesh. More...
	~oshGeoMesh () override
void	write (const std::string &fileName) override
	Write mesh to file. More...
void	report (std::ostream &out) const override
	Print a report about the mesh. More...
void	takeGeoMesh (geoMeshBase *otherGeoMesh) override
	Take the GeoMesh of another geoMeshBase. More...
void	reconstructGeo () override
	Construct the geometry from the mesh alone. More...
const Omega_h::Mesh &	getOshMesh () const
	Get the Omega_h::Mesh. More...
void	setOshMesh (Omega_h::Mesh *oshMesh)
	Set the mesh to an existing Omega_h::Mesh. 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 oshGeoMesh *	New ()

Protected Member Functions
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	resetNative () override

Static Private Member Functions
static GeoMesh	osh2GM (Omega_h::Mesh *oshMesh, const std::string &geo="", const std::string &link="")
static Omega_h::Mesh *	GM2osh (const GeoMesh &geoMesh, Omega_h::Library *lib=nullptr)

Private Attributes
std::unique_ptr< Omega_h::Mesh >	_oshMesh

Inherits NEM::MSH::geoMeshBase.

Constructor & Destructor Documentation

oshGeoMesh() [1/2]

NEM::MSH::oshGeoMesh::oshGeoMesh

(

)

Parameters

fileName	name of file that Omega_h can read
lib	library pointer; if nullptr, OmegaHInterface::GetLibrary() is used

Returns

new oshGeoMesh Construct a oshGeoMesh with an empty mesh

Definition at line 85 of file oshGeoMesh.C.

: oshGeoMesh(nullptr) {}

oshGeoMesh() [2/2]

NEM::MSH::oshGeoMesh::oshGeoMesh ( Omega_h::Mesh *  oshMesh, Omega_h::Library *  lib = nullptr  )

explicit

Parameters

oshMesh	existing Omega_h::Mesh; note the mesh is copied
lib	library pointer; if nullptr, OmegaHInterface::GetLibrary() is used

Definition at line 87 of file oshGeoMesh.C.

References _oshMesh, and NEM::MSH::OmegaHInterface::GetLibrary().

    : geoMeshBase(osh2GM(oshMesh)), _oshMesh() {
  if (!lib) lib = OmegaHInterface::GetLibrary().get();
  std::cout << "oshGeoMesh constructed" << std::endl;
  _oshMesh = std::unique_ptr<Omega_h::Mesh>(
      oshMesh ? new Omega_h::Mesh(*oshMesh) : new Omega_h::Mesh());
  _oshMesh->set_library(lib);
}

~oshGeoMesh()

NEM::MSH::oshGeoMesh::~oshGeoMesh ( )

override

Definition at line 96 of file oshGeoMesh.C.

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

Member Function Documentation

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

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 NEM::MSH::exoGeoMesh::addCellsToBlock(), NEM::MSH::exoGeoMesh::addElemBlock(), NEM::MSH::exoGeoMesh::addElemBlockProperty(), NEM::MSH::exoGeoMesh::addNodeSet(), NEM::MSH::exoGeoMesh::addSideSet(), NEM::MSH::exoGeoMesh::exoGeoMesh(), NEM::MSH::exoGeoMesh::getElemBlock(), NEM::MSH::exoGeoMesh::getElemBlockId(), NEM::MSH::exoGeoMesh::getSideSet(), NEM::MSH::vtkGeoMesh::getVtkMesh(), NEM::MSH::inpGeoMesh::inpGeoMesh(), NEM::MSH::exoGeoMesh::reassignCells(), reconstructGeo(), NEM::MSH::exoGeoMesh::reconstructGeo(), NEM::MSH::geoMeshBase::report(), NEM::MSH::exoGeoMesh::resetElemBlocks(), NEM::MSH::smeshGeoMesh::resetNative(), NEM::MSH::gmshGeoMesh::resetNative(), NEM::MSH::inpGeoMesh::resetNative(), NEM::MSH::foamGeoMesh::resetNative(), resetNative(), NEM::MSH::exoGeoMesh::resetNative(), NEM::MSH::exoGeoMesh::scaleNodes(), setOshMesh(), NEM::MSH::exoGeoMesh::setPhysGrpPropertyName(), NEM::MSH::exoGeoMesh::setSideSetObjId(), NEM::MSH::exoGeoMesh::stitch(), NEM::MSH::gmshGeoMesh::write(), NEM::MSH::vtkGeoMesh::write(), and NEM::MSH::exoGeoMesh::write().

{ return _geoMesh; }

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

getOshMesh()

const Omega_h::Mesh& NEM::MSH::oshGeoMesh::getOshMesh ( ) const

inline

Returns

reference to the Omega_h::Mesh

Definition at line 128 of file oshGeoMesh.H.

Referenced by NEM::SRV::omegahRefineSrv::RequestData().

{ return *_oshMesh; }

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

GM2osh()

Omega_h::Mesh * NEM::MSH::oshGeoMesh::GM2osh ( const GeoMesh &  geoMesh, Omega_h::Library *  lib = nullptr  )

staticprivate

Definition at line 635 of file oshGeoMesh.C.

References NEM::MSH::geoMeshBase::SideSet::getGeoEntArr(), NEM::MSH::OmegaHInterface::GetLibrary(), NEM::MSH::getOmega_hArrayFromVtkDataArray(), NEM::MSH::getOmega_hDimFromVTKType(), NEM::MSH::getOmega_hFamilyFromVTKType(), NEM::MSH::geoMeshBase::GeoMesh::link, NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::New(), and NEM::MSH::geoMeshBase::GeoMesh::sideSet.

Referenced by resetNative().

                                                       {
  if (!lib) {
    lib = OmegaHInterface::GetLibrary().get();
  }
  auto *oshMesh = new Omega_h::Mesh(lib);

  auto vtkMesh = geoMesh.mesh;
  if (vtkMesh->GetNumberOfCells() == 0) {
    return oshMesh;
  }
  auto link = geoMesh.link;
  auto sideSet = geoMesh.sideSet;
  vtkSmartPointer<vtkCellTypes> ct = vtkSmartPointer<vtkCellTypes>::New();
  vtkMesh->GetCellTypes(ct);
  if (ct->GetNumberOfTypes() != 1) {
    std::cerr << "Error: Omega_h mesh does not support mixed meshes. Received "
                 "mesh with "
              << ct->GetNumberOfTypes() << " different cell types."
              << std::endl;
    exit(1);
  }
  Omega_h_Family oshFamily =
      getOmega_hFamilyFromVTKType(static_cast<VTKCellType>(ct->GetCellType(0)));
  Omega_h::Int oshDim =
      getOmega_hDimFromVTKType(static_cast<VTKCellType>(ct->GetCellType(0)));

  {  // Add points and cells (needs both for build_from_elems_and_coords)
    // Add points
    Omega_h::HostWrite<Omega_h::Real> h_oshCoords(oshDim *
                                                  vtkMesh->GetNumberOfPoints());
    vtkSmartPointer<vtkPoints> vtkPoints = vtkMesh->GetPoints();

    std::array<double, 3> point{};
    for (vtkIdType i = 0; i < vtkPoints->GetNumberOfPoints(); ++i) {
      vtkPoints->GetPoint(i, point.data());

      h_oshCoords[i * oshDim] = point[0];
      h_oshCoords[i * oshDim + 1] = point[1];
      if (oshDim >= 3) h_oshCoords[i * oshDim + 2] = point[2];
    }

    Omega_h::Reals oshCoords(h_oshCoords);

    {  // Add cells of dimension oshDim
      auto it = vtkMesh->NewCellIterator();
      auto numNodes = Omega_h::element_degree(oshFamily, oshDim, Omega_h::VERT);
      Omega_h::HostWrite<Omega_h::LO> ev2v(numNodes *
                                           vtkMesh->GetNumberOfCells());
      int i = 0;
      for (it->InitTraversal(); !it->IsDoneWithTraversal();
           it->GoToNextCell()) {
        auto ids = it->GetPointIds();
        for (Omega_h::Int d = 0; d < numNodes; ++d) {
          ev2v[numNodes * i + d] = ids->GetId(d);
        }
        ++i;
      }
      it->Delete();
      Omega_h::LOs eqv2v(ev2v);
      Omega_h::build_from_elems_and_coords(oshMesh, oshFamily, oshDim, eqv2v,
                                           Omega_h::Reals(h_oshCoords));
      if (!link.empty()) {
        Omega_h::HostWrite<Omega_h::ClassId> h_class_id(
            vtkMesh->GetNumberOfCells());
        auto linkArr = vtkMesh->GetCellData()->GetArray(link.c_str());
        if (linkArr) {
          for (i = 0; i < h_class_id.size(); ++i) {
            h_class_id[i] =
                static_cast<Omega_h::ClassId>(linkArr->GetComponent(i, 0));
          }
          Omega_h::classify_equal_order(oshMesh, oshDim, eqv2v,
                                        h_class_id.write());
        }
      }
    }
    // Add cells of dimension oshDim - 1 from the sideSet
    if (sideSet.sides && sideSet.sides->GetNumberOfCells() > 0) {
      auto it = sideSet.sides->NewCellIterator();
      auto numNodes =
          Omega_h::element_degree(oshFamily, oshDim - 1, Omega_h::VERT);
      Omega_h::HostWrite<Omega_h::LO> ev2v(numNodes *
                                           sideSet.sides->GetNumberOfCells());
      int i = 0;
      for (it->InitTraversal(); !it->IsDoneWithTraversal();
           it->GoToNextCell()) {
        auto ids = it->GetPointIds();
        for (Omega_h::Int d = 0; d < numNodes; ++d) {
          ev2v[numNodes * i + d] = ids->GetId(d);
        }
        ++i;
      }
      it->Delete();
      Omega_h::LOs eqv2v(ev2v);
      // If we have a non-empty sideSet, we should have a non-empty geo ent
      // array
      Omega_h::HostWrite<Omega_h::LO> h_class_id(
          sideSet.sides->GetNumberOfCells());
      auto geoEntArr = geoMesh.sideSet.getGeoEntArr();
      for (i = 0; i < h_class_id.size(); ++i) {
        h_class_id[i] = geoEntArr->GetValue(i);
      }
      Omega_h::classify_equal_order(oshMesh, oshDim - 1, eqv2v,
                                    h_class_id.write());
    }
  }

  {  // Add point data
    for (int a = 0; a < vtkMesh->GetPointData()->GetNumberOfArrays(); ++a) {
      vtkSmartPointer<vtkDataArray> da = vtkMesh->GetPointData()->GetArray(a);
      if (da) {
        getOmega_hArrayFromVtkDataArray(oshMesh, da, Omega_h::VERT);
      }
    }
  }

  {  // Add cell data
    for (int a = 0; a < vtkMesh->GetCellData()->GetNumberOfArrays(); ++a) {
      vtkSmartPointer<vtkDataArray> da = vtkMesh->GetCellData()->GetArray(a);
      if (da && strcmp(da->GetName(), link.c_str()) != 0) {
        getOmega_hArrayFromVtkDataArray(oshMesh, da, oshDim);
      }
    }
  }
  Omega_h::finalize_classification(oshMesh);
  return oshMesh;
}

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 oshGeoMesh* NEM::MSH::oshGeoMesh::New ( )

static

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

osh2GM()

geoMeshBase::GeoMesh NEM::MSH::oshGeoMesh::osh2GM ( Omega_h::Mesh *  oshMesh, const std::string &  geo = "", const std::string &  link = ""  )

staticprivate

Definition at line 328 of file oshGeoMesh.C.

References NEM::MSH::geoMeshBase::GEO_ENT_DEFAULT_NAME, NEM::MSH::getVtkDataArrayFromOmega_hTag(), NEM::MSH::getVTKTypeFromOmega_hFamilyDim(), NEM::MSH::New(), nodes, NEM::MSH::oshFace2vtkFace(), and points.

Referenced by setOshMesh().

                                                               {
  auto vtkMesh = vtkSmartPointer<vtkUnstructuredGrid>::New();

  if (!oshMesh || !oshMesh->is_valid()) return {vtkMesh, "", "", {}};
  // Omega_h dimension is important to read its data.
  //
  // It stores 2D mesh without a z-coordinate while VTK always requires 3D. A
  // "2D mesh" in VTK will have z-coordinates set to zero.
  //
  // Also, an Omega_h mesh contains the main element and all its lower-dimension
  // constituents. E.g., a 3D mesh containing tetrahedrons will also contain the
  // four triangles, six edges, and four vertices. When converting to VTK, we
  // will only add the lower-dimensional elements if the classification of
  // elements appears valid.
  Omega_h::Int dim = oshMesh->dim();

  // An Omega_h mesh cannot have mixed elements. The family determines if the
  // mesh is composed of simplices (tetrahedrons and triangles) or hypercubes
  // (hexahedrons and quadrangles).
  Omega_h_Family family = oshMesh->family();
  VTKCellType vtk_type = getVTKTypeFromOmega_hFamilyDim(family, dim);

  auto linkName = link;
  if (link.empty()) {
    linkName = GEO_ENT_DEFAULT_NAME;
  }
  bool validSideSet = true;

  {  // Add points
    vtkSmartPointer<vtkPoints> points =
        vtkSmartPointer<vtkPoints>::Take(vtkPoints::New(VTK_DOUBLE));
    points->Allocate(oshMesh->nverts());
    std::vector<double> nodes;

    Omega_h::HostRead<Omega_h::Real> h_coord(oshMesh->coords());

    for (Omega_h::LO i = 0; i < oshMesh->nverts(); ++i) {
      points->InsertNextPoint(h_coord[i * dim + 0], h_coord[i * dim + 1],
                              dim == 2 ? 0 : h_coord[i * dim + 2]);
    }
    // Because we add them in order, the indices should be the same.
    vtkMesh->SetPoints(points);
    std::vector<size_t> nodeTags;
  }

  {  // Add cells
    Omega_h::Int deg = Omega_h::element_degree(family, dim, OMEGA_H_VERT);
    Omega_h::HostRead<Omega_h::LO> h_ev2v(oshMesh->ask_elem_verts());

    vtkMesh->Allocate(oshMesh->nelems());

    for (Omega_h::LO nelem = 0; nelem < oshMesh->nelems(); ++nelem) {
      vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
      ptIds->Allocate(deg);

      for (Omega_h::Int nvert = 0; nvert < deg; ++nvert)
        ptIds->InsertNextId(h_ev2v[nelem * deg + nvert]);

      vtkMesh->InsertNextCell(vtk_type, ptIds);
    }
  }

  {  // Add point data
    for (Omega_h::Int itag = 0; itag < oshMesh->ntags(Omega_h::VERT); ++itag) {
      vtkSmartPointer<vtkDataArray> vtkArray;
      auto oshTagName = oshMesh->get_tag(Omega_h::VERT, itag)->name();
      if (oshTagName != "class_dim" && oshTagName != "class_id" &&
          oshTagName != "coordinates" && oshTagName != "global" &&
          oshTagName != "local") {
        getVtkDataArrayFromOmega_hTag(oshMesh->get_tag(Omega_h::VERT, itag),
                                      vtkArray);
      }

      vtkMesh->GetPointData()->AddArray(vtkArray);
    }
  }

  {  // Add cell data
    for (Omega_h::Int itag = 0; itag < oshMesh->ntags(dim); ++itag) {
      vtkSmartPointer<vtkDataArray> vtkArray;
      auto oshTagName = oshMesh->get_tag(dim, itag)->name();
      if (oshTagName != "class_dim" && oshTagName != "class_id" &&
          oshTagName != "global" && oshTagName != "local") {
        getVtkDataArrayFromOmega_hTag(oshMesh->get_tag(dim, itag), vtkArray);
        vtkMesh->GetCellData()->AddArray(vtkArray);
      }
    }
  }

  // Add boundary elements (of one lower dimension), if they exist, so we don't
  // have to reconstruct geometry.
  auto sideSetPD = vtkSmartPointer<vtkPolyData>::New();
  sideSetPD->SetPoints(vtkMesh->GetPoints());
  sideSetPD->Allocate();
  auto sideSetEntities = vtkSmartPointer<vtkIntArray>::New();
  auto sideSetOrigCellId = vtkSmartPointer<vtkIdTypeArray>::New();
  sideSetOrigCellId->SetNumberOfComponents(2);
  auto sideSetCellFaceId = vtkSmartPointer<vtkIntArray>::New();
  sideSetCellFaceId->SetNumberOfComponents(2);
  // Map from highest dimensional entities to bounding entities of one lower
  // dimension (by "class_id").
  std::map<Omega_h::ClassId, std::set<Omega_h::ClassId>> entities;
  // List of bounding entities of one lower dimension (by "class_id").
  std::vector<Omega_h::ClassId> entities_boundary;
  Omega_h::HostRead<Omega_h::ClassId> arr_id;
  {  // Add all entities of max dimension
    if (oshMesh->has_tag(dim, "class_id")) {
      arr_id = oshMesh->get_array<Omega_h::ClassId>(dim, "class_id");
    } else {
      validSideSet = false;
    }
  }
  // Find boundary elements of dimension dim - 1. Also recover the bounding
  // entities (of dimension dim - 1) for the entities of highest dimension
  if (validSideSet && oshMesh->has_tag(dim - 1, "class_id") &&
      oshMesh->has_tag(dim - 1, "class_dim")) {
    Omega_h::HostRead<Omega_h::ClassId> arr_id_boundary =
        oshMesh->get_array<Omega_h::ClassId>(dim - 1, "class_id");
    Omega_h::HostRead<Omega_h::I8> arr_dim =
        oshMesh->get_array<Omega_h::I8>(dim - 1, "class_dim");
    auto parent = oshMesh->ask_up(dim - 1, dim);
    Omega_h::HostRead<Omega_h::LO> parent_a2ab = parent.a2ab;
    Omega_h::HostRead<Omega_h::LO> parent_ab2b = parent.ab2b;
    Omega_h::HostRead<Omega_h::I8> parent_codes = parent.codes;
    for (Omega_h::LO i = 0; i < arr_dim.size(); ++i) {
      if (arr_dim[i] == dim - 1) {
        bool newEntityBoundary = false;
        auto oshEntity = arr_id_boundary[i];
        auto entityIter = std::find(entities_boundary.begin(),
                                entities_boundary.end(), oshEntity);
        if (entityIter == entities_boundary.end()) {
          entities_boundary.emplace_back(oshEntity);
          newEntityBoundary = true;
        }
        std::array<vtkIdType, 2> origCell{-1, -1};
        std::array<int, 2> cellFace{-1, -1};
        Omega_h::ClassId firstParentEnt = -1;
        for (int j = 0; j < parent_a2ab[i + 1] - parent_a2ab[i]; ++j) {
          auto ab = parent_ab2b[i + j];
          auto b = parent_ab2b[ab];
          if (j == 0) {
            firstParentEnt = arr_id[b];
          }
          if (newEntityBoundary) {
            entities[arr_id[b]].emplace(oshEntity);
          }
          auto code = parent_codes[ab];
          auto oshFace = Omega_h::code_which_down(code);
          if (j == 0 || (j == 1 && arr_id[b] < firstParentEnt)) {
            origCell[1] = origCell[0];
            cellFace[1] = cellFace[0];
            origCell[0] = b;
            cellFace[0] = oshFace2vtkFace(oshFace, family, dim);
          } else {
            origCell[1] = b;
            cellFace[1] = oshFace2vtkFace(oshFace, family, dim);
          }
        }
        auto side = dim == 2
                        ? vtkMesh->GetCell(origCell[0])->GetEdge(cellFace[0])
                        : vtkMesh->GetCell(origCell[0])->GetFace(cellFace[0]);
        sideSetPD->InsertNextCell(side->GetCellType(), side->GetPointIds());
        sideSetOrigCellId->InsertNextTypedTuple(origCell.data());
        sideSetCellFaceId->InsertNextTypedTuple(cellFace.data());
        sideSetEntities->InsertNextValue(oshEntity);
      }
    }
    Omega_h::HostRead<Omega_h::LO> point_id = oshMesh->ask_verts_of(dim - 1);
    // It might be more efficient to get the underlying array pointer
    // and use std::copy.
    auto vtkEntities = vtkSmartPointer<vtkIntArray>::New();
    vtkEntities->SetName(linkName.c_str());
    vtkEntities->SetNumberOfValues(vtkMesh->GetNumberOfCells());
    for (vtkIdType i = 0; i < vtkMesh->GetNumberOfCells(); ++i) {
      // The physical group name matches the class_id
      vtkEntities->SetValue(i, arr_id[i]);
    }
    vtkMesh->GetCellData()->AddArray(vtkEntities);
    return {vtkMesh,
            {},
            linkName,
            {sideSetPD, sideSetEntities, sideSetOrigCellId, sideSetCellFaceId}};
  } else {
    return {vtkMesh, {}, "", {}};
  }
}

reconstructGeo()

void NEM::MSH::oshGeoMesh::reconstructGeo ( )

overridevirtual

Sets geometry, link, and side set. Does not alter the mesh.

Reimplemented from NEM::MSH::geoMeshBase.

Definition at line 136 of file oshGeoMesh.C.

References _oshMesh, NEM::MSH::geoMeshBase::getGeoMesh(), NEM::MSH::geoMeshBase::GeoMesh::link, mesh, NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::geoMeshBase::reconstructGeo(), and NEM::MSH::geoMeshBase::GeoMesh::sideSet.

                                {
  geoMeshBase::reconstructGeo();
  auto mesh = getGeoMesh().mesh;
  auto link = getGeoMesh().link;
  auto sideSet = getGeoMesh().sideSet;
  auto oshFamily = _oshMesh->family();
  auto oshDim = _oshMesh->dim();
  if (sideSet.sides && sideSet.sides->GetNumberOfCells() > 0) {
    for (int i = 0; i <= oshDim; ++i) {
      if (_oshMesh->has_tag(i, "class_dim")) {
        _oshMesh->remove_tag(i, "class_dim");
      }
      if (_oshMesh->has_tag(i, "class_id")) {
        _oshMesh->remove_tag(i, "class_id");
      }
    }
    {  // Set class_dim and class_id for dimension oshDim
      Omega_h::HostWrite<Omega_h::ClassId> h_class_id(mesh->GetNumberOfCells());
      auto linkArr = mesh->GetCellData()->GetArray(link.c_str());
      if (linkArr) {
        for (Omega_h::LO i = 0; i < h_class_id.size(); ++i) {
          h_class_id[i] =
              static_cast<Omega_h::ClassId>(linkArr->GetComponent(i, 0));
        }
        // Note we pass dummy because classify_equal_order just assumes that
        // we pass in h_class_id in same order that we create cells.
        // This is fine because reconstructGeo doesn't change the mesh.
        auto dummyEqv2v = Omega_h::LOs(
            mesh->GetNumberOfCells() *
                Omega_h::element_degree(oshFamily, oshDim, Omega_h::VERT),
            0);
        Omega_h::classify_equal_order(_oshMesh.get(), oshDim, dummyEqv2v,
                                      h_class_id.write());
      }
    }
    {  // Set class_dim and class_id for dimension oshDim - 1
      auto it = vtkSmartPointer<vtkCellIterator>::Take(
          sideSet.sides->NewCellIterator());
      auto numNodes =
          Omega_h::element_degree(oshFamily, oshDim - 1, Omega_h::VERT);
      Omega_h::HostWrite<Omega_h::LO> ev2v(numNodes *
                                           sideSet.sides->GetNumberOfCells());
      for (int i = (it->InitTraversal(), 0); !it->IsDoneWithTraversal();
           it->GoToNextCell(), ++i) {
        auto ids = it->GetPointIds();
        for (Omega_h::Int d = 0; d < numNodes; ++d) {
          ev2v[numNodes * i + d] = ids->GetId(d);
        }
      }
      Omega_h::LOs eqv2v(ev2v);
      // If we have a non-empty sideSet, we should have a non-empty geo ent
      // array
      Omega_h::HostWrite<Omega_h::LO> h_class_id(
          sideSet.sides->GetNumberOfCells());
      auto geoEntArr = sideSet.getGeoEntArr();
      for (Omega_h::LO i = 0; i < h_class_id.size(); ++i) {
        h_class_id[i] = geoEntArr->GetValue(i);
      }
      Omega_h::classify_equal_order(_oshMesh.get(), oshDim - 1, eqv2v,
                                    h_class_id.write());
    }
  }
  Omega_h::finalize_classification(_oshMesh.get());
}

report()

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

overridevirtual

Parameters

out

stream

Implements NEM::MSH::geoMeshBase.

Definition at line 115 of file oshGeoMesh.C.

References _oshMesh, and NEM::MSH::geoMeshBase::report().

                                             {
  geoMeshBase::report(out);
  out << "Family:\t"
      << (_oshMesh->family() == OMEGA_H_SIMPLEX ? "SIMPLEX" : "HYPERCUBE")
      << '\n';
  out << "Dim:\t" << _oshMesh->dim() << '\n';
}

resetNative()

void NEM::MSH::oshGeoMesh::resetNative ( )

overrideprivatevirtual

Implements NEM::MSH::geoMeshBase.

Definition at line 768 of file oshGeoMesh.C.

References _oshMesh, NEM::MSH::geoMeshBase::getGeoMesh(), and GM2osh().

                             {
  _oshMesh = std::unique_ptr<Omega_h::Mesh>(GM2osh(getGeoMesh()));
}

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

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 NEM::MSH::exoGeoMesh::addCellsToBlock(), NEM::MSH::exoGeoMesh::addElemBlock(), NEM::MSH::exoGeoMesh::addSideSet(), NEM::MSH::exoGeoMesh::reassignCells(), NEM::MSH::exoGeoMesh::reconstructGeo(), NEM::MSH::gmshGeoMesh::resetNative(), NEM::MSH::exoGeoMesh::resetNative(), NEM::MSH::exoGeoMesh::scaleNodes(), NEM::MSH::foamGeoMesh::setFoamMesh(), setOshMesh(), NEM::MSH::smeshGeoMesh::setSMeshMesh(), NEM::MSH::vtkGeoMesh::setVtkMesh(), NEM::MSH::exoGeoMesh::stitch(), takeGeoMesh(), and NEM::MSH::exoGeoMesh::takeGeoMesh().

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

setOshMesh()

void NEM::MSH::oshGeoMesh::setOshMesh

(

Omega_h::Mesh *

oshMesh

)

Parameters

oshMesh

an existing Omega_h::Mesh; note the mesh is actually copied

Definition at line 763 of file oshGeoMesh.C.

References _oshMesh, NEM::MSH::geoMeshBase::getGeoMesh(), osh2GM(), and NEM::MSH::geoMeshBase::setGeoMesh().

                                                {
  this->setGeoMesh(osh2GM(oshMesh, getGeoMesh().geo, getGeoMesh().link));
  _oshMesh = std::unique_ptr<Omega_h::Mesh>(new Omega_h::Mesh(*oshMesh));
}

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

takeGeoMesh()

void NEM::MSH::oshGeoMesh::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 123 of file oshGeoMesh.C.

References _oshMesh, NEM::MSH::New(), NEM::MSH::geoMeshBase::setGeoMesh(), and NEM::MSH::geoMeshBase::takeGeoMesh().

                                                      {
  auto otherOshGM = dynamic_cast<oshGeoMesh *>(otherGeoMesh);
  if (otherOshGM) {
    setGeoMesh(otherOshGM->getGeoMesh());
    otherOshGM->setGeoMesh(
        {vtkSmartPointer<vtkUnstructuredGrid>::New(), {}, {}, {}});
    _oshMesh = std::move(otherOshGM->_oshMesh);
    otherOshGM->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::oshGeoMesh::write ( const std::string &  fileName )

overridevirtual

Parameters

fileName

file name

Implements NEM::MSH::geoMeshBase.

Definition at line 98 of file oshGeoMesh.C.

References _oshMesh, and nemAux::find_ext().

                                                {
  std::string fileExt = nemAux::find_ext(fileName);

  if (fileExt == ".osh") {
    Omega_h::binary::write(fileName, _oshMesh.get());
  } else if (fileExt == ".msh") {
    Omega_h::gmsh::write(fileName, _oshMesh.get());
  } else if (fileExt == ".pvtu") {
    Omega_h::vtk::write_parallel(fileName, _oshMesh.get());
  } else if (fileExt == ".vtu") {
    Omega_h::vtk::write_vtu(fileName, _oshMesh.get());
  } else {
    std::cerr << "Omega_h library does not support writing " << fileExt
              << " format." << std::endl;
  }
}

Member Data Documentation

_oshMesh

std::unique_ptr<Omega_h::Mesh> NEM::MSH::oshGeoMesh::_oshMesh

private

Definition at line 140 of file oshGeoMesh.H.

Referenced by oshGeoMesh(), reconstructGeo(), report(), resetNative(), setOshMesh(), 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(), osh2GM(), NEM::MSH::exoGeoMesh::reconstructGeo(), NEM::MSH::geoMeshBase::reconstructGeo(), and NEM::MSH::gmshGeoMesh::resetNative().

---

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

• oshGeoMesh.H
• oshGeoMesh.C