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

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

#include <Quadrilateral.h>

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

Public Member Functions

NEKMESHUTILS_EXPORT Quadrilateral (ElmtConfig pConf, std::vector< NodeSharedPtr > pNodeList, std::vector< int > pTagList)
 Create a quadrilateral element. More...
 
NEKMESHUTILS_EXPORT Quadrilateral (const Quadrilateral &pSrc)
 
virtual NEKMESHUTILS_EXPORT ~Quadrilateral ()
 
virtual NEKMESHUTILS_EXPORT
SpatialDomains::GeometrySharedPtr 
GetGeom (int coordDim)
 Generate a Nektar++ geometry object for this element. More...
 
virtual NEKMESHUTILS_EXPORT void 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...
 
- 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...
 
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...
 
virtual NEKMESHUTILS_EXPORT int GetFaceVertex (int i, int j)
 Returns the local index of vertex j of face i. 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 quadrilateral. More...
 

Static Public Attributes

static LibUtilities::ShapeType m_type
 Element type. 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 2-dimensional four-sided element.

Definition at line 50 of file Quadrilateral.h.

Constructor & Destructor Documentation

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

Create a quadrilateral element.

Definition at line 55 of file Quadrilateral.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::ElmtConfig::m_faceNodes, Nektar::NekMeshUtils::ElmtConfig::m_order, Nektar::NekMeshUtils::ElmtConfig::m_reorient, Nektar::NekMeshUtils::Element::m_tag, Nektar::NekMeshUtils::Element::m_taglist, Nektar::NekMeshUtils::Element::m_vertex, and Nektar::NekMeshUtils::Element::m_volumeNodes.

Referenced by create().

58  : Element(pConf, GetNumNodes(pConf), pNodeList.size())
59 {
60  m_tag = "Q";
61  m_dim = 2;
62  m_taglist = pTagList;
63  int n = m_conf.m_order - 1;
64 
65  // Create a map to relate edge nodes to a pair of vertices
66  // defining an edge. This is based on the ordering produced by
67  // gmsh.
68  map<pair<int, int>, int> edgeNodeMap;
69  map<pair<int, int>, int>::iterator it;
70  edgeNodeMap[pair<int, int>(1, 2)] = 5;
71  edgeNodeMap[pair<int, int>(2, 3)] = 5 + n;
72  edgeNodeMap[pair<int, int>(3, 4)] = 5 + 2 * n;
73  edgeNodeMap[pair<int, int>(4, 1)] = 5 + 3 * n;
74 
75  // Add vertices. This logic will determine (in 2D) whether the
76  // element is clockwise (sum > 0) or counter-clockwise (sum < 0).
77  NekDouble sum = 0.0;
78  for (int i = 0; i < 4; ++i)
79  {
80  int o = (i + 1) % 4;
81  m_vertex.push_back(pNodeList[i]);
82  sum += (pNodeList[o]->m_x - pNodeList[i]->m_x) *
83  (pNodeList[o]->m_y + pNodeList[i]->m_y);
84  }
85 
86  // Create edges (with corresponding set of edge points)
87  for (it = edgeNodeMap.begin(); it != edgeNodeMap.end(); ++it)
88  {
89  vector<NodeSharedPtr> edgeNodes;
90  if (m_conf.m_order > 1)
91  {
92  for (int j = it->second; j < it->second + n; ++j)
93  {
94  edgeNodes.push_back(pNodeList[j - 1]);
95  }
96  }
97  m_edge.push_back(EdgeSharedPtr(new Edge(pNodeList[it->first.first - 1],
98  pNodeList[it->first.second - 1],
99  edgeNodes,
101  }
102 
103  if (pConf.m_reorient)
104  {
105  if (sum > 0.0)
106  {
107  reverse(m_edge.begin(), m_edge.end());
108  }
109  }
110 
111  if (m_conf.m_faceNodes)
112  {
113  m_volumeNodes.insert(m_volumeNodes.begin(),
114  pNodeList.begin() + 4 * m_conf.m_order,
115  pNodeList.end());
116  }
117 }
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 NEKMESHUTILS_EXPORT unsigned int GetNumNodes(ElmtConfig pConf)
Return the number of nodes defining a quadrilateral.
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
double NekDouble
std::vector< NodeSharedPtr > m_volumeNodes
List of element volume nodes.
Definition: Element.h:392
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
NEKMESHUTILS_EXPORT Nektar::NekMeshUtils::Quadrilateral::Quadrilateral ( const Quadrilateral pSrc)
virtual NEKMESHUTILS_EXPORT Nektar::NekMeshUtils::Quadrilateral::~Quadrilateral ( )
inlinevirtual

Definition at line 68 of file Quadrilateral.h.

69  {
70  }

Member Function Documentation

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

Creates an instance of this class.

Definition at line 54 of file Quadrilateral.h.

References Quadrilateral().

57  {
58  return boost::shared_ptr<Element>(
59  new Quadrilateral(pConf, pNodeList, pTagList));
60  }
NEKMESHUTILS_EXPORT Quadrilateral(ElmtConfig pConf, std::vector< NodeSharedPtr > pNodeList, std::vector< int > pTagList)
Create a quadrilateral element.
void Nektar::NekMeshUtils::Quadrilateral::GetCurvedNodes ( std::vector< NodeSharedPtr > &  nodeList) const
virtual

get list of volume interior nodes

Reimplemented from Nektar::NekMeshUtils::Element.

Definition at line 228 of file Quadrilateral.cpp.

References Nektar::NekMeshUtils::Element::m_edge, Nektar::NekMeshUtils::Element::m_vertex, and Nektar::NekMeshUtils::Element::m_volumeNodes.

229 {
230  int n = m_edge[0]->GetNodeCount();
231  nodeList.resize(n * n);
232 
233  // Write vertices
234  nodeList[0] = m_vertex[0];
235  nodeList[n - 1] = m_vertex[1];
236  nodeList[n * n - 1] = m_vertex[2];
237  nodeList[n * (n - 1)] = m_vertex[3];
238 
239  // Write edge-interior
240  int skips[4][2] = {
241  {0, 1}, {n - 1, n}, {n * n - 1, -1}, {n * (n - 1), -n}};
242  for (int i = 0; i < 4; ++i)
243  {
244  bool reverseEdge = m_edge[i]->m_n1 == m_vertex[i];
245 
246  if (!reverseEdge)
247  {
248  for (int j = 1; j < n - 1; ++j)
249  {
250  nodeList[skips[i][0] + j * skips[i][1]] =
251  m_edge[i]->m_edgeNodes[n - 2 - j];
252  }
253  }
254  else
255  {
256  for (int j = 1; j < n - 1; ++j)
257  {
258  nodeList[skips[i][0] + j * skips[i][1]] =
259  m_edge[i]->m_edgeNodes[j - 1];
260  }
261  }
262  }
263 
264  // Write interior
265  for (int i = 1; i < n - 1; ++i)
266  {
267  for (int j = 1; j < n - 1; ++j)
268  {
269  nodeList[i * n + j] =
270  m_volumeNodes[(i - 1) * (n - 2) + (j - 1)];
271  }
272  }
273 }
std::vector< NodeSharedPtr > m_vertex
List of element vertex nodes.
Definition: Element.h:386
std::vector< EdgeSharedPtr > m_edge
List of element edges.
Definition: Element.h:388
std::vector< NodeSharedPtr > m_volumeNodes
List of element volume nodes.
Definition: Element.h:392
StdRegions::Orientation Nektar::NekMeshUtils::Quadrilateral::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 119 of file Quadrilateral.cpp.

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

121 {
122  int locVert = edgeId;
123  if (edge->m_n1 == m_vertex[locVert])
124  {
125  return StdRegions::eForwards;
126  }
127  else if (edge->m_n2 == m_vertex[locVert])
128  {
129  return StdRegions::eBackwards;
130  }
131  else
132  {
133  ASSERTL1(false, "Edge is not connected to this quadrilateral.");
134  }
135 
137 }
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
SpatialDomains::GeometrySharedPtr Nektar::NekMeshUtils::Quadrilateral::GetGeom ( int  coordDim)
virtual

Generate a Nektar++ geometry object for this element.

Reimplemented from Nektar::NekMeshUtils::Element.

Definition at line 204 of file Quadrilateral.cpp.

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

205 {
209 
210  for (int i = 0; i < 4; ++i)
211  {
212  edges[i] = m_edge[i]->GetGeom(coordDim);
213  verts[i] = m_vertex[i]->GetGeom(coordDim);
214  }
215 
216  StdRegions::Orientation edgeorient[4] = {
217  SpatialDomains::SegGeom::GetEdgeOrientation(*edges[0], *edges[1]),
218  SpatialDomains::SegGeom::GetEdgeOrientation(*edges[1], *edges[2]),
219  SpatialDomains::SegGeom::GetEdgeOrientation(*edges[2], *edges[3]),
220  SpatialDomains::SegGeom::GetEdgeOrientation(*edges[3], *edges[0])};
221 
223  m_id, verts, edges, edgeorient);
224 
225  return ret;
226 }
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
boost::shared_ptr< QuadGeom > QuadGeomSharedPtr
Definition: QuadGeom.h:54
static StdRegions::Orientation GetEdgeOrientation(const SegGeom &edge1, const SegGeom &edge2)
Get the orientation of edge1.
Definition: SegGeom.cpp:293
std::vector< NodeSharedPtr > m_vertex
List of element vertex nodes.
Definition: Element.h:386
boost::shared_ptr< SegGeom > SegGeomSharedPtr
Definition: Geometry2D.h:60
std::vector< EdgeSharedPtr > m_edge
List of element edges.
Definition: Element.h:388
unsigned int m_id
ID of the element.
Definition: Element.h:376
boost::shared_ptr< PointGeom > PointGeomSharedPtr
Definition: Geometry.h:60
unsigned int Nektar::NekMeshUtils::Quadrilateral::GetNumNodes ( ElmtConfig  pConf)
static

Return the number of nodes defining a quadrilateral.

Definition at line 279 of file Quadrilateral.cpp.

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

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

280 {
281  int n = pConf.m_order;
282  if (!pConf.m_faceNodes)
283  return 4 * n;
284  else
285  return (n + 1) * (n + 1);
286 }
void Nektar::NekMeshUtils::Quadrilateral::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 139 of file Quadrilateral.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().

145 {
146  m_conf.m_order = order;
147  m_curveType = pType;
148  m_conf.m_volumeNodes = false;
149  m_volumeNodes.clear();
150 
151  // Quadrilaterals of order == 1 have no interior volume points.
152  if (order == 1)
153  {
154  m_conf.m_faceNodes = false;
155  return;
156  }
157 
158  m_conf.m_faceNodes = true;
159 
160  if (justConfig)
161  {
162  return;
163  }
164 
165  int nPoints = order + 1;
166  StdRegions::StdExpansionSharedPtr xmap = geom->GetXmap();
167 
168  Array<OneD, NekDouble> px;
169  LibUtilities::PointsKey pKey(nPoints, pType);
170  ASSERTL1(pKey.GetPointsDim() == 1, "Points distribution must be 1D");
171  LibUtilities::PointsManager()[pKey]->GetPoints(px);
172 
173  Array<OneD, Array<OneD, NekDouble> > phys(coordDim);
174 
175  for (int i = 0; i < coordDim; ++i)
176  {
177  phys[i] = Array<OneD, NekDouble>(xmap->GetTotPoints());
178  xmap->BwdTrans(geom->GetCoeffs(i), phys[i]);
179  }
180 
181  int nQuadIntPts = (nPoints - 2) * (nPoints - 2);
182  m_volumeNodes.resize(nQuadIntPts);
183 
184  for (int i = 1, cnt = 0; i < nPoints-1; ++i)
185  {
186  for (int j = 1; j < nPoints-1; ++j, ++cnt)
187  {
188  Array<OneD, NekDouble> xp(2);
189  xp[0] = px[j];
190  xp[1] = px[i];
191 
192  Array<OneD, NekDouble> x(3, 0.0);
193  for (int k = 0; k < coordDim; ++k)
194  {
195  x[k] = xmap->PhysEvaluate(xp, phys[k]);
196  }
197 
198  m_volumeNodes[cnt] = boost::shared_ptr<Node>(
199  new Node(id++, x[0], x[1], x[2]));
200  }
201  }
202 }
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

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

Element type.

Definition at line 62 of file Quadrilateral.h.