Nektar::NekMeshUtils::Mesh Class Reference

#include <Mesh.h>

Collaboration diagram for Nektar::NekMeshUtils::Mesh:

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

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...
boost::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...

Detailed Description

Definition at line 88 of file Mesh.h.

Constructor & Destructor Documentation

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

inline

Definition at line 91 of file Mesh.h.

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

Member Function Documentation

unsigned int 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 59 of file Mesh.cpp.

{
    unsigned int i, nElmt = 0;

    for (i = 0; i < m_expDim; ++i)
        nElmt += m_element[i].size();

    return nElmt;
}

unsigned int 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 50 of file Mesh.cpp.

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

unsigned int 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 73 of file Mesh.cpp.

{
    unsigned int nEnt = 0;

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

    return nEnt;
}

void 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 99 of file Mesh.cpp.

References ASSERTL1, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::eNodalPrismElec, Nektar::LibUtilities::eNodalPrismEvenlySpaced, Nektar::LibUtilities::eNodalTetElec, Nektar::LibUtilities::eNodalTetEvenlySpaced, Nektar::LibUtilities::eNodalTriElec, Nektar::LibUtilities::eNodalTriEvenlySpaced, Nektar::LibUtilities::ePolyEvenlySpaced, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eSegment, Nektar::LibUtilities::eTetrahedron, Nektar::LibUtilities::eTriangle, Nektar::iterator, and Nektar::LibUtilities::PrintProgressbar().

{
    // 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;

    boost::unordered_map<int, EdgeSharedPtr> edgeCopies;
    boost::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();
    }

    boost::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;
    }
}

Member Data Documentation

CADSystemSharedPtr Nektar::NekMeshUtils::Mesh::m_cad

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

Definition at line 129 of file Mesh.h.

CompositeMap Nektar::NekMeshUtils::Mesh::m_composite

Map for composites.

Definition at line 116 of file Mesh.h.

ConditionMap Nektar::NekMeshUtils::Mesh::m_condition

Boundary conditions maps tag to condition.

Definition at line 118 of file Mesh.h.

EdgeSet Nektar::NekMeshUtils::Mesh::m_edgeSet

Set of element edges.

Definition at line 110 of file Mesh.h.

ElementMap Nektar::NekMeshUtils::Mesh::m_element

Map for elements.

Definition at line 114 of file Mesh.h.

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

Dimension of the expansion.

Definition at line 98 of file Mesh.h.

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

List of face labels for composite annotation.

Definition at line 127 of file Mesh.h.

FaceSet Nektar::NekMeshUtils::Mesh::m_faceSet

Set of element faces.

Definition at line 112 of file Mesh.h.

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

List of fields names.

Definition at line 120 of file Mesh.h.

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

List of mesh nodes.

Definition at line 104 of file Mesh.h.

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

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

Definition at line 102 of file Mesh.h.

int Nektar::NekMeshUtils::Mesh::m_numNodes

used for meshing purposes to keep trac of ids

Definition at line 108 of file Mesh.h.

OctreeSharedPtr Nektar::NekMeshUtils::Mesh::m_octree

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

Definition at line 131 of file Mesh.h.

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

Dimension of the space in which the mesh is defined.

Definition at line 100 of file Mesh.h.

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 125 of file Mesh.h.

bool Nektar::NekMeshUtils::Mesh::m_verbose

Verbose flag.

Definition at line 96 of file Mesh.h.

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

Map of vertex normals.

Definition at line 122 of file Mesh.h.

NodeSet Nektar::NekMeshUtils::Mesh::m_vertexSet

Set of element vertices.

Definition at line 106 of file Mesh.h.