Nektar::NekMeshUtils::Face Class Reference

Represents a face comprised of three or more edges. More...

#include <Face.h>

Collaboration diagram for Nektar::NekMeshUtils::Face:

Public Member Functions
NEKMESHUTILS_EXPORT	Face (std::vector< NodeSharedPtr > pVertexList, std::vector< NodeSharedPtr > pFaceNodes, std::vector< EdgeSharedPtr > pEdgeList, LibUtilities::PointsType pCurveType)
	Create a new face. More...
NEKMESHUTILS_EXPORT	Face (const Face &pSrc)
	Copy an existing face. More...
NEKMESHUTILS_EXPORT	~Face ()
NEKMESHUTILS_EXPORT bool	operator== (Face &pSrc)
	Equality is defined by matching all vertices. More...
NEKMESHUTILS_EXPORT unsigned int	GetNodeCount () const
	Returns the total number of nodes (vertices, edge nodes and face nodes). More...
NEKMESHUTILS_EXPORT void	GetCurvedNodes (std::vector< NodeSharedPtr > &nodeList)
	Assemble a list of nodes on curved face. More...
NEKMESHUTILS_EXPORT std::string	GetXmlCurveString ()
	Generates a string listing the coordinates of all nodes associated with this face. More...
void	MakeOrder (int order, SpatialDomains::GeometrySharedPtr geom, LibUtilities::PointsType pType, int coordDim, int &id)
	Make this face an order order face. More...
NEKMESHUTILS_EXPORT SpatialDomains::Geometry2DSharedPtr	GetGeom (int coordDim)
	Generate either SpatialDomains::TriGeom or SpatialDomains::QuadGeom for this element. More...

Public Attributes
unsigned int	m_id
	ID of the face. More...
std::vector< NodeSharedPtr >	m_vertexList
	List of vertex nodes. More...
std::vector< EdgeSharedPtr >	m_edgeList
	List of corresponding edges. More...
std::vector< NodeSharedPtr >	m_faceNodes
	List of face-interior nodes defining the shape of the face. More...
LibUtilities::PointsType	m_curveType
	Distribution of points in this face. More...
std::vector< std::pair < ElementSharedPtr, int > >	m_elLink
	Element(s) which are linked to this face. More...
SpatialDomains::Geometry2DSharedPtr	m_geom
	Nektar++ representation of geometry. More...
CADObjectSharedPtr	m_parentCAD

Detailed Description

Represents a face comprised of three or more edges.

A face is defined by a list of vertices, a list of edges joining these vertices, and a list of control nodes within the interior of the face, defining the shape of the face.

Definition at line 61 of file Face.h.

Constructor & Destructor Documentation

NEKMESHUTILS_EXPORT Nektar::NekMeshUtils::Face::Face ( std::vector< NodeSharedPtr >  pVertexList, std::vector< NodeSharedPtr >  pFaceNodes, std::vector< EdgeSharedPtr >  pEdgeList, LibUtilities::PointsType  pCurveType  )

inline

Create a new face.

Definition at line 65 of file Face.h.

                : m_vertexList(pVertexList), m_edgeList(pEdgeList),
                  m_faceNodes(pFaceNodes), m_curveType(pCurveType), m_geom(){}

NEKMESHUTILS_EXPORT Nektar::NekMeshUtils::Face::Face ( const Face &  pSrc )

inline

Copy an existing face.

Definition at line 73 of file Face.h.

            : m_vertexList(pSrc.m_vertexList), m_edgeList(pSrc.m_edgeList),
              m_faceNodes(pSrc.m_faceNodes), m_curveType(pSrc.m_curveType),
              m_geom(pSrc.m_geom){}

NEKMESHUTILS_EXPORT Nektar::NekMeshUtils::Face::~Face ( )

inline

Definition at line 78 of file Face.h.

    {
    }

Member Function Documentation

void Nektar::NekMeshUtils::Face::GetCurvedNodes

(

std::vector< NodeSharedPtr > &

nodeList

)

Assemble a list of nodes on curved face.

Definition at line 47 of file Face.cpp.

References ASSERTL0, Nektar::LibUtilities::eNodalTriElec, Nektar::LibUtilities::eNodalTriEvenlySpaced, Nektar::LibUtilities::eNodalTriFekete, GetNodeCount(), m_curveType, m_edgeList, m_faceNodes, and m_vertexList.

Referenced by GetXmlCurveString().

{
    // Treat 2D point distributions differently to 3D.
    if (m_curveType == LibUtilities::eNodalTriFekete ||
        m_curveType == LibUtilities::eNodalTriEvenlySpaced ||
        m_curveType == LibUtilities::eNodalTriElec)
    {
        int n = m_edgeList[0]->GetNodeCount();
        int n2 = m_edgeList[1]->GetNodeCount();
        int n3 = m_edgeList[2]->GetNodeCount();

        bool same = (n == n2 ? (n2 == n3) : false);
        ASSERTL0(same, "Edges are not consistent");

        nodeList.insert(
            nodeList.end(), m_vertexList.begin(), m_vertexList.end());
        for (int k = 0; k < m_edgeList.size(); ++k)
        {
            nodeList.insert(nodeList.end(),
                            m_edgeList[k]->m_edgeNodes.begin(),
                            m_edgeList[k]->m_edgeNodes.end());
            if (m_edgeList[k]->m_n1 != m_vertexList[k])
            {
                // If edge orientation is reversed relative to node
                // ordering, we need to reverse order of nodes.
                std::reverse(nodeList.begin() + 3 + k * (n - 2),
                             nodeList.begin() + 3 + (k + 1) * (n - 2));
            }
        }
        nodeList.insert(
            nodeList.end(), m_faceNodes.begin(), m_faceNodes.end());
    }
    else
    {
        // Write out in 2D tensor product order.
        ASSERTL0(m_vertexList.size() == 4,
                 "Face nodes of tensor product only supported "
                 "for quadrilaterals.");

        int n = (int)sqrt((NekDouble)GetNodeCount());
        nodeList.resize(n * n);

        ASSERTL0(n * n == GetNodeCount(), "Wrong number of modes?");

        // Write vertices
        nodeList[0]         = m_vertexList[0];
        nodeList[n - 1]     = m_vertexList[1];
        nodeList[n * n - 1] = m_vertexList[2];
        nodeList[n * (n - 1)] = m_vertexList[3];

        // Write edge-interior
        int skips[4][2] = {
            {0, 1}, {n - 1, n}, {n * n - 1, -1}, {n * (n - 1), -n}};
        for (int i = 0; i < 4; ++i)
        {
            bool reverseEdge = m_edgeList[i]->m_n1 == m_vertexList[i];

            if (!reverseEdge)
            {
                for (int j = 1; j < n - 1; ++j)
                {
                    nodeList[skips[i][0] + j * skips[i][1]] =
                        m_edgeList[i]->m_edgeNodes[n - 2 - j];
                }
            }
            else
            {
                for (int j = 1; j < n - 1; ++j)
                {
                    nodeList[skips[i][0] + j * skips[i][1]] =
                        m_edgeList[i]->m_edgeNodes[j - 1];
                }
            }
        }

        // Write interior
        for (int i = 1; i < n - 1; ++i)
        {
            for (int j = 1; j < n - 1; ++j)
            {
                nodeList[i * n + j] =
                    m_faceNodes[(i - 1) * (n - 2) + (j - 1)];
            }
        }
    }
}

SpatialDomains::Geometry2DSharedPtr Nektar::NekMeshUtils::Face::GetGeom

(

int

coordDim

)

Generate either SpatialDomains::TriGeom or SpatialDomains::QuadGeom for this element.

Definition at line 282 of file Face.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::StdRegions::eBackwards, Nektar::StdRegions::eForwards, GetNodeCount(), m_curveType, m_edgeList, m_faceNodes, m_id, and m_vertexList.

{
    int nEdge = m_edgeList.size();

    SpatialDomains::SegGeomSharedPtr edges[4];
    SpatialDomains::Geometry2DSharedPtr ret;
    StdRegions::Orientation edgeo[4];

    for (int i = 0; i < nEdge; ++i)
    {
        edges[i] = m_edgeList[i]->GetGeom(coordDim);
    }

    for (int i = 0; i < nEdge; ++i)
    {
        edgeo[i] = m_edgeList[i]->m_n1 == m_vertexList[i]
                       ? StdRegions::eForwards
                       : StdRegions::eBackwards;
    }

    if (m_faceNodes.size() > 0)
    {
        if (nEdge == 3)
        {
            SpatialDomains::CurveSharedPtr c =
                MemoryManager<SpatialDomains::Curve>::AllocateSharedPtr(
                    m_id, m_curveType);

            for (int j = 0; j < m_vertexList.size(); j++)
            {
                c->m_points.push_back(m_vertexList[j]->GetGeom(coordDim));
            }
            for (int j = 0; j < nEdge; j++)
            {
                std::vector<NodeSharedPtr> ed = m_edgeList[j]->m_edgeNodes;
                if (edgeo[j] == StdRegions::eBackwards)
                {
                    for (int k = ed.size() - 1; k >= 0; k--)
                    {
                        c->m_points.push_back(ed[k]->GetGeom(coordDim));
                    }
                }
                else
                {
                    for (int k = 0; k < ed.size(); k++)
                    {
                        c->m_points.push_back(ed[k]->GetGeom(coordDim));
                    }
                }
            }
            for (int j = 0; j < m_faceNodes.size(); j++)
            {
                c->m_points.push_back(m_faceNodes[j]->GetGeom(coordDim));
            }

            ret = MemoryManager<SpatialDomains::TriGeom>::AllocateSharedPtr(
                m_id, edges, edgeo, c);
        }
        else
        {
            SpatialDomains::CurveSharedPtr c =
                MemoryManager<SpatialDomains::Curve>::AllocateSharedPtr(
                    m_id, m_curveType);

            ASSERTL0(m_vertexList.size() == 4,
                     "Face nodes of tensor product only supported "
                     "for quadrilaterals.");

            int n = (int)sqrt((NekDouble)GetNodeCount());
            std::vector<NodeSharedPtr> tmp(n * n);

            ASSERTL0(n * n == GetNodeCount(), "Wrong number of modes?");

            // Write vertices
            tmp[0]         = m_vertexList[0];
            tmp[n - 1]     = m_vertexList[1];
            tmp[n * n - 1] = m_vertexList[2];
            tmp[n * (n - 1)] = m_vertexList[3];

            // Write edge-interior
            int skips[4][2] = {
                {0, 1}, {n - 1, n}, {n * n - 1, -1}, {n * (n - 1), -n}};
            for (int i = 0; i < 4; ++i)
            {
                bool reverseEdge = edgeo[i] == StdRegions::eBackwards;

                if (reverseEdge)
                {
                    for (int j = 1; j < n - 1; ++j)
                    {
                        tmp[skips[i][0] + j * skips[i][1]] =
                            m_edgeList[i]->m_edgeNodes[n - 2 - j];
                    }
                }
                else
                {
                    for (int j = 1; j < n - 1; ++j)
                    {
                        tmp[skips[i][0] + j * skips[i][1]] =
                            m_edgeList[i]->m_edgeNodes[j - 1];
                    }
                }
            }

            // Write interior
            for (int i = 1; i < n - 1; ++i)
            {
                for (int j = 1; j < n - 1; ++j)
                {
                    tmp[i * n + j] =
                        m_faceNodes[(i - 1) * (n - 2) + (j - 1)];
                }
            }

            for (int k = 0; k < tmp.size(); ++k)
            {
                c->m_points.push_back(tmp[k]->GetGeom(coordDim));
            }

            ret =
                MemoryManager<SpatialDomains::QuadGeom>::AllocateSharedPtr(
                    m_id, edges, edgeo, c);
        }
    }
    else
    {
        if (nEdge == 3)
        {
            ret = MemoryManager<SpatialDomains::TriGeom>::AllocateSharedPtr(
                m_id, edges, edgeo);
        }
        else
        {
            ret =
                MemoryManager<SpatialDomains::QuadGeom>::AllocateSharedPtr(
                    m_id, edges, edgeo);
        }
    }

    return ret;
}

NEKMESHUTILS_EXPORT unsigned int Nektar::NekMeshUtils::Face::GetNodeCount ( ) const

inline

Returns the total number of nodes (vertices, edge nodes and face nodes).

Definition at line 100 of file Face.h.

References m_edgeList, m_faceNodes, and m_vertexList.

Referenced by GetCurvedNodes(), and GetGeom().

    {
        unsigned int n = m_faceNodes.size();
        for (int i = 0; i < m_edgeList.size(); ++i)
        {
            n += m_edgeList[i]->GetNodeCount();
        }
        n -= m_vertexList.size();
        return n;
    }

std::string Nektar::NekMeshUtils::Face::GetXmlCurveString

(

)

Generates a string listing the coordinates of all nodes associated with this face.

Definition at line 136 of file Face.cpp.

References GetCurvedNodes().

{
    std::stringstream s;
    std::string str;
    std::vector<NodeSharedPtr> nodeList;

    // assemble listof nodes
    GetCurvedNodes(nodeList);

    // put them into a string
    for (int k = 0; k < nodeList.size(); ++k)
    {
        s << std::scientific << std::setprecision(8) << "    "
          << nodeList[k]->m_x << "  " << nodeList[k]->m_y << "  "
          << nodeList[k]->m_z << "    ";
    }

    return s.str();
}

void Nektar::NekMeshUtils::Face::MakeOrder	(	int	order,
		SpatialDomains::GeometrySharedPtr	geom,
		LibUtilities::PointsType	pType,
		int	coordDim,
		int &	id
	)

Make this face an order order face.

See also

Element::MakeOrder.

Definition at line 156 of file Face.cpp.

References ASSERTL0, ASSERTL1, Nektar::LibUtilities::PointsKey::GetPointsDim(), m_curveType, m_faceNodes, m_parentCAD, m_vertexList, class_topology::Node, and Nektar::LibUtilities::PointsManager().

{
    if (m_vertexList.size() == 3)
    {
        // Triangles of order < 3 have no interior volume points.
        if (order < 3)
        {
            m_faceNodes.clear();
            return;
        }

        int nPoints = order + 1;
        StdRegions::StdExpansionSharedPtr xmap = geom->GetXmap();

        Array<OneD, NekDouble> px, py;
        LibUtilities::PointsKey pKey(nPoints, pType);
        ASSERTL1(pKey.GetPointsDim() == 2, "Points distribution must be 2D");
        LibUtilities::PointsManager()[pKey]->GetPoints(px, py);

        Array<OneD, Array<OneD, NekDouble> > phys(coordDim);

        for (int i = 0; i < coordDim; ++i)
        {
            phys[i] = Array<OneD, NekDouble>(xmap->GetTotPoints());
            xmap->BwdTrans(geom->GetCoeffs(i), phys[i]);
        }

        const int nTriPts = nPoints * (nPoints + 1) / 2;
        const int nTriIntPts = (nPoints - 3) * (nPoints - 2) / 2;
        m_faceNodes.resize(nTriIntPts);

        for (int i = 3 + 3*(nPoints-2), cnt = 0; i < nTriPts; ++i, ++cnt)
        {
            Array<OneD, NekDouble> xp(2);
            xp[0] = px[i];
            xp[1] = py[i];

            Array<OneD, NekDouble> x(3, 0.0);
            for (int j = 0; j < coordDim; ++j)
            {
                x[j] = xmap->PhysEvaluate(xp, phys[j]);
            }

            m_faceNodes[cnt] = boost::shared_ptr<Node>(
                new Node(id++, x[0], x[1], x[2]));
        }
        m_curveType = pType;
    }
    else if (m_vertexList.size() == 4)
    {
        // Quads of order < 2 have no interior volume points.
        if (order < 2)
        {
            m_faceNodes.clear();
            return;
        }

        int nPoints = order + 1;
        StdRegions::StdExpansionSharedPtr xmap = geom->GetXmap();

        Array<OneD, NekDouble> px;
        LibUtilities::PointsKey pKey(nPoints, pType);
        ASSERTL1(pKey.GetPointsDim() == 1, "Points distribution must be 1D");
        LibUtilities::PointsManager()[pKey]->GetPoints(px);

        Array<OneD, Array<OneD, NekDouble> > phys(coordDim);

        for (int i = 0; i < coordDim; ++i)
        {
            phys[i] = Array<OneD, NekDouble>(xmap->GetTotPoints());
            xmap->BwdTrans(geom->GetCoeffs(i), phys[i]);
        }

        int nQuadIntPts = (nPoints - 2) * (nPoints - 2);
        m_faceNodes.resize(nQuadIntPts);

        for (int i = 1, cnt = 0; i < nPoints-1; ++i)
        {
            for (int j = 1; j < nPoints-1; ++j, ++cnt)
            {
                Array<OneD, NekDouble> xp(2);
                xp[0] = px[j];
                xp[1] = px[i];

                Array<OneD, NekDouble> x(3, 0.0);
                for (int k = 0; k < coordDim; ++k)
                {
                    x[k] = xmap->PhysEvaluate(xp, phys[k]);
                }

                m_faceNodes[cnt] = boost::shared_ptr<Node>(
                    new Node(id++, x[0], x[1], x[2]));
            }
        }

        m_curveType = pType;
    }
    else
    {
        ASSERTL0(false, "Unknown number of vertices");
    }

    if(m_parentCAD)
    {
        CADSurfSharedPtr s = boost::dynamic_pointer_cast<CADSurf>(m_parentCAD);
        for(int i = 0; i < m_faceNodes.size(); i++)
        {
            Array<OneD, NekDouble> loc(3);
            loc[0] = m_faceNodes[i]->m_x;
            loc[1] = m_faceNodes[i]->m_y;
            loc[2] = m_faceNodes[i]->m_z;
            Array<OneD, NekDouble> uv(2);
            s->ProjectTo(loc,uv);
            loc = s->P(uv);
            m_faceNodes[i]->m_x = loc[0];
            m_faceNodes[i]->m_y = loc[1];
            m_faceNodes[i]->m_z = loc[2];
            m_faceNodes[i]->SetCADSurf(s->GetId(),s,uv);
        }
    }
}

NEKMESHUTILS_EXPORT bool Nektar::NekMeshUtils::Face::operator== ( Face &  pSrc )

inline

Equality is defined by matching all vertices.

Definition at line 83 of file Face.h.

References Nektar::StdRegions::find(), Nektar::iterator, and m_vertexList.

    {
        std::vector<NodeSharedPtr>::iterator it1, it2;
        for (it1 = m_vertexList.begin(); it1 != m_vertexList.end(); ++it1)
        {
            if (find(pSrc.m_vertexList.begin(),
                     pSrc.m_vertexList.end(),
                     *it1) == pSrc.m_vertexList.end())
            {
                return false;
            }
        }
        return true;
    }

Member Data Documentation

LibUtilities::PointsType Nektar::NekMeshUtils::Face::m_curveType

Distribution of points in this face.

Definition at line 139 of file Face.h.

Referenced by GetCurvedNodes(), GetGeom(), and MakeOrder().

std::vector<EdgeSharedPtr> Nektar::NekMeshUtils::Face::m_edgeList

List of corresponding edges.

Definition at line 135 of file Face.h.

Referenced by GetCurvedNodes(), GetGeom(), and GetNodeCount().

std::vector<std::pair<ElementSharedPtr, int> > Nektar::NekMeshUtils::Face::m_elLink

Element(s) which are linked to this face.

Definition at line 141 of file Face.h.

std::vector<NodeSharedPtr> Nektar::NekMeshUtils::Face::m_faceNodes

List of face-interior nodes defining the shape of the face.

Definition at line 137 of file Face.h.

Referenced by GetCurvedNodes(), GetGeom(), GetNodeCount(), and MakeOrder().

SpatialDomains::Geometry2DSharedPtr Nektar::NekMeshUtils::Face::m_geom

Nektar++ representation of geometry.

Definition at line 143 of file Face.h.

unsigned int Nektar::NekMeshUtils::Face::m_id

ID of the face.

Definition at line 131 of file Face.h.

Referenced by GetGeom().

CADObjectSharedPtr Nektar::NekMeshUtils::Face::m_parentCAD

Definition at line 145 of file Face.h.

Referenced by MakeOrder().

std::vector<NodeSharedPtr> Nektar::NekMeshUtils::Face::m_vertexList

List of vertex nodes.

Definition at line 133 of file Face.h.

Referenced by GetCurvedNodes(), GetGeom(), GetNodeCount(), MakeOrder(), and operator==().