A 3-dimensional five-faced element (2 triangles, 3 quadrilaterals). More...

#include <Prism.h>

Inheritance diagram for Nektar::NekMeshUtils::Prism:

Collaboration diagram for Nektar::NekMeshUtils::Prism:

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

NEKMESHUTILS_EXPORT	Prism (const Prism &pSrc)

virtual NEKMESHUTILS_EXPORT	~Prism ()

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

virtual NEKMESHUTILS_EXPORT void	Complete (int order)

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

Public Attributes
unsigned int	m_orientation

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

Protected Member Functions
void	OrientPrism ()
	Orient prism to align degenerate vertices. 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 3-dimensional five-faced element (2 triangles, 3 quadrilaterals).

Definition at line 50 of file Prism.h.

Constructor & Destructor Documentation

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

Create a prism element.

Definition at line 55 of file Prism.cpp.

Referenced by create().

     : Element(pConf, GetNumNodes(pConf), pNodeList.size())
 {
     m_tag     = "R";
     m_dim     = 3;
     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;
 
     // This edge-node map is based on Nektar++ ordering.
     edgeNodeMap[pair<int, int>(1, 2)] = 7;
     edgeNodeMap[pair<int, int>(2, 3)] = 7 + n;
     edgeNodeMap[pair<int, int>(4, 3)] = 7 + 2 * n;
     edgeNodeMap[pair<int, int>(1, 4)] = 7 + 3 * n;
     edgeNodeMap[pair<int, int>(1, 5)] = 7 + 4 * n;
     edgeNodeMap[pair<int, int>(2, 5)] = 7 + 5 * n;
     edgeNodeMap[pair<int, int>(3, 6)] = 7 + 6 * n;
     edgeNodeMap[pair<int, int>(4, 6)] = 7 + 7 * n;
     edgeNodeMap[pair<int, int>(5, 6)] = 7 + 8 * n;
 
     // Add vertices
     for (int i = 0; i < 6; ++i)
     {
         m_vertex.push_back(pNodeList[i]);
     }
 
     int eid = 0;
     // 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)));
         m_edge.back()->m_id = eid++;
     }
 
     if (m_conf.m_reorient)
     {
         OrientPrism();
     }
     else
     {
         m_orientation = 0;
     }
 
     // Create faces
     int face_ids[5][4] = {
         {0, 1, 2, 3}, {0, 1, 4, -1}, {1, 2, 5, 4}, {3, 2, 5, -1}, {0, 3, 5, 4}};
     int face_edges[5][4];
 
     int face_offset[5];
     face_offset[0] = 6 + 9 * n;
     for (int j = 0; j < 4; ++j)
     {
         int facenodes      = j % 2 == 0 ? n * n : n * (n - 1) / 2;
         face_offset[j + 1] = face_offset[j] + facenodes;
     }
 
     for (int j = 0; j < 5; ++j)
     {
         vector<NodeSharedPtr> faceVertices;
         vector<EdgeSharedPtr> faceEdges;
         vector<NodeSharedPtr> faceNodes;
         int nEdge = 3 - (j % 2 - 1);
 
         for (int k = 0; k < nEdge; ++k)
         {
             faceVertices.push_back(m_vertex[face_ids[j][k]]);
             NodeSharedPtr a = m_vertex[face_ids[j][k]];
             NodeSharedPtr b = m_vertex[face_ids[j][(k + 1) % nEdge]];
             unsigned int i;
             for (i = 0; i < m_edge.size(); ++i)
             {
                 if ((m_edge[i]->m_n1->m_id == a->m_id &&
                      m_edge[i]->m_n2->m_id == b->m_id) ||
                     (m_edge[i]->m_n1->m_id == b->m_id &&
                      m_edge[i]->m_n2->m_id == a->m_id))
                 {
                     faceEdges.push_back(m_edge[i]);
                     face_edges[j][k] = i;
                     break;
                 }
             }
 
             if (i == m_edge.size())
             {
                 face_edges[j][k] = -1;
             }
         }
 
         if (m_conf.m_faceNodes)
         {
             int face = j, facenodes;
 
             if (j % 2 == 0)
             {
                 facenodes = n * n;
                 if (m_orientation == 1)
                 {
                     face = (face + 4) % 6;
                 }
                 else if (m_orientation == 2)
                 {
                     face = (face + 2) % 6;
                 }
             }
             else
             {
                 // TODO: need to rotate these too.
                 facenodes = n * (n - 1) / 2;
             }
 
             for (int i = 0; i < facenodes; ++i)
             {
                 faceNodes.push_back(pNodeList[face_offset[face] + i]);
             }
         }
         m_face.push_back(FaceSharedPtr(new Face(
             faceVertices, faceNodes, faceEdges, m_conf.m_faceCurveType)));
     }
 
     // Re-order edge array to be consistent with Nektar++ ordering.
     vector<EdgeSharedPtr> tmp(9);
     ASSERTL1(face_edges[0][0] != -1, "face_edges[0][0] == -1");
     tmp[0] = m_edge[face_edges[0][0]];
     ASSERTL1(face_edges[0][1] != -1, "face_edges[0][1] == -1");
     tmp[1] = m_edge[face_edges[0][1]];
     ASSERTL1(face_edges[0][2] != -1, "face_edges[0][2] == -1");
     tmp[2] = m_edge[face_edges[0][2]];
     ASSERTL1(face_edges[0][3] != -1, "face_edges[0][3] == -1");
     tmp[3] = m_edge[face_edges[0][3]];
     ASSERTL1(face_edges[1][2] != -1, "face_edges[1][2] == -1");
     tmp[4] = m_edge[face_edges[1][2]];
     ASSERTL1(face_edges[1][1] != -1, "face_edges[1][1] == -1");
     tmp[5] = m_edge[face_edges[1][1]];
     ASSERTL1(face_edges[2][1] != -1, "face_edges[2][1] == -1");
     tmp[6] = m_edge[face_edges[2][1]];
     ASSERTL1(face_edges[3][2] != -1, "face_edges[3][2] == -1");
     tmp[7] = m_edge[face_edges[3][2]];
     ASSERTL1(face_edges[4][2] != -1, "face_edges[4][2] == -1");
     tmp[8] = m_edge[face_edges[4][2]];
     m_edge = tmp;
 }

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

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

inlinevirtual

Definition at line 74 of file Prism.h.

75 {

76 }

Member Function Documentation

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

virtual

Reimplemented from Nektar::NekMeshUtils::Element.

Definition at line 248 of file Prism.cpp.

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

 {
     int i, j, pos;
 
     // Create basis key for a nodal tetrahedron.
     LibUtilities::BasisKey B0(
         LibUtilities::eOrtho_A,
         order + 1,
         LibUtilities::PointsKey(order + 1,
                                 LibUtilities::eGaussLobattoLegendre));
     LibUtilities::BasisKey B1(
         LibUtilities::eOrtho_A,
         order + 1,
         LibUtilities::PointsKey(order + 1,
                                 LibUtilities::eGaussLobattoLegendre));
     LibUtilities::BasisKey B2(
         LibUtilities::eOrtho_B,
         order + 1,
         LibUtilities::PointsKey(order + 1,
                                 LibUtilities::eGaussRadauMAlpha1Beta0));
 
     // Create a standard nodal prism in order to get the Vandermonde
     // matrix to perform interpolation to nodal points.
     StdRegions::StdNodalPrismExpSharedPtr nodalPrism =
         MemoryManager<StdRegions::StdNodalPrismExp>::AllocateSharedPtr(
             B0, B1, B2, LibUtilities::eNodalPrismEvenlySpaced);
 
     Array<OneD, NekDouble> x, y, z;
     nodalPrism->GetNodalPoints(x, y, z);
 
     SpatialDomains::PrismGeomSharedPtr geom =
         boost::dynamic_pointer_cast<SpatialDomains::PrismGeom>(
             this->GetGeom(3));
 
     // Create basis key for a prism.
     LibUtilities::BasisKey C0(
         LibUtilities::eOrtho_A,
         order + 1,
         LibUtilities::PointsKey(order + 1,
                                 LibUtilities::eGaussLobattoLegendre));
     LibUtilities::BasisKey C1(
         LibUtilities::eOrtho_A,
         order + 1,
         LibUtilities::PointsKey(order + 1,
                                 LibUtilities::eGaussLobattoLegendre));
     LibUtilities::BasisKey C2(
         LibUtilities::eOrtho_B,
         order + 1,
         LibUtilities::PointsKey(order + 1,
                                 LibUtilities::eGaussRadauMAlpha1Beta0));
 
     // Create a prism.
     LocalRegions::PrismExpSharedPtr prism =
         MemoryManager<LocalRegions::PrismExp>::AllocateSharedPtr(
             C0, C1, C2, geom);
 
     // Get coordinate array for tetrahedron.
     int nqtot = prism->GetTotPoints();
     Array<OneD, NekDouble> alloc(6 * nqtot);
     Array<OneD, NekDouble> xi(alloc);
     Array<OneD, NekDouble> yi(alloc + nqtot);
     Array<OneD, NekDouble> zi(alloc + 2 * nqtot);
     Array<OneD, NekDouble> xo(alloc + 3 * nqtot);
     Array<OneD, NekDouble> yo(alloc + 4 * nqtot);
     Array<OneD, NekDouble> zo(alloc + 5 * nqtot);
     Array<OneD, NekDouble> tmp;
 
     prism->GetCoords(xi, yi, zi);
 
     for (i = 0; i < 3; ++i)
     {
         Array<OneD, NekDouble> coeffs(nodalPrism->GetNcoeffs());
         prism->FwdTrans(alloc + i * nqtot, coeffs);
         // Apply Vandermonde matrix to project onto nodal space.
         nodalPrism->ModalToNodal(coeffs, tmp = alloc + (i + 3) * nqtot);
     }
 
     // Now extract points from the co-ordinate arrays into the
     // edge/face/volume nodes. First, extract edge-interior nodes.
     for (i = 0; i < 9; ++i)
     {
         pos = 6 + i * (order - 1);
         m_edge[i]->m_edgeNodes.clear();
         for (j = 0; j < order - 1; ++j)
         {
             m_edge[i]->m_edgeNodes.push_back(NodeSharedPtr(
                 new Node(0, xo[pos + j], yo[pos + j], zo[pos + j])));
         }
     }
 
     // Now extract face-interior nodes.
     pos = 6 + 9 * (order - 1);
     for (i = 0; i < 5; ++i)
     {
         int facesize =
             i % 2 ? (order - 2) * (order - 1) / 2 : (order - 1) * (order - 1);
         m_face[i]->m_faceNodes.clear();
         for (j = 0; j < facesize; ++j)
         {
             m_face[i]->m_faceNodes.push_back(NodeSharedPtr(
                 new Node(0, xo[pos + j], yo[pos + j], zo[pos + j])));
         }
         pos += facesize;
     }
 
     // Finally extract volume nodes.
     for (i = pos; i < (order + 1) * (order + 1) * (order + 2) / 2; ++i)
     {
         m_volumeNodes.push_back(
             NodeSharedPtr(new Node(0, xo[i], yo[i], zo[i])));
     }
 
     m_conf.m_order       = order;
     m_conf.m_faceNodes   = true;
     m_conf.m_volumeNodes = true;
 }

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

inlinestatic

Creates an instance of this class.

Definition at line 54 of file Prism.h.

References Prism().

     {
         ElementSharedPtr e =
             boost::shared_ptr<Element>(new Prism(pConf, pNodeList, pTagList));
         vector<FaceSharedPtr> faces = e->GetFaceList();
         for (int i = 0; i < faces.size(); ++i)
         {
             faces[i]->m_elLink.push_back(pair<ElementSharedPtr, int>(e, i));
         }
         return e;
     }

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

virtual

Generate a Nektar++ geometry object for this element.

Reimplemented from Nektar::NekMeshUtils::Element.

Definition at line 230 of file Prism.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::NekMeshUtils::Element::m_face.

Referenced by Complete().

 {
     SpatialDomains::Geometry2DSharedPtr faces[5];
     SpatialDomains::PrismGeomSharedPtr ret;
 
     for (int i = 0; i < 5; ++i)
     {
         faces[i] = m_face[i]->GetGeom(coordDim);
     }
 
     ret = MemoryManager<SpatialDomains::PrismGeom>::AllocateSharedPtr(faces);
 
     return ret;
 }

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

static

Return the number of nodes defining a prism.

Definition at line 218 of file Prism.cpp.

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

 {
     int n = pConf.m_order;
     if (pConf.m_faceNodes && pConf.m_volumeNodes)
         return (n + 1) * (n + 1) * (n + 2) / 2;
     else if (pConf.m_faceNodes && !pConf.m_volumeNodes)
         return 3 * (n + 1) * (n + 1) + 2 * (n + 1) * (n + 2) / 2 - 9 * (n + 1) +
                6;
     else
         return 9 * (n + 1) - 12;
 }

void Nektar::NekMeshUtils::Prism::OrientPrism ( )

protected

Orient prism to align degenerate vertices.

Orientation of prismatric elements is required so that the singular vertices of triangular faces (which occur as a part of the collapsed co-ordinate system) align. The algorithm is based on that used in T. Warburton's thesis and in the original Nektar source.

First the points are re-ordered so that the highest global IDs represent the two singular points of the prism. Then, if necessary, the nodes are rotated either clockwise or counter-clockwise (w.r.t to the p-r plane) to correctly align the prism. The #orientation variable is set to:

0 if the prism is not rotated;
1 if the prism is rotated clockwise;
2 if the prism is rotated counter-clockwise.

This is necessary for some input modules (e.g. #InputNek) which add high-order information or bounary conditions to faces.

Definition at line 386 of file Prism.cpp.

References m_orientation, and Nektar::NekMeshUtils::Element::m_vertex.

Referenced by Prism().

 {
     int lid[6], gid[6];
 
     // Re-order vertices.
     for (int i = 0; i < 6; ++i)
     {
         lid[i] = i;
         gid[i] = m_vertex[i]->m_id;
     }
 
     gid[0] = gid[3] = max(gid[0], gid[3]);
     gid[1] = gid[2] = max(gid[1], gid[2]);
     gid[4] = gid[5] = max(gid[4], gid[5]);
 
     for (int i = 1; i < 6; ++i)
     {
         if (gid[0] < gid[i])
         {
             swap(gid[i], gid[0]);
             swap(lid[i], lid[0]);
         }
     }
 
     if (lid[0] == 4 || lid[0] == 5)
     {
         m_orientation = 0;
     }
     else if (lid[0] == 1 || lid[0] == 2)
     {
         // Rotate prism clockwise in p-r plane
         vector<NodeSharedPtr> vertexmap(6);
         vertexmap[0]  = m_vertex[4];
         vertexmap[1]  = m_vertex[0];
         vertexmap[2]  = m_vertex[3];
         vertexmap[3]  = m_vertex[5];
         vertexmap[4]  = m_vertex[1];
         vertexmap[5]  = m_vertex[2];
         m_vertex      = vertexmap;
         m_orientation = 1;
     }
     else if (lid[0] == 0 || lid[0] == 3)
     {
         // Rotate prism counter-clockwise in p-r plane
         vector<NodeSharedPtr> vertexmap(6);
         vertexmap[0]  = m_vertex[1];
         vertexmap[1]  = m_vertex[4];
         vertexmap[2]  = m_vertex[5];
         vertexmap[3]  = m_vertex[2];
         vertexmap[4]  = m_vertex[0];
         vertexmap[5]  = m_vertex[3];
         m_vertex      = vertexmap;
         m_orientation = 2;
     }
     else
     {
         cerr << "Warning: possible prism orientation problem." << endl;
     }
 }

Member Data Documentation

unsigned int Nektar::NekMeshUtils::Prism::m_orientation

Orientation of prism; unchanged = 0; clockwise = 1; counter-clockwise = 2. This is set by OrientPrism.

Definition at line 88 of file Prism.h.

Referenced by OrientPrism(), and Prism().

LibUtilities::ShapeType Nektar::NekMeshUtils::Prism::m_type

static

Initial value:

=
    GetElementFactory().RegisterCreatorFunction(
        LibUtilities::ePrism, Prism::create, "Prism")

Element type.

Definition at line 68 of file Prism.h.

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation