NEM::MSH Namespace Reference

Namespaces
	EXOMesh

Classes
class	dataSetRegionBoundaryFilter
	Like vtkDataSetRegionSurfaceFilter, this filter extracts boundaries of materials, including both interfaces and external boundaries. More...
class	exoGeoMesh
	A concrete implementation of geoMeshBase representing an Exodus II mesh. More...
class	foamGeoMesh
	A concrete implementation of geoMeshBase representing a mesh in a fvMesh. More...
class	geoMeshBase
	abstract class to specify geometry and mesh data More...
class	gmshGeoMesh
	A concrete implementation of geoMeshBase representing a Gmsh mesh. More...
class	GmshInterface
	management class for Gmsh interface More...
class	inpGeoMesh
	Class representing meshes in CalculiX input deck (similar to ABAQUS) More...
class	mergeCells
class	OmegaHInterface
	management class for Omega_h::Library More...
class	oshGeoMesh
	A concrete implementation of geoMeshBase representing a Omega_h::Mesh. More...
struct	SM_StdContainerWrapperFromIter
class	smeshGeoMesh
class	vtkGeoMesh
	A concrete implementation of geoMeshBase representing a mesh in a vtkUnstructuredGrid. More...

Typedefs
using	nemId_t = std::int64_t

Functions
bool	is_close (double val1, double val2, double floor, double rel_tol)
int	diffMesh (geoMeshBase *gmb1, geoMeshBase *gmb2, double floor=1e-9, double relTol=1e-6, double numCellsTol=-1., double numPointsTol=-1.)
	Compare two geoMeshBase objects. More...
	vtkStandardNewMacro (exoGeoMesh)
	vtkStandardNewMacro (foamGeoMesh)
MeshType	MeshTypeFromFilename (const std::string &fileName)
geoMeshBase *	Read (const std::string &fileName)
	Read a mesh from file. More...
geoMeshBase *	Read (const std::string &fileName, MeshType type)
	Read a mesh from file. More...
geoMeshBase *	New (MeshType type)
	Create a new mesh object. More...
geoMeshBase *	New (const std::string &fileName)
	Create a new mesh object. More...
	vtkStandardNewMacro (gmshGeoMesh)
	vtkStandardNewMacro (inpGeoMesh)
	vtkStandardNewMacro (oshGeoMesh)
VTKCellType	getVTKTypeFromOmega_hFamilyDim (Omega_h_Family family, Omega_h::Int dim)
Omega_h_Family	getOmega_hFamilyFromVTKType (VTKCellType vtkCellType)
Omega_h::Int	getOmega_hDimFromVTKType (VTKCellType vtkCellType)
template<typename OT , typename VT >
void	Otag2Varray (const Omega_h::TagBase *tagBase, VT *vtkArray)
void	getVtkDataArrayFromOmega_hTag (const Omega_h::TagBase *tagBase, vtkSmartPointer< vtkDataArray > &vtkArray)
int	oshFace2vtkFace (int oshFace, Omega_h_Family oshFamily, Omega_h::Int oshDim)
template<typename VT , typename OT >
void	Varray2Otag (Omega_h::Mesh *oshMesh, VT *vtkArray, Omega_h::Int oshDim)
template<typename VT >
void	Varray2Otag2 (Omega_h::Mesh *oshMesh, VT *vtkArray, Omega_h::Int oshDim)
void	getOmega_hArrayFromVtkDataArray (Omega_h::Mesh *oshMesh, vtkSmartPointer< vtkDataArray > &vtkArray, Omega_h::Int oshDim)
	vtkStandardNewMacro (smeshGeoMesh)
	mesh_ (gen_->CreateMesh(false))
template<class PtrSMDSIterator , class VALUE = typename std::decay< PtrSMDSIterator>::type::element_type::value_type, class EqualVALUE = std::equal_to<VALUE>>
SM_StdContainerWrapperFromIter< typename std::decay< PtrSMDSIterator >::type, VALUE, EqualVALUE >	containerWrapper (PtrSMDSIterator &&iter)
	vtkStandardNewMacro (vtkGeoMesh)
	vtkStandardNewMacro (dataSetRegionBoundaryFilter)
	vtkStandardNewMacro (mergeCells)

Typedef Documentation

nemId_t

using NEM::MSH::nemId_t = typedef std::int64_t

Definition at line 56 of file geoMeshBase.H.

Function Documentation

containerWrapper()

template<class PtrSMDSIterator , class VALUE = typename std::decay< PtrSMDSIterator>::type::element_type::value_type, class EqualVALUE = std::equal_to<VALUE>>

SM_StdContainerWrapperFromIter<typename std::decay<PtrSMDSIterator>::type, VALUE, EqualVALUE> NEM::MSH::containerWrapper

(

PtrSMDSIterator &&

iter

)

Definition at line 57 of file smeshUtils.H.

References NEM::MSH::SM_StdContainerWrapperFromIter< PtrSMDSIterator, VALUE, EqualVALUE >::iter.

Referenced by NEM::SRV::NucMeshSrv::FillOutputPortInformation(), NEM::NUCMESH::GroupData::setupAlgos(), and NEM::MSH::smeshGeoMesh::SmeshToGM().

                                         {
  return {std::forward<PtrSMDSIterator>(iter)};
}

diffMesh()

NEMOSYS_EXPORT int NEM::MSH::diffMesh	(	geoMeshBase *	gmb1,
		geoMeshBase *	gmb2,
		double	floor = 1e-9,
		double	relTol = 1e-6,
		double	numCellsTol = -1.,
		double	numPointsTol = -1.
	)

Parameters

gmb1	Reference geoMeshBase
gmb2	Other geoMeshBase
floor	If a floating point value is less than or equal to floor, it is treated as 0. Should be non-negative
relTol	Relative tolerance for comparing floating point values
numCellsTol	Tolerance for number of cells, if positive. If non-positive, exact match required for number of cells and cell data compared at each cell.
numPointsTol	Tolerance for number of points, if positive. If non-positive, exact match required for number of points and point data compared at each cell.

Returns

0 if gmb1 and gmb2 are similar; 1 otherwise

Definition at line 51 of file diffMesh.C.

References NEM::MSH::geoMeshBase::getCell(), NEM::MSH::geoMeshBase::getCellDataArrayCopy(), NEM::MSH::geoMeshBase::getGeoEntArrayName(), NEM::MSH::geoMeshBase::getNumberOfCellDataArrays(), NEM::MSH::geoMeshBase::getNumberOfCells(), NEM::MSH::geoMeshBase::getNumberOfPointDataArrays(), NEM::MSH::geoMeshBase::getNumberOfPoints(), NEM::MSH::geoMeshBase::getPoint(), NEM::MSH::geoMeshBase::getPointDataArrayCopy(), and is_close().

                                                      {
  // Check if equal number of points and cells.
  {
    auto points1 = gmb1->getNumberOfPoints();
    auto points2 = gmb2->getNumberOfPoints();
    if (numPointsTol > 0) {
      if (!is_close(points1, points2, 0, numPointsTol)) {
        std::cerr << "Meshes don't have similar number of points: " << points1
                  << " vs " << points2 << std::endl;
        return 1;
      }
    } else {
      if (points1 != points2) {
        std::cerr << "Meshes don't have same number of points: " << points1
                  << " vs " << points2 << std::endl;
        return 1;
      }
    }
  }
  {
    auto cells1 = gmb1->getNumberOfCells();
    auto cells2 = gmb2->getNumberOfCells();
    if (numCellsTol > 0) {
      if (!is_close(cells1, cells2, 0, numCellsTol)) {
        std::cerr << "Meshes don't have similar number of cells: " << cells1
                  << " vs " << cells2 << std::endl;
        return 1;
      }
    } else {
      if (cells1 != cells2) {
        std::cerr << "Meshes don't have same number of cells: " << cells1
                  << " vs " << cells2 << std::endl;
        return 1;
      }
    }
  }

  if (numPointsTol <= 0) {
    // Check if point coordinates match within tolerance
    for (int i = 0; i < gmb1->getNumberOfPoints(); ++i) {
      std::array<double, 3> coord1{};
      std::array<double, 3> coord2{};
      gmb1->getPoint(i, &coord1);
      gmb2->getPoint(i, &coord2);
      for (int j = 0; j < 3; ++j) {
        if (!is_close(coord1[j], coord2[j], floor, relTol)) {
          std::cerr << "Meshes differ in point coordinates" << std::endl;
          std::cerr << "Index " << i << " Component " << j << std::endl;
          std::cerr << "Coord 1 " << std::setprecision(15) << coord1[j]
                    << " Coord 2 " << std::setprecision(15) << coord2[j]
                    << std::endl;
          std::cerr << "Meshes differ in point coordinates" << std::endl;
          return 1;
        }
      }
    }
  }

  if (numCellsTol <= 0) {
    for (int i = 0; i < gmb1->getNumberOfCells(); ++i) {
      vtkSmartPointer<vtkPoints> points1 = gmb1->getCell(i)->GetPoints();
      vtkSmartPointer<vtkPoints> points2 = gmb2->getCell(i)->GetPoints();

      if (points1->GetNumberOfPoints() != points2->GetNumberOfPoints()) {
        std::cerr << "Meshes differ in cells" << std::endl;
        return 1;
      }

      for (int j = 0; j < points1->GetNumberOfPoints(); ++j) {
        std::vector<double> coord1(3);
        std::vector<double> coord2(3);
        points1->GetPoint(j, coord1.data());
        points2->GetPoint(j, coord2.data());
        for (int k = 0; k < 3; ++k) {
          if (!is_close(coord1[k], coord2[k], floor, relTol)) {
            std::cerr << "Meshes differ in cells" << std::endl;
            return 1;
          }
        }
      }
    }
  }

  int numPointArr1 = gmb1->getNumberOfPointDataArrays();
  int numPointArr2 = gmb2->getNumberOfPointDataArrays();

  if (numPointArr1 != numPointArr2) {
    std::cerr << "Meshes have different numbers of point data" << std::endl;
    std::cerr << "Mesh 1 has " << numPointArr1 << std::endl;
    std::cerr << "Mesh 2 has " << numPointArr2 << std::endl;
    return 1;
  }

  for (int i = 0; i < numPointArr1; ++i) {
    auto arr1 = gmb1->getPointDataArrayCopy(i);
    auto arr2 = gmb2->getPointDataArrayCopy(arr1->GetName());
    if (!arr2) {
      std::cerr << "Mesh 2 does not have a point data array of name "
                << arr1->GetName() << std::endl;
      return 1;
    }
    /*
    if (arr1->GetDataType() != arr2->GetDataType()) {
      std::cerr << "For point data array " << arr1->GetName()
                << ",\narrays do not have same data type:\n"
                << arr1->GetDataTypeAsString() << " vs "
                << arr2->GetDataTypeAsString() << std::endl;
      return 1;
    }
    */
    if (arr1->GetNumberOfComponents() != arr2->GetNumberOfComponents()) {
      std::cerr << "For point data array " << arr1->GetName()
                << ",\narrays do not have same number of components:\n"
                << arr1->GetNumberOfComponents() << " vs "
                << arr2->GetNumberOfComponents() << std::endl;
      return 1;
    }
    if (numPointsTol <= 0) {
      auto da1 = vtkDataArray::FastDownCast(arr1);
      auto da2 = vtkDataArray::FastDownCast(arr2);
      if (da1 && da2) {
        int numComponents = da1->GetNumberOfComponents();
        for (int j = 0; j < gmb1->getNumberOfPoints(); ++j) {
          std::vector<double> comps1(numComponents);
          std::vector<double> comps2(numComponents);
          da1->GetTuple(j, comps1.data());
          da2->GetTuple(j, comps2.data());
          for (int k = 0; k < numComponents; ++k) {
            if (!is_close(comps1[k], comps2[k], floor, relTol)) {
              std::cerr << "For point data array " << da1->GetName()
                        << std::endl;
              std::cerr << "Meshes differ in point data values at point " << j
                        << " component " << k << std::endl;
              std::cerr << comps1[k] << " " << comps2[k] << std::endl;
              return 1;
            }
          }
        }
      }
    }
  }

  int numCellArr1 = gmb1->getNumberOfCellDataArrays();
  int numCellArr2 = gmb2->getNumberOfCellDataArrays();

  if (numCellArr1 != numCellArr2) {
    std::cerr << "Meshes have different numbers of cell data" << std::endl;
    std::cerr << "Mesh 1 has " << numCellArr1 << std::endl;
    std::cerr << "Mesh 2 has " << numCellArr2 << std::endl;
    return 1;
  }

  for (int i = 0; i < numCellArr1; ++i) {
    auto arr1 = gmb1->getCellDataArrayCopy(i);
    if (arr1->GetName() == gmb1->getGeoEntArrayName()) {
      continue;
    }
    auto arr2 = gmb2->getCellDataArrayCopy(arr1->GetName());
    if (!arr2) {
      std::cerr << "Mesh 2 does not have a cell data array of name "
                << arr1->GetName() << std::endl;
      return 1;
    }
    /*
    if (arr1->GetDataType() != arr2->GetDataType()) {
      std::cerr << "For cell data array " << arr1->GetName()
                << ",\narrays do not have same data type:\n"
                << arr1->GetDataTypeAsString() << " vs "
                << arr2->GetDataTypeAsString() << std::endl;
      return 1;
    }
    */
    if (arr1->GetNumberOfComponents() != arr2->GetNumberOfComponents()) {
      std::cerr << "For cell data array " << arr1->GetName()
                << ",\narrays do not have same number of components:\n"
                << arr1->GetNumberOfComponents() << " vs "
                << arr2->GetNumberOfComponents() << std::endl;
      return 1;
    }
    if (numCellsTol <= 0) {
      auto da1 = vtkDataArray::FastDownCast(arr1);
      auto da2 = vtkDataArray::FastDownCast(arr2);
      if (da1 && da2) {
        int numComponents = da1->GetNumberOfComponents();
        for (int j = 0; j < gmb1->getNumberOfCells(); ++j) {
          std::vector<double> comps1(numComponents);
          std::vector<double> comps2(numComponents);
          da1->GetTuple(j, comps1.data());
          da2->GetTuple(j, comps2.data());
          for (int k = 0; k < numComponents; ++k) {
            if (!is_close(comps1[k], comps2[k], floor, relTol)) {
              std::cerr << "For cell data array " << da1->GetName()
                        << std::endl;
              std::cerr << "Meshes differ in cell data values at cell " << j
                        << " component " << k << std::endl;
              std::cerr << comps1[k] << " " << comps2[k] << std::endl;
              return 1;
            }
          }
        }
      }
    }
  }
  std::cout << "Meshes are the same" << std::endl;
  return 0;
}

getOmega_hArrayFromVtkDataArray()

void NEM::MSH::getOmega_hArrayFromVtkDataArray	(	Omega_h::Mesh *	oshMesh,
		vtkSmartPointer< vtkDataArray > &	vtkArray,
		Omega_h::Int	oshDim
	)

Definition at line 544 of file oshGeoMesh.C.

Referenced by NEM::MSH::oshGeoMesh::GM2osh().

                                                        {
  switch (vtkArray->GetDataType()) {
    case VTK_FLOAT: {
      vtkSmartPointer<vtkFloatArray> vtkArray_tmp =
          vtkFloatArray::FastDownCast(vtkArray);
      Varray2Otag<vtkFloatArray, Omega_h::Real>(oshMesh, vtkArray_tmp, oshDim);
      vtkArray = vtkArray_tmp;
      break;
    }
    case VTK_DOUBLE: {
      vtkSmartPointer<vtkDoubleArray> vtkArray_tmp =
          vtkDoubleArray::FastDownCast(vtkArray);
      Varray2Otag<vtkDoubleArray, Omega_h::Real>(oshMesh, vtkArray_tmp, oshDim);
      vtkArray = vtkArray_tmp;
      break;
    }
    case VTK_CHAR: {
      vtkSmartPointer<vtkCharArray> vtkArray_tmp =
          vtkCharArray::FastDownCast(vtkArray);
      Varray2Otag2<vtkCharArray>(oshMesh, vtkArray_tmp, oshDim);
      vtkArray = vtkArray_tmp;
      break;
    }
    case VTK_SIGNED_CHAR: {
      vtkSmartPointer<vtkSignedCharArray> vtkArray_tmp =
          vtkSignedCharArray::FastDownCast(vtkArray);
      Varray2Otag2<vtkSignedCharArray>(oshMesh, vtkArray_tmp, oshDim);
      vtkArray = vtkArray_tmp;
      break;
    }
    case VTK_SHORT: {
      vtkSmartPointer<vtkShortArray> vtkArray_tmp =
          vtkShortArray::FastDownCast(vtkArray);
      Varray2Otag2<vtkShortArray>(oshMesh, vtkArray_tmp, oshDim);
      vtkArray = vtkArray_tmp;
      break;
    }
    case VTK_INT: {
      vtkSmartPointer<vtkIntArray> vtkArray_tmp =
          vtkIntArray::FastDownCast(vtkArray);
      Varray2Otag2<vtkIntArray>(oshMesh, vtkArray_tmp, oshDim);
      vtkArray = vtkArray_tmp;
      break;
    }
    case VTK_LONG: {
      vtkSmartPointer<vtkLongArray> vtkArray_tmp =
          vtkLongArray::FastDownCast(vtkArray);
      Varray2Otag2<vtkLongArray>(oshMesh, vtkArray_tmp, oshDim);
      vtkArray = vtkArray_tmp;
      break;
    }
    case VTK_ID_TYPE: {
      vtkSmartPointer<vtkIdTypeArray> vtkArray_tmp =
          vtkIdTypeArray::FastDownCast(vtkArray);
      Varray2Otag2<vtkIdTypeArray>(oshMesh, vtkArray_tmp, oshDim);
      vtkArray = vtkArray_tmp;
      break;
    }
    case VTK_LONG_LONG: {
      vtkSmartPointer<vtkLongLongArray> vtkArray_tmp =
          vtkLongLongArray::FastDownCast(vtkArray);
      Varray2Otag2<vtkLongLongArray>(oshMesh, vtkArray_tmp, oshDim);
      vtkArray = vtkArray_tmp;
      break;
    }
      /*
      case VTK_VOID:
      case VTK_BIT:
      case VTK_UNSIGNED_CHAR:
      case VTK_UNSIGNED_SHORT:
      case VTK_UNSIGNED_INT:
      case VTK_UNSIGNED_LONG:
      case VTK_STRING:
      case VTK_OPAQUE:
      case VTK_UNSIGNED_LONG_LONG:
      case VTK___INT64:
      case VTK_UNSIGNED___INT64:
      case VTK_VARIANT:
      case VTK_OBJECT:
      case VTK_UNICODE_STRING:
      */
    default: {
      std::cerr << "VTK type " << vtkArray->GetDataTypeAsString()
                << " is not supported as an Omega_h type." << std::endl;
      exit(1);
    }
  }
}

getOmega_hDimFromVTKType()

Omega_h::Int NEM::MSH::getOmega_hDimFromVTKType

(

VTKCellType

vtkCellType

)

Definition at line 237 of file oshGeoMesh.C.

Referenced by NEM::MSH::oshGeoMesh::GM2osh().

                                                             {
  switch (vtkCellType) {
    case VTK_TETRA:
    case VTK_HEXAHEDRON: return 3;

    case VTK_TRIANGLE:
    case VTK_QUAD: return 2;

    case VTK_LINE: return 1;

    case VTK_VERTEX: return 0;
    case VTK_EMPTY_CELL:
    default: {
      std::cerr << "Omega_h supports only linear simplices and hypercubes. "
                   "VTKCellType "
                << vtkCellType << " is not supported." << std::endl;
      exit(1);
    }
  }
}

getOmega_hFamilyFromVTKType()

Omega_h_Family NEM::MSH::getOmega_hFamilyFromVTKType

(

VTKCellType

vtkCellType

)

Definition at line 217 of file oshGeoMesh.C.

Referenced by NEM::MSH::oshGeoMesh::GM2osh().

                                                                    {
  switch (vtkCellType) {
    case VTK_EMPTY_CELL:
    case VTK_VERTEX:
    case VTK_LINE:
    case VTK_TRIANGLE:
    case VTK_TETRA: return OMEGA_H_SIMPLEX;

    case VTK_QUAD:
    case VTK_HEXAHEDRON: return OMEGA_H_HYPERCUBE;

    default: {
      std::cerr << "Omega_h supports only linear simplices and hypercubes. "
                   "VTKCellType "
                << vtkCellType << " is not supported." << std::endl;
      exit(1);
    }
  }
}

getVtkDataArrayFromOmega_hTag()

void NEM::MSH::getVtkDataArrayFromOmega_hTag	(	const Omega_h::TagBase *	tagBase,
		vtkSmartPointer< vtkDataArray > &	vtkArray
	)

Definition at line 272 of file oshGeoMesh.C.

References New().

Referenced by NEM::MSH::oshGeoMesh::osh2GM().

                                                                            {
  switch (tagBase->type()) {
    case OMEGA_H_I8: {
      vtkSmartPointer<vtkTypeInt8Array> vtkArray_tmp =
          vtkSmartPointer<vtkTypeInt8Array>::New();
      Otag2Varray<Omega_h::I8, vtkTypeInt8Array>(tagBase, vtkArray_tmp);
      vtkArray = vtkArray_tmp;
      break;
    }
    case OMEGA_H_I32: {
      vtkSmartPointer<vtkTypeInt32Array> vtkArray_tmp =
          vtkSmartPointer<vtkTypeInt32Array>::New();
      Otag2Varray<Omega_h::I32, vtkTypeInt32Array>(tagBase, vtkArray_tmp);
      vtkArray = vtkArray_tmp;
      break;
    }
    case OMEGA_H_I64: {
      vtkSmartPointer<vtkTypeInt64Array> vtkArray_tmp =
          vtkSmartPointer<vtkTypeInt64Array>::New();
      Otag2Varray<Omega_h::I64, vtkTypeInt64Array>(tagBase, vtkArray_tmp);
      vtkArray = vtkArray_tmp;
      break;
    }
    case OMEGA_H_F64: {
      vtkSmartPointer<vtkTypeFloat64Array> vtkArray_tmp =
          vtkSmartPointer<vtkTypeFloat64Array>::New();
      Otag2Varray<Omega_h::Real, vtkTypeFloat64Array>(tagBase, vtkArray_tmp);
      vtkArray = vtkArray_tmp;
      break;
    }
  }
}

getVTKTypeFromOmega_hFamilyDim()

VTKCellType NEM::MSH::getVTKTypeFromOmega_hFamilyDim	(	Omega_h_Family	family,
		Omega_h::Int	dim
	)

Definition at line 201 of file oshGeoMesh.C.

Referenced by NEM::MSH::oshGeoMesh::osh2GM().

                                                           {
  return (
      family == OMEGA_H_SIMPLEX
          ? (dim == 3 ? VTK_TETRA
                      : (dim == 2 ? VTK_TRIANGLE
                                  : (dim == 1 ? VTK_LINE
                                              : (dim == 0 ? VTK_VERTEX
                                                          : VTK_EMPTY_CELL))))
          : (dim == 3 ? VTK_HEXAHEDRON
                      : (dim == 2 ? VTK_QUAD
                                  : (dim == 1 ? VTK_LINE
                                              : (dim == 0 ? VTK_VERTEX
                                                          : VTK_EMPTY_CELL)))));
}

is_close()

bool NEM::MSH::is_close	(	double	val1,
		double	val2,
		double	floor,
		double	rel_tol
	)

Definition at line 43 of file diffMesh.C.

Referenced by diffMesh().

                                                                      {
  if (std::fabs(val1) <= floor && std::fabs(val2) <= floor) {
    return true;
  } else {
    return std::fabs((val1 - val2) / val1) < rel_tol;
  }
}

mesh_()

NEM::MSH::mesh_

(

gen_->

CreateMeshfalse

)

Definition at line 123 of file smeshGeoMesh.C.

References NEM::MSH::geoMeshBase::report(), NEM::MSH::geoMeshBase::write(), and NEM::MSH::smeshGeoMesh::~smeshGeoMesh().

: geoMeshBase(), gen_{new SMESH_Gen{}}, mesh_(gen_->CreateMesh(false)) {}

MeshTypeFromFilename()

MeshType NEM::MSH::MeshTypeFromFilename

(

const std::string &

fileName

)

Definition at line 53 of file geoMeshFactory.C.

References EXO_GEO_MESH, nemAux::find_ext(), FOAM_GEO_MESH, GMSH_GEO_MESH, INP_GEO_MESH, OSH_GEO_MESH, and VTK_GEO_MESH.

Referenced by New(), and Read().

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

  if (fileExt == ".vtu" || fileExt == ".vtk") {
    return MeshType::VTK_GEO_MESH;
  } else if (fileExt == ".msh" || fileExt == ".geo") {
    return MeshType::GMSH_GEO_MESH;
  } else if (fileExt == ".osh") {
    return MeshType::OSH_GEO_MESH;
  } else if (fileExt == ".exo" || fileExt == ".e" || fileExt == ".gen" ||
             fileExt == ".g") {
    return MeshType::EXO_GEO_MESH;
  } else if (fileExt == ".inp") {
    return MeshType::INP_GEO_MESH;
  } else if (fileExt == ".foam") {
    return MeshType::FOAM_GEO_MESH;
  } else {
    std::cerr << "File extension " << fileExt << " is not supported."
              << std::endl;
    exit(1);
  }
}

New() [1/2]

NEMOSYS_EXPORT geoMeshBase * NEM::MSH::New

(

MeshType

type

)

Parameters

type	type of mesh

Returns

pointer to base mesh class

Definition at line 116 of file geoMeshFactory.C.

References EXO_GEO_MESH, FOAM_GEO_MESH, GMSH_GEO_MESH, INP_GEO_MESH, NEM::MSH::gmshGeoMesh::New(), NEM::MSH::vtkGeoMesh::New(), NEM::MSH::smeshGeoMesh::New(), NEM::MSH::foamGeoMesh::New(), NEM::MSH::exoGeoMesh::New(), NEM::MSH::inpGeoMesh::New(), NEM::MSH::oshGeoMesh::New(), OSH_GEO_MESH, SMESH_GEO_MESH, and VTK_GEO_MESH.

Referenced by MeshManipulationFoam::addArtificialThicknessElements(), NEM::MSH::exoGeoMesh::addCellsToBlock(), MeshManipulationFoam::addCohesiveElements(), NEM::MSH::exoGeoMesh::addElemBlock(), NEM::MSH::mergeCells::AddNewCellsDataSet(), NEM::MSH::mergeCells::AddNewCellsUnstructuredGrid(), NEM::MSH::exoGeoMesh::addSideSet(), meshSrch::buildCellLocator(), meshBase::buildStaticCellLocator(), meshBase::buildStaticPointLocator(), Foam::AMRFoam::checkForMotion(), meshSrch::chkDuplElm(), COBALT::cobalt::cobalt(), OrderOfAccuracy::computeDiff(), NEM::ADP::GradSizeField::computeL2GradAtAllCells(), PatchRecovery::computeNodalError(), OrderOfAccuracy::computeRichardsonExtrapolation(), NEM::ADP::Z2ErrorSizeField::computeSizeField(), NEM::ADP::GradSizeField::computeSizeField(), NEM::ADP::ValSizeField::computeSizeField(), ConservativeVolumeTransfer::ConservativeVolumeTransfer(), GaussCubature::constructGaussMesh(), meshBase::convertHexToTetVTK(), meshBase::convertQuads(), ConservativeVolumeTransfer::convertSupermeshToUnstructuredGrid(), NEM::GEO::rocPack::createCohesiveElements(), NEM::GEO::rocPack::createVtkCell(), diffMesh(), NEM::DRV::SmartConversionDriver::execute(), NEM::DRV::CFMeshMeshGenDriver::execute(), NEM::DRV::NucMeshDriver::execute(), NEM::DRV::OmegahRefineDriver::execute(), NEM::DRV::HexPackMeshDriver::execute(), NEM::MSH::exoGeoMesh::exoReader2GM(), meshBase::exportExoToVtk(), meshBase::exportGmshToVtk(), meshBase::exportPntToVtk(), cgnsAnalyzer::exportToVTKMesh(), hdf5Reader::exportToVTKMesh(), meshBase::exportVolToVtk(), meshBase::extractSelectedCells(), vtkMesh::extractSurface(), FOAM::foamMesh::extractSurface(), ConservativeVolumeTransfer::extractSurface(), FETransfer::FETransfer(), meshSrch::FindCellsInPolyData(), meshSrch::FindCellsInSphere(), meshSrch::FindCellsInTriSrf(), meshSrch::FindCellsWithinBounds(), meshSrch::FindPntsOnEdge(), meshSrch::FindPntsOnTriSrf(), NEM::MSH::foamGeoMesh::foam2GM(), NEM::DRV::ConversionDriver::freeSurfaceSideSet(), selectEnclosedPoints::fromDataSet(), NEM::DRV::ConversionDriver::genExo(), NEM::MSH::geoMeshBase::geoMeshBase(), proteusHdf5::getBoundarySideSets(), FOAM::foamMesh::getCell(), vtkMesh::getCell(), meshSrch::getCellVec(), FOAM::foamMesh::getCellVec(), vtkMesh::getCellVec(), FETransfer::getClosestSourceCell(), NEM::MSH::exoGeoMesh::getExoReader(), cgnsAnalyzer::getSectionMesh(), NEM::MSH::exoGeoMesh::getSS(), MeshQuality::getStats(), getVtkDataArrayFromOmega_hTag(), NEM::MSH::foamGeoMesh::GM2foam(), NEM::MSH::oshGeoMesh::GM2osh(), NEM::MSH::gmshGeoMesh::gmsh2GM(), NEM::MSH::inpGeoMesh::inp2GM(), FOAM::foamMesh::inspectEdges(), vtkMesh::inspectEdges(), GaussCubature::integrateOverAllCells(), ConservativeVolumeTransfer::interpolateCellDataToPoints(), GaussCubature::interpolateToGaussPoints(), NEM::MSH::mergeCells::MapPointsToIdsUsingGlobalIds(), NEM::MSH::mergeCells::MapPointsToIdsUsingLocator(), vtkMesh::merge(), NEM::MSH::geoMeshBase::mergeGeoMesh(), NEM::DRV::MeshGenDriver::MeshGenDriver(), meshPartitioner::meshPartitioner(), MeshQuality::MeshQuality(), New(), NEM::MSH::oshGeoMesh::osh2GM(), meshBase::partition(), PATRAN::patran::patran(), MeshManipulationFoam::periodicMeshMapper(), PNTMesh::pntMesh::pntPopulate(), proteusHdf5::proteusHdf5(), gmshMesh::read(), ReadALegacyVTKFile(), ReadAnXMLOrSTLFile(), ReadDegenerateVTKFile(), readLegacyVTKCells(), readLegacyVTKData(), readLegacyVTKFieldData(), NEM::MSH::exoGeoMesh::reconstructGeo(), PatchRecovery::recoverNodalSolution(), NEM::MSH::dataSetRegionBoundaryFilter::RequestData(), NEM::MSH::gmshGeoMesh::resetNative(), NEM::MSH::exoGeoMesh::resetNative(), NEM::MSH::exoGeoMesh::scaleNodes(), vtkMesh::setCellDataArray(), vtkMesh::setPointDataArray(), NEM::MSH::exoGeoMesh::setSideSetObjId(), NEM::MSH::mergeCells::StartUGrid(), NEM::MSH::exoGeoMesh::stitch(), meshBase::stitchMB(), NEM::MSH::oshGeoMesh::takeGeoMesh(), NEM::MSH::exoGeoMesh::takeGeoMesh(), NEM::MSH::geoMeshBase::takeGeoMesh(), ConservativeVolumeTransfer::transfer(), FETransfer::transferCellData(), ConservativeSurfaceTransfer::transferPointData(), FETransfer::transferPointData(), NEM::MSH::vtkGeoMesh::vtk2GM(), vtkMesh::vtkMesh(), vtkStandardNewMacro(), COBALT::cobalt::write(), NEM::MSH::vtkGeoMesh::write(), gmshMesh::write(), FOAM::foamMesh::write(), PATRAN::patran::write2(), PATRAN::patran::write6(), PATRAN::patran::write8(), meshBase::writeCobalt(), and writeVTFile().

                                    {
  switch (meshType) {
    case MeshType::VTK_GEO_MESH: return vtkGeoMesh::New();
    case MeshType::GMSH_GEO_MESH: {
#ifdef HAVE_GMSH
      return gmshGeoMesh::New();
#else
      std::cerr << "Please build NEMoSys with ENABLE_GMSH=ON to use this"
                << " feature!" << std::endl;
      throw;
#endif
    }
    case MeshType::OSH_GEO_MESH: return oshGeoMesh::New();
    case MeshType::EXO_GEO_MESH: return exoGeoMesh::New();
    case MeshType::INP_GEO_MESH: return inpGeoMesh::New();
    case MeshType::FOAM_GEO_MESH: {
#ifdef HAVE_CFMSH
      return foamGeoMesh::New();
#else
      std::cerr << "Please build NEMoSys with ENABLE_CFMSH=ON to use this"
                << " feature!" << std::endl;
      throw;
#endif
    }
    case MeshType::SMESH_GEO_MESH: {
#ifdef HAVE_OCC
      return smeshGeoMesh::New();
#else
      std::cerr << "Requires ENABLE_OPENCASCADE=ON\n";
      throw;
#endif
    }
  }
  return nullptr;
}

New() [2/2]

NEMOSYS_EXPORT geoMeshBase * NEM::MSH::New

(

const std::string &

fileName

)

Determines mesh type from file extension.

Parameters

fileName

name of file

Returns

pointer to base mesh class

Definition at line 152 of file geoMeshFactory.C.

References MeshTypeFromFilename(), and New().

                                            {
  return New(MeshTypeFromFilename(fileName));
}

oshFace2vtkFace()

int NEM::MSH::oshFace2vtkFace	(	int	oshFace,
		Omega_h_Family	oshFamily,
		Omega_h::Int	oshDim
	)

Definition at line 306 of file oshGeoMesh.C.

Referenced by NEM::MSH::oshGeoMesh::osh2GM().

                                       {
  switch (oshDim) {
    case 2: return oshFace;
    case 3:
      switch (oshFamily) {
        case OMEGA_H_SIMPLEX: return (oshFace + 3) % 4;
        case OMEGA_H_HYPERCUBE:
          switch (oshFace) {
            case 0: return 4;
            case 1: return 2;
            case 2: return 1;
            case 3: return 3;
            case 4: return 0;
            case 5: return 5;
            default: return -1;
          }
      }
    default: return -1;
  }
}

Otag2Varray()

template<typename OT , typename VT >

void NEM::MSH::Otag2Varray	(	const Omega_h::TagBase *	tagBase,
		VT *	vtkArray
	)

Definition at line 259 of file oshGeoMesh.C.

                                                              {
  const Omega_h::Tag<OT> *tag = Omega_h::as<OT>(tagBase);
  Omega_h::Int ncomps = tagBase->ncomps();
  Omega_h::HostRead<OT> tagArray(tag->array());

  vtkArray->SetName(tagBase->name().c_str());
  vtkArray->SetNumberOfComponents(ncomps);
  vtkArray->SetNumberOfValues(tagArray.size());

  for (Omega_h::LO i = 0; i < tagArray.size(); ++i)
    vtkArray->SetValue(i, tagArray.get(i));
}

Read() [1/2]

NEMOSYS_EXPORT geoMeshBase * NEM::MSH::Read

(

const std::string &

fileName

)

Determines mesh type from file extension.

Parameters

fileName

name of file

Returns

pointer to base mesh class

Definition at line 76 of file geoMeshFactory.C.

References MeshTypeFromFilename().

Referenced by MeshManipulationFoam::addArtificialThicknessElements(), MeshManipulationFoam::addCohesiveElements(), cfmeshGen::createMeshFromSTL(), snappymeshGen::createMeshFromSTL(), blockMeshGen::createMeshFromSTL(), NEM::DRV::SmartConversionDriver::execute(), NEM::DRV::OmegahRefineDriver::execute(), NEM::DRV::HexPackMeshDriver::execute(), NEM::MSH::exoGeoMesh::getSS(), and MeshManipulationFoam::periodicMeshMapper().

                                             {
  return Read(fileName, MeshTypeFromFilename(fileName));
}

Read() [2/2]

NEMOSYS_EXPORT geoMeshBase * NEM::MSH::Read	(	const std::string &	fileName,
		MeshType	type
	)

Parameters

fileName	name of file
type	type of mesh

Returns

pointer to base mesh class

Definition at line 80 of file geoMeshFactory.C.

References EXO_GEO_MESH, FOAM_GEO_MESH, GMSH_GEO_MESH, INP_GEO_MESH, OSH_GEO_MESH, NEM::MSH::inpGeoMesh::Read(), SMESH_GEO_MESH, and VTK_GEO_MESH.

                                                                {
  switch (meshType) {
    case MeshType::VTK_GEO_MESH: return vtkGeoMesh::Read(fileName);
    case MeshType::GMSH_GEO_MESH: {
#ifdef HAVE_GMSH
      return gmshGeoMesh::Read(fileName);
#else
      std::cerr << "Please build NEMoSys with ENABLE_GMSH=ON to use this"
                << " feature!" << std::endl;
      throw;
#endif
    }
    case MeshType::OSH_GEO_MESH: return oshGeoMesh::Read(fileName);
    case MeshType::EXO_GEO_MESH: return exoGeoMesh::Read(fileName);
    case MeshType::INP_GEO_MESH: return inpGeoMesh::Read(fileName);
    case MeshType::FOAM_GEO_MESH: {
#ifdef HAVE_CFMSH
      std::string fname = fileName;
      fname.erase(fname.find_last_of('.'));
      return foamGeoMesh::Read(fname);
#else
      std::cerr << "Please build NEMoSys with ENABLE_CFMSH=ON to use this"
                << " feature!" << std::endl;
      throw;
#endif
    }
    case MeshType::SMESH_GEO_MESH: {
      std::cerr << "Unsupported.\n";
      throw;
    }
  }
  // Don't put inside switch statement so static analyzers can detect unhandled
  // cases
  return nullptr;
}

Varray2Otag()

template<typename VT , typename OT >

void NEM::MSH::Varray2Otag	(	Omega_h::Mesh *	oshMesh,
		VT *	vtkArray,
		Omega_h::Int	oshDim
	)

Definition at line 518 of file oshGeoMesh.C.

Referenced by Varray2Otag2().

                                                                        {
  Omega_h::HostWrite<OT> h_oshArray;
  h_oshArray = Omega_h::HostWrite<OT>(vtkArray->GetNumberOfValues(),
                                      vtkArray->GetClassName());

  for (vtkIdType i = 0; i < vtkArray->GetNumberOfValues(); ++i)
    h_oshArray.set(i, vtkArray->GetValue(i));

  Omega_h::Read<OT> oshArray(h_oshArray);

  oshMesh->add_tag(oshDim, vtkArray->GetName(),
                   vtkArray->GetNumberOfComponents(), oshArray);
}

Varray2Otag2()

template<typename VT >

void NEM::MSH::Varray2Otag2	(	Omega_h::Mesh *	oshMesh,
		VT *	vtkArray,
		Omega_h::Int	oshDim
	)

Definition at line 533 of file oshGeoMesh.C.

References Varray2Otag().

                                                                         {
  Varray2Otag<
      VT, typename std::conditional<
              sizeof(typename VT::ValueType) <= 1, Omega_h::I8,
              typename std::conditional<
                  sizeof(typename VT::ValueType) <= 4, Omega_h::I32,
                  typename std::enable_if<sizeof(typename VT::ValueType) <= 8,
                                          Omega_h::I64>::type>::type>::type>(
      oshMesh, vtkArray, oshDim);
}

vtkStandardNewMacro() [1/9]

NEM::MSH::vtkStandardNewMacro

(

vtkGeoMesh

)

Definition at line 54 of file vtkGeoMesh.C.

References nemAux::find_ext(), New(), and NEM::MSH::vtkGeoMesh::vtkGeoMesh().

                                                            {
  vtkSmartPointer<vtkUnstructuredGrid> inUnstructuredGrid;

  std::string fileExt = nemAux::find_ext(fileName);
  if (fileExt == ".vtk") {  // Legacy type
    vtkSmartPointer<vtkGenericDataObjectReader> reader =
        vtkSmartPointer<vtkGenericDataObjectReader>::New();
    reader->SetFileName(fileName.c_str());
    reader->Update();

    inUnstructuredGrid = vtkUnstructuredGrid::SafeDownCast(reader->GetOutput());
  } else if (fileExt.substr(0, 3) == ".vt") {  // XML type
    vtkSmartPointer<vtkXMLGenericDataObjectReader> reader =
        vtkSmartPointer<vtkXMLGenericDataObjectReader>::New();
    reader->SetFileName(fileName.c_str());
    reader->Update();

    inUnstructuredGrid = vtkUnstructuredGrid::SafeDownCast(reader->GetOutput());
    /*
  } else if (fileExt == ".stl") {  // Allow STLs
    vtkSmartPointer<vtkSTLReader> reader = vtkSmartPointer<vtkSTLReader>::New();
    reader->SetFileName(fileName.c_str());
    reader->Update();

    // TODO: This cast fails. STL reader outputs vtkPolyData!
    inUnstructuredGrid = vtkUnstructuredGrid::SafeDownCast(reader->GetOutput());
    */
  } else {  // Not a VTK type
    std::cerr << "ERROR: File extension " << fileExt
              << " is not supported by vtkGeoMesh." << std::endl;
    exit(1);
  }

  if (!inUnstructuredGrid) {  // Not a mesh
    std::cerr << "ERROR: Only VTK Unstructured Grid (vtu) is supported."
              << std::endl;
    exit(1);
  }

  return new vtkGeoMesh(inUnstructuredGrid, geoArrayName);
}

vtkStandardNewMacro() [2/9]

NEM::MSH::vtkStandardNewMacro

(

mergeCells

)

Definition at line 59 of file mergeCells.C.

                         {
 public:
  std::map<vtkIdType, vtkIdType> IdTypeMap;
};

vtkStandardNewMacro() [3/9]

NEM::MSH::vtkStandardNewMacro

(

foamGeoMesh

)

Definition at line 63 of file foamGeoMesh.C.

References NEM::MSH::foamGeoMesh::foam2GM(), and NEM::MSH::foamGeoMesh::foamGeoMesh().

                                                              {
  auto foamGM = new foamGeoMesh();
  Foam::word regionName;

  if (fileName.empty()) {
    regionName = Foam::fvMesh::defaultRegion;
  } else {
    regionName = fileName;
  }

  bool writeDicts = false;
  std::unique_ptr<getDicts> initFoam;
  initFoam = std::unique_ptr<getDicts>(new getDicts());
  foamGM->controlDict_ = initFoam->createControlDict(writeDicts);

  foamGM->runTime_ = std::unique_ptr<Foam::Time>(
      new Foam::Time(foamGM->controlDict_.get(), ".", "."));

  foamGM->fmesh_.reset(new Foam::fvMesh(
      Foam::IOobject(regionName, foamGM->runTime_->timeName(),
                     *foamGM->runTime_, Foam::IOobject::MUST_READ)));

  auto gmMesh = foam2GM(foamGM->fmesh_.get());

  foamGM->setGeoMesh(gmMesh);

  return foamGM;
}

vtkStandardNewMacro() [4/9]

NEM::MSH::vtkStandardNewMacro

(

oshGeoMesh

)

Definition at line 73 of file oshGeoMesh.C.

References NEM::MSH::OmegaHInterface::GetLibrary().

                                                  {
  if (!lib) {
    lib = OmegaHInterface::GetLibrary().get();
  }
  Omega_h::Mesh oshMesh = Omega_h::read_mesh_file(fileName, lib->world());

  return new oshGeoMesh(&oshMesh, lib);
}

vtkStandardNewMacro() [5/9]

NEM::MSH::vtkStandardNewMacro

(

gmshGeoMesh

)

Definition at line 98 of file gmshGeoMesh.C.

References NEM::MSH::gmshGeoMesh::gmshGeoMesh(), and NEM::MSH::GmshInterface::Initialize().

                                                        {
  GmshInterface::Initialize();

  gmsh::open(fileName);

  std::string gmshMesh;
  gmsh::model::getCurrent(gmshMesh);

  return new gmshGeoMesh(gmshMesh);
}

vtkStandardNewMacro() [6/9]

NEM::MSH::vtkStandardNewMacro

(

smeshGeoMesh

)

Definition at line 120 of file smeshGeoMesh.C.

    : geoMeshBase(), gen_{new SMESH_Gen{}}, mesh_(gen_->CreateMesh(false)) {}

vtkStandardNewMacro() [7/9]

NEM::MSH::vtkStandardNewMacro

(

dataSetRegionBoundaryFilter

)

Definition at line 246 of file dataSetRegionBoundaryFilter.C.

                                    {
  info->Set(vtkAlgorithm::INPUT_REQUIRED_DATA_TYPE(), "vtkDataSet");
  return 1;
}

vtkStandardNewMacro() [8/9]

NEM::MSH::vtkStandardNewMacro

(

exoGeoMesh

)

Definition at line 247 of file exoGeoMesh.C.

References NEM::MSH::exoGeoMesh::exoGeoMesh().

                                                                    {
  return new exoGeoMesh(fileName, timeStep);
}

vtkStandardNewMacro() [9/9]

NEM::MSH::vtkStandardNewMacro

(

inpGeoMesh

)

Definition at line 593 of file inpGeoMesh.C.

                                                      {
  return new inpGeoMesh(fileName);
}