#include <Mesh.h>

Public Member Functions
NEKMESHUTILS_EXPORT	Mesh ()

NEKMESHUTILS_EXPORT unsigned int	GetNumElements ()
	Returns the total number of elements in the mesh with dimension expDim. More...

NEKMESHUTILS_EXPORT unsigned int	GetNumBndryElements ()
	Returns the total number of elements in the mesh with dimension < expDim. More...

NEKMESHUTILS_EXPORT unsigned int	GetNumEntities ()
	Returns the total number of entities in the mesh. More...

NEKMESHUTILS_EXPORT void	MakeOrder (int order, LibUtilities::PointsType distType)
	Convert this mesh into a mesh of uniform polynomial order `order` with a curve point distribution `distType`. More...

NEKMESHUTILS_EXPORT void	PrintStats (std::ostream &out)
	Print out basic statistics of this mesh. More...

Public Attributes
bool	m_verbose
	Verbose flag. More...

unsigned int	m_expDim
	Dimension of the expansion. More...

unsigned int	m_spaceDim
	Dimension of the space in which the mesh is defined. More...

unsigned int	m_nummode
	a order tag to aid output, a bit of a hack More...

std::vector< NodeSharedPtr >	m_node
	List of mesh nodes. More...

NodeSet	m_vertexSet
	Set of element vertices. More...

int	m_numNodes
	used for meshing purposes to keep trac of ids More...

EdgeSet	m_edgeSet
	Set of element edges. More...

FaceSet	m_faceSet
	Set of element faces. More...

ElementMap	m_element
	Map for elements. More...

CompositeMap	m_composite
	Map for composites. More...

ConditionMap	m_condition
	Boundary conditions maps tag to condition. More...

std::vector< std::string >	m_fields
	List of fields names. More...

std::unordered_map< int, Node >	m_vertexNormals
	Map of vertex normals. More...

std::set< std::pair< int, int > >	m_spherigonSurfs
	Set of all pairs of element ID and edge/face number on which to apply spherigon surface smoothing. More...

std::map< int, std::string >	m_faceLabels
	List of face labels for composite annotation. More...

CADSystemSharedPtr	m_cad
	CAD system pointer, if there is no cad its empty. More...

OctreeSharedPtr	m_octree
	Octree system pointer, if there is no octree its empty. More...

LibUtilities::FieldMetaDataMap	m_metadata
	Metadata map for storing any mesh generation parameters. More...

LibUtilities::CommSharedPtr	m_comm
	MPI communicator in case we end up using MPI multiple times from Nektar++ SessionReader object. More...

Detailed Description

Definition at line 91 of file Mesh.h.

Constructor & Destructor Documentation

◆ Mesh()

NEKMESHUTILS_EXPORT Nektar::NekMeshUtils::Mesh::Mesh ( )

inline

Definition at line 94 of file Mesh.h.

                                : m_verbose(false), m_nummode(0)
     {
     }

Member Function Documentation

◆ GetNumBndryElements()

unsigned int Nektar::NekMeshUtils::Mesh::GetNumBndryElements ( )

Returns the total number of elements in the mesh with dimension < expDim.

Return the number of boundary elements (i.e. one below the expansion dimension).

Definition at line 61 of file Mesh.cpp.

 {
     unsigned int i, nElmt = 0;
 
     for (i = 0; i < m_expDim; ++i)
         nElmt += m_element[i].size();
 
     return nElmt;
 }

◆ GetNumElements()

unsigned int Nektar::NekMeshUtils::Mesh::GetNumElements ( )

Returns the total number of elements in the mesh with dimension expDim.

Return the number of elements of the expansion dimension.

Definition at line 52 of file Mesh.cpp.

 {
     return m_element[m_expDim].size();
 }

◆ GetNumEntities()

unsigned int Nektar::NekMeshUtils::Mesh::GetNumEntities ( )

Returns the total number of entities in the mesh.

Return the total number of entities in the mesh (i.e. all elements, regardless of dimension).

Definition at line 75 of file Mesh.cpp.

 {
     unsigned int nEnt = 0;
 
     for (unsigned int d = 0; d <= m_expDim; ++d)
     {
         nEnt += m_element[d].size();
     }
 
     return nEnt;
 }

◆ MakeOrder()

void Nektar::NekMeshUtils::Mesh::MakeOrder	(	int	order,
		LibUtilities::PointsType	distType
	)

Convert this mesh into a mesh of uniform polynomial order order with a curve point distribution distType.

This routine adds curvature points into a mesh so that the resulting elements are all of a uniform order order and all high-order vertices are consistently ordered. It proceeds in a bottom-up fashion:

First construct all edge, face and elemental geometry mappings.
Then call the local MakeOrder functions on each edge, face and element of dimension Mesh::m_expDim.
Finally, any boundary elements are updated so that they have the same interior degrees of freedom as their corresponding edge or face links.

Definition at line 101 of file Mesh.cpp.

 {
     // Going to make a copy of the curavture information, since this is cheaper
     // than using Nektar's Geometry objects. Currently, the geometry objects
     // which make up a 3D element dont use the volume nodes, they are just
     // stored, so we can get away without copying them.
 
     int id = m_vertexSet.size();
 
     EdgeSet::iterator eit;
     FaceSet::iterator fit;
 
     std::unordered_map<int, EdgeSharedPtr> edgeCopies;
     std::unordered_map<int, FaceSharedPtr> faceCopies;
 
     // Decide on distribution of points to use for each shape type based on the
     // input we've been supplied.
     std::map<LibUtilities::ShapeType, LibUtilities::PointsType> pTypes;
     if (distType == LibUtilities::ePolyEvenlySpaced)
     {
         pTypes[LibUtilities::eSegment]  = LibUtilities::ePolyEvenlySpaced;
         pTypes[LibUtilities::eTriangle] = LibUtilities::eNodalTriEvenlySpaced;
         pTypes[LibUtilities::eQuadrilateral] = LibUtilities::ePolyEvenlySpaced;
         pTypes[LibUtilities::eTetrahedron] =
             LibUtilities::eNodalTetEvenlySpaced;
         pTypes[LibUtilities::ePrism] = LibUtilities::eNodalPrismEvenlySpaced;
         pTypes[LibUtilities::eHexahedron] = LibUtilities::ePolyEvenlySpaced;
     }
     else if (distType == LibUtilities::eGaussLobattoLegendre)
     {
         pTypes[LibUtilities::eSegment]  = LibUtilities::eGaussLobattoLegendre;
         pTypes[LibUtilities::eTriangle] = LibUtilities::eNodalTriElec;
         pTypes[LibUtilities::eQuadrilateral] =
             LibUtilities::eGaussLobattoLegendre;
         pTypes[LibUtilities::ePrism]       = LibUtilities::eNodalPrismElec;
         pTypes[LibUtilities::eTetrahedron] = LibUtilities::eNodalTetElec;
         pTypes[LibUtilities::eHexahedron] = LibUtilities::eGaussLobattoLegendre;
     }
     else
     {
         ASSERTL1(false, "Mesh::MakeOrder does not support this points type.");
     }
 
     // Begin by copying mesh objects for edges and faces so that we don't affect
     // any neighbouring elements in the mesh as we process each element. At the
     // same time we delete the curvature from the original edge and face, which
     // will be re-added with the MakeOrder routine.
 
     // First, we fill in the volume-interior nodes. This preserves the original
     // curvature of the mesh.
     const int nElmt = m_element[m_expDim].size();
     int tmpId       = 0;
     for (int i = 0; i < nElmt; ++i)
     {
         if (m_verbose)
         {
             LibUtilities::PrintProgressbar(i, nElmt, "MakeOrder: Elements: ");
         }
         ElementSharedPtr el                    = m_element[m_expDim][i];
         SpatialDomains::GeometrySharedPtr geom = el->GetGeom(m_spaceDim);
         geom->FillGeom();
         el->MakeOrder(order, geom, pTypes[el->GetConf().m_e], m_spaceDim,
                       tmpId);
     }
 
     // Now make copies of each of the edges.
     for (eit = m_edgeSet.begin(); eit != m_edgeSet.end(); eit++)
     {
         edgeCopies[(*eit)->m_id] = EdgeSharedPtr(new Edge(*(*eit)));
         (*eit)->m_edgeNodes.clear();
     }
 
     // Now copy faces. Make sure that this is a "deep copy", so that the face's
     // edge list corresponds to the copied edges, otherwise we end up in a
     // non-consistent state.
     for (fit = m_faceSet.begin(); fit != m_faceSet.end(); fit++)
     {
         FaceSharedPtr tmpFace = FaceSharedPtr(new Face(*(*fit)));
 
         for (int i = 0; i < tmpFace->m_edgeList.size(); ++i)
         {
             tmpFace->m_edgeList[i] = edgeCopies[tmpFace->m_edgeList[i]->m_id];
         }
 
         faceCopies[(*fit)->m_id] = tmpFace;
         (*fit)->m_faceNodes.clear();
     }
 
     std::unordered_set<int> processedEdges, processedFaces, processedVolumes;
 
     // note if CAD previously existed on the face or edge, the new points need
     // to be projected onto the CAD entity.
 
     // Call MakeOrder with our generated geometries on each edge to fill in edge
     // interior nodes.
     int ct = 0;
     for (eit = m_edgeSet.begin(); eit != m_edgeSet.end(); eit++, ct++)
     {
         if (m_verbose)
         {
             LibUtilities::PrintProgressbar(ct, m_edgeSet.size(),
                                            "MakeOrder: Edges: ");
         }
         int edgeId = (*eit)->m_id;
 
         if (processedEdges.find(edgeId) != processedEdges.end())
         {
             continue;
         }
 
         EdgeSharedPtr cpEdge                   = edgeCopies[edgeId];
         SpatialDomains::GeometrySharedPtr geom = cpEdge->GetGeom(m_spaceDim);
         geom->FillGeom();
 
         (*eit)->MakeOrder(order, geom, pTypes[LibUtilities::eSegment],
                           m_spaceDim, id);
         processedEdges.insert(edgeId);
     }
 
     // Call MakeOrder with our generated geometries on each face to fill in face
     // interior nodes.
     ct = 0;
     for (fit = m_faceSet.begin(); fit != m_faceSet.end(); fit++, ct++)
     {
         if (m_verbose)
         {
             LibUtilities::PrintProgressbar(ct, m_faceSet.size(),
                                            "MakeOrder: Faces: ");
         }
         int faceId = (*fit)->m_id;
 
         if (processedFaces.find(faceId) != processedFaces.end())
         {
             continue;
         }
 
         FaceSharedPtr cpFace                   = faceCopies[faceId];
         SpatialDomains::GeometrySharedPtr geom = cpFace->GetGeom(m_spaceDim);
         geom->FillGeom();
 
         LibUtilities::ShapeType type = (*fit)->m_vertexList.size() == 3
                                            ? LibUtilities::eTriangle
                                            : LibUtilities::eQuadrilateral;
         (*fit)->MakeOrder(order, geom, pTypes[type], m_spaceDim, id);
         processedFaces.insert(faceId);
     }
 
     // Copy curvature into boundary conditions
     for (int i = 0; i < m_element[1].size(); ++i)
     {
         ElementSharedPtr el = m_element[1][i];
         EdgeSharedPtr edge  = el->GetEdgeLink();
 
         if (!edge)
         {
             continue;
         }
 
         // Copy face curvature
         el->MakeOrder(order, SpatialDomains::GeometrySharedPtr(),
                       pTypes[el->GetConf().m_e], m_spaceDim, id, true);
         el->SetVolumeNodes(edge->m_edgeNodes);
     }
 
     for (int i = 0; i < m_element[2].size(); ++i)
     {
         ElementSharedPtr el = m_element[2][i];
         FaceSharedPtr face  = el->GetFaceLink();
 
         if (!face)
         {
             continue;
         }
 
         // Copy face curvature
         el->MakeOrder(order, SpatialDomains::GeometrySharedPtr(),
                       pTypes[el->GetConf().m_e], m_spaceDim, id, true);
         el->SetVolumeNodes(face->m_faceNodes);
     }
 
     for (int i = 0; i < nElmt; ++i)
     {
         vector<NodeSharedPtr> tmp = m_element[m_expDim][i]->GetVolumeNodes();
         for (int j = 0; j < tmp.size(); ++j)
         {
             tmp[j]->m_id = id++;
         }
     }
 
     if (m_verbose)
     {
         cout << endl;
     }
 }

◆ PrintStats()

void Nektar::NekMeshUtils::Mesh::PrintStats ( std::ostream & out )

Print out basic statistics of this mesh.

Definition at line 299 of file Mesh.cpp.

References Nektar::LibUtilities::ShapeTypeMap, and Nektar::LibUtilities::SIZE_ShapeType.

 {
     out << "Mesh statistics" << std::endl
         << "---------------" << std::endl
         << std::endl;
 
     out << "Mesh dimension       : " << m_spaceDim << std::endl
         << "Element dimension    : " << m_expDim << std::endl
         << "Has CAD attached     : " << (m_cad ? "yes" : "no") << std::endl
         << "Node count           : " << m_vertexSet.size() << std::endl;
 
     if (m_edgeSet.size() > 0)
     {
         out << "Edge count           : " << m_edgeSet.size() << std::endl;
     }
 
     if (m_faceSet.size() > 0)
     {
         out << "Face count           : " << m_faceSet.size() << std::endl;
     }
 
     out << "Elements             : " << m_element[m_expDim].size() << std::endl
         << "Bnd elements         : " << m_element[m_expDim - 1].size()
         << std::endl;
 
     // Print out number of composites
 
     out << "Number of composites : " << m_composite.size() << std::endl;
 
     // Calculate domain extent
     auto extent = m_element[m_expDim][0]->GetBoundingBox();
     for (int i = 1; i < m_element[m_expDim].size(); ++i)
     {
         auto el           = m_element[m_expDim][i]->GetBoundingBox();
         extent.first.m_x  = std::min(extent.first.m_x, el.first.m_x);
         extent.first.m_y  = std::min(extent.first.m_y, el.first.m_y);
         extent.first.m_z  = std::min(extent.first.m_z, el.first.m_z);
         extent.second.m_x = std::max(extent.second.m_x, el.second.m_x);
         extent.second.m_y = std::max(extent.second.m_y, el.second.m_y);
         extent.second.m_z = std::max(extent.second.m_z, el.second.m_z);
     }
 
     out << "Lower mesh extent    : " << extent.first.m_x << " "
         << extent.first.m_y << " " << extent.first.m_z << std::endl
         << "Upper mesh extent    : " << extent.second.m_x << " "
         << extent.second.m_y << " " << extent.second.m_z << std::endl;
 
     std::map<LibUtilities::ShapeType, std::pair<int, int>> elmtCounts;
 
     for (int i = 1; i < LibUtilities::SIZE_ShapeType; ++i)
     {
         elmtCounts[(LibUtilities::ShapeType)i] = std::make_pair(0, 0);
     }
 
     for (int dim = 0; dim <= 3; ++dim)
     {
         for (auto &elmt : m_element[dim])
         {
             auto &counts = elmtCounts[elmt->GetShapeType()];
 
             if (elmt->IsDeformed())
             {
                 counts.second++;
             }
             else
             {
                 counts.first++;
             }
         }
     }
 
     out << std::endl << "Element counts (regular/deformed/total):" << std::endl;
     for (int i = 1; i < LibUtilities::SIZE_ShapeType; ++i)
     {
         auto shapeType = (LibUtilities::ShapeType)i;
         auto counts    = elmtCounts[shapeType];
 
         if (counts.first + counts.second == 0)
         {
             continue;
         }
 
         out << "  " << std::setw(14)
             << LibUtilities::ShapeTypeMap[(LibUtilities::ShapeType)i] << ": "
             << setw(12) << counts.first << "  " << setw(12) << counts.second
             << "  " << setw(12) << counts.first + counts.second << std::endl;
     }
 }

Member Data Documentation

◆ m_cad

CADSystemSharedPtr Nektar::NekMeshUtils::Mesh::m_cad

CAD system pointer, if there is no cad its empty.

Definition at line 132 of file Mesh.h.

◆ m_comm

LibUtilities::CommSharedPtr Nektar::NekMeshUtils::Mesh::m_comm

MPI communicator in case we end up using MPI multiple times from Nektar++ SessionReader object.

Definition at line 139 of file Mesh.h.

◆ m_composite

CompositeMap Nektar::NekMeshUtils::Mesh::m_composite

Map for composites.

Definition at line 119 of file Mesh.h.

◆ m_condition

ConditionMap Nektar::NekMeshUtils::Mesh::m_condition

Boundary conditions maps tag to condition.

Definition at line 121 of file Mesh.h.

◆ m_edgeSet

EdgeSet Nektar::NekMeshUtils::Mesh::m_edgeSet

Set of element edges.

Definition at line 113 of file Mesh.h.

◆ m_element

ElementMap Nektar::NekMeshUtils::Mesh::m_element

Map for elements.

Definition at line 117 of file Mesh.h.

◆ m_expDim

unsigned int Nektar::NekMeshUtils::Mesh::m_expDim

Dimension of the expansion.

Definition at line 101 of file Mesh.h.

◆ m_faceLabels

std::map<int, std::string> Nektar::NekMeshUtils::Mesh::m_faceLabels

List of face labels for composite annotation.

Definition at line 130 of file Mesh.h.

◆ m_faceSet

FaceSet Nektar::NekMeshUtils::Mesh::m_faceSet

Set of element faces.

Definition at line 115 of file Mesh.h.

◆ m_fields

std::vector<std::string> Nektar::NekMeshUtils::Mesh::m_fields

List of fields names.

Definition at line 123 of file Mesh.h.

◆ m_metadata

LibUtilities::FieldMetaDataMap Nektar::NekMeshUtils::Mesh::m_metadata

Metadata map for storing any mesh generation parameters.

Definition at line 136 of file Mesh.h.

◆ m_node

std::vector<NodeSharedPtr> Nektar::NekMeshUtils::Mesh::m_node

List of mesh nodes.

Definition at line 107 of file Mesh.h.

◆ m_nummode

unsigned int Nektar::NekMeshUtils::Mesh::m_nummode

a order tag to aid output, a bit of a hack

Definition at line 105 of file Mesh.h.

◆ m_numNodes

int Nektar::NekMeshUtils::Mesh::m_numNodes

used for meshing purposes to keep trac of ids

Definition at line 111 of file Mesh.h.

◆ m_octree

OctreeSharedPtr Nektar::NekMeshUtils::Mesh::m_octree

Octree system pointer, if there is no octree its empty.

Definition at line 134 of file Mesh.h.

◆ m_spaceDim

unsigned int Nektar::NekMeshUtils::Mesh::m_spaceDim

Dimension of the space in which the mesh is defined.

Definition at line 103 of file Mesh.h.

◆ m_spherigonSurfs

std::set<std::pair<int, int> > Nektar::NekMeshUtils::Mesh::m_spherigonSurfs

Set of all pairs of element ID and edge/face number on which to apply spherigon surface smoothing.

Definition at line 128 of file Mesh.h.

◆ m_verbose

bool Nektar::NekMeshUtils::Mesh::m_verbose

Verbose flag.

Definition at line 99 of file Mesh.h.

◆ m_vertexNormals

std::unordered_map<int, Node> Nektar::NekMeshUtils::Mesh::m_vertexNormals

Map of vertex normals.

Definition at line 125 of file Mesh.h.

◆ m_vertexSet

NodeSet Nektar::NekMeshUtils::Mesh::m_vertexSet

Set of element vertices.

Definition at line 109 of file Mesh.h.

Public Member Functions

Public Attributes