Intrepid2
Intrepid2_CellTopologyTags.hpp
Go to the documentation of this file.
1 // @HEADER
2 // ************************************************************************
3 //
4 // Intrepid2 Package
5 // Copyright (2007) Sandia Corporation
6 //
7 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8 // license for use of this work by or on behalf of the U.S. Government.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // Questions? Contact Kyungjoo Kim (kyukim@sandia.gov), or
38 // Mauro Perego (mperego@sandia.gov)
39 //
40 // ************************************************************************
41 // @HEADER
42 
66 #ifndef __INTREPID2_CELLTOPOLOGYTAGS_HPP__
67 #define __INTREPID2_CELLTOPOLOGYTAGS_HPP__
68 
69 #include "Intrepid2_ConfigDefs.hpp"
70 
71 //#include "Intrepid2_Types.hpp"
72 #include "Intrepid2_Utils.hpp"
73 //#include "Intrepid2_Kernels.hpp"
74 
75 namespace Intrepid2 {
76 
77  namespace Impl {
78 
79 
80  // ---------------------------------------------------------------------------------------
81 
82  template<int N>
83  struct Line;
84 
88  template<>
89  struct Line<2> {
90  typedef struct Line<2> base_cell_topology_type;
91  enum : int { dimension = 1,
92  numNode = 2,
93  numVert = 2,
94  numEdge = 0,
95  numFace = 0,
96  numIntr = 1 };
97  static constexpr double coords[2][3]{ {-1.0, 0.0, 0.0}, { 1.0, 0.0, 0.0} };
98 
99  // base topology has this check method
100  template<typename PointViewType>
101  KOKKOS_INLINE_FUNCTION
102  static bool
103  checkPointInclusion(const PointViewType &point,
104  const double threshold) {
105  const double minus_one = -1.0 - threshold, plus_one = 1.0 + threshold;
106  return (minus_one <= point(0) && point(0) <= plus_one);
107  }
108  };
109 
113  template<>
114  struct Line<3> {
115  typedef struct Line<2> base_cell_topology_type;
116  enum : int { dimension = 1,
117  numNode = 3,
118  numVert = 2,
119  numEdge = 0,
120  numFace = 0,
121  numIntr = 1 };
122  static constexpr double coords[3][3]{ {-1.0, 0.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 0.0, 0.0} };
123 
124  template<typename PointViewType>
125  KOKKOS_INLINE_FUNCTION
126  static bool
127  checkPointInclusion(const PointViewType &point,
128  const double threshold) {
129  return base_cell_topology_type::checkPointInclusion(point, threshold);
130  }
131  };
132 
133  // ---------------------------------------------------------------------------------------
134 
135  template<int N>
136  struct Triangle;
137 
141  template<>
142  struct Triangle<3> {
143  typedef struct Triangle<3> base_cell_topology_type;
144  enum : int { dimension = 2,
145  numNode = 3,
146  numVert = 3,
147  numEdge = 3,
148  numFace = 0,
149  numIntr = 1 };
150  static constexpr double coords[3][3]{ { 0.0, 0.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 1.0, 0.0} };
151 
152  template<typename PointViewType>
153  KOKKOS_INLINE_FUNCTION
154  static bool
155  checkPointInclusion(const PointViewType &point,
156  const double threshold) {
157  const double distance = max( max( -point(0), -point(1) ), point(0) + point(1) - 1.0 );
158  return distance < threshold;
159  }
160  };
161 
165  template<>
166  struct Triangle<4> {
167  typedef struct Triangle<3> base_cell_topology_type;
168  enum : int { dimension = 2,
169  numNode = 4,
170  numVert = 3,
171  numEdge = 3,
172  numFace = 0,
173  numIntr = 1 };
174  static constexpr double coords[4][3]{ { 0.0, 0.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 1.0, 0.0}, { 1.0/3.0, 1.0/3.0, 0.0} };
175 
176  template<typename PointViewType>
177  KOKKOS_INLINE_FUNCTION
178  static bool
179  checkPointInclusion(const PointViewType &point,
180  const double threshold) {
181  return base_cell_topology_type::checkPointInclusion(point, threshold);
182  }
183  };
184 
188  template<>
189  struct Triangle<6> {
190  typedef struct Triangle<3> base_cell_topology_type;
191  enum : int { dimension = 2,
192  numNode = 6,
193  numVert = 3,
194  numEdge = 3,
195  numFace = 0,
196  numIntr = 1 };
197  static constexpr double coords[6][3]{ { 0.0, 0.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 1.0, 0.0},
198  { 0.5, 0.0, 0.0}, { 0.5, 0.5, 0.0}, { 0.0, 0.5, 0.0} };
199 
200  template<typename PointViewType>
201  KOKKOS_INLINE_FUNCTION
202  static bool
203  checkPointInclusion(const PointViewType &point,
204  const double threshold) {
205  return base_cell_topology_type::checkPointInclusion(point, threshold);
206  }
207  };
208 
209  // ---------------------------------------------------------------------------------------
210 
211  template<int N>
212  struct Quadrilateral;
213 
217  template<>
218  struct Quadrilateral<4> {
219  typedef struct Quadrilateral<4> base_cell_topology_type;
220  enum : int { dimension = 2,
221  numNode = 4,
222  numVert = 4,
223  numEdge = 4,
224  numFace = 0,
225  numIntr = 1 };
226  static constexpr double coords[4][3]{ {-1.0,-1.0, 0.0}, { 1.0,-1.0, 0.0}, { 1.0, 1.0, 0.0}, {-1.0, 1.0, 0.0} };
227 
228  template<typename PointViewType>
229  KOKKOS_INLINE_FUNCTION
230  static bool
231  checkPointInclusion(const PointViewType &point,
232  const double threshold) {
233  const double minus_one = -1.0 - threshold, plus_one = 1.0 + threshold;
234  return ((minus_one <= point(0) && point(0) <= plus_one) &&
235  (minus_one <= point(1) && point(1) <= plus_one));
236  }
237  };
238 
242  template<>
243  struct Quadrilateral<8> {
244  typedef struct Quadrilateral<4> base_cell_topology_type;
245  enum : int { dimension = 2,
246  numNode = 8,
247  numVert = 4,
248  numEdge = 4,
249  numFace = 0,
250  numIntr = 1 };
251  static constexpr double coords[8][3]{ {-1.0,-1.0, 0.0}, { 1.0,-1.0, 0.0}, { 1.0, 1.0, 0.0}, {-1.0, 1.0, 0.0},
252  { 0.0,-1.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 1.0, 0.0}, {-1.0, 0.0, 0.0} };
253 
254  template<typename PointViewType>
255  KOKKOS_INLINE_FUNCTION
256  static bool
257  checkPointInclusion(const PointViewType &point,
258  const double threshold) {
259  return base_cell_topology_type::checkPointInclusion(point, threshold);
260  }
261  };
262 
266  template<>
267  struct Quadrilateral<9> {
268  typedef struct Quadrilateral<4> base_cell_topology_type;
269  enum : int { dimension = 2,
270  numNode = 9,
271  numVert = 4,
272  numEdge = 4,
273  numFace = 0,
274  numIntr = 1 };
275  static constexpr double coords[9][3]{ {-1.0,-1.0, 0.0}, { 1.0,-1.0, 0.0}, { 1.0, 1.0, 0.0}, {-1.0, 1.0, 0.0},
276  { 0.0,-1.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 1.0, 0.0}, {-1.0, 0.0, 0.0}, { 0.0, 0.0, 0.0} };
277 
278  template<typename PointViewType>
279  KOKKOS_INLINE_FUNCTION
280  static bool
281  checkPointInclusion(const PointViewType &point,
282  const double threshold) {
283  return base_cell_topology_type::checkPointInclusion(point, threshold);
284  }
285  };
286 
287  // ---------------------------------------------------------------------------------------
288 
289  template<int N>
290  struct Tetrahedron;
291 
295  template<>
296  struct Tetrahedron<4> {
297  typedef struct Tetrahedron<4> base_cell_topology_type;
298  enum : int { dimension = 3,
299  numNode = 4,
300  numVert = 4,
301  numEdge = 6,
302  numFace = 4,
303  numIntr = 1 };
304  static constexpr double coords[4][3]{ { 0.0, 0.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 1.0, 0.0}, { 0.0, 0.0, 1.0} };
305 
306  template<typename PointViewType>
307  KOKKOS_INLINE_FUNCTION
308  static bool
309  checkPointInclusion(const PointViewType &point,
310  const double threshold) {
311  const double distance = max( max(-point(0),-point(1)),
312  max(-point(2), point(0) + point(1) + point(2) - 1) );
313 
314  return distance < threshold;
315  }
316  };
317 
321  template<>
322  struct Tetrahedron<8> {
323  typedef struct Tetrahedron<4> base_cell_topology_type;
324  enum : int { dimension = 3,
325  numNode = 8,
326  numVert = 4,
327  numEdge = 6,
328  numFace = 4,
329  numIntr = 1 };
330  static constexpr double coords[8][3]{ { 0.0, 0.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 1.0, 0.0}, { 0.0, 0.0, 1.0},
331  { 1/3, 0.0, 1/3}, { 1/3, 1/3, 1/3}, { 1/3, 1/3, 0.0}, { 0.0, 1/3, 1/3} };
332 
333  template<typename PointViewType>
334  KOKKOS_INLINE_FUNCTION
335  static bool
336  checkPointInclusion(const PointViewType &point,
337  const double threshold) {
338  return base_cell_topology_type::checkPointInclusion(point, threshold);
339  }
340  };
341 
345  template<>
346  struct Tetrahedron<10> {
347  typedef struct Tetrahedron<4> base_cell_topology_type;
348  enum : int { dimension = 3,
349  numNode = 10,
350  numVert = 4,
351  numEdge = 6,
352  numFace = 4,
353  numIntr = 1 };
354  static constexpr double coords[10][3]{ { 0.0, 0.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 1.0, 0.0}, { 0.0, 0.0, 1.0},
355  { 0.5, 0.0, 0.0}, { 0.5, 0.5, 0.0}, { 0.0, 0.5, 0.0}, { 0.0, 0.0, 0.5}, { 0.5, 0.0, 0.5}, { 0.0, 0.5, 0.5} };
356 
357  template<typename PointViewType>
358  KOKKOS_INLINE_FUNCTION
359  static bool
360  checkPointInclusion(const PointViewType &point,
361  const double threshold) {
362  return base_cell_topology_type::checkPointInclusion(point, threshold);
363  }
364  };
365 
369  template<>
370  struct Tetrahedron<11> {
371  typedef struct Tetrahedron<4> base_cell_topology_type;
372  enum : int { dimension = 3,
373  numNode = 11,
374  numVert = 4,
375  numEdge = 6,
376  numFace = 4,
377  numIntr = 1 };
378  static constexpr double coords[11][3]{ { 0.0, 0.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 1.0, 0.0}, { 0.0, 0.0, 1.0},
379  { 0.5, 0.0, 0.0}, { 0.5, 0.5, 0.0}, { 0.0, 0.5, 0.0}, { 0.0, 0.0, 0.5}, { 0.5, 0.0, 0.5}, { 0.0, 0.5, 0.5} };
380 
381  template<typename PointViewType>
382  KOKKOS_INLINE_FUNCTION
383  static bool
384  checkPointInclusion(const PointViewType &point,
385  const double threshold) {
386  return base_cell_topology_type::checkPointInclusion(point, threshold);
387  }
388  };
389 
390  // ---------------------------------------------------------------------------------------
391 
392  template<int N>
393  struct Hexahedron;
394 
398  template<>
399  struct Hexahedron<8> {
400  typedef struct Hexahedron<8> base_cell_topology_type;
401  enum : int { dimension = 3,
402  numNode = 8,
403  numVert = 8,
404  numEdge = 12,
405  numFace = 6,
406  numIntr = 1 };
407  static constexpr double coords[8][3]{ {-1.0,-1.0,-1.0}, { 1.0,-1.0,-1.0}, { 1.0, 1.0,-1.0}, {-1.0, 1.0,-1.0},
408  {-1.0,-1.0, 1.0}, { 1.0,-1.0, 1.0}, { 1.0, 1.0, 1.0}, {-1.0, 1.0, 1.0} };
409 
410  template<typename PointViewType>
411  KOKKOS_INLINE_FUNCTION
412  static bool
413  checkPointInclusion(const PointViewType &point,
414  const double threshold) {
415  const double minus_one = -1.0 - threshold, plus_one = 1.0 + threshold;
416  return ((minus_one <= point(0) && point(0) <= plus_one) &&
417  (minus_one <= point(1) && point(1) <= plus_one) &&
418  (minus_one <= point(2) && point(2) <= plus_one));
419  }
420  };
421 
425  template<>
426  struct Hexahedron<20> {
427  typedef struct Hexahedron<8> base_cell_topology_type;
428  enum : int { dimension = 3,
429  numNode = 20,
430  numVert = 8,
431  numEdge = 12,
432  numFace = 6,
433  numIntr = 1 };
434  static constexpr double coords[20][3]{ {-1.0,-1.0,-1.0}, { 1.0,-1.0,-1.0}, { 1.0, 1.0,-1.0}, {-1.0, 1.0,-1.0},
435  {-1.0,-1.0, 1.0}, { 1.0,-1.0, 1.0}, { 1.0, 1.0, 1.0}, {-1.0, 1.0, 1.0},
436  { 0.0,-1.0,-1.0}, { 1.0, 0.0,-1.0}, { 0.0, 1.0,-1.0}, {-1.0, 0.0,-1.0},
437  {-1.0,-1.0, 0.0}, { 1.0,-1.0, 0.0}, { 1.0, 1.0, 0.0}, {-1.0, 1.0, 0.0},
438  { 0.0,-1.0, 1.0}, { 1.0, 0.0, 1.0}, { 0.0, 1.0, 1.0}, {-1.0, 0.0, 1.0} };
439 
440  template<typename PointViewType>
441  KOKKOS_INLINE_FUNCTION
442  static bool
443  checkPointInclusion(const PointViewType &point,
444  const double threshold) {
445  return base_cell_topology_type::checkPointInclusion(point, threshold);
446  }
447 
448  };
449 
453  template<>
454  struct Hexahedron<27> {
455  typedef struct Hexahedron<8> base_cell_topology_type;
456  enum : int { dimension = 3,
457  numNode = 27,
458  numVert = 8,
459  numEdge = 12,
460  numFace = 6,
461  numIntr = 1 };
462  static constexpr double coords[27][3]{ {-1.0,-1.0,-1.0}, { 1.0,-1.0,-1.0}, { 1.0, 1.0,-1.0}, {-1.0, 1.0,-1.0},
463  {-1.0,-1.0, 1.0}, { 1.0,-1.0, 1.0}, { 1.0, 1.0, 1.0}, {-1.0, 1.0, 1.0},
464  { 0.0,-1.0,-1.0}, { 1.0, 0.0,-1.0}, { 0.0, 1.0,-1.0}, {-1.0, 0.0,-1.0},
465  {-1.0,-1.0, 0.0}, { 1.0,-1.0, 0.0}, { 1.0, 1.0, 0.0}, {-1.0, 1.0, 0.0},
466  { 0.0,-1.0, 1.0}, { 1.0, 0.0, 1.0}, { 0.0, 1.0, 1.0}, {-1.0, 0.0, 1.0},
467  { 0.0, 0.0, 0.0},
468  { 0.0, 0.0,-1.0}, { 0.0, 0.0, 1.0}, {-1.0, 0.0, 0.0}, { 1.0, 0.0, 0.0}, {0.0,-1.0, 0.0}, {0.0, 1.0, 0.0} };
469 
470  template<typename PointViewType>
471  KOKKOS_INLINE_FUNCTION
472  static bool
473  checkPointInclusion(const PointViewType &point,
474  const double threshold) {
475  return base_cell_topology_type::checkPointInclusion(point, threshold);
476  }
477  };
478 
479  // ---------------------------------------------------------------------------------------
480 
481  template<int N>
482  struct Pyramid;
483 
487  template<>
488  struct Pyramid<5> {
489  typedef struct Pyramid<5> base_cell_topology_type;
490  enum : int { dimension = 3,
491  numNode = 5,
492  numVert = 5,
493  numEdge = 8,
494  numFace = 5,
495  numIntr = 1 };
496  static constexpr double coords[5][3]{ {-1.0,-1.0, 0.0}, { 1.0,-1.0, 0.0}, { 1.0, 1.0, 0.0}, {-1.0, 1.0, 0.0}, { 0.0, 0.0, 1.0} };
497 
498  template<typename PointViewType>
499  KOKKOS_INLINE_FUNCTION
500  static bool
501  checkPointInclusion(const PointViewType &point,
502  const double threshold) {
503  const double minus_one = -1.0 - threshold, plus_one = 1.0 + threshold, minus_zero = -threshold;
504  const double left = minus_one + point(2);
505  const double right = plus_one - point(2);
506  return ((left <= point(0) && point(0) <= right) &&
507  (left <= point(1) && point(1) <= right) &&
508  (minus_zero <= point(2) && point(2) <= plus_one));
509  }
510  };
511 
515  template<>
516  struct Pyramid<13> {
517  typedef struct Pyramid<5> base_cell_topology_type;
518  enum : int { dimension = 3,
519  numNode = 13,
520  numVert = 5,
521  numEdge = 8,
522  numFace = 5,
523  numIntr = 1 };
524  static constexpr double coords[13][3]{ {-1.0,-1.0, 0.0}, { 1.0,-1.0, 0.0}, { 1.0, 1.0, 0.0}, {-1.0, 1.0, 0.0}, { 0.0, 0.0, 1.0},
525  { 0.0,-1.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 1.0, 0.0}, {-1.0, 0.0, 0.0},
526  {-0.5,-0.5, 0.5}, { 0.5,-0.5, 0.5}, { 0.5, 0.5, 0.5}, {-0.5, 0.5, 0.5} };
527 
528  template<typename PointViewType>
529  KOKKOS_INLINE_FUNCTION
530  static bool
531  checkPointInclusion(const PointViewType &point,
532  const double threshold) {
533  return base_cell_topology_type::checkPointInclusion(point, threshold);
534  }
535  };
536 
540  template<>
541  struct Pyramid<14> {
542  typedef struct Pyramid<5> base_cell_topology_type;
543  enum : int { dimension = 3,
544  numNode = 14,
545  numVert = 5,
546  numEdge = 8,
547  numFace = 5,
548  numIntr = 1 };
549  static constexpr double coords[14][3]{ {-1.0,-1.0, 0.0}, { 1.0,-1.0, 0.0}, { 1.0, 1.0, 0.0}, {-1.0, 1.0, 0.0}, { 0.0, 0.0, 1.0},
550  { 0.0,-1.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 1.0, 0.0}, {-1.0, 0.0, 0.0},
551  {-0.5,-0.5, 0.5}, { 0.5,-0.5, 0.5}, { 0.5, 0.5, 0.5}, {-0.5, 0.5, 0.5}, { 0.0, 0.0, 0.0} };
552 
553  template<typename PointViewType>
554  KOKKOS_INLINE_FUNCTION
555  static bool
556  checkPointInclusion(const PointViewType &point,
557  const double threshold) {
558  return base_cell_topology_type::checkPointInclusion(point, threshold);
559  }
560  };
561 
562  // ---------------------------------------------------------------------------------------
563 
564  template<int N>
565  struct Wedge;
566 
570  template<>
571  struct Wedge<6> {
572  typedef struct Wedge<6> base_cell_topology_type;
573  enum : int { dimension = 3,
574  numNode = 6,
575  numVert = 6,
576  numEdge = 9,
577  numFace = 5,
578  numIntr = 1 };
579  static constexpr double coords[6][3]{ { 0.0, 0.0,-1.0}, { 1.0, 0.0,-1.0}, { 0.0, 1.0,-1.0}, { 0.0, 0.0, 1.0}, { 1.0, 0.0, 1.0}, { 0.0, 1.0, 1.0} };
580 
581  template<typename PointViewType>
582  KOKKOS_INLINE_FUNCTION
583  static bool
584  checkPointInclusion(const PointViewType &point,
585  const double threshold) {
586  const double minus_one = -1.0 - threshold, plus_one = 1.0 + threshold;
587  const double distance = max( max( -point(0), -point(1) ), point(0) + point(1) - 1 );
588  return (distance < threshold && (minus_one <= point(2) && point(2) <= plus_one));
589  }
590  };
591 
595  template<>
596  struct Wedge<15> {
597  typedef struct Wedge<6> base_cell_topology_type;
598  enum : int { dimension = 3,
599  numNode = 15,
600  numVert = 6,
601  numEdge = 9,
602  numFace = 5,
603  numIntr = 1 };
604  static constexpr double coords[15][3]{ { 0.0, 0.0,-1.0}, { 1.0, 0.0,-1.0}, { 0.0, 1.0,-1.0}, { 0.0, 0.0, 1.0}, { 1.0, 0.0, 1.0}, { 0.0, 1.0, 1.0},
605  { 0.5, 0.0,-1.0}, { 0.5, 0.5,-1.0}, { 0.0, 0.5,-1.0}, { 0.0, 0.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 1.0, 0.0},
606  { 0.5, 0.0, 1.0}, { 0.5, 0.5, 1.0}, { 0.0, 0.5, 1.0} };
607 
608  template<typename PointViewType>
609  KOKKOS_INLINE_FUNCTION
610  static bool
611  checkPointInclusion(const PointViewType &point,
612  const double threshold) {
613  return base_cell_topology_type::checkPointInclusion(point, threshold);
614  }
615  };
616 
620  template<>
621  struct Wedge<18> {
622  typedef struct Wedge<6> base_cell_topology_type;
623  enum : int { dimension = 3,
624  numNode = 18,
625  numVert = 6,
626  numEdge = 9,
627  numFace = 5,
628  numIntr = 1 };
629  static constexpr double coords[18][3]{ { 0.0, 0.0,-1.0}, { 1.0, 0.0,-1.0}, { 0.0, 1.0,-1.0}, { 0.0, 0.0, 1.0}, { 1.0, 0.0, 1.0}, { 0.0, 1.0, 1.0},
630  { 0.5, 0.0,-1.0}, { 0.5, 0.5,-1.0}, { 0.0, 0.5,-1.0}, { 0.0, 0.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 1.0, 0.0},
631  { 0.5, 0.0, 1.0}, { 0.5, 0.5, 1.0}, { 0.0, 0.5, 1.0},
632  { 0.5, 0.0, 0.0}, { 0.5, 0.5, 0.0}, { 0.0, 0.5, 0.0} };
633 
634 
635  template<typename PointViewType>
636  KOKKOS_INLINE_FUNCTION
637  static bool
638  checkPointInclusion(const PointViewType &point,
639  const double threshold) {
640  return base_cell_topology_type::checkPointInclusion(point, threshold);
641  }
642  };
643 
644  }
645 }
646 
647 #endif
648 
Intrepid2_Utils.hpp
Header function for Intrepid2::Util class and other utility functions.
Generated by   doxygen 1.8.5