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

#include <Prism.h>

Inheritance 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	GetCurvedNodes (std::vector< NodeSharedPtr > &nodeList) const
	get list of volume interior nodes More...

virtual NEKMESHUTILS_EXPORT StdRegions::Orientation	GetEdgeOrient (int edgeId, EdgeSharedPtr edge)
	Get the edge orientation of `edge` with respect to the local element, which lies at edge index `edgeId`. More...

virtual NEKMESHUTILS_EXPORT void	MakeOrder (int order, SpatialDomains::GeometrySharedPtr geom, LibUtilities::PointsType pType, int coordDim, int &id, bool justConfig=false)
	Insert interior (i.e. volume) points into this element to make the geometry an order `order` representation. More...

virtual NEKMESHUTILS_EXPORT int	GetFaceVertex (int i, int j)
	Returns the local index of vertex `j` of face `i`. 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 LibUtilities::ShapeType	GetShapeType () const
	returns the shapetype 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 ()
	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, bool descend=true)
	Replace a vertex in the element. More...

NEKMESHUTILS_EXPORT void	SetEdge (unsigned int p, EdgeSharedPtr pNew, bool descend=true)
	Replace an edge in the element. More...

NEKMESHUTILS_EXPORT void	SetFace (unsigned int p, FaceSharedPtr pNew)
	Replace a face in the element. 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 bool	HasBoundaryLinks ()
	Is this element connected to a boundary. 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 ()
	Generate a list of vertices (1D), edges (2D), or faces (3D). More...

NEKMESHUTILS_EXPORT std::string	GetXmlCurveString ()
	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 bool	IsDeformed ()
	Determines whether an element is deformed by inspecting whether there are any edge, face or volume interior nodes. More...

NEKMESHUTILS_EXPORT std::pair< Node, Node >	GetBoundingBox ()
	Returns the approximate bounding box of this element based on the coordinates of all vertices, edges and faces of the element. Note that this does not robustly take into account the curvature of the element. More...

NEKMESHUTILS_EXPORT void	Print ()

virtual NEKMESHUTILS_EXPORT Array< OneD, NekDouble >	Normal (bool inward=false)
	returns the normal to the element More...

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

Public Attributes inherited from Nektar::NekMeshUtils::Element
CADObjectSharedPtr	m_parentCAD

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

Protected Member Functions
void	OrientPrism ()
	Orient prism to align degenerate vertices. More...

Static Private Attributes
static int	m_faceIds [5][4]
	Vertex IDs that make up prism faces. 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 49 of file Prism.h.

Constructor & Destructor Documentation

◆ Prism() [1/2]

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

Create a prism element.

Definition at line 63 of file Prism.cpp.

     : 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_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[m_faceIds[j][k]]);
             NodeSharedPtr a = m_vertex[m_faceIds[j][k]];
             NodeSharedPtr b = m_vertex[m_faceIds[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]);
             }
         }
 
         // Try to translate between common face curve types
         LibUtilities::PointsType pType = m_conf.m_faceCurveType;
 
         if (pType == LibUtilities::ePolyEvenlySpaced && (j == 1 || j == 3))
         {
             pType = LibUtilities::eNodalTriEvenlySpaced;
         }
 
         m_face.push_back(
             FaceSharedPtr(new Face(faceVertices, faceNodes, faceEdges, pType)));
     }
 
     // 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;
 }

◆ Prism() [2/2]

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

◆ ~Prism()

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

inlinevirtual

Definition at line 66 of file Prism.h.

References GetCurvedNodes(), GetEdgeOrient(), GetGeom(), GetNumNodes(), MakeOrder(), and NEKMESHUTILS_EXPORT.

67 {

68 }

Member Function Documentation

◆ create()

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 53 of file Prism.h.

     {
         return std::make_shared<Prism>(pConf, pNodeList, pTagList);
     }

◆ GetCurvedNodes()

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

virtual

get list of volume interior nodes

Reimplemented from Nektar::NekMeshUtils::Element.

Definition at line 354 of file Prism.cpp.

References Nektar::NekMeshUtils::HOTriangle< T >::Align(), Nektar::NekMeshUtils::HOQuadrilateral< T >::Align(), CellMLToNektar.pycml::copy(), Nektar::NekMeshUtils::Element::m_edge, Nektar::NekMeshUtils::Element::m_face, Nektar::NekMeshUtils::Element::m_id, Nektar::NekMeshUtils::Element::m_vertex, Nektar::NekMeshUtils::Element::m_volumeNodes, Nektar::NekMeshUtils::HOTriangle< T >::surfVerts, and Nektar::NekMeshUtils::HOQuadrilateral< T >::surfVerts.

Referenced by ~Prism().

 {
     int n = m_edge[0]->GetNodeCount();
     nodeList.resize(n*n*(n+1)/2);
 
     nodeList[0] = m_vertex[0];
     nodeList[1] = m_vertex[1];
     nodeList[2] = m_vertex[2];
     nodeList[3] = m_vertex[3];
     nodeList[4] = m_vertex[4];
     nodeList[5] = m_vertex[5];
     int k = 6;
 
     for(int i = 0; i < 4; i++)
     {
         bool reverseEdge = m_edge[i]->m_n1 == m_vertex[i];
         if (reverseEdge)
         {
             for(int j = 0; j < n-2; j++)
             {
                 nodeList[k++] = m_edge[i]->m_edgeNodes[j];
             }
         }
         else
         {
             for(int j = n-3; j >= 0; j--)
             {
                 nodeList[k++] = m_edge[i]->m_edgeNodes[j];
             }
         }
     }
 
     for(int i = 4; i < 8; i++)
     {
         bool reverseEdge = m_edge[i]->m_n1 == m_vertex[i-4];
         if (reverseEdge)
         {
             for(int j = 0; j < n-2; j++)
             {
                 nodeList[k++] = m_edge[i]->m_edgeNodes[j];
             }
         }
         else
         {
             for(int j = n-3; j >= 0; j--)
             {
                 nodeList[k++] = m_edge[i]->m_edgeNodes[j];
             }
         }
     }
     bool reverseEdge = m_edge[8]->m_n1 == m_vertex[4];
     if (reverseEdge)
     {
         for(int j = 0; j < n-2; j++)
         {
             nodeList[k++] = m_edge[8]->m_edgeNodes[j];
         }
     }
     else
     {
         for(int j = n-3; j >= 0; j--)
         {
             nodeList[k++] = m_edge[8]->m_edgeNodes[j];
         }
     }
 
     vector<vector<int> > ts;
     {
         vector<int> t(4);
         t[0] = m_vertex[0]->m_id;
         t[1] = m_vertex[1]->m_id;
         t[2] = m_vertex[2]->m_id;
         t[3] = m_vertex[3]->m_id;
         ts.push_back(t);
     }
     {
         vector<int> t(3);
         t[0] = m_vertex[0]->m_id;
         t[1] = m_vertex[1]->m_id;
         t[2] = m_vertex[4]->m_id;
         ts.push_back(t);
     }
     {
         vector<int> t(4);
         t[0] = m_vertex[1]->m_id;
         t[1] = m_vertex[2]->m_id;
         t[2] = m_vertex[5]->m_id;
         t[3] = m_vertex[4]->m_id;
         ts.push_back(t);
     }
     {
         vector<int> t(3);
         t[0] = m_vertex[3]->m_id;
         t[1] = m_vertex[2]->m_id;
         t[2] = m_vertex[5]->m_id;
         ts.push_back(t);
     }
     {
         vector<int> t(4);
         t[0] = m_vertex[0]->m_id;
         t[1] = m_vertex[3]->m_id;
         t[2] = m_vertex[5]->m_id;
         t[3] = m_vertex[4]->m_id;
         ts.push_back(t);
     }
 
     for(int i = 0; i < ts.size(); i++)
     {
         if(ts[i].size() == 3)
         {
             vector<int> fcid;
             fcid.push_back(m_face[i]->m_vertexList[0]->m_id);
             fcid.push_back(m_face[i]->m_vertexList[1]->m_id);
             fcid.push_back(m_face[i]->m_vertexList[2]->m_id);
 
             HOTriangle<NodeSharedPtr> hot(fcid, m_face[i]->m_faceNodes);
 
             hot.Align(ts[i]);
 
             std::copy(hot.surfVerts.begin(),
                       hot.surfVerts.end(),
                       nodeList.begin() + k);
             k+= hot.surfVerts.size();
         }
         else
         {
             vector<int> fcid;
             fcid.push_back(m_face[i]->m_vertexList[0]->m_id);
             fcid.push_back(m_face[i]->m_vertexList[1]->m_id);
             fcid.push_back(m_face[i]->m_vertexList[2]->m_id);
             fcid.push_back(m_face[i]->m_vertexList[3]->m_id);
 
             HOQuadrilateral<NodeSharedPtr> hoq(fcid, m_face[i]->m_faceNodes);
 
             hoq.Align(ts[i]);
 
             std::copy(hoq.surfVerts.begin(),
                       hoq.surfVerts.end(),
                       nodeList.begin() + k);
             k+= hoq.surfVerts.size();
         }
     }
 
     std::copy(m_volumeNodes.begin(),
               m_volumeNodes.end(),
               nodeList.begin() + k);
 }

◆ GetEdgeOrient()

StdRegions::Orientation Nektar::NekMeshUtils::Prism::GetEdgeOrient	(	int	edgeId,
		EdgeSharedPtr	edge
	)

virtual

Get the edge orientation of edge with respect to the local element, which lies at edge index edgeId.

Reimplemented from Nektar::NekMeshUtils::Element.

Definition at line 262 of file Prism.cpp.

References ASSERTL1, Nektar::StdRegions::eBackwards, Nektar::StdRegions::eForwards, Nektar::StdRegions::eNoOrientation, and Nektar::NekMeshUtils::Element::m_vertex.

Referenced by ~Prism().

 {
     static int edgeVerts[9][2] = {
         {0,1}, {1,2}, {3,2}, {0,3}, {0,4}, {1,4}, {2,5}, {3,5}, {4,5}
     };
 
     if (edge->m_n1 == m_vertex[edgeVerts[edgeId][0]])
     {
         return StdRegions::eForwards;
     }
     else if (edge->m_n1 == m_vertex[edgeVerts[edgeId][1]])
     {
         return StdRegions::eBackwards;
     }
     else
     {
         ASSERTL1(false, "Edge is not connected to this quadrilateral.");
     }
 
     return StdRegions::eNoOrientation;
 }

◆ GetFaceVertex()

virtual NEKMESHUTILS_EXPORT int Nektar::NekMeshUtils::Prism::GetFaceVertex	(	int	i,
		int	j
	)

inlinevirtual

Returns the local index of vertex j of face i.

Reimplemented from Nektar::NekMeshUtils::Element.

Definition at line 85 of file Prism.h.

References m_faceIds.

     {
         return m_faceIds[i][j];
     }

◆ GetGeom()

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 245 of file Prism.cpp.

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

Referenced by ~Prism().

 {
     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(
         m_id, faces);
 
     ret->Setup();
     return ret;
 }

◆ GetNumNodes()

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

static

Return the number of nodes defining a prism.

Definition at line 233 of file Prism.cpp.

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

Referenced by Nektar::Utilities::InputGmsh::GetNnodes(), and ~Prism().

 {
     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;
 }

◆ MakeOrder()

void Nektar::NekMeshUtils::Prism::MakeOrder	(	int	order,
		SpatialDomains::GeometrySharedPtr	geom,
		LibUtilities::PointsType	edgeType,
		int	coordDim,
		int &	id,
		bool	justConfig = `false`
	)

virtual

Insert interior (i.e. volume) points into this element to make the geometry an order order representation.

Parameters

order	The desired polynomial order.
geom	The geometry object used to describe the curvature mapping.
edgeType	The points distribution to use on the volume.
coordDim	The coordinate (i.e. space) dimension.
id	Counter which should be incremented to supply consistent vertex IDs.
justConfig	If true, then the configuration Element::m_conf will be updated but no nodes will be generated. This is used when considering boundary elements, which just require copying of face or edge interior nodes.

Reimplemented from Nektar::NekMeshUtils::Element.

Definition at line 285 of file Prism.cpp.

References ASSERTL1, Nektar::LibUtilities::PointsKey::GetPointsDim(), Nektar::NekMeshUtils::Element::m_conf, Nektar::NekMeshUtils::Element::m_curveType, Nektar::NekMeshUtils::ElmtConfig::m_faceNodes, Nektar::NekMeshUtils::ElmtConfig::m_order, Nektar::NekMeshUtils::ElmtConfig::m_volumeNodes, Nektar::NekMeshUtils::Element::m_volumeNodes, class_topology::Node, and Nektar::LibUtilities::PointsManager().

Referenced by ~Prism().

 {
     m_conf.m_order = order;
     m_curveType = pType;
     m_volumeNodes.clear();
 
     if (order == 1)
     {
         m_conf.m_volumeNodes = m_conf.m_faceNodes = false;
         return;
     }
     else if (order == 2)
     {
         m_conf.m_faceNodes   = true;
         m_conf.m_volumeNodes = false;
         return;
     }
 
     m_conf.m_faceNodes   = true;
     m_conf.m_volumeNodes = true;
 
     if (justConfig)
     {
         return;
     }
 
     int nPoints = order + 1;
     StdRegions::StdExpansionSharedPtr xmap = geom->GetXmap();
 
     Array<OneD, NekDouble> px, py, pz;
     LibUtilities::PointsKey pKey(nPoints, pType);
     ASSERTL1(pKey.GetPointsDim() == 3, "Points distribution must be 3D");
     LibUtilities::PointsManager()[pKey]->GetPoints(px, py, pz);
 
     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 nPrismPts  = nPoints * nPoints * (nPoints + 1) / 2;
     const int nPrismIntPts = (nPoints - 2) * (nPoints - 3) * (nPoints - 2) / 2;
     m_volumeNodes.resize(nPrismIntPts);
 
     for (int i = nPrismPts - nPrismIntPts, cnt = 0; i < nPrismPts; ++i, ++cnt)
     {
         Array<OneD, NekDouble> xp(3);
         xp[0] = px[i];
         xp[1] = py[i];
         xp[2] = pz[i];
 
         Array<OneD, NekDouble> x(3, 0.0);
         for (int j = 0; j < coordDim; ++j)
         {
             x[j] = xmap->PhysEvaluate(xp, phys[j]);
         }
 
         m_volumeNodes[cnt] = std::shared_ptr<Node>(
             new Node(id++, x[0], x[1], x[2]));
     }
 }

◆ OrientPrism()

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

◆ m_faceIds

int Nektar::NekMeshUtils::Prism::m_faceIds

staticprivate

Initial value:

= {
    {0, 1, 2, 3}, {0, 1, 4, -1}, {1, 2, 5, 4}, {3, 2, 5, -1}, {0, 3, 5, 4}
}

Vertex IDs that make up prism faces.

Definition at line 100 of file Prism.h.

Referenced by GetFaceVertex(), and Prism().

◆ m_orientation

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 94 of file Prism.h.

Referenced by OrientPrism(), and Prism().

◆ m_type

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

static

Initial value:

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

Element type.

Definition at line 60 of file Prism.h.

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Prism() [1/2]

◆ Prism() [2/2]

◆ ~Prism()

Member Function Documentation

◆ create()

◆ GetCurvedNodes()

◆ GetEdgeOrient()

◆ GetFaceVertex()

◆ GetGeom()

◆ GetNumNodes()

◆ MakeOrder()

◆ OrientPrism()

Member Data Documentation

◆ m_faceIds

◆ m_orientation

◆ m_type