Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
Prism.cpp
Go to the documentation of this file.
1 ////////////////////////////////////////////////////////////////////////////////
2 //
3 // File: Prism.cpp
4 //
5 // For more information, please see: http://www.nektar.info/
6 //
7 // The MIT License
8 //
9 // Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
10 // Department of Aeronautics, Imperial College London (UK), and Scientific
11 // Computing and Imaging Institute, University of Utah (USA).
12 //
13 // License for the specific language governing rights and limitations under
14 // Permission is hereby granted, free of charge, to any person obtaining a
15 // copy of this software and associated documentation files (the "Software"),
16 // to deal in the Software without restriction, including without limitation
17 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
18 // and/or sell copies of the Software, and to permit persons to whom the
19 // Software is furnished to do so, subject to the following conditions:
20 //
21 // The above copyright notice and this permission notice shall be included
22 // in all copies or substantial portions of the Software.
23 //
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
25 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
30 // DEALINGS IN THE SOFTWARE.
31 //
32 // Description: Mesh prism object.
33 //
34 ////////////////////////////////////////////////////////////////////////////////
35 
37 #include <LocalRegions/PrismExp.h>
39 
42 
44 
45 using namespace std;
46 
47 namespace Nektar
48 {
49 namespace NekMeshUtils
50 {
51 
52 LibUtilities::ShapeType Prism::m_type =
54  LibUtilities::ePrism, Prism::create, "Prism");
55 
56 /// Vertex IDs that make up prism faces.
57 int Prism::m_faceIds[5][4] = {
58  {0, 1, 2, 3}, {0, 1, 4, -1}, {1, 2, 5, 4}, {3, 2, 5, -1}, {0, 3, 5, 4}
59 };
60 
61 /**
62  * @brief Create a prism element.
63  */
64 Prism::Prism(ElmtConfig pConf,
65  vector<NodeSharedPtr> pNodeList,
66  vector<int> pTagList)
67  : Element(pConf, GetNumNodes(pConf), pNodeList.size())
68 {
69  m_tag = "R";
70  m_dim = 3;
71  m_taglist = pTagList;
72  int n = m_conf.m_order - 1;
73 
74  // Create a map to relate edge nodes to a pair of vertices
75  // defining an edge. This is based on the ordering produced by
76  // gmsh.
77  map<pair<int, int>, int> edgeNodeMap;
78  map<pair<int, int>, int>::iterator it;
79 
80  // This edge-node map is based on Nektar++ ordering.
81  edgeNodeMap[pair<int, int>(1, 2)] = 7;
82  edgeNodeMap[pair<int, int>(2, 3)] = 7 + n;
83  edgeNodeMap[pair<int, int>(4, 3)] = 7 + 2 * n;
84  edgeNodeMap[pair<int, int>(1, 4)] = 7 + 3 * n;
85  edgeNodeMap[pair<int, int>(1, 5)] = 7 + 4 * n;
86  edgeNodeMap[pair<int, int>(2, 5)] = 7 + 5 * n;
87  edgeNodeMap[pair<int, int>(3, 6)] = 7 + 6 * n;
88  edgeNodeMap[pair<int, int>(4, 6)] = 7 + 7 * n;
89  edgeNodeMap[pair<int, int>(5, 6)] = 7 + 8 * n;
90 
91  // Add vertices
92  for (int i = 0; i < 6; ++i)
93  {
94  m_vertex.push_back(pNodeList[i]);
95  }
96 
97  int eid = 0;
98  // Create edges (with corresponding set of edge points)
99  for (it = edgeNodeMap.begin(); it != edgeNodeMap.end(); ++it)
100  {
101  vector<NodeSharedPtr> edgeNodes;
102  if (m_conf.m_order > 1)
103  {
104  for (int j = it->second; j < it->second + n; ++j)
105  {
106  edgeNodes.push_back(pNodeList[j - 1]);
107  }
108  }
109  m_edge.push_back(EdgeSharedPtr(new Edge(pNodeList[it->first.first - 1],
110  pNodeList[it->first.second - 1],
111  edgeNodes,
113  m_edge.back()->m_id = eid++;
114  }
115 
116  if (m_conf.m_reorient)
117  {
118  OrientPrism();
119  }
120  else
121  {
122  m_orientation = 0;
123  }
124 
125  // Create faces
126  int face_edges[5][4];
127 
128  int face_offset[5];
129  face_offset[0] = 6 + 9 * n;
130  for (int j = 0; j < 4; ++j)
131  {
132  int facenodes = j % 2 == 0 ? n * n : n * (n - 1) / 2;
133  face_offset[j + 1] = face_offset[j] + facenodes;
134  }
135 
136  for (int j = 0; j < 5; ++j)
137  {
138  vector<NodeSharedPtr> faceVertices;
139  vector<EdgeSharedPtr> faceEdges;
140  vector<NodeSharedPtr> faceNodes;
141  int nEdge = 3 - (j % 2 - 1);
142 
143  for (int k = 0; k < nEdge; ++k)
144  {
145  faceVertices.push_back(m_vertex[m_faceIds[j][k]]);
146  NodeSharedPtr a = m_vertex[m_faceIds[j][k]];
147  NodeSharedPtr b = m_vertex[m_faceIds[j][(k + 1) % nEdge]];
148  unsigned int i;
149  for (i = 0; i < m_edge.size(); ++i)
150  {
151  if ((m_edge[i]->m_n1->m_id == a->m_id &&
152  m_edge[i]->m_n2->m_id == b->m_id) ||
153  (m_edge[i]->m_n1->m_id == b->m_id &&
154  m_edge[i]->m_n2->m_id == a->m_id))
155  {
156  faceEdges.push_back(m_edge[i]);
157  face_edges[j][k] = i;
158  break;
159  }
160  }
161 
162  if (i == m_edge.size())
163  {
164  face_edges[j][k] = -1;
165  }
166  }
167 
168  if (m_conf.m_faceNodes)
169  {
170  int face = j, facenodes;
171 
172  if (j % 2 == 0)
173  {
174  facenodes = n * n;
175  if (m_orientation == 1)
176  {
177  face = (face + 4) % 6;
178  }
179  else if (m_orientation == 2)
180  {
181  face = (face + 2) % 6;
182  }
183  }
184  else
185  {
186  // TODO: need to rotate these too.
187  facenodes = n * (n - 1) / 2;
188  }
189 
190  for (int i = 0; i < facenodes; ++i)
191  {
192  faceNodes.push_back(pNodeList[face_offset[face] + i]);
193  }
194  }
195 
196  // Try to translate between common face curve types
198 
199  if (pType == LibUtilities::ePolyEvenlySpaced && (j == 1 || j == 3))
200  {
202  }
203 
204  m_face.push_back(
205  FaceSharedPtr(new Face(faceVertices, faceNodes, faceEdges, pType)));
206  }
207 
208  // Re-order edge array to be consistent with Nektar++ ordering.
209  vector<EdgeSharedPtr> tmp(9);
210  ASSERTL1(face_edges[0][0] != -1, "face_edges[0][0] == -1");
211  tmp[0] = m_edge[face_edges[0][0]];
212  ASSERTL1(face_edges[0][1] != -1, "face_edges[0][1] == -1");
213  tmp[1] = m_edge[face_edges[0][1]];
214  ASSERTL1(face_edges[0][2] != -1, "face_edges[0][2] == -1");
215  tmp[2] = m_edge[face_edges[0][2]];
216  ASSERTL1(face_edges[0][3] != -1, "face_edges[0][3] == -1");
217  tmp[3] = m_edge[face_edges[0][3]];
218  ASSERTL1(face_edges[1][2] != -1, "face_edges[1][2] == -1");
219  tmp[4] = m_edge[face_edges[1][2]];
220  ASSERTL1(face_edges[1][1] != -1, "face_edges[1][1] == -1");
221  tmp[5] = m_edge[face_edges[1][1]];
222  ASSERTL1(face_edges[2][1] != -1, "face_edges[2][1] == -1");
223  tmp[6] = m_edge[face_edges[2][1]];
224  ASSERTL1(face_edges[3][2] != -1, "face_edges[3][2] == -1");
225  tmp[7] = m_edge[face_edges[3][2]];
226  ASSERTL1(face_edges[4][2] != -1, "face_edges[4][2] == -1");
227  tmp[8] = m_edge[face_edges[4][2]];
228  m_edge = tmp;
229 }
230 
231 /**
232  * @brief Return the number of nodes defining a prism.
233  */
234 unsigned int Prism::GetNumNodes(ElmtConfig pConf)
235 {
236  int n = pConf.m_order;
237  if (pConf.m_faceNodes && pConf.m_volumeNodes)
238  return (n + 1) * (n + 1) * (n + 2) / 2;
239  else if (pConf.m_faceNodes && !pConf.m_volumeNodes)
240  return 3 * (n + 1) * (n + 1) + 2 * (n + 1) * (n + 2) / 2 - 9 * (n + 1) +
241  6;
242  else
243  return 9 * (n + 1) - 12;
244 }
245 
247 {
250 
251  for (int i = 0; i < 5; ++i)
252  {
253  faces[i] = m_face[i]->GetGeom(coordDim);
254  }
255 
257 
258  return ret;
259 }
260 
262  int edgeId, EdgeSharedPtr edge)
263 {
264  static int edgeVerts[9][2] = {
265  {0,1}, {1,2}, {3,2}, {0,3}, {0,4}, {1,4}, {2,5}, {3,5}, {4,5}
266  };
267 
268  if (edge->m_n1 == m_vertex[edgeVerts[edgeId][0]])
269  {
270  return StdRegions::eForwards;
271  }
272  else if (edge->m_n1 == m_vertex[edgeVerts[edgeId][1]])
273  {
274  return StdRegions::eBackwards;
275  }
276  else
277  {
278  ASSERTL1(false, "Edge is not connected to this quadrilateral.");
279  }
280 
282 }
283 
284 void Prism::MakeOrder(int order,
287  int coordDim,
288  int &id,
289  bool justConfig)
290 {
291  m_conf.m_order = order;
292  m_curveType = pType;
293  m_volumeNodes.clear();
294 
295  if (order == 1)
296  {
298  return;
299  }
300  else if (order == 2)
301  {
302  m_conf.m_faceNodes = true;
303  m_conf.m_volumeNodes = false;
304  return;
305  }
306 
307  m_conf.m_faceNodes = true;
308  m_conf.m_volumeNodes = true;
309 
310  if (justConfig)
311  {
312  return;
313  }
314 
315  int nPoints = order + 1;
316  StdRegions::StdExpansionSharedPtr xmap = geom->GetXmap();
317 
318  Array<OneD, NekDouble> px, py, pz;
319  LibUtilities::PointsKey pKey(nPoints, pType);
320  ASSERTL1(pKey.GetPointsDim() == 3, "Points distribution must be 3D");
321  LibUtilities::PointsManager()[pKey]->GetPoints(px, py, pz);
322 
323  Array<OneD, Array<OneD, NekDouble> > phys(coordDim);
324 
325  for (int i = 0; i < coordDim; ++i)
326  {
327  phys[i] = Array<OneD, NekDouble>(xmap->GetTotPoints());
328  xmap->BwdTrans(geom->GetCoeffs(i), phys[i]);
329  }
330 
331  const int nPrismPts = nPoints * nPoints * (nPoints + 1) / 2;
332  const int nPrismIntPts = (nPoints - 2) * (nPoints - 3) * (nPoints - 2) / 2;
333  m_volumeNodes.resize(nPrismIntPts);
334 
335  for (int i = nPrismPts - nPrismIntPts, cnt = 0; i < nPrismPts; ++i, ++cnt)
336  {
338  xp[0] = px[i];
339  xp[1] = py[i];
340  xp[2] = pz[i];
341 
342  Array<OneD, NekDouble> x(3, 0.0);
343  for (int j = 0; j < coordDim; ++j)
344  {
345  x[j] = xmap->PhysEvaluate(xp, phys[j]);
346  }
347 
348  m_volumeNodes[cnt] = boost::shared_ptr<Node>(
349  new Node(id++, x[0], x[1], x[2]));
350  }
351 }
352 
353 void Prism::GetCurvedNodes(std::vector<NodeSharedPtr> &nodeList) const
354 {
355  int n = m_edge[0]->GetNodeCount();
356  nodeList.resize(n*n*(n+1)/2);
357 
358  nodeList[0] = m_vertex[0];
359  nodeList[1] = m_vertex[1];
360  nodeList[2] = m_vertex[2];
361  nodeList[3] = m_vertex[3];
362  nodeList[4] = m_vertex[4];
363  nodeList[5] = m_vertex[5];
364  int k = 6;
365 
366  for(int i = 0; i < 4; i++)
367  {
368  bool reverseEdge = m_edge[i]->m_n1 == m_vertex[i];
369  if (reverseEdge)
370  {
371  for(int j = 0; j < n-2; j++)
372  {
373  nodeList[k++] = m_edge[i]->m_edgeNodes[j];
374  }
375  }
376  else
377  {
378  for(int j = n-3; j >= 0; j--)
379  {
380  nodeList[k++] = m_edge[i]->m_edgeNodes[j];
381  }
382  }
383  }
384 
385  for(int i = 4; i < 8; i++)
386  {
387  bool reverseEdge = m_edge[i]->m_n1 == m_vertex[i-4];
388  if (reverseEdge)
389  {
390  for(int j = 0; j < n-2; j++)
391  {
392  nodeList[k++] = m_edge[i]->m_edgeNodes[j];
393  }
394  }
395  else
396  {
397  for(int j = n-3; j >= 0; j--)
398  {
399  nodeList[k++] = m_edge[i]->m_edgeNodes[j];
400  }
401  }
402  }
403  bool reverseEdge = m_edge[8]->m_n1 == m_vertex[4];
404  if (reverseEdge)
405  {
406  for(int j = 0; j < n-2; j++)
407  {
408  nodeList[k++] = m_edge[8]->m_edgeNodes[j];
409  }
410  }
411  else
412  {
413  for(int j = n-3; j >= 0; j--)
414  {
415  nodeList[k++] = m_edge[8]->m_edgeNodes[j];
416  }
417  }
418 
419  vector<vector<int> > ts;
420  {
421  vector<int> t(4);
422  t[0] = m_vertex[0]->m_id;
423  t[1] = m_vertex[1]->m_id;
424  t[2] = m_vertex[2]->m_id;
425  t[3] = m_vertex[3]->m_id;
426  ts.push_back(t);
427  }
428  {
429  vector<int> t(3);
430  t[0] = m_vertex[0]->m_id;
431  t[1] = m_vertex[1]->m_id;
432  t[2] = m_vertex[4]->m_id;
433  ts.push_back(t);
434  }
435  {
436  vector<int> t(4);
437  t[0] = m_vertex[1]->m_id;
438  t[1] = m_vertex[2]->m_id;
439  t[2] = m_vertex[5]->m_id;
440  t[3] = m_vertex[4]->m_id;
441  ts.push_back(t);
442  }
443  {
444  vector<int> t(3);
445  t[0] = m_vertex[3]->m_id;
446  t[1] = m_vertex[2]->m_id;
447  t[2] = m_vertex[5]->m_id;
448  ts.push_back(t);
449  }
450  {
451  vector<int> t(4);
452  t[0] = m_vertex[0]->m_id;
453  t[1] = m_vertex[3]->m_id;
454  t[2] = m_vertex[5]->m_id;
455  t[3] = m_vertex[4]->m_id;
456  ts.push_back(t);
457  }
458 
459  for(int i = 0; i < ts.size(); i++)
460  {
461  if(ts[i].size() == 3)
462  {
463  vector<int> fcid;
464  fcid.push_back(m_face[i]->m_vertexList[0]->m_id);
465  fcid.push_back(m_face[i]->m_vertexList[1]->m_id);
466  fcid.push_back(m_face[i]->m_vertexList[2]->m_id);
467 
468  HOTriangle<NodeSharedPtr> hot(fcid, m_face[i]->m_faceNodes);
469 
470  hot.Align(ts[i]);
471 
472  std::copy(hot.surfVerts.begin(),
473  hot.surfVerts.end(),
474  nodeList.begin() + k);
475  k+= hot.surfVerts.size();
476  }
477  else
478  {
479  vector<int> fcid;
480  fcid.push_back(m_face[i]->m_vertexList[0]->m_id);
481  fcid.push_back(m_face[i]->m_vertexList[1]->m_id);
482  fcid.push_back(m_face[i]->m_vertexList[2]->m_id);
483  fcid.push_back(m_face[i]->m_vertexList[3]->m_id);
484 
485  HOQuadrilateral<NodeSharedPtr> hoq(fcid, m_face[i]->m_faceNodes);
486 
487  hoq.Align(ts[i]);
488 
489  std::copy(hoq.surfVerts.begin(),
490  hoq.surfVerts.end(),
491  nodeList.begin() + k);
492  k+= hoq.surfVerts.size();
493  }
494  }
495 
496  std::copy(m_volumeNodes.begin(),
497  m_volumeNodes.end(),
498  nodeList.begin() + k);
499 }
500 
501 /**
502  * @brief Orient prism to align degenerate vertices.
503  *
504  * Orientation of prismatric elements is required so that the singular
505  * vertices of triangular faces (which occur as a part of the
506  * collapsed co-ordinate system) align. The algorithm is based on that
507  * used in T. Warburton's thesis and in the original Nektar source.
508  *
509  * First the points are re-ordered so that the highest global IDs
510  * represent the two singular points of the prism. Then, if necessary,
511  * the nodes are rotated either clockwise or counter-clockwise (w.r.t
512  * to the p-r plane) to correctly align the prism. The #orientation
513  * variable is set to:
514  *
515  * - 0 if the prism is not rotated;
516  * - 1 if the prism is rotated clockwise;
517  * - 2 if the prism is rotated counter-clockwise.
518  *
519  * This is necessary for some input modules (e.g. #InputNek) which add
520  * high-order information or bounary conditions to faces.
521  */
523 {
524  int lid[6], gid[6];
525 
526  // Re-order vertices.
527  for (int i = 0; i < 6; ++i)
528  {
529  lid[i] = i;
530  gid[i] = m_vertex[i]->m_id;
531  }
532 
533  gid[0] = gid[3] = max(gid[0], gid[3]);
534  gid[1] = gid[2] = max(gid[1], gid[2]);
535  gid[4] = gid[5] = max(gid[4], gid[5]);
536 
537  for (int i = 1; i < 6; ++i)
538  {
539  if (gid[0] < gid[i])
540  {
541  swap(gid[i], gid[0]);
542  swap(lid[i], lid[0]);
543  }
544  }
545 
546  if (lid[0] == 4 || lid[0] == 5)
547  {
548  m_orientation = 0;
549  }
550  else if (lid[0] == 1 || lid[0] == 2)
551  {
552  // Rotate prism clockwise in p-r plane
553  vector<NodeSharedPtr> vertexmap(6);
554  vertexmap[0] = m_vertex[4];
555  vertexmap[1] = m_vertex[0];
556  vertexmap[2] = m_vertex[3];
557  vertexmap[3] = m_vertex[5];
558  vertexmap[4] = m_vertex[1];
559  vertexmap[5] = m_vertex[2];
560  m_vertex = vertexmap;
561  m_orientation = 1;
562  }
563  else if (lid[0] == 0 || lid[0] == 3)
564  {
565  // Rotate prism counter-clockwise in p-r plane
566  vector<NodeSharedPtr> vertexmap(6);
567  vertexmap[0] = m_vertex[1];
568  vertexmap[1] = m_vertex[4];
569  vertexmap[2] = m_vertex[5];
570  vertexmap[3] = m_vertex[2];
571  vertexmap[4] = m_vertex[0];
572  vertexmap[5] = m_vertex[3];
573  m_vertex = vertexmap;
574  m_orientation = 2;
575  }
576  else
577  {
578  cerr << "Warning: possible prism orientation problem." << endl;
579  }
580 }
581 }
582 }
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
Basic information about an element.
Definition: ElementConfig.h:50
LibUtilities::PointsType m_faceCurveType
Distribution of points in faces.
Definition: ElementConfig.h:94
Represents an edge which joins two points.
Definition: Edge.h:58
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
void Align(std::vector< int > vertId)
Align this surface to a given vertex ID.
Definition: HOAlignment.h:135
unsigned int m_orientation
Definition: Prism.h:96
std::vector< T > surfVerts
The quadrilateral surface vertices – templated so that this can either be nodes or IDs...
Definition: HOAlignment.h:231
Represents a face comprised of three or more edges.
Definition: Face.h:61
static int m_faceIds[5][4]
Vertex IDs that make up prism faces.
Definition: Prism.h:102
STL namespace.
std::vector< T > surfVerts
The triangle surface vertices – templated so that this can either be nodes or IDs.
Definition: HOAlignment.h:65
virtual NEKMESHUTILS_EXPORT SpatialDomains::GeometrySharedPtr GetGeom(int coordDim)
Generate a Nektar++ geometry object for this element.
Definition: Prism.cpp:246
ElementFactory & GetElementFactory()
Definition: Element.cpp:47
ElmtConfig m_conf
Contains configuration of the element.
Definition: Element.h:380
void OrientPrism()
Orient prism to align degenerate vertices.
Definition: Prism.cpp:522
virtual NEKMESHUTILS_EXPORT void GetCurvedNodes(std::vector< NodeSharedPtr > &nodeList) const
get list of volume interior nodes
Definition: Prism.cpp:353
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
1D Evenly-spaced points using Lagrange polynomial
Definition: PointsType.h:65
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...
Definition: Prism.cpp:261
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
static NEKMESHUTILS_EXPORT unsigned int GetNumNodes(ElmtConfig pConf)
Return the number of nodes defining a prism.
Definition: Prism.cpp:234
bool m_volumeNodes
Denotes whether the element contains volume (i.e. interior) nodes. These are not supported by either ...
Definition: ElementConfig.h:85
std::vector< EdgeSharedPtr > m_edge
List of element edges.
Definition: Element.h:388
unsigned int GetPointsDim() const
Definition: Points.h:149
boost::shared_ptr< Node > NodeSharedPtr
Definition: Node.h:50
PointsManagerT & PointsManager(void)
Defines a specification for a set of points.
Definition: Points.h:58
std::vector< NodeSharedPtr > m_volumeNodes
List of element volume nodes.
Definition: Element.h:392
void Align(std::vector< int > vertId)
Align this surface to a given vertex ID.
Definition: HOAlignment.h:277
A lightweight struct for dealing with high-order triangle alignment.
Definition: HOAlignment.h:50
std::string m_tag
Tag character describing the element.
Definition: Element.h:382
boost::shared_ptr< Geometry2D > Geometry2DSharedPtr
Definition: Geometry2D.h:59
boost::shared_ptr< Edge > EdgeSharedPtr
Shared pointer to an edge.
Definition: Edge.h:135
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
A lightweight struct for dealing with high-order quadrilateral alignment.
Definition: HOAlignment.h:215
unsigned int m_id
ID of the element.
Definition: Element.h:376
boost::shared_ptr< PrismGeom > PrismGeomSharedPtr
Definition: PrismGeom.h:109
LibUtilities::PointsType m_curveType
Volume curve type.
Definition: Element.h:394
std::vector< FaceSharedPtr > m_face
List of element faces.
Definition: Element.h:390
bool m_reorient
Denotes whether the element needs to be re-orientated for a spectral element framework.
Definition: ElementConfig.h:90
2D Evenly-spaced points on a Triangle
Definition: PointsType.h:72
boost::shared_ptr< Face > FaceSharedPtr
Definition: Face.h:148
boost::shared_ptr< StdExpansion > StdExpansionSharedPtr
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 representa...
Definition: Prism.cpp:284
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
boost::shared_ptr< Geometry > GeometrySharedPtr
Definition: Geometry.h:53
Base class for element definitions.
Definition: Element.h:59
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, tDescription pDesc="")
Register a class with the factory.
Definition: NekFactory.hpp:215