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

#include <Face.h>

Collaboration diagram for Nektar::NekMeshUtils::Face:

Public Member Functions
	Face (std::vector< NodeSharedPtr > pVertexList, std::vector< NodeSharedPtr > pFaceNodes, std::vector< EdgeSharedPtr > pEdgeList, LibUtilities::PointsType pCurveType)
	Create a new face. More...

	Face (const Face &pSrc)
	Copy an existing face. More...

	~Face ()

bool	operator== (Face &pSrc)
	Equality is defined by matching all vertices. More...

unsigned int	GetNodeCount () const
	Returns the total number of nodes (vertices, edge nodes and face nodes). More...

void	GetCurvedNodes (std::vector< NodeSharedPtr > &nodeList) const
	Assemble a list of nodes on curved face. More...

std::string	GetXmlCurveString () const
	Generates a string listing the coordinates of all nodes associated with this face. More...

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

vector< pair< ElementSharedPtr, int > >	m_elLink
	Element(s) which are linked to this face. More...

SpatialDomains::Geometry2DSharedPtr	m_geom
	Nektar++ representation of geometry. More...

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 60 of file Face.h.

Constructor & Destructor Documentation

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 64 of file Face.h.

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

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

inline

Copy an existing face.

Definition at line 74 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)
     {
     }

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

inline

Definition at line 80 of file Face.h.

81 {

82 }

Member Function Documentation

void Nektar::NekMeshUtils::Face::GetCurvedNodes ( std::vector< NodeSharedPtr > & nodeList ) const

inline

Assemble a list of nodes on curved face.

Definition at line 114 of file Face.h.

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

inline

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

Definition at line 220 of file Face.h.

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

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

inline

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

Definition at line 102 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 ( ) const

inline

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

Definition at line 198 of file Face.h.

References GetCurvedNodes().

     {
         std::stringstream s;
         std::string str;
         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();
     }

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

inline

Equality is defined by matching all vertices.

Definition at line 85 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;
     }