A 2-dimensional four-sided element. More...

#include <Quadrilateral.h>

Inheritance diagram for Nektar::NekMeshUtils::Quadrilateral:

Collaboration diagram for Nektar::NekMeshUtils::Quadrilateral:

Public Member Functions
NEKMESHUTILS_EXPORT	Quadrilateral (ElmtConfig pConf, std::vector< NodeSharedPtr > pNodeList, std::vector< int > pTagList)
	Create a quadrilateral element. More...

NEKMESHUTILS_EXPORT	Quadrilateral (const Quadrilateral &pSrc)

virtual NEKMESHUTILS_EXPORT	~Quadrilateral ()

virtual NEKMESHUTILS_EXPORT SpatialDomains::GeometrySharedPtr	GetGeom (int coordDim)
	Generate a Nektar++ geometry object for this element. More...

virtual NEKMESHUTILS_EXPORT void	Complete (int order)
	Complete this object. More...

Public Member Functions inherited from Nektar::NekMeshUtils::Element
NEKMESHUTILS_EXPORT	Element (ElmtConfig pConf, unsigned int pNumNodes, unsigned int pGotNodes)

NEKMESHUTILS_EXPORT unsigned int	GetId () const
	Returns the ID of the element (or associated edge or face for boundary elements). More...

NEKMESHUTILS_EXPORT unsigned int	GetDim () const
	Returns the expansion dimension of the element. More...

NEKMESHUTILS_EXPORT ElmtConfig	GetConf () const
	Returns the configuration of the element. More...

NEKMESHUTILS_EXPORT std::string	GetTag () const
	Returns the tag which defines the element shape. More...

NEKMESHUTILS_EXPORT NodeSharedPtr	GetVertex (unsigned int i) const
	Access a vertex node. More...

NEKMESHUTILS_EXPORT EdgeSharedPtr	GetEdge (unsigned int i) const
	Access an edge. More...

NEKMESHUTILS_EXPORT FaceSharedPtr	GetFace (unsigned int i) const
	Access a face. More...

NEKMESHUTILS_EXPORT std::vector< NodeSharedPtr >	GetVertexList () const
	Access the list of vertex nodes. More...

NEKMESHUTILS_EXPORT std::vector< EdgeSharedPtr >	GetEdgeList () const
	Access the list of edges. More...

NEKMESHUTILS_EXPORT std::vector< FaceSharedPtr >	GetFaceList () const
	Access the list of faces. More...

NEKMESHUTILS_EXPORT std::vector< NodeSharedPtr >	GetVolumeNodes () const
	Access the list of volume nodes. More...

NEKMESHUTILS_EXPORT void	SetVolumeNodes (std::vector< NodeSharedPtr > &nodes)

NEKMESHUTILS_EXPORT LibUtilities::PointsType	GetCurveType () const

NEKMESHUTILS_EXPORT void	SetCurveType (LibUtilities::PointsType cT)

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

NEKMESHUTILS_EXPORT std::vector< int >	GetTagList () const
	Access the list of tags associated with this element. More...

NEKMESHUTILS_EXPORT unsigned int	GetVertexCount () const
	Returns the number of vertices. More...

NEKMESHUTILS_EXPORT unsigned int	GetEdgeCount () const
	Returns the number of edges. More...

NEKMESHUTILS_EXPORT unsigned int	GetFaceCount () const
	Returns the number of faces. More...

NEKMESHUTILS_EXPORT void	SetId (unsigned int p)
	Change the ID of the element. More...

NEKMESHUTILS_EXPORT void	SetVertex (unsigned int p, NodeSharedPtr pNew)
	Replace a vertex with another vertex object. More...

NEKMESHUTILS_EXPORT void	SetEdge (unsigned int p, EdgeSharedPtr pNew)
	Replace an edge with another edge object. More...

NEKMESHUTILS_EXPORT void	SetFace (unsigned int p, FaceSharedPtr pNew)
	Replace a face with another face object. More...

NEKMESHUTILS_EXPORT void	SetEdgeLink (EdgeSharedPtr pLink)
	Set a correspondence between this element and an edge (2D boundary element). More...

NEKMESHUTILS_EXPORT EdgeSharedPtr	GetEdgeLink ()
	Get correspondence between this element and an edge. More...

NEKMESHUTILS_EXPORT void	SetFaceLink (FaceSharedPtr pLink)
	Set a correspondence between this element and a face (3D boundary element). More...

NEKMESHUTILS_EXPORT FaceSharedPtr	GetFaceLink ()
	Get correspondence between this element and a face. More...

NEKMESHUTILS_EXPORT void	SetBoundaryLink (int i, int j)
	Set a correspondence between edge or face i and its representative boundary element m->element[expDim-1][j]. More...

NEKMESHUTILS_EXPORT int	GetBoundaryLink (int i)
	Get the location of the boundary face/edge i for this element. More...

NEKMESHUTILS_EXPORT void	SetTagList (const std::vector< int > &tags)
	Set the list of tags associated with this element. More...

virtual NEKMESHUTILS_EXPORT std::string	GetXmlString () const
	Generate a list of vertices (1D), edges (2D), or faces (3D). More...

NEKMESHUTILS_EXPORT void	GetCurvedNodes (std::vector< NodeSharedPtr > &nodeList) const

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

NEKMESHUTILS_EXPORT int	GetMaxOrder ()
	Obtain the order of an element by looking at edges. More...

NEKMESHUTILS_EXPORT void	Print ()

Static Public Member Functions
static ElementSharedPtr	create (ElmtConfig pConf, std::vector< NodeSharedPtr > pNodeList, std::vector< int > pTagList)
	Creates an instance of this class. More...

static NEKMESHUTILS_EXPORT unsigned int	GetNumNodes (ElmtConfig pConf)
	Return the number of nodes defining a quadrilateral. More...

Static Public Attributes
static LibUtilities::ShapeType	m_type
	Element type. More...

Additional Inherited Members
Protected Attributes inherited from Nektar::NekMeshUtils::Element
unsigned int	m_id
	ID of the element. More...

unsigned int	m_dim
	Dimension of the element. More...

ElmtConfig	m_conf
	Contains configuration of the element. More...

std::string	m_tag
	Tag character describing the element. More...

std::vector< int >	m_taglist
	List of integers specifying properties of the element. More...

std::vector< NodeSharedPtr >	m_vertex
	List of element vertex nodes. More...

std::vector< EdgeSharedPtr >	m_edge
	List of element edges. More...

std::vector< FaceSharedPtr >	m_face
	List of element faces. More...

std::vector< NodeSharedPtr >	m_volumeNodes
	List of element volume nodes. More...

LibUtilities::PointsType	m_curveType
	Volume curve type. More...

EdgeSharedPtr	m_edgeLink
	Pointer to the corresponding edge if element is a 2D boundary. More...

FaceSharedPtr	m_faceLink
	Pointer to the corresponding face if element is a 3D boundary. More...

std::map< int, int >	m_boundaryLinks
	Array mapping faces/edges to the location of the appropriate boundary elements in m->element. More...

SpatialDomains::GeometrySharedPtr	m_geom
	Nektar++ geometry object for this element. More...

Detailed Description

A 2-dimensional four-sided element.

Definition at line 49 of file Quadrilateral.h.

Constructor & Destructor Documentation

Nektar::NekMeshUtils::Quadrilateral::Quadrilateral	(	ElmtConfig	pConf,
		std::vector< NodeSharedPtr >	pNodeList,
		std::vector< int >	pTagList
	)

Create a quadrilateral element.

Definition at line 53 of file Quadrilateral.cpp.

Referenced by create().

     : Element(pConf, GetNumNodes(pConf), pNodeList.size())
 {
     m_tag     = "Q";
     m_dim     = 2;
     m_taglist = pTagList;
     int n     = m_conf.m_order - 1;
 
     // Create a map to relate edge nodes to a pair of vertices
     // defining an edge. This is based on the ordering produced by
     // gmsh.
     map<pair<int, int>, int> edgeNodeMap;
     map<pair<int, int>, int>::iterator it;
     edgeNodeMap[pair<int, int>(1, 2)] = 5;
     edgeNodeMap[pair<int, int>(2, 3)] = 5 + n;
     edgeNodeMap[pair<int, int>(3, 4)] = 5 + 2 * n;
     edgeNodeMap[pair<int, int>(4, 1)] = 5 + 3 * n;
 
     // Add vertices. This logic will determine (in 2D) whether the
     // element is clockwise (sum > 0) or counter-clockwise (sum < 0).
     NekDouble sum = 0.0;
     for (int i = 0; i < 4; ++i)
     {
         int o = (i + 1) % 4;
         m_vertex.push_back(pNodeList[i]);
         sum += (pNodeList[o]->m_x - pNodeList[i]->m_x) *
                (pNodeList[o]->m_y + pNodeList[i]->m_y);
     }
 
     // Create edges (with corresponding set of edge points)
     for (it = edgeNodeMap.begin(); it != edgeNodeMap.end(); ++it)
     {
         vector<NodeSharedPtr> edgeNodes;
         if (m_conf.m_order > 1)
         {
             for (int j = it->second; j < it->second + n; ++j)
             {
                 edgeNodes.push_back(pNodeList[j - 1]);
             }
         }
         m_edge.push_back(EdgeSharedPtr(new Edge(pNodeList[it->first.first - 1],
                                                 pNodeList[it->first.second - 1],
                                                 edgeNodes,
                                                 m_conf.m_edgeCurveType)));
     }
 
     if (pConf.m_reorient)
     {
         if (sum > 0.0)
         {
             reverse(m_edge.begin(), m_edge.end());
         }
     }
 
     if (m_conf.m_faceNodes)
     {
         m_volumeNodes.insert(m_volumeNodes.begin(),
                              pNodeList.begin() + 4 * m_conf.m_order,
                              pNodeList.end());
     }
 }

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

virtual NEKMESHUTILS_EXPORT Nektar::NekMeshUtils::Quadrilateral::~Quadrilateral ( )

inlinevirtual

Definition at line 73 of file Quadrilateral.h.

74 {

75 }

Member Function Documentation

void Nektar::NekMeshUtils::Quadrilateral::Complete ( int order )

virtual

Complete this object.

Reimplemented from Nektar::NekMeshUtils::Element.

Definition at line 117 of file Quadrilateral.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eOrtho_A, GetGeom(), Nektar::NekMeshUtils::Element::m_conf, Nektar::NekMeshUtils::Element::m_edge, Nektar::NekMeshUtils::ElmtConfig::m_faceNodes, Nektar::NekMeshUtils::ElmtConfig::m_order, Nektar::NekMeshUtils::ElmtConfig::m_volumeNodes, and Nektar::NekMeshUtils::Element::m_volumeNodes.

 {
     LibUtilities::BasisKey C0(
         LibUtilities::eOrtho_A,
         order + 1,
         LibUtilities::PointsKey(order + 1,
                                 LibUtilities::eGaussLobattoLegendre));
 
     SpatialDomains::QuadGeomSharedPtr geom =
         boost::dynamic_pointer_cast<SpatialDomains::QuadGeom>(this->GetGeom(3));
 
     // Create a quad.
     LocalRegions::QuadExpSharedPtr quad =
         MemoryManager<LocalRegions::QuadExp>::AllocateSharedPtr(C0, C0, geom);
 
     // Get coordinate array for quadrilateral.
     int nqtot = quad->GetTotPoints();
     Array<OneD, NekDouble> alloc(3 * nqtot);
     Array<OneD, NekDouble> x(alloc);
     Array<OneD, NekDouble> y(alloc + 1 * nqtot);
     Array<OneD, NekDouble> z(alloc + 2 * nqtot);
 
     quad->GetCoords(x, y, z);
 
     // Now extract points from the co-ordinate arrays into the edge
     // and face nodes. First, extract edge-interior nodes.
     int edgeMap[4][2] = {{0, 1},
                          {order, order + 1},
                          {nqtot - 1, -1},
                          {order * (order + 1), -order - 1}};
 
     for (int i = 0; i < 4; ++i)
     {
         int pos = edgeMap[i][0] + edgeMap[i][1];
         m_edge[i]->m_edgeNodes.clear();
         for (int j = 1; j < order; ++j, pos += edgeMap[i][1])
         {
             m_edge[i]->m_edgeNodes.push_back(
                 NodeSharedPtr(new Node(0, x[pos], y[pos], z[pos])));
         }
     }
 
     // Extract face-interior nodes.
     m_volumeNodes.clear();
     for (int i = 1; i < order; ++i)
     {
         int pos = i * (order + 1);
         for (int j = 1; j < order; ++j)
         {
             m_volumeNodes.push_back(
                 NodeSharedPtr(new Node(0, x[pos + j], y[pos + j], z[pos + j])));
         }
     }
 
     m_conf.m_order       = order;
     m_conf.m_faceNodes   = true;
     m_conf.m_volumeNodes = true;
 }

static ElementSharedPtr Nektar::NekMeshUtils::Quadrilateral::create	(	ElmtConfig	pConf,
		std::vector< NodeSharedPtr >	pNodeList,
		std::vector< int >	pTagList
	)

inlinestatic

Creates an instance of this class.

Definition at line 53 of file Quadrilateral.h.

References Quadrilateral().

     {
         ElementSharedPtr e = boost::shared_ptr<Element>(
             new Quadrilateral(pConf, pNodeList, pTagList));
         std::vector<EdgeSharedPtr> m_edges = e->GetEdgeList();
         for (int i = 0; i < m_edges.size(); ++i)
         {
             m_edges[i]->m_elLink.push_back(std::pair<ElementSharedPtr, int>(e, i));
         }
         return e;
     }

SpatialDomains::GeometrySharedPtr Nektar::NekMeshUtils::Quadrilateral::GetGeom ( int coordDim )

virtual

Generate a Nektar++ geometry object for this element.

Reimplemented from Nektar::NekMeshUtils::Element.

Definition at line 176 of file Quadrilateral.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::SpatialDomains::SegGeom::GetEdgeOrientation(), Nektar::NekMeshUtils::Element::m_edge, Nektar::NekMeshUtils::Element::m_id, and Nektar::NekMeshUtils::Element::m_vertex.

Referenced by Complete().

 {
     SpatialDomains::SegGeomSharedPtr edges[4];
     SpatialDomains::PointGeomSharedPtr verts[4];
     SpatialDomains::QuadGeomSharedPtr ret;
 
     for (int i = 0; i < 4; ++i)
     {
         edges[i] = m_edge[i]->GetGeom(coordDim);
         verts[i] = m_vertex[i]->GetGeom(coordDim);
     }
 
     StdRegions::Orientation edgeorient[4] = {
         SpatialDomains::SegGeom::GetEdgeOrientation(*edges[0], *edges[1]),
         SpatialDomains::SegGeom::GetEdgeOrientation(*edges[1], *edges[2]),
         SpatialDomains::SegGeom::GetEdgeOrientation(*edges[2], *edges[3]),
         SpatialDomains::SegGeom::GetEdgeOrientation(*edges[3], *edges[0])};
 
     ret = MemoryManager<SpatialDomains::QuadGeom>::AllocateSharedPtr(
         m_id, verts, edges, edgeorient);
 
     return ret;
 }

unsigned int Nektar::NekMeshUtils::Quadrilateral::GetNumNodes ( ElmtConfig pConf )

static

Return the number of nodes defining a quadrilateral.

Definition at line 203 of file Quadrilateral.cpp.

References Nektar::NekMeshUtils::ElmtConfig::m_faceNodes, and Nektar::NekMeshUtils::ElmtConfig::m_order.

Referenced by Nektar::Utilities::InputGmsh::GetNnodes().

 {
     int n = pConf.m_order;
     if (!pConf.m_faceNodes)
         return 4 * n;
     else
         return (n + 1) * (n + 1);
 }

Member Data Documentation

LibUtilities::ShapeType Nektar::NekMeshUtils::Quadrilateral::m_type

static

Initial value:

=
    GetElementFactory().RegisterCreatorFunction(
        LibUtilities::eQuadrilateral, Quadrilateral::create, "Quadrilateral")

Element type.

Definition at line 67 of file Quadrilateral.h.

Public Member Functions

Static Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation