Base class for element definitions. More...

#include <MeshElements.h>

Inheritance diagram for Nektar::Utilities::Element:

Collaboration diagram for Nektar::Utilities::Element:

Public Member Functions
	Element (ElmtConfig pConf, unsigned int pNumNodes, unsigned int pGotNodes)
unsigned int	GetId () const
	Returns the ID of the element (or associated edge or face for boundary elements).
unsigned int	GetDim () const
	Returns the expansion dimension of the element.
ElmtConfig	GetConf () const
	Returns the configuration of the element.
std::string	GetTag () const
	Returns the tag which defines the element shape.
NodeSharedPtr	GetVertex (unsigned int i) const
	Access a vertex node.
EdgeSharedPtr	GetEdge (unsigned int i) const
	Access an edge.
FaceSharedPtr	GetFace (unsigned int i) const
	Access a face.
std::vector< NodeSharedPtr >	GetVertexList () const
	Access the list of vertex nodes.
std::vector< EdgeSharedPtr >	GetEdgeList () const
	Access the list of edges.
std::vector< FaceSharedPtr >	GetFaceList () const
	Access the list of faces.
std::vector< NodeSharedPtr >	GetVolumeNodes () const
	Access the list of volume nodes.
void	SetVolumeNodes (std::vector< NodeSharedPtr > &nodes)
LibUtilities::PointsType	GetCurveType () const
void	SetCurveType (LibUtilities::PointsType cT)
unsigned int	GetNodeCount () const
	Returns the total number of nodes (vertices, edge nodes and face nodes and volume nodes).
std::vector< int >	GetTagList () const
	Access the list of tags associated with this element.
unsigned int	GetVertexCount () const
	Returns the number of vertices.
unsigned int	GetEdgeCount () const
	Returns the number of edges.
unsigned int	GetFaceCount () const
	Returns the number of faces.
void	SetId (unsigned int p)
	Change the ID of the element.
void	SetVertex (unsigned int p, NodeSharedPtr pNew)
	Replace a vertex with another vertex object.
void	SetEdge (unsigned int p, EdgeSharedPtr pNew)
	Replace an edge with another edge object.
void	SetFace (unsigned int p, FaceSharedPtr pNew)
	Replace a face with another face object.
void	SetEdgeLink (EdgeSharedPtr pLink)
	Set a correspondence between this element and an edge (2D boundary element).
EdgeSharedPtr	GetEdgeLink ()
	Get correspondence between this element and an edge.
void	SetFaceLink (FaceSharedPtr pLink)
	Set a correspondence between this element and a face (3D boundary element).
FaceSharedPtr	GetFaceLink ()
	Get correspondence between this element and a face.
void	SetBoundaryLink (int i, int j)
	Set a correspondence between edge or face i and its representative boundary element m->element[expDim-1][j].
int	GetBoundaryLink (int i)
	Get the location of the boundary face/edge i for this element.
void	SetTagList (const std::vector< int > &tags)
	Set the list of tags associated with this element.
virtual std::string	GetXmlString () const
	Generate a list of vertices (1D), edges (2D), or faces (3D).
std::vector< NodeSharedPtr >	tensorNodeOrdering (const std::vector< NodeSharedPtr > &nodes, int n) const
	Reorders Gmsh ordered nodes into a row-by-row ordering required for Nektar++ curve tags.
std::string	GetXmlCurveString () const
	Generates a string listing the coordinates of all nodes associated with this element.
virtual SpatialDomains::GeometrySharedPtr	GetGeom (int coordDim)
	Generate a Nektar++ geometry object for this element.
int	GetMaxOrder ()
	Obtain the order of an element by looking at edges.
virtual void	Complete (int order)
	Complete this object.
void	Print ()

Protected Attributes
unsigned int	m_id
	ID of the element.
unsigned int	m_dim
	Dimension of the element.
ElmtConfig	m_conf
	Contains configuration of the element.
std::string	m_tag
	Tag character describing the element.
std::vector< int >	m_taglist
	List of integers specifying properties of the element.
std::vector< NodeSharedPtr >	m_vertex
	List of element vertex nodes.
std::vector< EdgeSharedPtr >	m_edge
	List of element edges.
std::vector< FaceSharedPtr >	m_face
	List of element faces.
std::vector< NodeSharedPtr >	m_volumeNodes
	List of element volume nodes.
LibUtilities::PointsType	m_curveType
	Volume curve type.
EdgeSharedPtr	m_edgeLink
	Pointer to the corresponding edge if element is a 2D boundary.
FaceSharedPtr	m_faceLink
	Pointer to the corresponding face if element is a 3D boundary.
std::map< int, int >	m_boundaryLinks
	Array mapping faces/edges to the location of the appropriate boundary elements in m->element.
SpatialDomains::GeometrySharedPtr	m_geom
	Nektar++ geometry object for this element.

Detailed Description

Base class for element definitions.

An element is defined by a list of vertices, edges and faces (depending on the dimension of the problem). This base class provides the underlying structure.

Definition at line 628 of file MeshElements.h.

Constructor & Destructor Documentation

Element::Element	(	ElmtConfig	pConf,
		unsigned int	pNumNodes,
		unsigned int	pGotNodes
	)

Definition at line 68 of file MeshElements.cpp.

References Nektar::Utilities::ElmtConfig::m_e.

            : m_conf(pConf), 
              m_curveType(LibUtilities::ePolyEvenlySpaced),
              m_geom()
        {
            if (pNumNodes != pGotNodes)
            {
                cerr << "Number of modes mismatch for type " 
                     << pConf.m_e << "! Should be " << pNumNodes 
                     << " but got " << pGotNodes << " nodes." << endl;
                abort();
            }
        }

Member Function Documentation

virtual void Nektar::Utilities::Element::Complete ( int order )

inlinevirtual

Complete this object.

Reimplemented in Nektar::Utilities::Prism, Nektar::Utilities::Tetrahedron, Nektar::Utilities::Quadrilateral, and Nektar::Utilities::Triangle.

Definition at line 1009 of file MeshElements.h.

References ASSERTL0.

            {
                ASSERTL0(false, "This function should be implemented at a shape level.");
            }

int Nektar::Utilities::Element::GetBoundaryLink ( int i )

inline

Get the location of the boundary face/edge i for this element.

Definition at line 762 of file MeshElements.h.

References Nektar::iterator.

                                       {
                std::map<int,int>::iterator it = m_boundaryLinks.find(i);
                if (it == m_boundaryLinks.end())
                {
                    return -1;
                }
                else
                {
                    return it->second;
                }
            }

ElmtConfig Nektar::Utilities::Element::GetConf ( ) const

inline

Returns the configuration of the element.

Definition at line 646 of file MeshElements.h.

                                       {
                return m_conf;
            }

LibUtilities::PointsType Nektar::Utilities::Element::GetCurveType ( ) const

inline

Definition at line 686 of file MeshElements.h.

References Nektar::Utilities::Face::m_curveType.

                                                        {
                return m_curveType;
            }

unsigned int Nektar::Utilities::Element::GetDim ( ) const

inline

Returns the expansion dimension of the element.

Definition at line 642 of file MeshElements.h.

                                        {
                return m_dim;
            }

EdgeSharedPtr Nektar::Utilities::Element::GetEdge ( unsigned int i ) const

inline

Access an edge.

Definition at line 660 of file MeshElements.h.

                                                        {
                return m_edge[i];
            }

unsigned int Nektar::Utilities::Element::GetEdgeCount ( ) const

inline

Returns the number of edges.

Definition at line 721 of file MeshElements.h.

                                              {
                return m_edge.size();
            }

EdgeSharedPtr Nektar::Utilities::Element::GetEdgeLink ( )

inline

Get correspondence between this element and an edge.

Definition at line 744 of file MeshElements.h.

                                        {
                return m_edgeLink;
            }

std::vector<EdgeSharedPtr> Nektar::Utilities::Element::GetEdgeList ( ) const

inline

Access the list of edges.

Definition at line 672 of file MeshElements.h.

Referenced by Nektar::Utilities::Triangle::create(), and Nektar::Utilities::Quadrilateral::create().

                                                         {
                return m_edge;
            }

FaceSharedPtr Nektar::Utilities::Element::GetFace ( unsigned int i ) const

inline

Access a face.

Definition at line 664 of file MeshElements.h.

Referenced by Nektar::Utilities::InputNek::Process().

                                                        {
                return m_face[i];
            }

unsigned int Nektar::Utilities::Element::GetFaceCount ( ) const

inline

Returns the number of faces.

Definition at line 725 of file MeshElements.h.

                                              {
                return m_face.size();
            }

FaceSharedPtr Nektar::Utilities::Element::GetFaceLink ( )

inline

Get correspondence between this element and a face.

Definition at line 753 of file MeshElements.h.

                                        {
                return m_faceLink;
            }

std::vector<FaceSharedPtr> Nektar::Utilities::Element::GetFaceList ( ) const

inline

Access the list of faces.

Definition at line 676 of file MeshElements.h.

Referenced by Nektar::Utilities::Tetrahedron::create(), Nektar::Utilities::Pyramid::create(), Nektar::Utilities::Prism::create(), and Nektar::Utilities::Hexahedron::create().

                                                         {
                return m_face;
            }

virtual SpatialDomains::GeometrySharedPtr Nektar::Utilities::Element::GetGeom ( int coordDim )

inlinevirtual

Generate a Nektar++ geometry object for this element.

Reimplemented in Nektar::Utilities::Hexahedron, Nektar::Utilities::Prism, Nektar::Utilities::Pyramid, Nektar::Utilities::Tetrahedron, Nektar::Utilities::Quadrilateral, Nektar::Utilities::Triangle, and Nektar::Utilities::Line.

Definition at line 1002 of file MeshElements.h.

References ASSERTL0.

            {
                ASSERTL0(false, "This function should be implemented at a shape level.");
                return boost::shared_ptr<SpatialDomains::Geometry>();
            }

unsigned int Nektar::Utilities::Element::GetId ( ) const

inline

Returns the ID of the element (or associated edge or face for boundary elements).

Definition at line 636 of file MeshElements.h.

References Nektar::Utilities::Face::m_id.

                                       {
                if (m_faceLink.get() != 0) return m_faceLink->m_id;
                if (m_edgeLink.get() != 0) return m_edgeLink->m_id;
                return m_id;
            }

int Element::GetMaxOrder ( )

Obtain the order of an element by looking at edges.

Definition at line 308 of file MeshElements.cpp.

References m_edge.

        {
            int i, ret = 1;
            
            for (i = 0; i < m_edge.size(); ++i)
            {
                int edgeOrder = m_edge[i]->GetNodeCount()-1;
                if (edgeOrder > ret)
                {
                    ret = edgeOrder;
                }
            }
            
            return ret;
        }

unsigned int Nektar::Utilities::Element::GetNodeCount ( ) const

inline

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

Definition at line 694 of file MeshElements.h.

            {
                unsigned int n = m_volumeNodes.size();
                if (m_dim == 2)
                {
                    for (int i = 0; i < m_edge.size(); ++i)
                    {
                        n += m_edge[i]->GetNodeCount();
                    }
                    n -= m_vertex.size();
                }
                else
                {
                    cerr << "Not supported." << endl;
                    exit(1);
                }
                return n;
            }

std::string Nektar::Utilities::Element::GetTag ( ) const

inline

Returns the tag which defines the element shape.

Definition at line 650 of file MeshElements.h.

                                     {
                if (m_faceLink.get() != 0) return "F";
                if (m_edgeLink.get() != 0) return "E";
                return m_tag;
            }

std::vector<int> Nektar::Utilities::Element::GetTagList ( ) const

inline

Access the list of tags associated with this element.

Definition at line 713 of file MeshElements.h.

                                              {
                return m_taglist;
            }

NodeSharedPtr Nektar::Utilities::Element::GetVertex ( unsigned int i ) const

inline

Access a vertex node.

Definition at line 656 of file MeshElements.h.

                                                          {
                return m_vertex[i];
            }

unsigned int Nektar::Utilities::Element::GetVertexCount ( ) const

inline

Returns the number of vertices.

Definition at line 717 of file MeshElements.h.

                                                {
                return m_vertex.size();
            }

std::vector<NodeSharedPtr> Nektar::Utilities::Element::GetVertexList ( ) const

inline

Access the list of vertex nodes.

Definition at line 668 of file MeshElements.h.

                                                           {
                return m_vertex;
            }

std::vector<NodeSharedPtr> Nektar::Utilities::Element::GetVolumeNodes ( ) const

inline

Access the list of volume nodes.

Definition at line 680 of file MeshElements.h.

                                                            {
                return m_volumeNodes;
            }

std::string Nektar::Utilities::Element::GetXmlCurveString ( ) const

inline

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

Definition at line 918 of file MeshElements.h.

            {
                // Temporary node list for reordering
                std::vector<NodeSharedPtr> nodeList;
                // Node orderings are different for different elements.
                // Triangle
                if (m_vertex.size() == 3)
                {
                    int n = m_edge[0]->GetNodeCount();
                    nodeList.resize(n*(n+1)/2);
                    // Populate nodelist
                    std::copy(m_vertex.begin(), m_vertex.end(), nodeList.begin());
                    for (int i = 0; i < 3; ++i)
                    {
                        std::copy(m_edge[i]->m_edgeNodes.begin(), m_edge[i]->m_edgeNodes.end(), nodeList.begin() + 3 + i*(n-2));
                        if (m_edge[i]->m_n1 != m_vertex[i])
                        {
                            // If edge orientation is reversed relative to node
                            // ordering, we need to reverse order of nodes.
                            std::reverse(nodeList.begin() + 3 + i*(n-2),
                                         nodeList.begin() + 3 + (i+1)*(n-2));
                        }
                    }
                    // Triangle ordering lists vertices, edges then interior.
                    // Interior nodes are row by row from edge 0 up to vertex 2
                    // so need to reorder interior nodes only.
                    std::vector<NodeSharedPtr> interior(m_volumeNodes.size());
                    std::copy(m_volumeNodes.begin(), m_volumeNodes.end(), interior.begin());
                    interior = tensorNodeOrdering(interior, n-3);
                    std::copy(interior.begin(), interior.end(), nodeList.begin() + 3*(n-1));
                }
                // Quad
                else if (m_dim == 2 && m_vertex.size() == 4)
                {
                    int n = m_edge[0]->GetNodeCount();
                    nodeList.resize(n*n);
                    // Populate nodelist
                    std::copy(m_vertex.begin(), m_vertex.end(), nodeList.begin());
                    for (int i = 0; i < 4; ++i)
                    {
                        std::copy(m_edge[i]->m_edgeNodes.begin(),
                                  m_edge[i]->m_edgeNodes.end(),
                                  nodeList.begin() + 4 + i*(n-2));
                        if (m_edge[i]->m_n1 != m_vertex[i])
                        {
                            // If m_edge orientation is reversed relative to node
                            // ordering, we need to reverse order of nodes.
                            std::reverse(nodeList.begin() + 4 + i*(n-2),
                                         nodeList.begin() + 4 + (i+1)*(n-2));
                        }
                    }
                    std::copy(m_volumeNodes.begin(), m_volumeNodes.end(), nodeList.begin() + 4*(n-1));
                    // Quadrilateral ordering lists all nodes row by row
                    // starting from edge 0 up to edge 2, so need to reorder
                    // all nodes.
                    nodeList = tensorNodeOrdering(nodeList, n);
                }
                else
                {
                    cerr << "GetXmlCurveString for a " << m_vertex.size()
                         << "-vertex element is not yet implemented." << endl;
                }
                // Finally generate the XML string corresponding to our new
                // node reordering.
                std::stringstream s;
                std::string str;
                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();
            }

virtual std::string Nektar::Utilities::Element::GetXmlString ( ) const

inlinevirtual

Generate a list of vertices (1D), edges (2D), or faces (3D).

Definition at line 779 of file MeshElements.h.

            {
                std::stringstream s;
                switch (m_dim)
                {
                case 1:
                    for(int j=0; j< m_vertex.size(); ++j)
                    {
                        s << std::setw(5) << m_vertex[j]->m_id << " ";
                    }
                    break;
                case 2:
                    for(int j=0; j< m_edge.size(); ++j)
                    {
                        s << std::setw(5) << m_edge[j]->m_id << " ";
                    }
                    break;
                case 3:
                    for(int j=0; j< m_face.size(); ++j)
                    {
                        s << std::setw(5) << m_face[j]->m_id << " ";
                    }
                    break;
                }
                return s.str();
            }

void Nektar::Utilities::Element::Print ( )

inline

Definition at line 1013 of file MeshElements.h.

            {
                int i, j;
                for (i = 0; i < m_vertex.size(); ++i)
                {
                    cout << m_vertex[i]->m_x << " " << m_vertex[i]->m_y << " " << m_vertex[i]->m_z << endl;
                }
                for (i = 0; i < m_edge.size(); ++i)
                {
                    for (j = 0; j < m_edge[i]->m_edgeNodes.size(); ++j)
                    {
                        NodeSharedPtr n = m_edge[i]->m_edgeNodes[j];
                        cout << n->m_x << " " << n->m_y << " " << n->m_z << endl;
                    }
                }
                for (i = 0; i < m_face.size(); ++i)
                {
                    for (j = 0; j < m_face[i]->m_faceNodes.size(); ++j)
                    {
                        NodeSharedPtr n = m_face[i]->m_faceNodes[j];
                        cout << n->m_x << " " << n->m_y << " " << n->m_z << endl;
                    }
                }
            }

void Nektar::Utilities::Element::SetBoundaryLink	(	int	i,
		int	j
	)

inline

Set a correspondence between edge or face i and its representative boundary element m->element[expDim-1][j].

Definition at line 758 of file MeshElements.h.

                                               {
                m_boundaryLinks[i] = j;
            }

void Nektar::Utilities::Element::SetCurveType ( LibUtilities::PointsType cT )

inline

Definition at line 689 of file MeshElements.h.

References Nektar::Utilities::Face::m_curveType.

                                                         {
                m_curveType = cT;
            }

void Element::SetEdge	(	unsigned int	p,
		EdgeSharedPtr	pNew
	)

Replace an edge with another edge object.

Replace an edge in the element.

When an edge is replaced, the element faces are also searched and the corresponding face edges are updated to maintain consistency.

Parameters

p	Index of the edge to replace.
pNew	New edge.

Definition at line 276 of file MeshElements.cpp.

References m_edge, and m_face.

        {
            EdgeSharedPtr vOld = m_edge[p];
            m_edge[p] = pNew;
            for (unsigned int i = 0; i < m_face.size(); ++i)
            {
                for (unsigned int j = 0; j < m_face[i]->m_edgeList.size(); ++j)
                {
                    if (m_face[i]->m_edgeList[j] == vOld)
                    {
                        m_face[i]->m_edgeList[j] = pNew;
                    }
                }
            }
        }

void Nektar::Utilities::Element::SetEdgeLink ( EdgeSharedPtr pLink )

inline

Set a correspondence between this element and an edge (2D boundary element).

Definition at line 740 of file MeshElements.h.

                                                  {
                m_edgeLink = pLink;
            }

void Element::SetFace	(	unsigned int	p,
		FaceSharedPtr	pNew
	)

Replace a face with another face object.

Replace a face in the element.

When a face is replaced, no other consistency checks are required.

Parameters

p	Index of the face to replace.
pNew	New face.

Definition at line 300 of file MeshElements.cpp.

References m_face.

        {
            m_face[p] = pNew;
        }

void Nektar::Utilities::Element::SetFaceLink ( FaceSharedPtr pLink )

inline

Set a correspondence between this element and a face (3D boundary element).

Definition at line 749 of file MeshElements.h.

                                                  {
                m_faceLink = pLink;
            }

void Nektar::Utilities::Element::SetId ( unsigned int p )

inline

Change the ID of the element.

Definition at line 729 of file MeshElements.h.

References Nektar::Utilities::Face::m_id.

                                       {
                m_id = p;
            }

void Nektar::Utilities::Element::SetTagList ( const std::vector< int > & tags )

inline

Set the list of tags associated with this element.

Definition at line 774 of file MeshElements.h.

            {
                m_taglist = tags;
            }

void Element::SetVertex	(	unsigned int	p,
		NodeSharedPtr	pNew
	)

Replace a vertex with another vertex object.

Replace a vertex in the element.

When a vertex is replaced, the element edges and faces are also searched and the corresponding edge/face nodes are updated to maintain consistency.

Parameters

p	Index of the vertex to replace.
pNew	New vertex.

Definition at line 228 of file MeshElements.cpp.

References m_edge, m_face, and m_vertex.

        {
            NodeSharedPtr vOld = m_vertex[p];
            m_vertex[p] = pNew;
            for (unsigned int i = 0; i < m_edge.size(); ++i)
            {
                if (m_edge[i]->m_n1 == vOld)
                {
                    m_edge[i]->m_n1 = pNew;
                }
                else if (m_edge[i]->m_n2 == vOld)
                {
                    m_edge[i]->m_n2 = pNew;
                }
            }
            for (unsigned int i = 0; i < m_face.size(); ++i)
            {
                // Replace vertices in faces
                for (unsigned int j = 0; j < m_face[i]->m_vertexList.size(); ++j)
                {
                    if (m_face[i]->m_vertexList[j] == vOld)
                    {
                        m_face[i]->m_vertexList[j] = pNew;
                    }
                }
                for (unsigned int j = 0; j < m_face[i]->m_edgeList.size(); ++j)
                {
                    if (m_face[i]->m_edgeList[j]->m_n1 == vOld)
                    {
                        m_face[i]->m_edgeList[j]->m_n1 = pNew;
                    }
                    else if (m_face[i]->m_edgeList[j]->m_n2 == vOld)
                    {
                        m_face[i]->m_edgeList[j]->m_n2 = pNew;
                    }
                }
            }
        }

void Nektar::Utilities::Element::SetVolumeNodes ( std::vector< NodeSharedPtr > & nodes )

inline

Definition at line 683 of file MeshElements.h.

                                                                 {
                m_volumeNodes = nodes;
            }

std::vector<NodeSharedPtr> Nektar::Utilities::Element::tensorNodeOrdering	(	const std::vector< NodeSharedPtr > &	nodes,
		int	n
	)		const

inline

Reorders Gmsh ordered nodes into a row-by-row ordering required for Nektar++ curve tags.

The interior nodes of elements in the Gmsh format are ordered as for a lower-order element of the same type. This promotes the recursive approach to the reordering algorithm.

Definition at line 814 of file MeshElements.h.

            {
                std::vector<NodeSharedPtr> nodeList;
                int cnt2;
                // Triangle
                if (m_vertex.size() == 3)
                {
                    nodeList.resize(nodes.size());
                    // Vertices
                    nodeList[0] = nodes[0];
                    if (n > 1)
                    {
                        nodeList[n-1] = nodes[1];
                        nodeList[n*(n+1)/2 - 1] = nodes[2];
                    }
                    // Edges
                    int cnt = n;
                    for (int i = 1; i < n-1; ++i)
                    {
                        nodeList[i] = nodes[3+i-1];
                        nodeList[cnt] = nodes[3+3*(n-2)-i];
                        nodeList[cnt+n-i-1] = nodes[3+(n-2)+i-1];
                        cnt += n-i;
                    }
                    // Interior (recursion)
                    if (n > 3)
                    {
                        // Reorder interior nodes
                        std::vector<NodeSharedPtr> interior((n-3)*(n-2)/2);
                        std::copy(nodes.begin() + 3+3*(n-2), nodes.end(), interior.begin());
                        interior = tensorNodeOrdering(interior, n-3);
                        // Copy into full node list
                        cnt = n;
                        cnt2 = 0;
                        for (int j = 1; j < n-2; ++j)
                        {
                            for (int i = 0; i < n-j-2; ++i)
                            {
                                nodeList[cnt+i+1] = interior[cnt2+i];
                            }
                            cnt += n-j;
                            cnt2 += n-2-j;
                        }
                    }
                }
                // Quad
                else if (m_dim == 2 && m_vertex.size() == 4)
                {
                    nodeList.resize(nodes.size());
                    // Vertices and edges
                    nodeList[0] = nodes[0];
                    if (n > 1)
                    {
                        nodeList[n-1] = nodes[1];
                        nodeList[n*n-1] = nodes[2];
                        nodeList[n*(n-1)] = nodes[3];
                    }
                    for (int i = 1; i < n-1; ++i)
                    {
                        nodeList[i] = nodes[4+i-1];
                    }
                    for (int i = 1; i < n-1; ++i)
                    {
                        nodeList[n*n-1-i] = nodes[4+2*(n-2)+i-1];
                    }
                    // Interior (recursion)
                    if (n > 2)
                    {
                        // Reorder interior nodes
                        std::vector<NodeSharedPtr> interior((n-2)*(n-2));
                        std::copy(nodes.begin() + 4+4*(n-2), nodes.end(), interior.begin());
                        interior = tensorNodeOrdering(interior, n-2);
                        // Copy into full node list
                        for (int j = 1; j < n-1; ++j)
                        {
                            nodeList[j*n] = nodes[4+3*(n-2)+n-2-j];
                            for (int i = 1; i < n-1; ++i)
                            {
                                nodeList[j*n+i] = interior[(j-1)*(n-2)+(i-1)];
                            }
                            nodeList[(j+1)*n-1] = nodes[4+(n-2)+j-1];
                        }
                    }
                }
                else
                {
                    cerr << "TensorNodeOrdering for a " << m_vertex.size()
                         << "-vertex element is not yet implemented." << endl;
                }
                return nodeList;
            }

Member Data Documentation

std::map<int,int> Nektar::Utilities::Element::m_boundaryLinks

protected

Array mapping faces/edges to the location of the appropriate boundary elements in m->element.

Definition at line 1065 of file MeshElements.h.

ElmtConfig Nektar::Utilities::Element::m_conf

protected

Contains configuration of the element.

Definition at line 1044 of file MeshElements.h.

Referenced by Nektar::Utilities::Triangle::Complete(), Nektar::Utilities::Quadrilateral::Complete(), Nektar::Utilities::Tetrahedron::Complete(), Nektar::Utilities::Prism::Complete(), Nektar::Utilities::Hexahedron::Hexahedron(), Nektar::Utilities::Line::Line(), Nektar::Utilities::Prism::Prism(), Nektar::Utilities::Pyramid::Pyramid(), Nektar::Utilities::Quadrilateral::Quadrilateral(), Nektar::Utilities::Tetrahedron::Tetrahedron(), and Nektar::Utilities::Triangle::Triangle().

LibUtilities::PointsType Nektar::Utilities::Element::m_curveType

protected

Volume curve type.

Definition at line 1058 of file MeshElements.h.

Referenced by Nektar::Utilities::Line::GetGeom(), and Nektar::Utilities::Triangle::Triangle().

unsigned int Nektar::Utilities::Element::m_dim

protected

Dimension of the element.

Definition at line 1042 of file MeshElements.h.

Referenced by Nektar::Utilities::Hexahedron::Hexahedron(), Nektar::Utilities::Line::Line(), Nektar::Utilities::Point::Point(), Nektar::Utilities::Prism::Prism(), Nektar::Utilities::Pyramid::Pyramid(), Nektar::Utilities::Quadrilateral::Quadrilateral(), Nektar::Utilities::Tetrahedron::Tetrahedron(), and Nektar::Utilities::Triangle::Triangle().

std::vector<EdgeSharedPtr> Nektar::Utilities::Element::m_edge

protected

List of element edges.

Definition at line 1052 of file MeshElements.h.

EdgeSharedPtr Nektar::Utilities::Element::m_edgeLink

protected

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

Definition at line 1060 of file MeshElements.h.

std::vector<FaceSharedPtr> Nektar::Utilities::Element::m_face

protected

List of element faces.

Definition at line 1054 of file MeshElements.h.

Referenced by Nektar::Utilities::Tetrahedron::Complete(), Nektar::Utilities::Prism::Complete(), Nektar::Utilities::Tetrahedron::GetGeom(), Nektar::Utilities::Pyramid::GetGeom(), Nektar::Utilities::Prism::GetGeom(), Nektar::Utilities::Hexahedron::GetGeom(), Nektar::Utilities::Hexahedron::Hexahedron(), Nektar::Utilities::Prism::Prism(), Nektar::Utilities::Pyramid::Pyramid(), SetEdge(), SetFace(), SetVertex(), and Nektar::Utilities::Tetrahedron::Tetrahedron().

FaceSharedPtr Nektar::Utilities::Element::m_faceLink

protected

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

Definition at line 1062 of file MeshElements.h.

SpatialDomains::GeometrySharedPtr Nektar::Utilities::Element::m_geom

protected

Nektar++ geometry object for this element.

Definition at line 1067 of file MeshElements.h.

Referenced by Nektar::Utilities::Pyramid::GetGeom().

unsigned int Nektar::Utilities::Element::m_id

protected

ID of the element.

Definition at line 1040 of file MeshElements.h.

Referenced by Nektar::Utilities::Line::GetGeom(), Nektar::Utilities::Triangle::GetGeom(), and Nektar::Utilities::Quadrilateral::GetGeom().

std::string Nektar::Utilities::Element::m_tag

protected

Tag character describing the element.

Definition at line 1046 of file MeshElements.h.

Referenced by Nektar::Utilities::Hexahedron::Hexahedron(), Nektar::Utilities::Line::Line(), Nektar::Utilities::Point::Point(), Nektar::Utilities::Prism::Prism(), Nektar::Utilities::Pyramid::Pyramid(), Nektar::Utilities::Quadrilateral::Quadrilateral(), Nektar::Utilities::Tetrahedron::Tetrahedron(), and Nektar::Utilities::Triangle::Triangle().

std::vector<int> Nektar::Utilities::Element::m_taglist

protected

List of integers specifying properties of the element.

Definition at line 1048 of file MeshElements.h.

Referenced by Nektar::Utilities::Hexahedron::Hexahedron(), Nektar::Utilities::Line::Line(), Nektar::Utilities::Point::Point(), Nektar::Utilities::Prism::Prism(), Nektar::Utilities::Pyramid::Pyramid(), Nektar::Utilities::Quadrilateral::Quadrilateral(), Nektar::Utilities::Tetrahedron::Tetrahedron(), and Nektar::Utilities::Triangle::Triangle().

std::vector<NodeSharedPtr> Nektar::Utilities::Element::m_vertex

protected

List of element vertex nodes.

Definition at line 1050 of file MeshElements.h.

std::vector<NodeSharedPtr> Nektar::Utilities::Element::m_volumeNodes

protected

List of element volume nodes.

Definition at line 1056 of file MeshElements.h.

Referenced by Nektar::Utilities::Triangle::Complete(), Nektar::Utilities::Quadrilateral::Complete(), Nektar::Utilities::Tetrahedron::Complete(), Nektar::Utilities::Prism::Complete(), Nektar::Utilities::Quadrilateral::Quadrilateral(), and Nektar::Utilities::Triangle::Triangle().

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation