Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
Public Member Functions | Static Public Member Functions | Static Public Attributes | Static Private Attributes | List of all members
Nektar::NekMeshUtils::Hexahedron Class Reference

A 3-dimensional six-faced element. More...

#include <Hexahedron.h>

Inheritance diagram for Nektar::NekMeshUtils::Hexahedron:
Inheritance graph
[legend]
Collaboration diagram for Nektar::NekMeshUtils::Hexahedron:
Collaboration graph
[legend]

Public Member Functions

NEKMESHUTILS_EXPORT Hexahedron (ElmtConfig pConf, std::vector< NodeSharedPtr > pNodeList, std::vector< int > pTagList)
 Create a hexahedral element. More...
 
NEKMESHUTILS_EXPORT Hexahedron (const Hexahedron &pSrc)
 copy hex element More...
 
virtual NEKMESHUTILS_EXPORT ~Hexahedron ()
 
virtual NEKMESHUTILS_EXPORT
SpatialDomains::GeometrySharedPtr 
GetGeom (int coordDim)
 Generate a Nektar++ geometry object for this element. 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 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...
 
virtual NEKMESHUTILS_EXPORT void GetCurvedNodes (std::vector< NodeSharedPtr > &nodeList) const
 get list of volume interior nodes 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 void Print ()
 
virtual NEKMESHUTILS_EXPORT
Array< OneD, NekDouble
Normal (bool inward=false)
 returns the normal to the element More...
 

Static Public Member Functions

static NEKMESHUTILS_EXPORT
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 hexahedron. More...
 

Static Public Attributes

static LibUtilities::ShapeType m_type
 Element type. More...
 

Static Private Attributes

static int m_faceIds [6][4]
 Vertex IDs that make up hexahedron faces. More...
 

Additional Inherited Members

- Public Attributes inherited from Nektar::NekMeshUtils::Element
CADObjectSharedPtr m_parentCAD
 
- 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< NodeSharedPtrm_vertex
 List of element vertex nodes. More...
 
std::vector< EdgeSharedPtrm_edge
 List of element edges. More...
 
std::vector< FaceSharedPtrm_face
 List of element faces. More...
 
std::vector< NodeSharedPtrm_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 six-faced element.

Definition at line 49 of file Hexahedron.h.

Constructor & Destructor Documentation

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

Create a hexahedral element.

Definition at line 58 of file Hexahedron.cpp.

References Nektar::iterator, Nektar::NekMeshUtils::Element::m_conf, Nektar::NekMeshUtils::Element::m_dim, Nektar::NekMeshUtils::Element::m_edge, Nektar::NekMeshUtils::ElmtConfig::m_edgeCurveType, Nektar::NekMeshUtils::Element::m_face, Nektar::NekMeshUtils::ElmtConfig::m_faceCurveType, m_faceIds, Nektar::NekMeshUtils::ElmtConfig::m_faceNodes, Nektar::NekMeshUtils::ElmtConfig::m_order, Nektar::NekMeshUtils::Element::m_tag, Nektar::NekMeshUtils::Element::m_taglist, and Nektar::NekMeshUtils::Element::m_vertex.

Referenced by create().

61  : Element(pConf, GetNumNodes(pConf), pNodeList.size())
62 {
63  m_tag = "H";
64  m_dim = 3;
65  m_taglist = pTagList;
66  int n = m_conf.m_order - 1;
67 
68  // Create a map to relate edge nodes to a pair of vertices defining an edge
69  // This is based on the ordering produced by gmsh.
70  map<pair<int, int>, int> edgeNodeMap;
71  map<pair<int, int>, int>::iterator it;
72  edgeNodeMap[pair<int, int>(1, 2)] = 9;
73  edgeNodeMap[pair<int, int>(2, 3)] = 9 + n;
74  edgeNodeMap[pair<int, int>(3, 4)] = 9 + 2 * n;
75  edgeNodeMap[pair<int, int>(4, 1)] = 9 + 3 * n;
76  edgeNodeMap[pair<int, int>(1, 5)] = 9 + 4 * n;
77  edgeNodeMap[pair<int, int>(2, 6)] = 9 + 5 * n;
78  edgeNodeMap[pair<int, int>(3, 7)] = 9 + 6 * n;
79  edgeNodeMap[pair<int, int>(4, 8)] = 9 + 7 * n;
80  edgeNodeMap[pair<int, int>(5, 6)] = 9 + 8 * n;
81  edgeNodeMap[pair<int, int>(6, 7)] = 9 + 9 * n;
82  edgeNodeMap[pair<int, int>(7, 8)] = 9 + 10 * n;
83  edgeNodeMap[pair<int, int>(8, 5)] = 9 + 11 * n;
84 
85  // Add vertices
86  for (int i = 0; i < 8; ++i)
87  {
88  m_vertex.push_back(pNodeList[i]);
89  }
90 
91  // Create edges (with corresponding set of edge points)
92  for (it = edgeNodeMap.begin(); it != edgeNodeMap.end(); ++it)
93  {
94  vector<NodeSharedPtr> edgeNodes;
95  if (m_conf.m_order > 1)
96  {
97  for (int j = it->second; j < it->second + n; ++j)
98  {
99  edgeNodes.push_back(pNodeList[j - 1]);
100  }
101  }
102  m_edge.push_back(EdgeSharedPtr(new Edge(pNodeList[it->first.first - 1],
103  pNodeList[it->first.second - 1],
104  edgeNodes,
106  }
107 
108  // Create faces
109  int face_edges[6][4];
110  for (int j = 0; j < 6; ++j)
111  {
112  vector<NodeSharedPtr> faceVertices;
113  vector<EdgeSharedPtr> faceEdges;
114  vector<NodeSharedPtr> faceNodes;
115  for (int k = 0; k < 4; ++k)
116  {
117  faceVertices.push_back(m_vertex[m_faceIds[j][k]]);
118  NodeSharedPtr a = m_vertex[m_faceIds[j][k]];
119  NodeSharedPtr b = m_vertex[m_faceIds[j][(k + 1) % 4]];
120  for (unsigned int i = 0; i < m_edge.size(); ++i)
121  {
122  if (((*(m_edge[i]->m_n1) == *a) &&
123  (*(m_edge[i]->m_n2) == *b)) ||
124  ((*(m_edge[i]->m_n1) == *b) && (*(m_edge[i]->m_n2) == *a)))
125  {
126  face_edges[j][k] = i;
127  faceEdges.push_back(m_edge[i]);
128  break;
129  }
130  }
131  }
132 
133  if (m_conf.m_faceNodes)
134  {
135  int N = 8 + 12 * n + j * n * n;
136  for (int i = 0; i < n * n; ++i)
137  {
138  faceNodes.push_back(pNodeList[N + i]);
139  }
140  }
141  m_face.push_back(FaceSharedPtr(new Face(
142  faceVertices, faceNodes, faceEdges, m_conf.m_faceCurveType)));
143  }
144 
145  // Reorder edges to be consistent with Nektar++ ordering.
146  vector<EdgeSharedPtr> tmp(12);
147  tmp[0] = m_edge[face_edges[0][0]];
148  tmp[1] = m_edge[face_edges[0][1]];
149  tmp[2] = m_edge[face_edges[0][2]];
150  tmp[3] = m_edge[face_edges[0][3]];
151  tmp[4] = m_edge[face_edges[1][3]];
152  tmp[5] = m_edge[face_edges[1][1]];
153  tmp[6] = m_edge[face_edges[2][1]];
154  tmp[7] = m_edge[face_edges[4][1]];
155  tmp[8] = m_edge[face_edges[5][0]];
156  tmp[9] = m_edge[face_edges[5][1]];
157  tmp[10] = m_edge[face_edges[5][2]];
158  tmp[11] = m_edge[face_edges[5][3]];
159  m_edge = tmp;
160 }
bool m_faceNodes
Denotes whether the element contains face nodes. For 2D elements, if this is true then the element co...
Definition: ElementConfig.h:80
static int m_faceIds[6][4]
Vertex IDs that make up hexahedron faces.
Definition: Hexahedron.h:95
LibUtilities::PointsType m_faceCurveType
Distribution of points in faces.
Definition: ElementConfig.h:94
ElmtConfig m_conf
Contains configuration of the element.
Definition: Element.h:380
std::vector< int > m_taglist
List of integers specifying properties of the element.
Definition: Element.h:384
LibUtilities::PointsType m_edgeCurveType
Distribution of points in edges.
Definition: ElementConfig.h:92
unsigned int m_order
Order of the element.
Definition: ElementConfig.h:87
std::vector< NodeSharedPtr > m_vertex
List of element vertex nodes.
Definition: Element.h:386
unsigned int m_dim
Dimension of the element.
Definition: Element.h:378
std::vector< EdgeSharedPtr > m_edge
List of element edges.
Definition: Element.h:388
boost::shared_ptr< Node > NodeSharedPtr
Definition: Node.h:50
static NEKMESHUTILS_EXPORT unsigned int GetNumNodes(ElmtConfig pConf)
Return the number of nodes defining a hexahedron.
Definition: Hexahedron.cpp:271
std::string m_tag
Tag character describing the element.
Definition: Element.h:382
boost::shared_ptr< Edge > EdgeSharedPtr
Shared pointer to an edge.
Definition: Edge.h:136
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
NEKMESHUTILS_EXPORT Element(ElmtConfig pConf, unsigned int pNumNodes, unsigned int pGotNodes)
Definition: Element.cpp:54
std::vector< FaceSharedPtr > m_face
List of element faces.
Definition: Element.h:390
boost::shared_ptr< Face > FaceSharedPtr
Definition: Face.h:153
NEKMESHUTILS_EXPORT Nektar::NekMeshUtils::Hexahedron::Hexahedron ( const Hexahedron pSrc)

copy hex element

virtual NEKMESHUTILS_EXPORT Nektar::NekMeshUtils::Hexahedron::~Hexahedron ( )
inlinevirtual

Definition at line 72 of file Hexahedron.h.

73  {
74  }

Member Function Documentation

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

Creates an instance of this class.

Definition at line 53 of file Hexahedron.h.

References Hexahedron().

57  {
58  return boost::shared_ptr<Element>(
59  new Hexahedron(pConf, pNodeList, pTagList));
60  }
NEKMESHUTILS_EXPORT Hexahedron(ElmtConfig pConf, std::vector< NodeSharedPtr > pNodeList, std::vector< int > pTagList)
Create a hexahedral element.
Definition: Hexahedron.cpp:58
StdRegions::Orientation Nektar::NekMeshUtils::Hexahedron::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 178 of file Hexahedron.cpp.

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

180 {
181  static int edgeVerts[12][2] = { {0,1}, {1,2}, {2,3}, {3,0}, {0,4}, {1,5},
182  {2,6}, {3,7}, {4,5}, {5,6}, {6,7}, {7,4} };
183 
184  if (edge->m_n1 == m_vertex[edgeVerts[edgeId][0]])
185  {
186  return StdRegions::eForwards;
187  }
188  else if (edge->m_n1 == m_vertex[edgeVerts[edgeId][1]])
189  {
190  return StdRegions::eBackwards;
191  }
192  else
193  {
194  ASSERTL1(false, "Edge is not connected to this hexahedron.");
195  }
196 
198 }
std::vector< NodeSharedPtr > m_vertex
List of element vertex nodes.
Definition: Element.h:386
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
virtual NEKMESHUTILS_EXPORT int Nektar::NekMeshUtils::Hexahedron::GetFaceVertex ( int  i,
int  j 
)
inlinevirtual

Returns the local index of vertex j of face i.

Reimplemented from Nektar::NekMeshUtils::Element.

Definition at line 89 of file Hexahedron.h.

References m_faceIds.

90  {
91  return m_faceIds[i][j];
92  }
static int m_faceIds[6][4]
Vertex IDs that make up hexahedron faces.
Definition: Hexahedron.h:95
SpatialDomains::GeometrySharedPtr Nektar::NekMeshUtils::Hexahedron::GetGeom ( int  coordDim)
virtual

Generate a Nektar++ geometry object for this element.

Reimplemented from Nektar::NekMeshUtils::Element.

Definition at line 162 of file Hexahedron.cpp.

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

163 {
166 
167  for (int i = 0; i < 6; ++i)
168  {
169  faces[i] = boost::dynamic_pointer_cast<SpatialDomains::QuadGeom>(
170  m_face[i]->GetGeom(coordDim));
171  }
172 
174 
175  return ret;
176 }
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
boost::shared_ptr< QuadGeom > QuadGeomSharedPtr
Definition: QuadGeom.h:54
boost::shared_ptr< HexGeom > HexGeomSharedPtr
Definition: HexGeom.h:110
std::vector< FaceSharedPtr > m_face
List of element faces.
Definition: Element.h:390
unsigned int Nektar::NekMeshUtils::Hexahedron::GetNumNodes ( ElmtConfig  pConf)
static

Return the number of nodes defining a hexahedron.

Definition at line 271 of file Hexahedron.cpp.

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

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

272 {
273  int n = pConf.m_order;
274  if (pConf.m_faceNodes && pConf.m_volumeNodes)
275  return (n + 1) * (n + 1) * (n + 1);
276  else if (pConf.m_faceNodes && !pConf.m_volumeNodes)
277  return 6 * (n + 1) * (n + 1) - 12 * (n + 1) + 8;
278  else
279  return 12 * (n + 1) - 16;
280 }
void Nektar::NekMeshUtils::Hexahedron::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
orderThe desired polynomial order.
geomThe geometry object used to describe the curvature mapping.
edgeTypeThe points distribution to use on the volume.
coordDimThe coordinate (i.e. space) dimension.
idCounter which should be incremented to supply consistent vertex IDs.
justConfigIf 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 200 of file Hexahedron.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().

206 {
207  m_curveType = pType;
208  m_conf.m_order = order;
209  m_volumeNodes.clear();
210 
211  if (order == 1)
212  {
214  return;
215  }
216 
217  m_conf.m_faceNodes = true;
218  m_conf.m_volumeNodes = true;
219 
220  if (justConfig)
221  {
222  return;
223  }
224 
225  int nPoints = order + 1;
226  StdRegions::StdExpansionSharedPtr xmap = geom->GetXmap();
227 
228  Array<OneD, NekDouble> px;
229  LibUtilities::PointsKey pKey(nPoints, pType);
230  ASSERTL1(pKey.GetPointsDim() == 1, "Points distribution must be 1D");
231  LibUtilities::PointsManager()[pKey]->GetPoints(px);
232 
233  Array<OneD, Array<OneD, NekDouble> > phys(coordDim);
234 
235  for (int i = 0; i < coordDim; ++i)
236  {
237  phys[i] = Array<OneD, NekDouble>(xmap->GetTotPoints());
238  xmap->BwdTrans(geom->GetCoeffs(i), phys[i]);
239  }
240 
241  int nHexIntPts = (nPoints - 2) * (nPoints - 2) * (nPoints - 2);
242  m_volumeNodes.resize(nHexIntPts);
243 
244  for (int i = 1, cnt = 0; i < nPoints-1; ++i)
245  {
246  for (int j = 1; j < nPoints-1; ++j)
247  {
248  for (int k = 1; k < nPoints-1; ++k, ++cnt)
249  {
250  Array<OneD, NekDouble> xp(3);
251  xp[0] = px[k];
252  xp[1] = px[j];
253  xp[2] = px[i];
254 
255  Array<OneD, NekDouble> x(3, 0.0);
256  for (int k = 0; k < coordDim; ++k)
257  {
258  x[k] = xmap->PhysEvaluate(xp, phys[k]);
259  }
260 
261  m_volumeNodes[cnt] = boost::shared_ptr<Node>(
262  new Node(id++, x[0], x[1], x[2]));
263  }
264  }
265  }
266 }
bool m_faceNodes
Denotes whether the element contains face nodes. For 2D elements, if this is true then the element co...
Definition: ElementConfig.h:80
ElmtConfig m_conf
Contains configuration of the element.
Definition: Element.h:380
unsigned int m_order
Order of the element.
Definition: ElementConfig.h:87
bool m_volumeNodes
Denotes whether the element contains volume (i.e. interior) nodes. These are not supported by either ...
Definition: ElementConfig.h:85
PointsManagerT & PointsManager(void)
std::vector< NodeSharedPtr > m_volumeNodes
List of element volume nodes.
Definition: Element.h:392
LibUtilities::PointsType m_curveType
Volume curve type.
Definition: Element.h:394
boost::shared_ptr< StdExpansion > StdExpansionSharedPtr
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228

Member Data Documentation

int Nektar::NekMeshUtils::Hexahedron::m_faceIds
staticprivate
Initial value:
= {
{0, 1, 2, 3}, {0, 1, 5, 4}, {1, 2, 6, 5},
{3, 2, 6, 7}, {0, 3, 7, 4}, {4, 5, 6, 7}
}

Vertex IDs that make up hexahedron faces.

Definition at line 95 of file Hexahedron.h.

Referenced by GetFaceVertex(), and Hexahedron().

LibUtilities::ShapeType Nektar::NekMeshUtils::Hexahedron::m_type
static
Initial value:

Element type.

Definition at line 62 of file Hexahedron.h.