deal.II version 9.8.0
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Loading...
Searching...
No Matches
reference_cell.h
Go to the documentation of this file.
1// -----------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
4// Copyright (C) 2020 - 2026 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Detailed license information governing the source code and contributions
9// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
10//
11// -----------------------------------------------------------------------------
12
13#ifndef dealii_tria_reference_cell_h
14#define dealii_tria_reference_cell_h
15
16#include <deal.II/base/config.h>
17
18#include <deal.II/base/array_view.h>
19#include <deal.II/base/geometry_info.h>
20#include <deal.II/base/ndarray.h>
21#include <deal.II/base/point.h>
22#include <deal.II/base/tensor.h>
23#include <deal.II/base/types.h>
24#include <deal.II/base/utilities.h>
25
26#include <deal.II/grid/tria_orientation.h>
27
28#include <boost/container/small_vector.hpp>
29
30#include <iosfwd>
31#include <string>
32
33DEAL_II_NAMESPACE_OPEN
34
35// Forward declarations
36#ifndef DOXYGEN
37template <int dim, int spacedim>
38class Mapping;
39
40template <int dim>
41class Quadrature;
42
43template <int dim>
44class ReferenceCell;
45#endif
46
47
48namespace internal
49{
62 template <int dim>
63 constexpr ReferenceCell<dim>
64 make_reference_cell_from_int(const std::uint8_t kind);
65} // namespace internal
66
67
68
75enum class IsotropicRefinementChoice : std::uint8_t
76{
80 isotropic_refinement = 0,
84 cut_tet_68 = 1,
88 cut_tet_57 = 2,
92 cut_tet_49 = 3,
93};
94
95
96
127template <int dim>
128class ReferenceCell
129{
130public:
140 DEAL_II_DEPRECATED_EARLY_WITH_COMMENT(
141 "Use ReferenceCells::n_vertices_to_reference_cell() instead")
142 static ReferenceCell
143 n_vertices_to_type(const int dim_, const unsigned int n_vertices);
144
153 constexpr ReferenceCell();
154
159
165 constexpr bool
166 is_hyper_cube() const;
167
171 constexpr bool
172 is_simplex() const;
173
179 constexpr unsigned int
180 get_dimension() const;
181
185
190
201 double
202 d_linear_shape_function(const Point<dim> &xi, const unsigned int i) const;
203
208 Tensor<1, dim>
209 d_linear_shape_function_gradient(const Point<dim> &xi,
210 const unsigned int i) const;
211
221 template <int spacedim = dim>
222 std::unique_ptr<Mapping<dim, spacedim>>
223 get_default_mapping(const unsigned int degree) const;
224
236 template <int spacedim = dim>
237 const Mapping<dim, spacedim> &
238 get_default_linear_mapping() const;
239
248 Quadrature<dim>
249 get_gauss_type_quadrature(const unsigned n_points_1d) const;
250
260 Quadrature<dim>
261 get_midpoint_quadrature() const;
262
276 const Quadrature<dim> &
277 get_nodal_type_quadrature() const;
278
282
287
293 constexpr unsigned int
294 n_vertices() const;
295
300 std_cxx20::ranges::iota_view<unsigned int, unsigned int>
301 vertex_indices() const;
302
310 Point<dim>
311 vertex(const unsigned int v) const;
312
318 constexpr unsigned int
319 n_lines() const;
320
325 std_cxx20::ranges::iota_view<unsigned int, unsigned int>
326 line_indices() const;
327
333 constexpr unsigned int
334 n_faces() const;
335
340 std_cxx20::ranges::iota_view<unsigned int, unsigned int>
341 face_indices() const;
342
348 std_cxx20::ranges::iota_view<unsigned int, unsigned int>
349 face_indices_by_type(const ReferenceCell<dim - 1> &face_ref_type) const;
350
354 constexpr unsigned int
355 n_isotropic_refinement_choices() const;
356
360 IsotropicRefinementChoice
361 get_isotropic_refinement_choice(const unsigned int ref_choice) const;
362
374 constexpr unsigned int
375 n_isotropic_children() const;
376
381 unsigned int
382 n_children(const RefinementCase<dim> ref_case =
383 RefinementCase<dim>::isotropic_refinement) const;
384
389 std_cxx20::ranges::iota_view<unsigned int, unsigned int>
390 isotropic_child_indices() const;
391
411 std::pair<unsigned int, RefinementCase<dim - 1>>
412 equivalent_refinement_case(
413 const types::geometric_orientation combined_face_orientation,
414 const internal::SubfaceCase<dim> subface_case,
415 const unsigned int subface_no) const;
416
424 ArrayView<const RefinementCase<dim>>
425 refinement_cases() const;
426
439 constexpr ReferenceCell<dim - 1>
440 face_reference_cell(const unsigned int face_index) const;
441
445
450
457 DEAL_II_DEPRECATED_WITH_COMMENT(
458 "Use numbers::default_geometric_orientation instead.")
459 static constexpr types::geometric_orientation
460 default_combined_face_orientation();
461
470 DEAL_II_DEPRECATED_WITH_COMMENT(
471 "Use numbers::reverse_line_orientation instead.")
472 static constexpr types::geometric_orientation
473 reversed_combined_line_orientation();
474
482 DEAL_II_DEPRECATED_WITH_COMMENT(
483 "Use the version of this function which takes the orientation as the third "
484 "parameter instead.")
485 unsigned int
486 child_cell_on_face(const unsigned int face, const unsigned int subface) const;
487
528 unsigned int
529 child_cell_on_face(
530 const unsigned int face,
531 const unsigned int subface,
532 const types::geometric_orientation combined_orientation) const;
533
543 std::array<unsigned int, 2>
544 standard_vertex_to_face_and_vertex_index(const unsigned int vertex) const;
545
555 std::array<unsigned int, 2>
556 standard_line_to_face_and_line_index(const unsigned int line) const;
557
566 unsigned int
567 line_to_cell_vertices(const unsigned int line,
568 const unsigned int vertex) const;
569
588 unsigned int
589 face_to_cell_lines(const unsigned int face,
590 const unsigned int line,
591 const types::geometric_orientation face_orientation) const;
592
609 unsigned int
610 face_to_cell_vertices(
611 const unsigned int face,
612 const unsigned int vertex,
613 const types::geometric_orientation face_orientation) const;
614
635 unsigned int
636 face_and_line_to_cell_vertices(
637 const unsigned int face,
638 const unsigned int line,
639 const unsigned int vertex,
640 const types::geometric_orientation face_orientation) const;
641
661 Point<dim>
662 face_vertex_location(const unsigned int face,
663 const unsigned int vertex) const;
664
678 Point<dim>
679 subface_vertex_location(
680 const unsigned int face_no,
681 const unsigned int subface_no,
682 const unsigned int subface_vertex_no,
683 const RefinementCase<dim - 1> face_refinement_case) const;
684
689 unsigned int
690 standard_to_real_face_vertex(
691 const unsigned int vertex,
692 const unsigned int face,
693 const types::geometric_orientation face_orientation) const;
694
699 unsigned int
700 standard_to_real_face_line(
701 const unsigned int line,
702 const unsigned int face,
703 const types::geometric_orientation face_orientation) const;
704
712 DEAL_II_DEPRECATED_WITH_COMMENT(
713 "Use face_to_cell_line_orientation() instead.")
714 types::geometric_orientation
715 standard_vs_true_line_orientation(
716 const unsigned int line,
717 const unsigned int face,
718 const types::geometric_orientation face_orientation,
719 const types::geometric_orientation line_orientation) const;
720
743 types::geometric_orientation
744 face_to_cell_line_orientation(
745 const unsigned int face_line_no,
746 const unsigned int face_no,
747 const types::geometric_orientation face_orientation,
748 const types::geometric_orientation line_orientation) const;
749
775 unsigned int
776 opposite_face_index(const unsigned int face_no) const;
777
781
787
801 double
802 volume() const;
803
819 double
820 face_measure(const unsigned int face_no) const;
821
834 Point<dim>
835 barycenter() const;
836
856 bool
857 contains_point(const Point<dim> &p, const double tolerance = 0) const;
858
863 Point<dim>
864 closest_point(const Point<dim> &p) const;
865
873 Tensor<1, dim>
874 face_tangent_vector(const unsigned int face_no, const unsigned int i) const;
875
885 DEAL_II_DEPRECATED_WITH_COMMENT("Use face_tangent_vector() instead.")
886 Tensor<1, dim>
887 unit_tangential_vectors(const unsigned int face_no,
888 const unsigned int i) const;
889
893 Tensor<1, dim>
894 face_normal_vector(const unsigned int face_no) const;
895
901 DEAL_II_DEPRECATED_WITH_COMMENT("Use face_normal_vector() instead.")
902 Tensor<1, dim>
903 unit_normal_vectors(const unsigned int face_no) const;
904
910 unsigned int
911 n_face_orientations(const unsigned int face_no) const;
912
929 template <typename T, std::size_t N>
930 DEAL_II_DEPRECATED types::geometric_orientation
931 compute_orientation(const std::array<T, N> &vertices_0,
932 const std::array<T, N> &vertices_1) const;
933
958 template <typename T>
959 types::geometric_orientation
960 get_combined_orientation(const ArrayView<const T> &vertices_0,
961 const ArrayView<const T> &vertices_1) const;
962
963
977 template <typename T, std::size_t N>
978 DEAL_II_DEPRECATED std::array<T, N>
979 permute_according_orientation(const std::array<T, N> &vertices,
980 const unsigned int orientation) const;
981
993 template <typename T>
994 boost::container::small_vector<T, 8>
995 permute_by_combined_orientation(
996 const ArrayView<const T> &vertices,
997 const types::geometric_orientation orientation) const;
998
1004 types::geometric_orientation
1005 get_inverse_combined_orientation(
1006 const types::geometric_orientation orientation) const;
1007
1011 ArrayView<const unsigned int>
1012 faces_for_given_vertex(const unsigned int vertex_index) const;
1013
1025 constexpr ::ndarray<unsigned int, 13, 4>
1026 new_isotropic_child_face_lines(const unsigned int refinement_choice) const;
1027
1041 constexpr ::ndarray<unsigned int, 13, 4, 2>
1042 new_isotropic_child_face_line_vertices(
1043 const unsigned int refinement_choice) const;
1044
1056 constexpr ::ndarray<unsigned int, 10, 6>
1057 new_isotropic_child_cell_faces(const unsigned int refinement_choice) const;
1058
1070 constexpr ::ndarray<unsigned int, 10, 8>
1071 new_isotropic_child_cell_vertices(const unsigned int refinement_choice) const;
1072
1076
1081
1085 unsigned int
1086 exodusii_vertex_to_deal_vertex(const unsigned int vertex_n) const;
1087
1091 unsigned int
1092 exodusii_face_to_deal_face(const unsigned int face_n) const;
1093
1097 unsigned int
1098 unv_vertex_to_deal_vertex(const unsigned int vertex_n) const;
1099
1103 unsigned int
1104 vtk_linear_type() const;
1105
1110 unsigned int
1111 vtk_quadratic_type() const;
1112
1117 unsigned int
1118 vtk_lagrange_type() const;
1119
1132 unsigned int
1133 vtk_lexicographic_to_node_index(
1134 const std::array<unsigned, dim> &node_indices,
1135 const std::array<unsigned, dim> &nodes_per_direction,
1136 const bool legacy_format) const;
1137
1141 unsigned int
1142 vtk_vertex_to_deal_vertex(const unsigned int vertex_index) const;
1143
1147 unsigned int
1148 gmsh_element_type() const;
1149
1153
1158
1163 std::string
1164 to_string() const;
1165
1169 constexpr operator std::uint8_t() const;
1170
1174 constexpr bool
1175 operator==(const ReferenceCell<dim> &type) const;
1176
1180 constexpr bool
1181 operator!=(const ReferenceCell<dim> &type) const;
1182
1188 template <class Archive>
1189 void
1190 serialize(Archive &archive, const unsigned int /*version*/);
1191
1195 static constexpr std::size_t
1196 memory_consumption();
1197
1201
1202private:
1206 std::uint8_t kind;
1207
1214 constexpr ReferenceCell(const std::uint8_t kind);
1215
1221 static constexpr ndarray<unsigned int, 1, 1> vertex_vertex_permutations = {
1222 {{{0}}}};
1223
1230
1241
1246 static constexpr ndarray<unsigned int, 8, 4>
1247 quadrilateral_vertex_permutations = {{
1248 {{0, 1, 2, 3}},
1249 {{0, 2, 1, 3}},
1250 {{2, 0, 3, 1}},
1251 {{2, 3, 0, 1}},
1252 {{3, 2, 1, 0}},
1253 {{3, 1, 2, 0}},
1254 {{1, 3, 0, 2}},
1255 {{1, 0, 3, 2}},
1256 }};
1257
1261 static constexpr ndarray<unsigned int, 6, 3> triangle_line_permutations = {
1262 {{{0, 1, 2}},
1263 {{2, 1, 0}},
1264 {{2, 0, 1}},
1265 {{1, 0, 2}},
1266 {{1, 2, 0}},
1267 {{0, 2, 1}}}};
1268
1273 static constexpr ndarray<unsigned int, 8, 4> quadrilateral_line_permutations =
1274 {{
1275 {{0, 1, 2, 3}},
1276 {{2, 3, 0, 1}},
1277 {{3, 2, 0, 1}},
1278 {{0, 1, 3, 2}},
1279 {{1, 0, 3, 2}},
1280 {{3, 2, 1, 0}},
1281 {{2, 3, 1, 0}},
1282 {{1, 0, 2, 3}},
1283 }};
1284
1289 template <int dim_>
1290 friend constexpr ReferenceCell<dim_>
1291 internal::make_reference_cell_from_int(const std::uint8_t);
1292
1293 template <int dim_>
1294 friend std::ostream &
1295 operator<<(std::ostream &out, const ReferenceCell<dim_> &reference_cell);
1296
1297 template <int dim_>
1298 friend std::istream &
1299 operator>>(std::istream &in, ReferenceCell<dim_> &reference_cell);
1300};
1301
1302
1311template <int dim>
1312std::ostream &
1313operator<<(std::ostream &out, const ReferenceCell<dim> &reference_cell);
1314
1322template <int dim>
1323std::istream &
1324operator>>(std::istream &in, ReferenceCell<dim> &reference_cell);
1325
1326
1327
1328template <int dim>
1329inline constexpr ReferenceCell<dim>::ReferenceCell(const std::uint8_t kind)
1330 : kind(kind)
1331{}
1332
1333
1334
1335template <int dim>
1336inline constexpr ReferenceCell<dim>::operator std::uint8_t() const
1337{
1338 return kind;
1339}
1340
1341
1342
1343template <int dim>
1344inline constexpr bool
1345ReferenceCell<dim>::operator==(const ReferenceCell<dim> &type) const
1346{
1347 return kind == type.kind;
1348}
1349
1350
1351
1352template <int dim>
1353inline constexpr bool
1354ReferenceCell<dim>::operator!=(const ReferenceCell<dim> &type) const
1355{
1356 return kind != type.kind;
1357}
1358
1359
1360
1361namespace internal
1362{
1363 template <int dim>
1364 inline constexpr ReferenceCell<dim>
1365 make_reference_cell_from_int(const std::uint8_t kind)
1366 {
1367#ifndef DEAL_II_CXX14_CONSTEXPR_BUG
1368 // Make sure these are the only indices from which objects can be
1369 // created.
1370 Assert((kind == std::numeric_limits<std::uint8_t>::max()) || (kind < 8),
1371 ExcInternalError());
1372#endif
1373
1374 // Call the private constructor, which we can from here because this
1375 // function is a 'friend'.
1376 return {kind};
1377 }
1378} // namespace internal
1379
1380
1381
1389namespace ReferenceCells
1390{
1391 constexpr ReferenceCell<0> Vertex =
1392 internal::make_reference_cell_from_int<0>(0);
1393 constexpr ReferenceCell<1> Line =
1394 internal::make_reference_cell_from_int<1>(1);
1395 constexpr ReferenceCell<2> Triangle =
1396 internal::make_reference_cell_from_int<2>(2);
1397 constexpr ReferenceCell<2> Quadrilateral =
1398 internal::make_reference_cell_from_int<2>(3);
1399 constexpr ReferenceCell<3> Tetrahedron =
1400 internal::make_reference_cell_from_int<3>(4);
1401 constexpr ReferenceCell<3> Pyramid =
1402 internal::make_reference_cell_from_int<3>(5);
1403 constexpr ReferenceCell<3> Wedge =
1404 internal::make_reference_cell_from_int<3>(6);
1405 constexpr ReferenceCell<3> Hexahedron =
1406 internal::make_reference_cell_from_int<3>(7);
1407
1408 template <int dim>
1409 constexpr ReferenceCell<dim> Invalid =
1410 internal::make_reference_cell_from_int<dim>(
1411 std::numeric_limits<std::uint8_t>::max());
1412
1417 template <int dim>
1418 constexpr const std::vector<ReferenceCell<dim>>
1419 get_reference_cells_in_dim();
1420
1426 template <int dim>
1427 constexpr const ReferenceCell<dim> &
1428 get_simplex();
1429
1435 template <int dim>
1436 constexpr const ReferenceCell<dim> &
1437 get_hypercube();
1438
1443 template <int dim>
1444 constexpr unsigned int
1445 n_reference_cells_in_dim();
1446
1459 template <int dim>
1460 ReferenceCell<dim>
1461 n_vertices_to_reference_cell(const unsigned int n_vertices);
1462
1470 template <int structdim>
1471 constexpr unsigned int
1472 max_n_vertices();
1473
1481 template <int structdim>
1482 constexpr unsigned int
1483 max_n_lines();
1484
1500 template <int structdim>
1501 constexpr unsigned int
1502 max_n_faces();
1503
1513 template <int structdim>
1514 constexpr unsigned int
1515 max_n_children();
1516} // namespace ReferenceCells
1517
1518
1519
1520template <int dim>
1521inline constexpr ReferenceCell<dim>::ReferenceCell()
1522 : ReferenceCell(ReferenceCells::Invalid<dim>)
1523{}
1524
1525
1526
1527template <int dim>
1528template <class Archive>
1529inline void
1530ReferenceCell<dim>::serialize(Archive &archive, const unsigned int /*version*/)
1531{
1532 archive &kind;
1533}
1534
1535
1536
1537template <int dim>
1538inline constexpr std::size_t
1543
1544
1545
1546template <int dim>
1547inline ArrayView<const unsigned int>
1548ReferenceCell<dim>::faces_for_given_vertex(const unsigned int vertex) const
1549{
1550 AssertIndexRange(vertex, n_vertices());
1551 switch (this->kind)
1552 {
1553 case ReferenceCells::Line:
1554 return {&GeometryInfo<2>::vertex_to_face[vertex][0], 1};
1555 case ReferenceCells::Quadrilateral:
1556 return {&GeometryInfo<2>::vertex_to_face[vertex][0], 2};
1557 case ReferenceCells::Triangle:
1558 {
1559 static constexpr ndarray<unsigned int, 3, 2> table = {
1560 {{{0, 2}}, {{0, 1}}, {{1, 2}}}};
1561 return table[vertex];
1562 }
1563 case ReferenceCells::Tetrahedron:
1564 {
1565 static constexpr ndarray<unsigned int, 4, 3> table = {
1566 {{{0, 1, 2}}, {{0, 1, 3}}, {{0, 2, 3}}, {{1, 2, 3}}}};
1567
1568 return table[vertex];
1569 }
1570 case ReferenceCells::Pyramid:
1571 {
1572 static constexpr unsigned int X = numbers::invalid_unsigned_int;
1573 static constexpr ndarray<unsigned int, 5, 4> table = {
1574 {{{0, 1, 3, X}},
1575 {{0, 2, 3, X}},
1576 {{0, 1, 4, X}},
1577 {{0, 2, 4, X}},
1578 {{1, 2, 3, 4}}}};
1579
1580 return {&table[vertex][0], vertex == 4 ? 4u : 3u};
1581 }
1582 case ReferenceCells::Wedge:
1583 {
1584 AssertIndexRange(vertex, 6);
1585 static constexpr ndarray<unsigned int, 6, 3> table = {{{{0, 2, 4}},
1586 {{0, 2, 3}},
1587 {{0, 3, 4}},
1588 {{1, 2, 4}},
1589 {{1, 2, 3}},
1590 {{1, 3, 4}}}};
1591
1592 return table[vertex];
1593 }
1594 case ReferenceCells::Hexahedron:
1595 return {&GeometryInfo<3>::vertex_to_face[vertex][0], 3};
1596 default:
1597 DEAL_II_NOT_IMPLEMENTED();
1598 }
1599
1600 return {};
1601}
1602
1603
1604
1605template <int dim>
1606constexpr ::ndarray<unsigned int, 13, 4>
1607ReferenceCell<dim>::new_isotropic_child_face_lines(
1608 const unsigned int refinement_choice) const
1609{
1610 AssertIndexRange(refinement_choice, n_isotropic_refinement_choices());
1611
1612 if constexpr (dim == 3)
1613 {
1614 const unsigned int X = numbers::invalid_unsigned_int;
1615
1616 switch (this->kind)
1617 {
1618 case ReferenceCells::Tetrahedron:
1619 {
1620 switch (refinement_choice)
1621 {
1622 case 0:
1623 // new line is (6,8)
1624 return {{{{2, 3, 8, X}},
1625 {{0, 9, 5, X}},
1626 {{1, 6, 11, X}},
1627 {{4, 10, 7, X}},
1628 {{2, 12, 5, X}},
1629 {{1, 9, 12, X}},
1630 {{4, 8, 12, X}},
1631 {{6, 12, 10, X}},
1632 {{X, X, X, X}},
1633 {{X, X, X, X}},
1634 {{X, X, X, X}},
1635 {{X, X, X, X}},
1636 {{X, X, X, X}}}};
1637 case 1:
1638 // new line is (5,7)
1639 return {{{{2, 3, 8, X}},
1640 {{0, 9, 5, X}},
1641 {{1, 6, 11, X}},
1642 {{4, 10, 7, X}},
1643 {{0, 3, 12, X}},
1644 {{1, 12, 8, X}},
1645 {{4, 12, 9, X}},
1646 {{7, 11, 12, X}},
1647 {{X, X, X, X}},
1648 {{X, X, X, X}},
1649 {{X, X, X, X}},
1650 {{X, X, X, X}},
1651 {{X, X, X, X}}}};
1652 case 2:
1653 // new line is (4,9)
1654 return {{{{2, 3, 8, X}},
1655 {{0, 9, 5, X}},
1656 {{1, 6, 11, X}},
1657 {{4, 10, 7, X}},
1658 {{0, 12, 11, X}},
1659 {{2, 6, 12, X}},
1660 {{3, 12, 7, X}},
1661 {{5, 10, 12, X}},
1662 {{X, X, X, X}},
1663 {{X, X, X, X}},
1664 {{X, X, X, X}},
1665 {{X, X, X, X}},
1666 {{X, X, X, X}}}};
1667 default:
1668 DEAL_II_ASSERT_UNREACHABLE();
1669 }
1670 }
1671
1672 case ReferenceCells::Pyramid:
1673 {
1674 constexpr ::ndarray<unsigned int, 13, 4>
1675 new_quad_lines_pyramid = {
1676 {{{0, 10, 16, X}}, // child 0
1677 {{2, 16, 6, X}},
1678 {{0, 17, 12, X}}, // child 1
1679 {{3, 7, 17, X}},
1680 {{1, 18, 15, X}}, // child 2
1681 {{2, 4, 18, X}},
1682 {{1, 13, 19, X}}, // child 3
1683 {{3, 19, 9, X}},
1684 {{5, 8, 11, 14}}, // child 9 (top)
1685 {{11, 17, 16, X}}, // child 8 (upside down)
1686 {{14, 18, 19, X}},
1687 {{5, 16, 18, X}},
1688 {{8, 19, 17, X}}}};
1689 return new_quad_lines_pyramid;
1690 }
1691
1692 case ReferenceCells::Wedge:
1693 {
1694 constexpr ::ndarray<unsigned int, 13, 4>
1695 new_quad_lines_wedge = {{{{2, 20, 11, X}}, // mid tri
1696 {{3, 6, 18, X}},
1697 {{19, 7, 10, X}},
1698 {{18, 19, 20, X}},
1699 {{4, 0, 14, 18}}, // lower
1700 {{0, 8, 12, 20}},
1701 {{8, 4, 13, 19}},
1702 {{5, 1, 18, 15}}, // upper
1703 {{1, 9, 20, 17}},
1704 {{9, 5, 19, 16}},
1705 {{X, X, X, X}},
1706 {{X, X, X, X}},
1707 {{X, X, X, X}}}};
1708 return new_quad_lines_wedge;
1709 }
1710
1711 case ReferenceCells::Hexahedron:
1712 {
1713 constexpr ::ndarray<unsigned int, 13, 4>
1714 new_quad_lines_hex = {{{{10, 28, 16, 24}},
1715 {{28, 14, 17, 25}},
1716 {{11, 29, 24, 20}},
1717 {{29, 15, 25, 21}},
1718 {{18, 26, 0, 28}},
1719 {{26, 22, 1, 29}},
1720 {{19, 27, 28, 4}},
1721 {{27, 23, 29, 5}},
1722 {{2, 24, 8, 26}},
1723 {{24, 6, 9, 27}},
1724 {{3, 25, 26, 12}},
1725 {{25, 7, 27, 13}},
1726 {{X, X, X, X}}}};
1727 return new_quad_lines_hex;
1728 }
1729
1730 default:
1731 DEAL_II_ASSERT_UNREACHABLE();
1732 }
1733 }
1734 else
1735 // We should never get here except in the 3d case.
1736 DEAL_II_ASSERT_UNREACHABLE();
1737
1738 return {};
1739}
1740
1741
1742
1743template <int dim>
1744constexpr ::ndarray<unsigned int, 13, 4, 2>
1745ReferenceCell<dim>::new_isotropic_child_face_line_vertices(
1746 const unsigned int refinement_choice) const
1747{
1748 AssertIndexRange(refinement_choice, n_isotropic_refinement_choices());
1749
1750 if constexpr (dim == 3)
1751 {
1752 const unsigned int X = numbers::invalid_unsigned_int;
1753
1754 switch (this->kind)
1755 {
1756 case ReferenceCells::Tetrahedron:
1757 {
1758 switch (refinement_choice)
1759 {
1760 case 0:
1761 // new line is (6, 8)
1762 return {{{{{{6, 4}}, {{4, 7}}, {{7, 6}}, {{X, X}}}},
1763 {{{{4, 5}}, {{5, 8}}, {{8, 4}}, {{X, X}}}},
1764 {{{{5, 6}}, {{6, 9}}, {{9, 5}}, {{X, X}}}},
1765 {{{{7, 8}}, {{8, 9}}, {{9, 7}}, {{X, X}}}},
1766 {{{{4, 6}}, {{6, 8}}, {{8, 4}}, {{X, X}}}},
1767 {{{{6, 5}}, {{5, 8}}, {{8, 6}}, {{X, X}}}},
1768 {{{{8, 7}}, {{7, 6}}, {{6, 8}}, {{X, X}}}},
1769 {{{{9, 6}}, {{6, 8}}, {{8, 9}}, {{X, X}}}},
1770 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1771 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1772 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1773 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1774 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}}}};
1775 case 1:
1776 // new line is (5, 7)
1777 return {{{{{{6, 4}}, {{4, 7}}, {{7, 6}}, {{X, X}}}},
1778 {{{{4, 5}}, {{5, 8}}, {{8, 4}}, {{X, X}}}},
1779 {{{{5, 6}}, {{6, 9}}, {{9, 5}}, {{X, X}}}},
1780 {{{{7, 8}}, {{8, 9}}, {{9, 7}}, {{X, X}}}},
1781 {{{{5, 4}}, {{4, 7}}, {{7, 5}}, {{X, X}}}},
1782 {{{{6, 5}}, {{5, 7}}, {{7, 6}}, {{X, X}}}},
1783 {{{{8, 7}}, {{7, 5}}, {{5, 8}}, {{X, X}}}},
1784 {{{{7, 9}}, {{9, 5}}, {{5, 7}}, {{X, X}}}},
1785 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1786 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1787 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1788 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1789 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}}}};
1790 case 2:
1791 // new line is (4, 9)
1792 return {{{{{{6, 4}}, {{4, 7}}, {{7, 6}}, {{X, X}}}},
1793 {{{{4, 5}}, {{5, 8}}, {{8, 4}}, {{X, X}}}},
1794 {{{{5, 6}}, {{6, 9}}, {{9, 5}}, {{X, X}}}},
1795 {{{{7, 8}}, {{8, 9}}, {{9, 7}}, {{X, X}}}},
1796 {{{{5, 4}}, {{4, 9}}, {{9, 5}}, {{X, X}}}},
1797 {{{{4, 6}}, {{6, 9}}, {{9, 4}}, {{X, X}}}},
1798 {{{{7, 4}}, {{4, 9}}, {{9, 7}}, {{X, X}}}},
1799 {{{{4, 8}}, {{8, 9}}, {{9, 4}}, {{X, X}}}},
1800 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1801 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1802 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1803 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1804 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}}}};
1805 default:
1806 DEAL_II_ASSERT_UNREACHABLE();
1807 }
1808 }
1809
1810 case ReferenceCells::Pyramid:
1811 {
1812 constexpr ::ndarray<unsigned int, 13, 4, 2>
1813 quad_lines_vertices_pyramid = {
1814 {// child 0
1815 {{{{13, 7}}, {{7, 9}}, {{9, 13}}, {{X, X}}}},
1816 {{{{5, 13}}, {{13, 9}}, {{9, 5}}, {{X, X}}}},
1817 // child 1
1818 {{{{7, 13}}, {{13, 10}}, {{10, 7}}, {{X, X}}}},
1819 {{{{13, 6}}, {{6, 10}}, {{10, 13}}, {{X, X}}}},
1820 // child 2
1821 {{{{8, 13}}, {{13, 11}}, {{11, 8}}, {{X, X}}}},
1822 {{{{13, 5}}, {{5, 11}}, {{11, 13}}, {{X, X}}}},
1823 // child 3
1824 {{{{13, 8}}, {{8, 12}}, {{12, 13}}, {{X, X}}}},
1825 {{{{6, 13}}, {{13, 12}}, {{12, 6}}, {{X, X}}}},
1826 // child 9 (top)
1827 {{{{9, 11}}, {{10, 12}}, {{9, 10}}, {{11, 12}}}},
1828 // child 8 (upside down)
1829 {{{{9, 10}}, {{10, 13}}, {{13, 9}}, {{X, X}}}},
1830 {{{{12, 11}}, {{11, 13}}, {{13, 12}}, {{X, X}}}},
1831 {{{{11, 9}}, {{9, 13}}, {{13, 11}}, {{X, X}}}},
1832 {{{{10, 12}}, {{12, 13}}, {{13, 10}}, {{X, X}}}}}};
1833 return quad_lines_vertices_pyramid;
1834 }
1835
1836 case ReferenceCells::Wedge:
1837 {
1838 constexpr ::ndarray<unsigned int, 13, 4, 2>
1839 quad_lines_vertices_wedge = {
1840 {// mid tri
1841 {{{{12, 15}}, {{15, 17}}, {{17, 12}}, {{X, X}}}},
1842 {{{{15, 13}}, {{13, 16}}, {{16, 15}}, {{X, X}}}},
1843 {{{{17, 16}}, {{16, 14}}, {{14, 17}}, {{X, X}}}},
1844 {{{{15, 16}}, {{16, 17}}, {{17, 15}}, {{X, X}}}},
1845 // lower
1846 {{{{7, 16}}, {{6, 15}}, {{7, 6}}, {{16, 15}}}},
1847 {{{{6, 15}}, {{8, 17}}, {{6, 8}}, {{15, 17}}}},
1848 {{{{8, 17}}, {{7, 16}}, {{8, 7}}, {{17, 16}}}},
1849 // upper
1850 {{{{16, 10}}, {{15, 9}}, {{16, 15}}, {{10, 9}}}},
1851 {{{{15, 9}}, {{17, 11}}, {{15, 17}}, {{9, 11}}}},
1852 {{{{17, 11}}, {{16, 10}}, {{17, 16}}, {{11, 10}}}},
1853 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1854 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1855 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}}}};
1856 return quad_lines_vertices_wedge;
1857 }
1858
1859 case ReferenceCells::Hexahedron:
1860 {
1861 constexpr ::ndarray<unsigned int, 13, 4, 2>
1862 quad_lines_vertices_hex = {
1863 {{{{{10, 22}}, {{24, 26}}, {{10, 24}}, {{22, 26}}}},
1864 {{{{24, 26}}, {{11, 23}}, {{24, 11}}, {{26, 23}}}},
1865 {{{{22, 14}}, {{26, 25}}, {{22, 26}}, {{14, 25}}}},
1866 {{{{26, 25}}, {{23, 15}}, {{26, 23}}, {{25, 15}}}},
1867 {{{{8, 24}}, {{20, 26}}, {{8, 20}}, {{24, 26}}}},
1868 {{{{20, 26}}, {{12, 25}}, {{20, 12}}, {{26, 25}}}},
1869 {{{{24, 9}}, {{26, 21}}, {{24, 26}}, {{9, 21}}}},
1870 {{{{26, 21}}, {{25, 13}}, {{26, 25}}, {{21, 13}}}},
1871 {{{{16, 20}}, {{22, 26}}, {{16, 22}}, {{20, 26}}}},
1872 {{{{22, 26}}, {{17, 21}}, {{22, 17}}, {{26, 21}}}},
1873 {{{{20, 18}}, {{26, 23}}, {{20, 26}}, {{18, 23}}}},
1874 {{{{26, 23}}, {{21, 19}}, {{26, 21}}, {{23, 19}}}},
1875 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}}}};
1876 return quad_lines_vertices_hex;
1877 }
1878 default:
1879 DEAL_II_ASSERT_UNREACHABLE();
1880 }
1881 }
1882 else
1883 // We should never get here except in the 3d case.
1884 DEAL_II_ASSERT_UNREACHABLE();
1885
1886 return {};
1887}
1888
1889
1890
1891template <int dim>
1892constexpr ::ndarray<unsigned int, 10, 6>
1893ReferenceCell<dim>::new_isotropic_child_cell_faces(
1894 const unsigned int refinement_choice) const
1895{
1896 AssertIndexRange(refinement_choice, n_isotropic_refinement_choices());
1897
1898 if constexpr (dim == 3)
1899 {
1900 const unsigned int X = numbers::invalid_unsigned_int;
1901
1902 switch (this->kind)
1903 {
1904 case ReferenceCells::Tetrahedron:
1905 {
1906 switch (refinement_choice)
1907 {
1908 case 0:
1909 // new line is (6, 8)
1910 return {{
1911 {{8, 13, 16, 0, X, X}},
1912 {{9, 12, 1, 21, X, X}},
1913 {{10, 2, 17, 20, X, X}},
1914 {{3, 14, 18, 22, X, X}},
1915 {{11, 1, 4, 5, X, X}},
1916 {{15, 0, 4, 6, X, X}},
1917 {{19, 7, 6, 3, X, X}},
1918 {{23, 5, 2, 7, X, X}},
1919 {{X, X, X, X, X, X}},
1920 {{X, X, X, X, X, X}},
1921 }};
1922 case 1:
1923 // new line is (5, 7)
1924 return {{
1925 {{8, 13, 16, 0, X, X}},
1926 {{9, 12, 1, 21, X, X}},
1927 {{10, 2, 17, 20, X, X}},
1928 {{3, 14, 18, 22, X, X}},
1929 {{11, 4, 0, 5, X, X}},
1930 {{15, 4, 1, 6, X, X}},
1931 {{19, 2, 5, 7, X, X}},
1932 {{23, 6, 7, 3, X, X}},
1933 {{X, X, X, X, X, X}},
1934 {{X, X, X, X, X, X}},
1935 }};
1936 case 2:
1937 // new line is (4, 9)
1938 return {{
1939 {{8, 13, 16, 0, X, X}},
1940 {{9, 12, 1, 21, X, X}},
1941 {{10, 2, 17, 20, X, X}},
1942 {{3, 14, 18, 22, X, X}},
1943 {{11, 4, 5, 2, X, X}},
1944 {{15, 6, 7, 3, X, X}},
1945 {{19, 5, 0, 6, X, X}},
1946 {{23, 1, 4, 7, X, X}},
1947 {{X, X, X, X, X, X}},
1948 {{X, X, X, X, X, X}},
1949 }};
1950 default:
1951 DEAL_II_ASSERT_UNREACHABLE();
1952 }
1953 }
1954 case ReferenceCells::Pyramid:
1955 {
1956 constexpr ::ndarray<unsigned int, 10, 6>
1957 cell_quads_pyramid = {{
1958 {{13, 17, 0, 26, 1, X}}, // bottom pyramids
1959 {{14, 2, 22, 25, 3, X}}, //
1960 {{15, 18, 4, 5, 29, X}}, //
1961 {{16, 6, 21, 7, 30, X}}, //
1962 {{5, 1, 20, 11, X, X}}, // bottom wedges
1963 {{7, 3, 12, 24, X, X}}, //
1964 {{0, 2, 28, 9, X, X}}, //
1965 {{4, 6, 10, 32, X, X}}, //
1966 {{8, 9, 10, 11, 12, X}}, // upside down pyramid
1967 {{8, 19, 23, 27, 31, X}} // top pyramid
1968 }};
1969 return cell_quads_pyramid;
1970 }
1971
1972 case ReferenceCells::Wedge:
1973 {
1974 // Considerations that went into creating this table
1975 // - Keep aspect ratio of 1.0 if parent had 1.0 (this is why the
1976 // centre wedge is rotated by 180° compared to the parent)
1977 // - Order of children is similar to the order of a reference
1978 // triangle in the x-y-plane (i.e. like the top triangle of the
1979 // parent)
1980 constexpr ::ndarray<unsigned int, 10, 6> cell_quads_wedge =
1981 {{
1982 {{23, 0, 10, 5, 19, X}}, // bottom children
1983 {{22, 1, 11, 14, 4, X}}, //
1984 {{24, 2, 6, 15, 18, X}}, //
1985 {{25, 3, 6, 5, 4, X}}, //
1986 {{0, 26, 12, 8, 21, X}}, // top children
1987 {{1, 27, 13, 16, 7, X}}, //
1988 {{2, 28, 9, 17, 20, X}}, //
1989 {{3, 29, 9, 8, 7, X}}, //
1990 {{X, X, X, X, X, X}},
1991 {{X, X, X, X, X, X}},
1992 }};
1993 return cell_quads_wedge;
1994 }
1995
1996 case ReferenceCells::Hexahedron:
1997 {
1998 constexpr ::ndarray<unsigned int, 10, 6> cell_quads_hex = {{
1999 {{12, 0, 20, 4, 28, 8}}, // bottom children
2000 {{0, 16, 22, 6, 29, 9}}, //
2001 {{13, 1, 4, 24, 30, 10}}, //
2002 {{1, 17, 6, 26, 31, 11}}, //
2003 {{14, 2, 21, 5, 8, 32}}, // top children
2004 {{2, 18, 23, 7, 9, 33}}, //
2005 {{15, 3, 5, 25, 10, 34}}, //
2006 {{3, 19, 7, 27, 11, 35}}, //
2007 {{X, X, X, X, X, X}},
2008 {{X, X, X, X, X, X}},
2009 }};
2010 return cell_quads_hex;
2011 }
2012 default:
2013 DEAL_II_ASSERT_UNREACHABLE();
2014 }
2015 }
2016 else
2017 // We should never get here except in the 3d case.
2018 DEAL_II_ASSERT_UNREACHABLE();
2019
2020 return {};
2021}
2022
2023
2024
2025template <int dim>
2026constexpr ::ndarray<unsigned int, 10, 8>
2027ReferenceCell<dim>::new_isotropic_child_cell_vertices(
2028 const unsigned int refinement_choice) const
2029{
2030 AssertIndexRange(refinement_choice, n_isotropic_refinement_choices());
2031
2032 if constexpr (dim == 3)
2033 {
2034 constexpr unsigned int X = numbers::invalid_unsigned_int;
2035
2036 switch (this->kind)
2037 {
2038 case ReferenceCells::Tetrahedron:
2039 {
2040 switch (refinement_choice)
2041 {
2042 case 0:
2043 // new line is (6,8)
2044 return {{
2045 {{0, 4, 6, 7, X, X, X, X}},
2046 {{4, 1, 5, 8, X, X, X, X}},
2047 {{6, 5, 2, 9, X, X, X, X}},
2048 {{7, 8, 9, 3, X, X, X, X}},
2049 {{4, 5, 6, 8, X, X, X, X}},
2050 {{4, 7, 8, 6, X, X, X, X}},
2051 {{6, 9, 7, 8, X, X, X, X}},
2052 {{5, 8, 9, 6, X, X, X, X}},
2053 {{X, X, X, X, X, X, X, X}},
2054 {{X, X, X, X, X, X, X, X}},
2055 }};
2056 case 1:
2057 // new line is (5,7)
2058 return {{
2059 {{0, 4, 6, 7, X, X, X, X}},
2060 {{4, 1, 5, 8, X, X, X, X}},
2061 {{6, 5, 2, 9, X, X, X, X}},
2062 {{7, 8, 9, 3, X, X, X, X}},
2063 {{4, 5, 6, 7, X, X, X, X}},
2064 {{4, 7, 8, 5, X, X, X, X}},
2065 {{6, 9, 7, 5, X, X, X, X}},
2066 {{5, 8, 9, 7, X, X, X, X}},
2067 {{X, X, X, X, X, X, X, X}},
2068 {{X, X, X, X, X, X, X, X}},
2069 }};
2070 case 2:
2071 // new line is (4,9)
2072 return {{
2073 {{0, 4, 6, 7, X, X, X, X}},
2074 {{4, 1, 5, 8, X, X, X, X}},
2075 {{6, 5, 2, 9, X, X, X, X}},
2076 {{7, 8, 9, 3, X, X, X, X}},
2077 {{4, 5, 6, 9, X, X, X, X}},
2078 {{4, 7, 8, 9, X, X, X, X}},
2079 {{6, 9, 7, 4, X, X, X, X}},
2080 {{5, 8, 9, 4, X, X, X, X}},
2081 {{X, X, X, X, X, X, X, X}},
2082 {{X, X, X, X, X, X, X, X}},
2083 }};
2084
2085 default:
2086 DEAL_II_ASSERT_UNREACHABLE();
2087 }
2088 }
2089 case ReferenceCells::Pyramid:
2090 {
2091 constexpr ::ndarray<unsigned int, 10, 8>
2092 cell_vertices_pyramid = {{
2093 {{0, 7, 5, 13, 9, X, X, X}}, // bottom pyramid
2094 {{7, 1, 13, 6, 10, X, X, X}}, //
2095 {{5, 13, 2, 8, 11, X, X, X}}, //
2096 {{13, 6, 8, 3, 12, X, X, X}}, //
2097 {{5, 13, 11, 9, X, X, X, X}}, // bottom wedges
2098 {{13, 6, 12, 10, X, X, X, X}}, //
2099 {{7, 13, 9, 10, X, X, X, X}}, //
2100 {{13, 8, 11, 12, X, X, X, X}}, //
2101 {{9, 11, 10, 12, 13, X, X, X}}, // upside down pyramid
2102 {{9, 10, 11, 12, 4, X, X, X}}, // top pyramid
2103 }};
2104 return cell_vertices_pyramid;
2105 }
2106
2107 case ReferenceCells::Wedge:
2108 {
2109 constexpr ::ndarray<unsigned int, 10, 8>
2110 cell_vertices_wedge = {{
2111 {{0, 6, 8, 12, 15, 17, X, X}}, // bottom children
2112 {{6, 1, 7, 15, 13, 16, X, X}}, //
2113 {{8, 7, 2, 17, 16, 14, X, X}}, //
2114 {{7, 8, 6, 16, 17, 15, X, X}}, //
2115 {{12, 15, 17, 3, 9, 11, X, X}}, // top children
2116 {{15, 13, 16, 9, 4, 10, X, X}}, //
2117 {{17, 16, 14, 11, 10, 5, X, X}}, //
2118 {{16, 17, 15, 10, 11, 9, X, X}}, //
2119 {{X, X, X, X, X, X, X, X}},
2120 {{X, X, X, X, X, X, X, X}},
2121 }};
2122 return cell_vertices_wedge;
2123 }
2124
2125 case ReferenceCells::Hexahedron:
2126 {
2127 constexpr ::ndarray<unsigned int, 10, 8> cell_vertices_hex =
2128 {{
2129 {{0, 10, 8, 24, 16, 22, 20, 26}}, // bottom children
2130 {{10, 1, 24, 9, 22, 17, 26, 21}}, //
2131 {{8, 24, 2, 11, 20, 26, 18, 23}}, //
2132 {{24, 9, 11, 3, 26, 21, 23, 19}}, //
2133 {{16, 22, 20, 26, 4, 14, 12, 25}}, // top children
2134 {{22, 17, 26, 21, 14, 5, 25, 13}}, //
2135 {{20, 26, 18, 23, 12, 25, 6, 15}}, //
2136 {{26, 21, 23, 19, 25, 13, 15, 7}}, //
2137 {{X, X, X, X, X, X, X, X}},
2138 {{X, X, X, X, X, X, X, X}},
2139 }};
2140 return cell_vertices_hex;
2141 }
2142
2143 default:
2144 DEAL_II_ASSERT_UNREACHABLE();
2145 }
2146 }
2147 else
2148 // We should never get here except in the 3d case.
2149 DEAL_II_ASSERT_UNREACHABLE();
2150
2151 return {};
2152}
2153
2154
2155
2156template <int dim>
2157inline constexpr bool
2158ReferenceCell<dim>::is_hyper_cube() const
2159{
2160 return (*this == ReferenceCells::Vertex || *this == ReferenceCells::Line ||
2161 *this == ReferenceCells::Quadrilateral ||
2162 *this == ReferenceCells::Hexahedron);
2163}
2164
2165
2166
2167template <int dim>
2168inline constexpr bool
2169ReferenceCell<dim>::is_simplex() const
2170{
2171 return (*this == ReferenceCells::Vertex || *this == ReferenceCells::Line ||
2172 *this == ReferenceCells::Triangle ||
2173 *this == ReferenceCells::Tetrahedron);
2174}
2175
2176
2177
2178template <int dim>
2179inline constexpr unsigned int
2180ReferenceCell<dim>::get_dimension() const
2181{
2182 return dim;
2183}
2184
2185
2186
2187template <int dim>
2188Quadrature<dim>
2189ReferenceCell<dim>::get_midpoint_quadrature() const
2190{
2191 return Quadrature<dim>(std::vector<Point<dim>>({barycenter()}),
2192 std::vector<double>({volume()}));
2193}
2194
2195
2196
2197template <int dim>
2198inline constexpr unsigned int
2199ReferenceCell<dim>::n_vertices() const
2200{
2201 switch (this->kind)
2202 {
2203 case ReferenceCells::Vertex:
2204 return 1;
2205 case ReferenceCells::Line:
2206 return 2;
2207 case ReferenceCells::Triangle:
2208 return 3;
2209 case ReferenceCells::Quadrilateral:
2210 return 4;
2211 case ReferenceCells::Tetrahedron:
2212 return 4;
2213 case ReferenceCells::Pyramid:
2214 return 5;
2215 case ReferenceCells::Wedge:
2216 return 6;
2217 case ReferenceCells::Hexahedron:
2218 return 8;
2219 default:
2220 DEAL_II_NOT_IMPLEMENTED();
2221 }
2222
2223 return numbers::invalid_unsigned_int;
2224}
2225
2226
2227
2228template <int dim>
2229inline constexpr unsigned int
2230ReferenceCell<dim>::n_lines() const
2231{
2232 switch (this->kind)
2233 {
2234 case ReferenceCells::Vertex:
2235 return 0;
2236 case ReferenceCells::Line:
2237 return 1;
2238 case ReferenceCells::Triangle:
2239 return 3;
2240 case ReferenceCells::Quadrilateral:
2241 return 4;
2242 case ReferenceCells::Tetrahedron:
2243 return 6;
2244 case ReferenceCells::Pyramid:
2245 return 8;
2246 case ReferenceCells::Wedge:
2247 return 9;
2248 case ReferenceCells::Hexahedron:
2249 return 12;
2250 default:
2251 DEAL_II_NOT_IMPLEMENTED();
2252 }
2253
2254 return numbers::invalid_unsigned_int;
2255}
2256
2257
2258
2259template <int dim>
2260Point<dim>
2261ReferenceCell<dim>::vertex(const unsigned int v) const
2262{
2263 AssertIndexRange(v, n_vertices());
2264
2265 switch (dim)
2266 {
2267 case 0:
2268 {
2269 if (*this == ReferenceCells::Vertex)
2270 return Point<dim>();
2271 break;
2272 }
2273 case 1:
2274 {
2275 static const Point<dim> vertices[2] = {
2276 Point<dim>(), // the origin
2277 Point<dim>::unit_vector(0) // unit point along x-axis
2278 };
2279 if (*this == ReferenceCells::Line)
2280 return vertices[v];
2281 break;
2282 }
2283 case 2:
2284 {
2285 switch (this->kind)
2286 {
2287 case ReferenceCells::Triangle:
2288 {
2289 static const Point<dim> vertices[3] = {
2290 Point<dim>(), // the origin
2291 Point<dim>::unit_vector(0), // unit point along x-axis
2292 Point<dim>::unit_vector(1) // unit point along y-axis
2293 };
2294 return vertices[v];
2295 }
2296 case ReferenceCells::Quadrilateral:
2297 {
2298 static const Point<dim> vertices[4] = {
2299 // First the two points on the x-axis
2300 Point<dim>(),
2301 Point<dim>::unit_vector(0),
2302 // Then these two points shifted in the y-direction
2303 Point<dim>() + Point<dim>::unit_vector(1),
2304 Point<dim>::unit_vector(0) + Point<dim>::unit_vector(1)};
2305 return vertices[v];
2306 }
2307 }
2308 break;
2309 }
2310 case 3:
2311 {
2312 switch (this->kind)
2313 {
2314 case ReferenceCells::Tetrahedron:
2315 {
2316 static const Point<dim> vertices[4] = {
2317 Point<dim>(), // the origin
2318 Point<dim>::unit_vector(0), // unit point along x-axis
2319 Point<dim>::unit_vector(1), // unit point along y-axis
2320 Point<dim>::unit_vector(2) // unit point along z-axis
2321 };
2322 return vertices[v];
2323 }
2324 case ReferenceCells::Pyramid:
2325 {
2326 static const Point<dim> vertices[5] = {
2327 Point<dim>{-1.0, -1.0, 0.0},
2328 Point<dim>{+1.0, -1.0, 0.0},
2329 Point<dim>{-1.0, +1.0, 0.0},
2330 Point<dim>{+1.0, +1.0, 0.0},
2331 Point<dim>{+0.0, +0.0, 1.0}};
2332 return vertices[v];
2333 }
2334 case ReferenceCells::Wedge:
2335 {
2336 static const Point<dim> vertices[6] = {
2337 // First the three points on the triangular base of the
2338 // wedge:
2339 Point<dim>(),
2340 Point<dim>::unit_vector(0),
2341 Point<dim>::unit_vector(1),
2342 // And now everything shifted in the z-direction again
2343 Point<dim>() + Point<dim>::unit_vector(2),
2344 Point<dim>::unit_vector(0) + Point<dim>::unit_vector(2),
2345 Point<dim>::unit_vector(1) + Point<dim>::unit_vector(2)};
2346 return vertices[v];
2347 }
2348 case ReferenceCells::Hexahedron:
2349 {
2350 static const Point<dim> vertices[8] = {
2351 // First the two points on the x-axis
2352 Point<dim>(),
2353 Point<dim>::unit_vector(0),
2354 // Then these two points shifted in the y-direction
2355 Point<dim>() + Point<dim>::unit_vector(1),
2356 Point<dim>::unit_vector(0) + Point<dim>::unit_vector(1),
2357 // And now all four points shifted in the z-direction
2358 Point<dim>() + Point<dim>::unit_vector(2),
2359 Point<dim>::unit_vector(0) + Point<dim>::unit_vector(2),
2360 Point<dim>() + Point<dim>::unit_vector(1) +
2361 Point<dim>::unit_vector(2),
2362 Point<dim>::unit_vector(0) + Point<dim>::unit_vector(1) +
2363 Point<dim>::unit_vector(2)};
2364 return vertices[v];
2365 }
2366 }
2367 break;
2368 }
2369 default:
2370 DEAL_II_NOT_IMPLEMENTED();
2371 }
2372
2373 DEAL_II_NOT_IMPLEMENTED();
2374 return Point<dim>();
2375}
2376
2377
2378
2379template <int dim>
2380inline constexpr unsigned int
2381ReferenceCell<dim>::n_faces() const
2382{
2383 switch (this->kind)
2384 {
2385 case ReferenceCells::Vertex:
2386 return 0;
2387 case ReferenceCells::Line:
2388 return 2;
2389 case ReferenceCells::Triangle:
2390 return 3;
2391 case ReferenceCells::Quadrilateral:
2392 return 4;
2393 case ReferenceCells::Tetrahedron:
2394 return 4;
2395 case ReferenceCells::Pyramid:
2396 return 5;
2397 case ReferenceCells::Wedge:
2398 return 5;
2399 case ReferenceCells::Hexahedron:
2400 return 6;
2401 default:
2402 DEAL_II_NOT_IMPLEMENTED();
2403 }
2404
2405 return numbers::invalid_unsigned_int;
2406}
2407
2408
2409
2410template <int dim>
2411inline std_cxx20::ranges::iota_view<unsigned int, unsigned int>
2412ReferenceCell<dim>::face_indices() const
2413{
2414 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(0U,
2415 n_faces());
2416}
2417
2418
2419
2420template <int dim>
2421inline std_cxx20::ranges::iota_view<unsigned int, unsigned int>
2422ReferenceCell<dim>::face_indices_by_type(
2423 const ReferenceCell<dim - 1> &face_ref_type) const
2424{
2425 switch (this->kind)
2426 {
2427 case ReferenceCells::Vertex:
2428 return this->face_indices(); // no faces
2429 case ReferenceCells::Line:
2430 if (face_ref_type == ReferenceCells::Vertex)
2431 return this->face_indices();
2432 else
2433 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(0U,
2434 0U);
2435 case ReferenceCells::Triangle:
2436 case ReferenceCells::Quadrilateral:
2437 if (face_ref_type == ReferenceCells::Line)
2438 return this->face_indices();
2439 else
2440 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(0U,
2441 0U);
2442 case ReferenceCells::Tetrahedron:
2443 if (face_ref_type == ReferenceCells::Triangle)
2444 return this->face_indices();
2445 else
2446 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(0U,
2447 0U);
2448 case ReferenceCells::Pyramid:
2449 switch (face_ref_type)
2450 {
2451 case ReferenceCells::Triangle:
2452 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(
2453 1U, 5U);
2454 case ReferenceCells::Quadrilateral:
2455 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(
2456 0U, 1U);
2457 default:
2458 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(
2459 0U, 0U);
2460 }
2461 case ReferenceCells::Wedge:
2462 switch (face_ref_type)
2463 {
2464 case ReferenceCells::Triangle:
2465 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(
2466 0U, 2U);
2467 case ReferenceCells::Quadrilateral:
2468 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(
2469 2U, 5U);
2470 default:
2471 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(
2472 0U, 0U);
2473 }
2474 case ReferenceCells::Hexahedron:
2475 if (face_ref_type == ReferenceCells::Quadrilateral)
2476 return this->face_indices();
2477 else
2478 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(0U,
2479 0U);
2480 default:
2481 DEAL_II_NOT_IMPLEMENTED();
2482 }
2483
2484 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(0U, 0U);
2485}
2486
2487
2488
2489template <int dim>
2490inline constexpr unsigned int
2491ReferenceCell<dim>::n_isotropic_refinement_choices() const
2492{
2493 switch (this->kind)
2494 {
2495 case ReferenceCells::Vertex:
2496 return 1;
2497 case ReferenceCells::Line:
2498 return 1;
2499 case ReferenceCells::Triangle:
2500 return 1;
2501 case ReferenceCells::Quadrilateral:
2502 return 1;
2503 case ReferenceCells::Tetrahedron:
2504 return 3;
2505 case ReferenceCells::Pyramid:
2506 return 1;
2507 case ReferenceCells::Wedge:
2508 return 1;
2509 case ReferenceCells::Hexahedron:
2510 return 1;
2511 default:
2512 DEAL_II_ASSERT_UNREACHABLE();
2513 }
2514
2515 return numbers::invalid_unsigned_int;
2516}
2517
2518
2519
2520template <int dim>
2521inline IsotropicRefinementChoice
2522ReferenceCell<dim>::get_isotropic_refinement_choice(
2523 const unsigned int ref_choice) const
2524{
2525 AssertIndexRange(ref_choice, n_isotropic_refinement_choices());
2526 switch (this->kind)
2527 {
2528 case ReferenceCells::Tetrahedron:
2529 {
2530 static constexpr ndarray<IsotropicRefinementChoice, 3>
2531 isotropic_ref_choices = {{IsotropicRefinementChoice::cut_tet_68,
2532 IsotropicRefinementChoice::cut_tet_57,
2533 IsotropicRefinementChoice::cut_tet_49}};
2534 return isotropic_ref_choices[ref_choice];
2535 }
2536 default:
2537 {
2538 DEAL_II_NOT_IMPLEMENTED();
2539 }
2540 }
2541
2542 return IsotropicRefinementChoice::isotropic_refinement;
2543}
2544
2545
2546
2547template <int dim>
2548inline constexpr unsigned int
2549ReferenceCell<dim>::n_isotropic_children() const
2550{
2551 switch (this->kind)
2552 {
2553 case ReferenceCells::Vertex:
2554 return 1;
2555 case ReferenceCells::Line:
2556 return 2;
2557 case ReferenceCells::Triangle:
2558 return 4;
2559 case ReferenceCells::Quadrilateral:
2560 return 4;
2561 case ReferenceCells::Tetrahedron:
2562 return 8;
2563 case ReferenceCells::Pyramid:
2564 return 10;
2565 case ReferenceCells::Wedge:
2566 return 8;
2567 case ReferenceCells::Hexahedron:
2568 return 8;
2569 default:
2570 DEAL_II_ASSERT_UNREACHABLE();
2571 }
2572
2573 return numbers::invalid_unsigned_int;
2574}
2575
2576
2577
2578template <int dim>
2579unsigned int
2580ReferenceCell<dim>::n_children(const RefinementCase<dim> ref_case) const
2581{
2582 // Use GeometryInfo here to keep it the single source of truth
2583 if (this->is_hyper_cube())
2584 return GeometryInfo<dim>::n_children(ref_case);
2585
2586 // TODO: Rewrite once refinement cases are cleaned up
2587 // For all other cells, we assume that only isotropic refinement is
2588 // implemented. This is a strong assumption that should be removed as soon as
2589 // the issue regarding the uniqueness of refinement cases is resolved.
2590 //
2591 // This is a short outline of the issue: Different refinement options are
2592 // stored as an enum, primarily focusing on hypercubes. They therefore are (to
2593 // some extent) unsuitable for other cell types. For example, there are
2594 // multiple ways to isotropically refine a tetrahedron. Distinguishing between
2595 // these required the introduction of the additional
2596 // `IsotropicRefinementChoice` enum. However, this leads to a conflict where
2597 // the same integer value is assigned to multiple different refinement options
2598 // across the existing refinement cases. The most critical conflict is likely
2599 // `IsotropicRefinementChoice::isotropic_refinement` shadowing
2600 // `RefinementPossibilities<~>::no_refinement`.
2601 // The following code attempts to circumvent this mess by predicting whether
2602 // the given refinement case is isotropic and then returning either the number
2603 // of isotropic children or `0` (see below for why `0` is used).
2604
2605 // Detect isotropic refinement.
2606 // Only in 3D and only for Tetrahedrons we have ambiguity. But first assume
2607 // that we don't have a tet.
2608 bool is_isotropic =
2609 (ref_case == RefinementPossibilities<dim>::isotropic_refinement);
2610
2611 // check if assumption of line above was correct, else apply fix for tet
2612 if constexpr (dim == 3) // check for dim first (only 3D relevant for tet)
2613 if (*this == ReferenceCells::Tetrahedron) // tets
2614 is_isotropic =
2615 ((ref_case == //
2616 RefinementPossibilities<dim>::isotropic_refinement) ||
2617 // We must not check
2618 // `IsotropicRefinementChoice::isotropic_refinement`
2619 // because it coincides with
2620 // `RefinementPossibilities<dim>::no_refinement`
2621 // (both are 0).
2622 (ref_case ==
2623 static_cast<typename RefinementPossibilities<dim>::Possibilities>(
2624 IsotropicRefinementChoice::cut_tet_68)) || //
2625 (ref_case ==
2626 static_cast<typename RefinementPossibilities<dim>::Possibilities>(
2627 IsotropicRefinementChoice::cut_tet_57)) || //
2628 (ref_case ==
2629 static_cast<typename RefinementPossibilities<dim>::Possibilities>(
2630 IsotropicRefinementChoice::cut_tet_49)));
2631
2632
2633 // return the according value
2634 if (is_isotropic)
2635 return n_isotropic_children();
2636
2637 // Unsupported case
2638
2639 // DEAL_II_NOT_IMPLEMENTED();
2640 // We must return some data. Many parts of the code aren't aware
2641 // which refinement cases are actually supported, calling this
2642 // function with impossible refinement cases and expecting some
2643 // output. One example is the constructor of `FiniteElement`.
2644 return 0;
2645}
2646
2647
2648
2649template <int dim>
2650inline std_cxx20::ranges::iota_view<unsigned int, unsigned int>
2651ReferenceCell<dim>::isotropic_child_indices() const
2652{
2653 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(
2654 0U, n_isotropic_children());
2655}
2656
2657
2658
2659template <int dim>
2660inline std_cxx20::ranges::iota_view<unsigned int, unsigned int>
2661ReferenceCell<dim>::vertex_indices() const
2662{
2663 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(0U,
2664 n_vertices());
2665}
2666
2667
2668
2669template <int dim>
2670inline std_cxx20::ranges::iota_view<unsigned int, unsigned int>
2671ReferenceCell<dim>::line_indices() const
2672{
2673 return std_cxx20::ranges::iota_view<unsigned int, unsigned int>(0U,
2674 n_lines());
2675}
2676
2677
2678
2679template <int dim>
2680inline ArrayView<const RefinementCase<dim>>
2681ReferenceCell<dim>::refinement_cases() const
2682{
2683 AssertDimension(dim, get_dimension());
2684
2685 if constexpr (dim == 0)
2686 {
2687 // Like equivalent_refinement_case(), to better enable generic
2688 // programming, return a value implying vertices can be refined since 1d
2689 // Triangulations can be refined.
2690 static constexpr std::array<RefinementCase<0>, 1> possibilities{
2691 {RefinementPossibilities<0>::isotropic_refinement}};
2692 return make_array_view(possibilities);
2693 }
2694 else if constexpr (dim == 1)
2695 {
2696 static constexpr std::array<RefinementCase<1>, 1> possibilities{
2697 {RefinementPossibilities<1>::isotropic_refinement}};
2698 return make_array_view(possibilities);
2699 }
2700 else if constexpr (dim == 2)
2701 {
2702 switch (this->kind)
2703 {
2704 case ReferenceCells::Triangle:
2705 {
2706 static constexpr std::array<RefinementCase<2>, 1> possibilities{
2707 {RefinementPossibilities<2>::isotropic_refinement}};
2708 return make_array_view(possibilities);
2709 }
2710 case ReferenceCells::Quadrilateral:
2711 {
2712 static constexpr std::array<RefinementCase<2>, 3> possibilities{
2713 {RefinementPossibilities<2>::cut_x,
2714 RefinementPossibilities<2>::cut_y,
2715 RefinementPossibilities<2>::isotropic_refinement}};
2716 return make_array_view(possibilities);
2717 }
2718 default:
2719 DEAL_II_ASSERT_UNREACHABLE();
2720 }
2721 }
2722 else if constexpr (dim == 3)
2723 {
2724 switch (this->kind)
2725 {
2726 case ReferenceCells::Tetrahedron:
2727 case ReferenceCells::Pyramid:
2728 case ReferenceCells::Wedge:
2729 {
2730 static constexpr std::array<RefinementCase<3>, 1> possibilities{
2731 {RefinementPossibilities<3>::isotropic_refinement}};
2732 return make_array_view(possibilities);
2733 }
2734 case ReferenceCells::Hexahedron:
2735 {
2736 static constexpr std::array<RefinementCase<3>, 7> possibilities{
2737 {RefinementPossibilities<3>::cut_x,
2738 RefinementPossibilities<3>::cut_y,
2739 RefinementPossibilities<3>::cut_xy,
2740 RefinementPossibilities<3>::cut_z,
2741 RefinementPossibilities<3>::cut_xz,
2742 RefinementPossibilities<3>::cut_yz,
2743 RefinementPossibilities<3>::isotropic_refinement}};
2744 return make_array_view(possibilities);
2745 }
2746 default:
2747 DEAL_II_ASSERT_UNREACHABLE();
2748 }
2749 }
2750
2751 DEAL_II_ASSERT_UNREACHABLE();
2752 return ArrayView<RefinementCase<dim>>();
2753}
2754
2755
2756
2757template <int dim>
2758inline constexpr ReferenceCell<dim - 1>
2759ReferenceCell<dim>::face_reference_cell(const unsigned int face_no) const
2760{
2761 AssertIndexRange(face_no, n_faces());
2762
2763 if constexpr (dim == 0)
2764 return ReferenceCells::Invalid<dim - 1>;
2765 else if constexpr (dim == 1)
2766 return ReferenceCells::Vertex;
2767 else if constexpr (dim == 2)
2768 return ReferenceCells::Line;
2769 else if constexpr (dim == 3)
2770 {
2771 switch (this->kind)
2772 {
2773 case ReferenceCells::Tetrahedron:
2774 return ReferenceCells::Triangle;
2775 case ReferenceCells::Pyramid:
2776 if (face_no == 0)
2777 return ReferenceCells::Quadrilateral;
2778 else
2779 return ReferenceCells::Triangle;
2780 case ReferenceCells::Wedge:
2781 if (face_no > 1)
2782 return ReferenceCells::Quadrilateral;
2783 else
2784 return ReferenceCells::Triangle;
2785 case ReferenceCells::Hexahedron:
2786 return ReferenceCells::Quadrilateral;
2787 default:
2788 DEAL_II_NOT_IMPLEMENTED();
2789 }
2790 }
2791 else
2792 DEAL_II_NOT_IMPLEMENTED();
2793}
2794
2795
2796
2797template <int dim>
2798inline constexpr types::geometric_orientation
2803
2804
2805
2806template <int dim>
2807inline constexpr types::geometric_orientation
2808ReferenceCell<dim>::reversed_combined_line_orientation()
2809{
2810 // For a reversed line 'orientation' is false and neither flip nor rotate
2811 // are defined.
2812 return numbers::reverse_line_orientation;
2813}
2814
2815
2816
2817template <int dim>
2818inline unsigned int
2819ReferenceCell<dim>::child_cell_on_face(const unsigned int face,
2820 const unsigned int subface) const
2821{
2822 return child_cell_on_face(face,
2823 subface,
2824 numbers::default_geometric_orientation);
2825}
2826
2827
2828
2829template <int dim>
2830inline unsigned int
2831ReferenceCell<dim>::child_cell_on_face(
2832 const unsigned int face,
2833 const unsigned int subface,
2834 const types::geometric_orientation combined_orientation) const
2835{
2836 AssertIndexRange(face, n_faces());
2837 AssertIndexRange(subface, face_reference_cell(face).n_isotropic_children());
2838
2839 switch (this->kind)
2840 {
2841 case ReferenceCells::Vertex:
2842 case ReferenceCells::Line:
2843 {
2844 DEAL_II_NOT_IMPLEMENTED();
2845 break;
2846 }
2847 case ReferenceCells::Triangle:
2848 {
2849 static constexpr ndarray<unsigned int, 3, 2> subcells = {
2850 {{{0, 1}}, {{1, 2}}, {{2, 0}}}};
2851
2852 Assert(combined_orientation ==
2853 numbers::default_geometric_orientation ||
2854 combined_orientation == numbers::reverse_line_orientation,
2855 ExcInternalError());
2856 return subcells[face][combined_orientation ==
2857 numbers::default_geometric_orientation ?
2858 subface :
2859 1 - subface];
2860 }
2861 case ReferenceCells::Quadrilateral:
2862 {
2863 const auto [face_orientation, face_rotation, face_flip] =
2864 internal::split_face_orientation(combined_orientation);
2865
2866 return GeometryInfo<2>::child_cell_on_face(
2867 RefinementCase<2>(RefinementPossibilities<2>::isotropic_refinement),
2868 face,
2869 subface,
2870 face_orientation,
2871 face_flip,
2872 face_rotation);
2873 }
2874 case ReferenceCells::Tetrahedron:
2875 case ReferenceCells::Pyramid:
2876 case ReferenceCells::Wedge:
2877 {
2878 DEAL_II_NOT_IMPLEMENTED();
2879 break;
2880 }
2881 case ReferenceCells::Hexahedron:
2882 {
2883 const auto [face_orientation, face_rotation, face_flip] =
2884 internal::split_face_orientation(combined_orientation);
2885
2886 return GeometryInfo<3>::child_cell_on_face(
2887 RefinementCase<3>(RefinementPossibilities<3>::isotropic_refinement),
2888 face,
2889 subface,
2890 face_orientation,
2891 face_flip,
2892 face_rotation);
2893 }
2894 default:
2895 DEAL_II_NOT_IMPLEMENTED();
2896 }
2897
2898 return numbers::invalid_unsigned_int;
2899}
2900
2901
2902
2903template <int dim>
2904inline std::array<unsigned int, 2>
2905ReferenceCell<dim>::standard_vertex_to_face_and_vertex_index(
2906 const unsigned int vertex) const
2907{
2908 AssertIndexRange(vertex, n_vertices());
2909 // Work around a GCC warning at higher optimization levels by making all of
2910 // these tables the same size
2911 constexpr unsigned int X = numbers::invalid_unsigned_int;
2912
2913 switch (this->kind)
2914 {
2915 case ReferenceCells::Vertex:
2916 DEAL_II_NOT_IMPLEMENTED();
2917 break;
2918 case ReferenceCells::Line:
2919 {
2920 static constexpr ndarray<unsigned int, 2, 2> table = {
2921 {{{0, 0}}, {{1, 0}}}};
2922
2923 return table[vertex];
2924 }
2925 case ReferenceCells::Triangle:
2926 {
2927 static constexpr ndarray<unsigned int, 6, 2> table = {
2928 {{{0, 0}}, {{0, 1}}, {{1, 1}}, {{X, X}}, {{X, X}}, {{X, X}}}};
2929
2930 return table[vertex];
2931 }
2932 case ReferenceCells::Quadrilateral:
2933 {
2934 return GeometryInfo<2>::standard_quad_vertex_to_line_vertex_index(
2935 vertex);
2936 }
2937 case ReferenceCells::Tetrahedron:
2938 {
2939 static constexpr ndarray<unsigned int, 6, 2> table = {
2940 {{{0, 0}}, {{0, 1}}, {{0, 2}}, {{1, 2}}, {{X, X}}, {{X, X}}}};
2941
2942 return table[vertex];
2943 }
2944 case ReferenceCells::Pyramid:
2945 {
2946 static constexpr ndarray<unsigned int, 6, 2> table = {
2947 {{{0, 0}}, {{0, 1}}, {{0, 2}}, {{0, 3}}, {{1, 2}}, {{X, X}}}};
2948
2949 return table[vertex];
2950 }
2951 case ReferenceCells::Wedge:
2952 {
2953 static constexpr ndarray<unsigned int, 6, 2> table = {
2954 {{{0, 1}}, {{0, 0}}, {{0, 2}}, {{1, 0}}, {{1, 1}}, {{1, 2}}}};
2955
2956 return table[vertex];
2957 }
2958 case ReferenceCells::Hexahedron:
2959 {
2960 return GeometryInfo<3>::standard_hex_vertex_to_quad_vertex_index(
2961 vertex);
2962 }
2963 default:
2964 DEAL_II_NOT_IMPLEMENTED();
2965 }
2966
2967 return {};
2968}
2969
2970
2971
2972template <int dim>
2973inline std::array<unsigned int, 2>
2974ReferenceCell<dim>::standard_line_to_face_and_line_index(
2975 const unsigned int line) const
2976{
2977 AssertIndexRange(line, n_lines());
2978
2979 switch (this->kind)
2980 {
2981 case ReferenceCells::Vertex:
2982 case ReferenceCells::Line:
2983 case ReferenceCells::Triangle:
2984 case ReferenceCells::Quadrilateral:
2985 {
2986 DEAL_II_NOT_IMPLEMENTED();
2987 break;
2988 }
2989 case ReferenceCells::Tetrahedron:
2990 {
2991 static const std::array<unsigned int, 2> table[6] = {
2992 {{0, 0}}, {{0, 1}}, {{0, 2}}, {{1, 1}}, {{1, 2}}, {{2, 1}}};
2993
2994 return table[line];
2995 }
2996 case ReferenceCells::Pyramid:
2997 {
2998 static const std::array<unsigned int, 2> table[8] = {{{0, 0}},
2999 {{0, 1}},
3000 {{0, 2}},
3001 {{0, 3}},
3002 {{1, 2}},
3003 {{2, 1}},
3004 {{1, 1}},
3005 {{2, 2}}};
3006
3007 return table[line];
3008 }
3009 case ReferenceCells::Wedge:
3010 {
3011 static const std::array<unsigned int, 2> table[9] = {{{0, 0}},
3012 {{0, 2}},
3013 {{0, 1}},
3014 {{1, 0}},
3015 {{1, 1}},
3016 {{1, 2}},
3017 {{2, 0}},
3018 {{2, 1}},
3019 {{3, 1}}};
3020
3021 return table[line];
3022 }
3023 case ReferenceCells::Hexahedron:
3024 {
3025 return GeometryInfo<3>::standard_hex_line_to_quad_line_index(line);
3026 }
3027 default:
3028 DEAL_II_NOT_IMPLEMENTED();
3029 }
3030
3031 return {};
3032}
3033
3034
3035
3036template <int dim>
3037inline unsigned int
3038ReferenceCell<dim>::line_to_cell_vertices(const unsigned int line,
3039 const unsigned int vertex) const
3040{
3041 AssertIndexRange(vertex, 2);
3042 AssertIndexRange(line, n_lines());
3043
3044 switch (this->kind)
3045 {
3046 case ReferenceCells::Vertex:
3047 case ReferenceCells::Line:
3048 return vertex;
3049 case ReferenceCells::Triangle:
3050 {
3051 static constexpr ndarray<unsigned int, 3, 2> table = {
3052 {{{0, 1}}, {{1, 2}}, {{2, 0}}}};
3053 return table[line][vertex];
3054 }
3055 case ReferenceCells::Quadrilateral:
3056 {
3057 static constexpr ndarray<unsigned int, 4, 2> table = {
3058 {{{0, 2}}, {{1, 3}}, {{0, 1}}, {{2, 3}}}};
3059 return table[line][vertex];
3060 }
3061 case ReferenceCells::Tetrahedron:
3062 {
3063 static constexpr ndarray<unsigned int, 6, 2> table = {
3064 {{{0, 1}}, {{1, 2}}, {{2, 0}}, {{0, 3}}, {{1, 3}}, {{2, 3}}}};
3065 return table[line][vertex];
3066 }
3067 case ReferenceCells::Pyramid:
3068 {
3069 static constexpr ndarray<unsigned int, 8, 2> table = {{{{0, 2}},
3070 {{1, 3}},
3071 {{0, 1}},
3072 {{2, 3}},
3073 {{0, 4}},
3074 {{1, 4}},
3075 {{2, 4}},
3076 {{3, 4}}}};
3077 return table[line][vertex];
3078 }
3079 case ReferenceCells::Wedge:
3080 {
3081 static constexpr ndarray<unsigned int, 9, 2> table = {{{{0, 1}},
3082 {{1, 2}},
3083 {{2, 0}},
3084 {{3, 4}},
3085 {{4, 5}},
3086 {{5, 3}},
3087 {{0, 3}},
3088 {{1, 4}},
3089 {{2, 5}}}};
3090 return table[line][vertex];
3091 }
3092 case ReferenceCells::Hexahedron:
3093 {
3094 // first four lines comprise the bottom face, next four are the top,
3095 // and the last four are 'bottom to top'
3096 static constexpr ndarray<unsigned int, 12, 2> table = {{{{0, 2}},
3097 {{1, 3}},
3098 {{0, 1}},
3099 {{2, 3}},
3100 {{4, 6}},
3101 {{5, 7}},
3102 {{4, 5}},
3103 {{6, 7}},
3104 {{0, 4}},
3105 {{1, 5}},
3106 {{2, 6}},
3107 {{3, 7}}}};
3108 return table[line][vertex];
3109 }
3110
3111 default:
3112 DEAL_II_NOT_IMPLEMENTED();
3113 }
3114
3115 return numbers::invalid_unsigned_int;
3116}
3117
3118
3119
3120template <int dim>
3121inline unsigned int
3122ReferenceCell<dim>::face_to_cell_lines(
3123 const unsigned int face,
3124 const unsigned int line,
3125 const types::geometric_orientation combined_face_orientation) const
3126{
3127 AssertIndexRange(face, n_faces());
3128 AssertIndexRange(line, face_reference_cell(face).n_lines());
3129
3130 static constexpr unsigned int X = numbers::invalid_unsigned_int;
3131
3132 switch (this->kind)
3133 {
3134 case ReferenceCells::Vertex:
3135 {
3136 // We can't get here based on the assertions above: vertices
3137 // have no faces.
3138 DEAL_II_ASSERT_UNREACHABLE();
3139 break;
3140 }
3141 case ReferenceCells::Line:
3142 {
3143 // We can't get here based on the assertions above: lines
3144 // have vertices as faces, which have no bounding lines.
3145 DEAL_II_ASSERT_UNREACHABLE();
3146 break;
3147 }
3148 case ReferenceCells::Triangle:
3149 case ReferenceCells::Quadrilateral:
3150 {
3151 // 2d cells have only one line per face, so the line we are
3152 // looking for is actually the face we were given:
3153 return face;
3154 }
3155 case ReferenceCells::Tetrahedron:
3156 {
3157 static constexpr ndarray<unsigned int, 4, 3> table = {
3158 {{{0, 1, 2}}, {{0, 3, 4}}, {{2, 5, 3}}, {{1, 4, 5}}}};
3159
3160 return table[face][standard_to_real_face_line(
3161 line, face, combined_face_orientation)];
3162 }
3163 case ReferenceCells::Pyramid:
3164 {
3165 static constexpr ndarray<unsigned int, 5, 4> table = {
3166 {{{0, 1, 2, 3}},
3167 {{0, 6, 4, X}},
3168 {{1, 5, 7, X}},
3169 {{2, 4, 5, X}},
3170 {{3, 7, 6, X}}}};
3171
3172 return table[face][standard_to_real_face_line(
3173 line, face, combined_face_orientation)];
3174 }
3175 case ReferenceCells::Wedge:
3176 {
3177 static constexpr ndarray<unsigned int, 5, 4> table = {
3178 {{{0, 2, 1, X}},
3179 {{3, 4, 5, X}},
3180 {{6, 7, 0, 3}},
3181 {{7, 8, 1, 4}},
3182 {{8, 6, 2, 5}}}};
3183
3184 return table[face][standard_to_real_face_line(
3185 line, face, combined_face_orientation)];
3186 }
3187 case ReferenceCells::Hexahedron:
3188 {
3189 const auto [face_orientation, face_rotation, face_flip] =
3190 internal::split_face_orientation(combined_face_orientation);
3191
3192 return GeometryInfo<3>::face_to_cell_lines(
3193 face, line, face_orientation, face_flip, face_rotation);
3194 }
3195 default:
3196 DEAL_II_NOT_IMPLEMENTED();
3197 }
3198
3199 return numbers::invalid_unsigned_int;
3200}
3201
3202
3203
3204template <int dim>
3205inline unsigned int
3206ReferenceCell<dim>::face_to_cell_vertices(
3207 const unsigned int face,
3208 const unsigned int vertex,
3209 const types::geometric_orientation combined_face_orientation) const
3210{
3211 AssertIndexRange(face, n_faces());
3212 AssertIndexRange(vertex, face_reference_cell(face).n_vertices());
3213 AssertIndexRange(combined_face_orientation, n_face_orientations(face));
3214
3215 switch (this->kind)
3216 {
3217 case ReferenceCells::Vertex:
3218 {
3219 // We can't get here based on the assertions above: vertices
3220 // have no faces.
3221 DEAL_II_ASSERT_UNREACHABLE();
3222 break;
3223 }
3224 case ReferenceCells::Line:
3225 {
3226 // A line has only one vertex per face, so the vertex we are
3227 // looking for is actually the face we were given:
3228 return face;
3229 }
3230 case ReferenceCells::Triangle:
3231 {
3232 static constexpr ndarray<unsigned int, 3, 2> table = {
3233 {{{0, 1}}, {{1, 2}}, {{2, 0}}}};
3234
3235 return table[face][combined_face_orientation ==
3236 numbers::default_geometric_orientation ?
3237 vertex :
3238 (1 - vertex)];
3239 }
3240 case ReferenceCells::Quadrilateral:
3241 {
3242 const auto [face_orientation, face_rotation, face_flip] =
3243 internal::split_face_orientation(combined_face_orientation);
3244
3245 return GeometryInfo<2>::face_to_cell_vertices(
3246 face, vertex, face_orientation, face_flip, face_rotation);
3247 }
3248 case ReferenceCells::Tetrahedron:
3249 {
3250 static constexpr ndarray<unsigned int, 4, 3> table = {
3251 {{{0, 1, 2}}, {{1, 0, 3}}, {{0, 2, 3}}, {{2, 1, 3}}}};
3252
3253 return table[face][standard_to_real_face_vertex(
3254 vertex, face, combined_face_orientation)];
3255 }
3256 case ReferenceCells::Pyramid:
3257 {
3258 constexpr auto X = numbers::invalid_unsigned_int;
3259 static constexpr ndarray<unsigned int, 5, 4> table = {
3260 {{{0, 1, 2, 3}},
3261 {{0, 2, 4, X}},
3262 {{3, 1, 4, X}},
3263 {{1, 0, 4, X}},
3264 {{2, 3, 4, X}}}};
3265
3266 return table[face][standard_to_real_face_vertex(
3267 vertex, face, combined_face_orientation)];
3268 }
3269 case ReferenceCells::Wedge:
3270 {
3271 constexpr auto X = numbers::invalid_unsigned_int;
3272 static constexpr ndarray<unsigned int, 6, 4> table = {
3273 {{{1, 0, 2, X}},
3274 {{3, 4, 5, X}},
3275 {{0, 1, 3, 4}},
3276 {{1, 2, 4, 5}},
3277 {{2, 0, 5, 3}}}};
3278
3279 return table[face][standard_to_real_face_vertex(
3280 vertex, face, combined_face_orientation)];
3281 }
3282 case ReferenceCells::Hexahedron:
3283 {
3284 const auto [face_orientation, face_rotation, face_flip] =
3285 internal::split_face_orientation(combined_face_orientation);
3286
3287 return GeometryInfo<3>::face_to_cell_vertices(
3288 face, vertex, face_orientation, face_flip, face_rotation);
3289 }
3290 default:
3291 DEAL_II_NOT_IMPLEMENTED();
3292 }
3293
3294 return numbers::invalid_unsigned_int;
3295}
3296
3297
3298
3299template <int dim>
3300inline unsigned int
3301ReferenceCell<dim>::face_and_line_to_cell_vertices(
3302 const unsigned int face,
3303 const unsigned int line,
3304 const unsigned int vertex,
3305 const types::geometric_orientation combined_face_orientation) const
3306{
3307 AssertIndexRange(face, n_faces());
3308 AssertIndexRange(line, this->face_reference_cell(face).n_lines());
3309 AssertIndexRange(vertex, 2);
3310 AssertIndexRange(combined_face_orientation, n_face_orientations(face));
3311
3312 switch (this->kind)
3313 {
3314 case ReferenceCells::Vertex:
3315 {
3316 // We can't get here based on the assertions above: vertices
3317 // have no faces.
3318 DEAL_II_ASSERT_UNREACHABLE();
3319 break;
3320 }
3321 case ReferenceCells::Line:
3322 {
3323 // We can't get here based on the assertions above: Lines'
3324 // faces are vertices that have no lines as sub-objects.
3325 DEAL_II_ASSERT_UNREACHABLE();
3326 break;
3327 }
3328 case ReferenceCells::Triangle:
3329 case ReferenceCells::Quadrilateral:
3330 {
3331 // For 2d objects, each face has (and is identical to) exactly
3332 // one line, so we can ask the other function:
3333 return face_to_cell_vertices(face, vertex, combined_face_orientation);
3334 }
3335 case ReferenceCells::Tetrahedron:
3336 {
3337 Assert(combined_face_orientation ==
3338 numbers::default_geometric_orientation,
3339 ExcNotImplemented());
3340
3341 const static ::ndarray<unsigned int, 4, 3, 2> table = {
3342 {{{{{0, 1}}, {{1, 2}}, {{2, 0}}}},
3343 {{{{1, 0}}, {{0, 3}}, {{3, 1}}}},
3344 {{{{0, 2}}, {{2, 3}}, {{3, 0}}}},
3345 {{{{2, 1}}, {{1, 3}}, {{3, 2}}}}}};
3346
3347 return table[face][line][vertex];
3348 }
3349 case ReferenceCells::Pyramid:
3350 {
3351 Assert(combined_face_orientation ==
3352 numbers::default_geometric_orientation,
3353 ExcNotImplemented());
3354
3355 static const unsigned int X = static_cast<unsigned int>(-1);
3356 const static ::ndarray<unsigned int, 5, 4, 2> table = {
3357 {{{{{0, 2}}, {{1, 3}}, {{0, 1}}, {{2, 3}}}},
3358 {{{{0, 2}}, {{2, 4}}, {{4, 0}}, {{X, X}}}},
3359 {{{{3, 1}}, {{1, 4}}, {{4, 3}}, {{X, X}}}},
3360 {{{{1, 0}}, {{0, 4}}, {{4, 1}}, {{X, X}}}},
3361 {{{{2, 3}}, {{3, 4}}, {{4, 2}}, {{X, X}}}}}};
3362
3363 return table[face][line][vertex];
3364 }
3365 case ReferenceCells::Wedge:
3366 {
3367 Assert(combined_face_orientation ==
3368 numbers::default_geometric_orientation,
3369 ExcNotImplemented());
3370
3371 static const unsigned int X = static_cast<unsigned int>(-1);
3372 const static ::ndarray<unsigned int, 5, 4, 2> table = {
3373 {{{{{1, 0}}, {{0, 2}}, {{2, 1}}, {{X, X}}}},
3374 {{{{3, 4}}, {{4, 5}}, {{5, 3}}, {{X, X}}}},
3375 {{{{0, 3}}, {{1, 4}}, {{0, 1}}, {{3, 4}}}},
3376 {{{{1, 4}}, {{2, 5}}, {{1, 2}}, {{4, 5}}}},
3377 {{{{2, 5}}, {{0, 3}}, {{2, 0}}, {{5, 3}}}}}};
3378
3379 return table[face][line][vertex];
3380 }
3381 case ReferenceCells::Hexahedron:
3382 {
3383 Assert(combined_face_orientation ==
3384 numbers::default_geometric_orientation,
3385 ExcNotImplemented());
3386
3387 const static ::ndarray<unsigned int, 6, 4, 2> table = {
3388 {{{{{0, 4}}, {{2, 6}}, {{0, 2}}, {{4, 6}}}},
3389 {{{{1, 5}}, {{3, 7}}, {{1, 3}}, {{5, 7}}}},
3390 {{{{0, 1}}, {{4, 5}}, {{0, 4}}, {{1, 5}}}},
3391 {{{{2, 3}}, {{6, 7}}, {{2, 6}}, {{3, 7}}}},
3392 {{{{0, 2}}, {{1, 3}}, {{0, 1}}, {{2, 3}}}},
3393 {{{{4, 6}}, {{5, 7}}, {{4, 5}}, {{6, 7}}}}}};
3394
3395 return table[face][line][vertex];
3396 }
3397 default:
3398 DEAL_II_NOT_IMPLEMENTED();
3399 }
3400
3401 return numbers::invalid_unsigned_int;
3402}
3403
3404
3405
3406template <int dim>
3407Point<dim>
3408ReferenceCell<dim>::face_vertex_location(const unsigned int face,
3409 const unsigned int vertex) const
3410{
3411 return this->vertex(face_to_cell_vertices(
3412 face, vertex, numbers::default_geometric_orientation));
3413}
3414
3415
3416
3417template <int dim>
3418inline unsigned int
3419ReferenceCell<dim>::standard_to_real_face_vertex(
3420 const unsigned int vertex,
3421 const unsigned int face,
3422 const types::geometric_orientation face_orientation) const
3423{
3424 AssertIndexRange(face, n_faces());
3425 AssertIndexRange(vertex, face_reference_cell(face).n_vertices());
3426 AssertIndexRange(face_orientation, n_face_orientations(face));
3427
3428 switch (face_reference_cell(face))
3429 {
3430 case ReferenceCells::Vertex:
3431 // test to ensure that face_orientation is
3432 // default_geometric_orientation already done with
3433 // AssertIndexRange(face_orientation, ...) above.
3434 return vertex;
3435 case ReferenceCells::Line:
3436 return line_vertex_permutations[face_orientation][vertex];
3437 case ReferenceCells::Triangle:
3438 return triangle_vertex_permutations[face_orientation][vertex];
3439 case ReferenceCells::Quadrilateral:
3440 return quadrilateral_vertex_permutations[face_orientation][vertex];
3441 default:
3442 DEAL_II_NOT_IMPLEMENTED();
3443 }
3444
3445 DEAL_II_ASSERT_UNREACHABLE();
3446 return numbers::invalid_unsigned_int;
3447}
3448
3449
3450
3451template <int dim>
3452inline unsigned int
3453ReferenceCell<dim>::standard_to_real_face_line(
3454 const unsigned int line,
3455 const unsigned int face,
3456 const types::geometric_orientation face_orientation) const
3457{
3458 AssertIndexRange(face, n_faces());
3459 AssertIndexRange(line, face_reference_cell(face).n_lines());
3460 AssertIndexRange(face_orientation, n_face_orientations(face));
3461
3462 switch (face_reference_cell(face))
3463 {
3464 case ReferenceCells::Triangle:
3465 return triangle_line_permutations[face_orientation][line];
3466 case ReferenceCells::Quadrilateral:
3467 return quadrilateral_line_permutations[face_orientation][line];
3468 // case ReferenceCells::Vertex:
3469 // case ReferenceCells::Line:
3470 // case ReferenceCells::Invalid:
3471 default:
3472 DEAL_II_NOT_IMPLEMENTED();
3473 }
3474
3475 DEAL_II_ASSERT_UNREACHABLE();
3476 return numbers::invalid_unsigned_int;
3477}
3478
3479
3480
3481namespace ReferenceCells
3482{
3483 template <int dim>
3484 constexpr const std::vector<ReferenceCell<dim>>
3485 get_reference_cells_in_dim()
3486 {
3487 if constexpr (dim == 0)
3488 return {{ReferenceCells::Vertex}};
3489 else if constexpr (dim == 1)
3490 return {{ReferenceCells::Line}};
3491 else if constexpr (dim == 2)
3492 return {{ReferenceCells::Triangle, ReferenceCells::Quadrilateral}};
3493 else if constexpr (dim == 3)
3494 return {{ReferenceCells::Tetrahedron,
3495 ReferenceCells::Pyramid,
3496 ReferenceCells::Wedge,
3497 ReferenceCells::Hexahedron}};
3498 else
3499 DEAL_II_NOT_IMPLEMENTED();
3500
3501 return {};
3502 }
3503
3504
3505
3506 template <int dim>
3507 inline constexpr const ReferenceCell<dim> &
3508 get_simplex()
3509 {
3510 if constexpr (dim == 0)
3511 return ReferenceCells::Vertex;
3512 else if constexpr (dim == 1)
3513 return ReferenceCells::Line;
3514 else if constexpr (dim == 2)
3515 return ReferenceCells::Triangle;
3516 else if constexpr (dim == 3)
3517 return ReferenceCells::Tetrahedron;
3518 else
3519 DEAL_II_NOT_IMPLEMENTED();
3520
3521 return ReferenceCells::Invalid<dim>;
3522 }
3523
3524
3525
3526 template <int dim>
3527 inline constexpr const ReferenceCell<dim> &
3528 get_hypercube()
3529 {
3530 if constexpr (dim == 0)
3531 return ReferenceCells::Vertex;
3532 else if constexpr (dim == 1)
3533 return ReferenceCells::Line;
3534 else if constexpr (dim == 2)
3535 return ReferenceCells::Quadrilateral;
3536 else if constexpr (dim == 3)
3537 return ReferenceCells::Hexahedron;
3538 else
3539 DEAL_II_NOT_IMPLEMENTED();
3540 return ReferenceCells::Invalid<dim>;
3541 }
3542
3543
3544
3545 template <int dim>
3546 inline constexpr unsigned int
3547 n_reference_cells_in_dim()
3548 {
3549 if constexpr (dim == 0 || dim == 1)
3550 return 1; // Vertex or Line
3551 else if (dim == 2)
3552 return 2; // Quad and Tri
3553 else if (dim == 3)
3554 return 4; // Tet, Pyramid, Wedge and Hex
3555 else
3556 DEAL_II_NOT_IMPLEMENTED();
3557 return 0;
3558 }
3559
3560
3561
3562 template <int dim>
3563 inline ReferenceCell<dim>
3564 n_vertices_to_reference_cell(const unsigned int n_vertices)
3565 {
3566 if constexpr (dim == 0)
3567 if (n_vertices == 1)
3568 return ReferenceCells::Vertex;
3569
3570 if constexpr (dim == 1)
3571 {
3572 if (n_vertices == 2)
3573 return ReferenceCells::Line;
3574 }
3575
3576 if constexpr (dim == 2)
3577 {
3578 if (n_vertices == 3)
3579 return ReferenceCells::Triangle;
3580 else if (n_vertices == 4)
3581 return ReferenceCells::Quadrilateral;
3582 }
3583
3584 if constexpr (dim == 3)
3585 {
3586 if (n_vertices == 4)
3587 return ReferenceCells::Tetrahedron;
3588 else if (n_vertices == 5)
3589 return ReferenceCells::Pyramid;
3590 if (n_vertices == 6)
3591 return ReferenceCells::Wedge;
3592 else if (n_vertices == 8)
3593 return ReferenceCells::Hexahedron;
3594 }
3595
3596 Assert(false,
3597 ExcMessage("The combination of dim = " + std::to_string(dim) +
3598 " and n_vertices = " + std::to_string(n_vertices) +
3599 " does not correspond to a known reference cell type."));
3600 return ReferenceCells::Invalid<dim>;
3601 }
3602
3603
3604
3605 template <int structdim>
3606 inline constexpr unsigned int
3611
3612
3613
3614 template <int structdim>
3615 inline constexpr unsigned int
3620
3621
3622
3623 template <int structdim>
3624 inline constexpr unsigned int
3629
3630
3631
3632 template <int structdim>
3633 inline constexpr unsigned int
3634 max_n_children()
3635 {
3636 // Pyramids (3D) have 10 children.
3637 return structdim == 3 ? 10 : GeometryInfo<structdim>::max_children_per_cell;
3638 }
3639} // namespace ReferenceCells
3640
3641
3642
3643template <int dim>
3644inline ReferenceCell<dim>
3645ReferenceCell<dim>::n_vertices_to_type(const int dim_,
3646 const unsigned int n_vertices)
3647{
3648 AssertDimension(dim, dim_);
3649 return ReferenceCells::n_vertices_to_reference_cell<dim>(n_vertices);
3650}
3651
3652
3653
3654template <int dim>
3655inline double
3656ReferenceCell<dim>::d_linear_shape_function(const Point<dim> &xi,
3657 const unsigned int i) const
3658{
3659 AssertIndexRange(i, n_vertices());
3660
3661 switch (this->kind)
3662 {
3663 case ReferenceCells::Vertex:
3664 return 1.0;
3665 case ReferenceCells::Line:
3666 case ReferenceCells::Quadrilateral:
3667 case ReferenceCells::Hexahedron:
3668 if constexpr (dim > 0)
3669 return GeometryInfo<dim>::d_linear_shape_function(xi, i);
3670 DEAL_II_ASSERT_UNREACHABLE();
3671 // see also BarycentricPolynomials<2>::compute_value
3672 case ReferenceCells::Triangle:
3673 {
3674 switch (i)
3675 {
3676 case 0:
3677 return 1.0 - xi[std::min(0, dim - 1)] -
3678 xi[std::min(1, dim - 1)];
3679 case 1:
3680 return xi[std::min(0, dim - 1)];
3681 case 2:
3682 return xi[std::min(1, dim - 1)];
3683 default:
3684 DEAL_II_ASSERT_UNREACHABLE();
3685 }
3686 }
3687 // see also BarycentricPolynomials<3>::compute_value
3688 case ReferenceCells::Tetrahedron:
3689 {
3690 switch (i)
3691 {
3692 case 0:
3693 return 1.0 - xi[std::min(0, dim - 1)] -
3694 xi[std::min(1, dim - 1)] - xi[std::min(2, dim - 1)];
3695 case 1:
3696 return xi[std::min(0, dim - 1)];
3697 case 2:
3698 return xi[std::min(1, dim - 1)];
3699 case 3:
3700 return xi[std::min(2, dim - 1)];
3701 default:
3702 DEAL_II_ASSERT_UNREACHABLE();
3703 }
3704 }
3705 // see also ScalarLagrangePolynomialPyramid::compute_value()
3706 case ReferenceCells::Pyramid:
3707 {
3708 const double Q14 = 0.25;
3709
3710 const double r = xi[std::min(0, dim - 1)];
3711 const double s = xi[std::min(1, dim - 1)];
3712 const double t = xi[std::min(2, dim - 1)];
3713
3714 const double ratio =
3715 (std::fabs(t - 1.0) > 1.0e-14 ? (r * s * t) / (1.0 - t) : 0.0);
3716
3717 if (i == 0)
3718 return Q14 * ((1.0 - r) * (1.0 - s) - t + ratio);
3719 if (i == 1)
3720 return Q14 * ((1.0 + r) * (1.0 - s) - t - ratio);
3721 if (i == 2)
3722 return Q14 * ((1.0 - r) * (1.0 + s) - t - ratio);
3723 if (i == 3)
3724 return Q14 * ((1.0 + r) * (1.0 + s) - t + ratio);
3725 else
3726 return t;
3727 }
3728 // see also ScalarLagrangePolynomialWedge::compute_value()
3729 case ReferenceCells::Wedge:
3730 return ReferenceCells::Triangle.d_linear_shape_function(
3731 Point<2>(xi[std::min(0, dim - 1)], xi[std::min(1, dim - 1)]),
3732 i % 3) *
3733 ReferenceCells::Line.d_linear_shape_function(
3734 Point<1>(xi[std::min(2, dim - 1)]), i / 3);
3735 default:
3736 DEAL_II_NOT_IMPLEMENTED();
3737 }
3738
3739 DEAL_II_ASSERT_UNREACHABLE();
3740 return 0.0;
3741}
3742
3743
3744
3745template <int dim>
3746inline Tensor<1, dim>
3747ReferenceCell<dim>::d_linear_shape_function_gradient(const Point<dim> &xi,
3748 const unsigned int i) const
3749{
3750 switch (this->kind)
3751 {
3752 case ReferenceCells::Vertex:
3753 case ReferenceCells::Line:
3754 case ReferenceCells::Quadrilateral:
3755 case ReferenceCells::Hexahedron:
3756 return GeometryInfo<dim>::d_linear_shape_function_gradient(xi, i);
3757 // see also BarycentricPolynomials<2>::compute_grad()
3758 case ReferenceCells::Triangle:
3759 switch (i)
3760 {
3761 case 0:
3762 return Point<dim>(-1.0, -1.0);
3763 case 1:
3764 return Point<dim>(+1.0, +0.0);
3765 case 2:
3766 return Point<dim>(+0.0, +1.0);
3767 default:
3768 DEAL_II_ASSERT_UNREACHABLE();
3769 }
3770 default:
3771 DEAL_II_NOT_IMPLEMENTED();
3772 }
3773
3774 return Point<dim>(+0.0, +0.0, +0.0);
3775}
3776
3777
3778
3779template <int dim>
3780inline double
3781ReferenceCell<dim>::volume() const
3782{
3783 switch (this->kind)
3784 {
3785 case ReferenceCells::Vertex:
3786 return 1;
3787 case ReferenceCells::Line:
3788 return 1;
3789 case ReferenceCells::Triangle:
3790 return 1. / 2.;
3791 case ReferenceCells::Quadrilateral:
3792 return 1;
3793 case ReferenceCells::Tetrahedron:
3794 return 1. / 6.;
3795 case ReferenceCells::Pyramid:
3796 return 4. / 3.;
3797 case ReferenceCells::Wedge:
3798 return 1. / 2.;
3799 case ReferenceCells::Hexahedron:
3800 return 1;
3801 default:
3802 DEAL_II_NOT_IMPLEMENTED();
3803 }
3804
3805 return 0.0;
3806}
3807
3808
3809
3810template <int dim>
3811inline double
3812ReferenceCell<dim>::face_measure(const unsigned int face_no) const
3813{
3814 AssertIndexRange(face_no, n_faces());
3815 constexpr double X = std::numeric_limits<double>::signaling_NaN();
3816
3817 static const std::array<double, 5> tri_faces{
3818 {1.0, std::sqrt(2.0), 1.0, X, X}};
3819 static const std::array<double, 5> tet_faces{
3820 {0.5, 0.5, 0.5, std::sqrt(3.0) / 2.0, X}};
3821 static const std::array<double, 5> pyramid_faces{
3822 {4, std::sqrt(2.0), std::sqrt(2.0), std::sqrt(2.0), std::sqrt(2.0)}};
3823 static const std::array<double, 5> wedge_faces{
3824 {0.5, 0.5, 1.0, std::sqrt(2.0), 1.0}};
3825
3826 switch (this->kind)
3827 {
3828 case ReferenceCells::Vertex:
3829 case ReferenceCells::Line:
3830 case ReferenceCells::Quadrilateral:
3831 case ReferenceCells::Hexahedron:
3832 return 1.0;
3833 case ReferenceCells::Triangle:
3834 return tri_faces[face_no];
3835 case ReferenceCells::Tetrahedron:
3836 return tet_faces[face_no];
3837 case ReferenceCells::Pyramid:
3838 return pyramid_faces[face_no];
3839 case ReferenceCells::Wedge:
3840 return wedge_faces[face_no];
3841 }
3842 DEAL_II_ASSERT_UNREACHABLE();
3843 return X;
3844}
3845
3846
3847
3848template <int dim>
3849inline Point<dim>
3850ReferenceCell<dim>::barycenter() const
3851{
3852 switch (this->kind)
3853 {
3854 case ReferenceCells::Vertex:
3855 return Point<dim>();
3856 case ReferenceCells::Line:
3857 return Point<dim>(1. / 2.);
3858 case ReferenceCells::Triangle:
3859 return Point<dim>(1. / 3., 1. / 3.);
3860 case ReferenceCells::Quadrilateral:
3861 return Point<dim>(1. / 2., 1. / 2.);
3862 case ReferenceCells::Tetrahedron:
3863 return Point<dim>(1. / 4., 1. / 4., 1. / 4.);
3864 case ReferenceCells::Pyramid:
3865 return Point<dim>(0, 0, 1. / 4.);
3866 case ReferenceCells::Wedge:
3867 return Point<dim>(1. / 3, 1. / 3, 1. / 2.);
3868 case ReferenceCells::Hexahedron:
3869 return Point<dim>(1. / 2., 1. / 2., 1. / 2.);
3870 default:
3871 DEAL_II_NOT_IMPLEMENTED();
3872 }
3873
3874 return Point<dim>();
3875}
3876
3877
3878
3879template <int dim>
3880inline bool
3881ReferenceCell<dim>::contains_point(const Point<dim> &p,
3882 const double tolerance) const
3883{
3884 // Introduce abbreviations to silence compiler warnings about invalid
3885 // array accesses (that can't happen, of course, but the compiler
3886 // doesn't know that).
3887 constexpr unsigned int x_coordinate = 0;
3888 constexpr unsigned int y_coordinate = (dim >= 2 ? 1 : 0);
3889 constexpr unsigned int z_coordinate = (dim >= 3 ? 2 : 0);
3890
3891 switch (this->kind)
3892 {
3893 case ReferenceCells::Vertex:
3894 {
3895 // Vertices are special cases in that they do not actually
3896 // have coordinates. Error out if this function is called
3897 // with a vertex:
3898 Assert(false,
3899 ExcMessage("Vertices are zero-dimensional objects and "
3900 "as a consequence have no coordinates. You "
3901 "cannot meaningfully ask whether a point is "
3902 "inside a vertex (within a certain tolerance) "
3903 "without coordinate values."));
3904 return false;
3905 }
3906 case ReferenceCells::Line:
3907 case ReferenceCells::Quadrilateral:
3908 case ReferenceCells::Hexahedron:
3909 {
3910 for (unsigned int d = 0; d < dim; ++d)
3911 if ((p[d] < -tolerance) || (p[d] > 1 + tolerance))
3912 return false;
3913 return true;
3914 }
3915 case ReferenceCells::Triangle:
3916 case ReferenceCells::Tetrahedron:
3917 {
3918 // First make sure that we are in the first quadrant or octant
3919 for (unsigned int d = 0; d < dim; ++d)
3920 if (p[d] < -tolerance)
3921 return false;
3922
3923 // Now we also need to make sure that we are below the diagonal line
3924 // or plane that delineates the simplex. This diagonal is given by
3925 // sum(p[d])<=1, and a diagonal a distance eps away is given by
3926 // sum(p[d])<=1+eps*sqrt(d). (For example, the point at (1,1) is a
3927 // distance of 1/sqrt(2) away from the diagonal. That is, its
3928 // sum satisfies
3929 // sum(p[d]) = 2 <= 1 + (1/sqrt(2)) * sqrt(2)
3930 // in other words, it satisfies the predicate with eps=1/sqrt(2).)
3931 double sum = 0;
3932 for (unsigned int d = 0; d < dim; ++d)
3933 sum += p[d];
3934 return (sum <= 1 + tolerance * std::sqrt(1. * dim));
3935 }
3936 case ReferenceCells::Pyramid:
3937 {
3938 // A pyramid only lives in the upper half-space:
3939 if (p[z_coordinate] < -tolerance)
3940 return false;
3941
3942 // It also only lives in the space below z=1:
3943 if (p[z_coordinate] > 1 + tolerance)
3944 return false;
3945
3946 // Within what's left of the space, a pyramid is a cone that tapers
3947 // towards the top. First compute the distance of the point to the
3948 // axis in the max norm (this is the right norm because the vertices
3949 // of the pyramid are at points +/-1, +/-1):
3950 const double distance_from_axis =
3951 std::max(std::fabs(p[x_coordinate]), std::fabs(p[y_coordinate]));
3952
3953 // We are inside the pyramid if the distance from the axis is less
3954 // than (1-z)
3955 return (distance_from_axis <= 1 + tolerance - p[z_coordinate]);
3956 }
3957 case ReferenceCells::Wedge:
3958 {
3959 // The wedge we use is a triangle extruded into the third
3960 // dimension by one unit. So we can use the same logic as for
3961 // triangles above (i.e., for the simplex above, using dim==2)
3962 // and then check the third dimension separately.
3963
3964 if ((p[x_coordinate] < -tolerance) || (p[y_coordinate] < -tolerance))
3965 return false;
3966
3967 const double sum = p[x_coordinate] + p[y_coordinate];
3968 if (sum > 1 + tolerance * std::sqrt(2.0))
3969 return false;
3970
3971 if (p[z_coordinate] < -tolerance)
3972 return false;
3973 if (p[z_coordinate] > 1 + tolerance)
3974 return false;
3975
3976 return true;
3977 }
3978 default:
3979 DEAL_II_NOT_IMPLEMENTED();
3980 }
3981
3982 return false;
3983}
3984
3985
3986
3987template <int dim>
3988inline Tensor<1, dim>
3989ReferenceCell<dim>::unit_tangential_vectors(const unsigned int face_no,
3990 const unsigned int i) const
3991{
3992 return face_tangent_vector(face_no, i);
3993}
3994
3995
3996
3997template <int dim>
3998inline Tensor<1, dim>
3999ReferenceCell<dim>::face_tangent_vector(const unsigned int face_no,
4000 const unsigned int i) const
4001{
4002 AssertIndexRange(face_no, n_faces());
4003
4004 // Simplify the 1d case by setting tangents (which are used for boundary
4005 // forms and thus Jacobians) equal to the unit vector
4006 if constexpr (dim == 1)
4007 {
4008 return Tensor<1, dim>{{1.0}};
4009 }
4010
4011 AssertIndexRange(i, dim - 1);
4012
4013 switch (this->kind)
4014 {
4015 case ReferenceCells::Vertex:
4016 case ReferenceCells::Line:
4017 case ReferenceCells::Quadrilateral:
4018 case ReferenceCells::Hexahedron:
4019 AssertIndexRange(face_no, GeometryInfo<dim>::faces_per_cell);
4020 return GeometryInfo<dim>::unit_tangential_vectors[face_no][i];
4021 case ReferenceCells::Triangle:
4022 if constexpr (dim == 2)
4023 {
4024 AssertIndexRange(face_no, 3);
4025 constexpr std::array<Tensor<1, dim>, 3> table = {
4026 {Point<dim>(1, 0),
4027 Point<dim>(-numbers::SQRT1_2, +numbers::SQRT1_2),
4028 Point<dim>(0, -1)}};
4029
4030 return table[face_no];
4031 }
4032 else
4033 DEAL_II_ASSERT_UNREACHABLE();
4034 case ReferenceCells::Tetrahedron:
4035 if constexpr (dim == 3)
4036 {
4037 AssertIndexRange(face_no, 4);
4038 // We need std::pow(1.0/3.0, 0.25) in a constexpr context, but that
4039 // function isn't constexpr yet so hard-code the value and assert
4040 // that it is close
4041 constexpr double third_r4 = 0.7598356856515925473311877;
4042 Assert(std::abs((third_r4 * third_r4) * (third_r4 * third_r4) -
4043 1.0 / 3.0) < 1e-14,
4044 ExcInternalError());
4045 constexpr ndarray<Tensor<1, dim>, 4, 2> table = {
4046 {{{Point<dim>(0, 1, 0), Point<dim>(1, 0, 0)}},
4047 {{Point<dim>(1, 0, 0), Point<dim>(0, 0, 1)}},
4048 {{Point<dim>(0, 0, 1), Point<dim>(0, 1, 0)}},
4049 {{Point<dim>(-third_r4, +third_r4, 0),
4050 Point<dim>(-third_r4, 0, +third_r4)}}}};
4051
4052 return table[face_no][i];
4053 }
4054 else
4055 DEAL_II_ASSERT_UNREACHABLE();
4056 case ReferenceCells::Pyramid:
4057 if constexpr (dim == 3)
4058 {
4059 AssertIndexRange(face_no, 5);
4060 constexpr ndarray<Tensor<1, dim>, 5, 2> table = {
4061 {{{Point<dim>(0, 1, 0), Point<dim>(1, 0, 0)}},
4062 {{Point<dim>(+numbers::SQRT1_2, 0, +numbers::SQRT1_2),
4063 Point<dim>(0, 1, 0)}},
4064 {{Point<dim>(+numbers::SQRT1_2, 0, -numbers::SQRT1_2),
4065 Point<dim>(0, 1, 0)}},
4066 {{Point<dim>(1, 0, 0),
4067 Point<dim>(0, +numbers::SQRT1_2, +numbers::SQRT1_2)}},
4068 {{Point<dim>(1, 0, 0),
4069 Point<dim>(0, +numbers::SQRT1_2, -numbers::SQRT1_2)}}}};
4070
4071 return table[face_no][i];
4072 }
4073 else
4074 DEAL_II_ASSERT_UNREACHABLE();
4075 case ReferenceCells::Wedge:
4076 if constexpr (dim == 3)
4077 {
4078 AssertIndexRange(face_no, 5);
4079 constexpr ndarray<Tensor<1, dim>, 5, 2> table = {
4080 {{{Point<dim>(0, 1, 0), Point<dim>(1, 0, 0)}},
4081 {{Point<dim>(1, 0, 0), Point<dim>(0, 1, 0)}},
4082 {{Point<dim>(1, 0, 0), Point<dim>(0, 0, 1)}},
4083 {{Point<dim>(-numbers::SQRT1_2, +numbers::SQRT1_2, 0),
4084 Point<dim>(0, 0, 1)}},
4085 {{Point<dim>(0, 0, 1), Point<dim>(0, 1, 0)}}}};
4086
4087 return table[face_no][i];
4088 }
4089 else
4090 DEAL_II_ASSERT_UNREACHABLE();
4091 default:
4092 DEAL_II_NOT_IMPLEMENTED();
4093 }
4094
4095
4096 return {};
4097}
4098
4099
4100
4101template <int dim>
4102inline Tensor<1, dim>
4103ReferenceCell<dim>::unit_normal_vectors(const unsigned int face_no) const
4104{
4105 return face_normal_vector(face_no);
4106}
4107
4108
4109
4110template <int dim>
4111inline Tensor<1, dim>
4112ReferenceCell<dim>::face_normal_vector(const unsigned int face_no) const
4113{
4114 if (is_hyper_cube())
4115 {
4116 AssertIndexRange(face_no, GeometryInfo<dim>::faces_per_cell);
4117 return GeometryInfo<dim>::unit_normal_vector[face_no];
4118 }
4119 else if (dim == 2)
4120 {
4121 Assert(*this == ReferenceCells::Triangle, ExcInternalError());
4122
4123 // Return the rotated vector
4124 return cross_product_2d(face_tangent_vector(face_no, 0));
4125 }
4126 else if (dim == 3)
4127 {
4128 return cross_product_3d(face_tangent_vector(face_no, 0),
4129 face_tangent_vector(face_no, 1));
4130 }
4131
4132 DEAL_II_NOT_IMPLEMENTED();
4133
4134 return {};
4135}
4136
4137
4138
4139template <int dim>
4140inline unsigned int
4141ReferenceCell<dim>::n_face_orientations(const unsigned int face_no) const
4142{
4143 AssertIndexRange(face_no, n_faces());
4144
4145 switch (face_reference_cell(face_no))
4146 {
4147 case ReferenceCells::Vertex:
4148 return 1;
4149 case ReferenceCells::Line:
4150 return 2;
4151 case ReferenceCells::Triangle:
4152 return 6;
4153 case ReferenceCells::Quadrilateral:
4154 return 8;
4155 default:
4156 DEAL_II_NOT_IMPLEMENTED();
4157 }
4158
4159 DEAL_II_ASSERT_UNREACHABLE();
4160 return numbers::invalid_unsigned_int;
4161}
4162
4163
4164
4165template <int dim>
4166inline types::geometric_orientation
4167ReferenceCell<dim>::standard_vs_true_line_orientation(
4168 const unsigned int line,
4169 const unsigned int face,
4170 const types::geometric_orientation combined_face_orientation,
4171 const types::geometric_orientation line_orientation) const
4172{
4173 return face_to_cell_line_orientation(line,
4174 face,
4175 combined_face_orientation,
4176 line_orientation);
4177}
4178
4179
4180
4181template <int dim>
4182inline types::geometric_orientation
4183ReferenceCell<dim>::face_to_cell_line_orientation(
4184 const unsigned int face_line_no,
4185 const unsigned int face_no,
4186 const types::geometric_orientation combined_face_orientation,
4187 const types::geometric_orientation line_orientation) const
4188{
4189 constexpr auto D = numbers::default_geometric_orientation;
4190 constexpr auto R = numbers::reverse_line_orientation;
4191 static constexpr unsigned int X = numbers::invalid_unsigned_int;
4192
4193 if (this->face_reference_cell(face_no) == ReferenceCells::Quadrilateral)
4194 {
4195 static constexpr ::ndarray<types::geometric_orientation, 2, 8>
4196 orientation_quad{
4197 {{{D, D, D, R, R, R, R, D}}, {{D, D, R, D, R, R, D, R}}}};
4198 // We use face_line_no / 2 here since lines i and i + 1 are parallel
4199 // and, on a given face, have the same relative orientations.
4200 const bool match =
4201 line_orientation ==
4202 orientation_quad[face_line_no / 2][combined_face_orientation];
4203
4204 return match ? numbers::default_geometric_orientation :
4205 numbers::reverse_line_orientation;
4206 }
4207 else if (this->face_reference_cell(face_no) == ReferenceCells::Triangle)
4208 {
4209 Assert(face_line_no < 3,
4210 ExcMessage("Invalid face_line_no number for a triangular face"));
4211
4212 // if the line in the face and the line on the reference cell have the
4213 // same orientation, then switching vertices 1 and 2 reverses the
4214 // orientation (i.e. in the first array the 2nd, the 4th and the last
4215 // entry) but rotating the triangle does not switch the orientation (the
4216 // remaining entries)
4217 // if the line in the face and the line on the reference cell do not have
4218 // the same orientation, then it is the other way around
4219 static constexpr ::ndarray<types::geometric_orientation, 2, 6>
4220 orientation_triangle{{{{D, R, D, R, D, R}}, {{R, D, R, D, R, D}}}};
4221
4222 unsigned int combined_line;
4223
4224 if (*this == ReferenceCells::Tetrahedron)
4225 {
4226 static constexpr ::ndarray<unsigned int, 4, 3> combined_lines{
4227 {{{0, 0, 0}}, {{X, 0, 1}}, {{X, 0, X}}, {{X, X, X}}}};
4228
4229 combined_line = combined_lines[face_no][face_line_no];
4230
4231 Assert(combined_line != X,
4232 ExcMessage(
4233 "This function can only be called for following face-line "
4234 "combinations: (0,0), (0,1), (0,2), (1,1), (1,2), (2,1)"));
4235 }
4236 else if (*this == ReferenceCells::Pyramid)
4237 {
4238 // face_line_no 0 already done above
4239 Assert(face_line_no == 1 || face_line_no == 2,
4240 ExcMessage(
4241 "Invalid face line number for the triangular faces"));
4242
4243 // face 0 with lines 0-3 already done above
4244 // lines 6 (face 1, face_line_no 1) and 5 (face 2, face_line_no 1) are
4245 // oriented the same way in the cell and on the faces
4246 // lines 4 (face 1, face_line 2) and 7 (face 2, face_line 2) are not
4247 // oriented the same way in the cell and on the faces
4248 static constexpr ::ndarray<unsigned int, 3, 3> combined_lines{
4249 {{{X, X, X}}, {{X, 0, 1}}, {{X, 0, 1}}}};
4250
4251 combined_line = combined_lines[face_no][face_line_no];
4252 }
4253 else if (*this == ReferenceCells::Wedge)
4254 {
4255 // lines 0,1,2 (face 0, face_line_no 0,1,2) are not
4256 // oriented the same way in the cell and on the face
4257 // lines 4,5,6 (face 1, face_line 0,1,2) are
4258 // oriented the same way in the cell and on the faces
4259 static constexpr ::ndarray<unsigned int, 2, 3> combined_lines{
4260 {{{1, 1, 1}}, {{0, 0, 0}}}};
4261
4262 combined_line = combined_lines[face_no][face_line_no];
4263 }
4264 else
4265 DEAL_II_ASSERT_UNREACHABLE();
4266
4267 const bool match =
4268 line_orientation ==
4269 orientation_triangle[combined_line][combined_face_orientation];
4270
4271 return match ? numbers::default_geometric_orientation :
4272 numbers::reverse_line_orientation;
4273 }
4274 else
4275 DEAL_II_ASSERT_UNREACHABLE();
4276 return numbers::invalid_geometric_orientation;
4277}
4278
4279
4280
4281template <int dim>
4282inline unsigned int
4283ReferenceCell<dim>::opposite_face_index(const unsigned int face_no) const
4284{
4285 AssertIndexRange(face_no, n_faces());
4286 switch (this->kind)
4287 {
4288 case ReferenceCells::Vertex:
4289 DEAL_II_NOT_IMPLEMENTED();
4290 case ReferenceCells::Quadrilateral:
4291 {
4292 return GeometryInfo<2>::opposite_face[face_no];
4293 }
4294 case ReferenceCells::Hexahedron:
4295 {
4296 return GeometryInfo<3>::opposite_face[face_no];
4297 }
4298 case ReferenceCells::Line:
4299 case ReferenceCells::Triangle:
4300 case ReferenceCells::Tetrahedron:
4301 {
4302 return (face_no + 1) % (this->get_dimension() + 1);
4303 }
4304 case ReferenceCells::Pyramid:
4305 {
4306 switch (face_no)
4307 {
4308 case 0:
4309 return 0;
4310 case 1:
4311 return 2;
4312 case 2:
4313 return 1;
4314 case 3:
4315 return 4;
4316 case 4:
4317 return 3;
4318 default:
4319 return numbers::invalid_unsigned_int;
4320 }
4321 }
4322 case ReferenceCells::Wedge:
4323 {
4324 switch (face_no)
4325 {
4326 case 0:
4327 return 1;
4328 case 1:
4329 return 0;
4330 case 2:
4331 return 3;
4332 case 3:
4333 return 4;
4334 case 4:
4335 return 2;
4336 default:
4337 return numbers::invalid_unsigned_int;
4338 }
4339 }
4340 default:
4341 DEAL_II_ASSERT_UNREACHABLE();
4342 }
4343 return numbers::invalid_unsigned_int;
4344}
4345
4346namespace internal
4347{
4348 template <int dim, typename T>
4349 class NoPermutation : public ::ExceptionBase
4350 {
4351 public:
4365
4369 virtual ~NoPermutation() noexcept override = default;
4370
4374 virtual void
4375 print_info(std::ostream &out) const override
4376 {
4377 out << '[';
4378
4379 const unsigned int n_vertices = entity_type.n_vertices();
4380
4381 for (unsigned int i = 0; i < n_vertices; ++i)
4382 {
4383 out << vertices_0[i];
4384 if (i + 1 != n_vertices)
4385 out << ',';
4386 }
4387
4388 out << "] is not a valid permutation of [";
4389
4390 for (unsigned int i = 0; i < n_vertices; ++i)
4391 {
4392 out << vertices_1[i];
4393 if (i + 1 != n_vertices)
4394 out << ',';
4395 }
4396
4397 out << "]." << std::endl;
4398 }
4399
4403 const ReferenceCell<dim> entity_type;
4404
4408 const ArrayView<const T> vertices_0;
4409
4413 const ArrayView<const T> vertices_1;
4414 };
4415
4416} // namespace internal
4417
4418
4419
4420template <int dim>
4421template <typename T, std::size_t N>
4422inline types::geometric_orientation
4423ReferenceCell<dim>::compute_orientation(
4424 const std::array<T, N> &vertices_0,
4425 const std::array<T, N> &vertices_1) const
4426{
4427 Assert(N >= n_vertices(),
4428 ExcMessage("The number of array elements must be equal to or "
4429 "greater than the number of vertices of the cell "
4430 "referenced by this object."));
4431
4432 // Call the non-deprecated function, taking care of calling it only with
4433 // those array elements that we actually care about (see the note
4434 // in the documentation about the arguments potentially being
4435 // larger arrays than necessary).
4436 return get_combined_orientation(
4437 make_array_view(vertices_0.begin(), vertices_0.begin() + n_vertices()),
4438 make_array_view(vertices_1.begin(), vertices_1.begin() + n_vertices()));
4439}
4440
4441
4442
4443template <int dim>
4444template <typename T>
4445types::geometric_orientation
4446ReferenceCell<dim>::get_combined_orientation(
4447 const ArrayView<const T> &vertices_0,
4448 const ArrayView<const T> &vertices_1) const
4449{
4450 Assert(vertices_0.size() == n_vertices(),
4451 ExcMessage("The number of array elements must be equal to "
4452 "the number of vertices of the cell "
4453 "referenced by this object."));
4454 Assert(vertices_1.size() == n_vertices(),
4455 ExcMessage("The number of array elements must be equal to "
4456 "the number of vertices of the cell "
4457 "referenced by this object."));
4458
4459 auto compute_orientation = [&](const auto &table,
4460 const unsigned int n_vertices) {
4461 for (types::geometric_orientation o = 0; o < table.size(); ++o)
4462 {
4463 bool match = true;
4464 for (unsigned int j = 0; j < n_vertices; ++j)
4465 match = (match && vertices_0[j] == vertices_1[table[o][j]]);
4466
4467 if (match)
4468 return o;
4469 }
4470
4471 // Do not use `this` in Assert because nvcc when using C++20 assumes that
4472 // `this` is an integer and we get the following error: invalid type
4473 // argument of unary '*' (have 'int')
4474 [[maybe_unused]] const auto &ref_cell = *this;
4475 Assert(false,
4476 (internal::NoPermutation<dim, T>(ref_cell, vertices_0, vertices_1)));
4477 return std::numeric_limits<types::geometric_orientation>::max();
4478 };
4479
4480 switch (this->kind)
4481 {
4482 case ReferenceCells::Vertex:
4483 return compute_orientation(vertex_vertex_permutations, 1);
4484 case ReferenceCells::Line:
4485 return compute_orientation(line_vertex_permutations, 2);
4486 case ReferenceCells::Triangle:
4487 return compute_orientation(triangle_vertex_permutations, 3);
4488 case ReferenceCells::Quadrilateral:
4489 return compute_orientation(quadrilateral_vertex_permutations, 4);
4490 default:
4491 DEAL_II_NOT_IMPLEMENTED();
4492 }
4493
4494 Assert(false,
4495 (internal::NoPermutation<dim, T>(*this, vertices_0, vertices_1)));
4496 return std::numeric_limits<types::geometric_orientation>::max();
4497}
4498
4499
4500
4501template <int dim>
4502template <typename T, std::size_t N>
4503inline std::array<T, N>
4504ReferenceCell<dim>::permute_according_orientation(
4505 const std::array<T, N> &vertices,
4506 const unsigned int orientation) const
4507{
4508 Assert(N >= n_vertices(),
4509 ExcMessage("The number of array elements must be equal to or "
4510 "greater than the number of vertices of the cell "
4511 "referenced by this object."));
4512
4513 // Call the non-deprecated function, taking care of calling it only with
4514 // those array elements that we actually care about (see the note
4515 // in the documentation about the arguments potentially being
4516 // larger arrays than necessary).
4517 const auto permutation = permute_by_combined_orientation(
4518 make_array_view(vertices.begin(), vertices.begin() + n_vertices()),
4519 orientation);
4520
4521 std::array<T, N> temp;
4522 std::copy(permutation.begin(), permutation.end(), temp.begin());
4523
4524 return temp;
4525}
4526
4527
4528
4529template <int dim>
4530template <typename T>
4531boost::container::small_vector<T, 8>
4532ReferenceCell<dim>::permute_by_combined_orientation(
4533 const ArrayView<const T> &vertices,
4534 const types::geometric_orientation orientation) const
4535{
4536 AssertDimension(vertices.size(), n_vertices());
4537 boost::container::small_vector<T, 8> result(n_vertices());
4538
4539 auto permute = [&](const auto &table, unsigned int n_vertices) {
4540 AssertIndexRange(orientation, table.size());
4541 for (unsigned int j = 0; j < n_vertices; ++j)
4542 result[j] = vertices[table[orientation][j]];
4543 };
4544
4545 switch (this->kind)
4546 {
4547 case ReferenceCells::Vertex:
4548 permute(vertex_vertex_permutations, 1);
4549 break;
4550 case ReferenceCells::Line:
4551 permute(line_vertex_permutations, 2);
4552 break;
4553 case ReferenceCells::Triangle:
4554 permute(triangle_vertex_permutations, 3);
4555 break;
4556 case ReferenceCells::Quadrilateral:
4557 permute(quadrilateral_vertex_permutations, 4);
4558 break;
4559 default:
4560 DEAL_II_NOT_IMPLEMENTED();
4561 }
4562
4563 return result;
4564}
4565
4566
4567
4568template <int dim>
4569inline types::geometric_orientation
4570ReferenceCell<dim>::get_inverse_combined_orientation(
4571 const types::geometric_orientation orientation) const
4572{
4573 switch (this->kind)
4574 {
4575 case ReferenceCells::Vertex:
4576 // Things are always default-oriented in 1D
4577 return orientation;
4578
4579 case ReferenceCells::Line:
4580 // the 1d orientations are the identity and a flip: i.e., the identity
4581 // and an involutory mapping
4582 return orientation;
4583
4584 case ReferenceCells::Triangle:
4585 {
4586 AssertIndexRange(orientation, 6);
4587 constexpr std::array<types::geometric_orientation, 6> inverses{
4588 {0, 1, 4, 3, 2, 5}};
4589 return inverses[orientation];
4590 }
4591 case ReferenceCells::Quadrilateral:
4592 {
4593 AssertIndexRange(orientation, 8);
4594 constexpr std::array<types::geometric_orientation, 8> inverses{
4595 {0, 1, 6, 3, 4, 5, 2, 7}};
4596 return inverses[orientation];
4597 }
4598 default:
4599 DEAL_II_NOT_IMPLEMENTED();
4600 }
4601
4602 return std::numeric_limits<types::geometric_orientation>::max();
4603}
4604
4605
4606DEAL_II_NAMESPACE_CLOSE
4607
4608#endif
array_view.h
make_array_view
ArrayView< std::remove_reference_t< typename std::iterator_traits< Iterator >::reference >, MemorySpaceType > make_array_view(const Iterator begin, const Iterator end)
Definition array_view.h:1002
ArrayView::size
std::size_t size() const
Definition array_view.h:737
Mapping
Abstract base class for mapping classes.
Definition mapping.h:318
Point
Definition point.h:111
Point::unit_vector
static constexpr Point< dim, Number > unit_vector(const unsigned int i)
ReferenceCell< 0 >::unv_vertex_to_deal_vertex
unsigned int unv_vertex_to_deal_vertex(const unsigned int vertex_n) const
Definition reference_cell.cc:663
ReferenceCell::get_nodal_type_quadrature
const Quadrature< dim > & get_nodal_type_quadrature() const
Definition reference_cell.cc:526
ReferenceCell< 0 >::face_to_cell_lines
unsigned int face_to_cell_lines(const unsigned int face, const unsigned int line, const types::geometric_orientation face_orientation) const
Definition reference_cell.h:3122
ReferenceCell< 0 >::unit_normal_vectors
Tensor< 1, dim > unit_normal_vectors(const unsigned int face_no) const
Definition reference_cell.h:4103
ReferenceCell::quadrilateral_vertex_permutations
static constexpr ndarray< unsigned int, 8, 4 > quadrilateral_vertex_permutations
Definition reference_cell.h:1247
ReferenceCell::is_simplex
constexpr bool is_simplex() const
Definition reference_cell.h:2169
ReferenceCell< 0 >::volume
double volume() const
Definition reference_cell.h:3781
ReferenceCell< 0 >::n_vertices
constexpr unsigned int n_vertices() const
Definition reference_cell.h:2199
ReferenceCell< 0 >::compute_orientation
types::geometric_orientation compute_orientation(const std::array< T, N > &vertices_0, const std::array< T, N > &vertices_1) const
Definition reference_cell.h:4423
ReferenceCell::get_isotropic_refinement_choice
IsotropicRefinementChoice get_isotropic_refinement_choice(const unsigned int ref_choice) const
Definition reference_cell.h:2522
ReferenceCell< 0 >::face_to_cell_line_orientation
types::geometric_orientation face_to_cell_line_orientation(const unsigned int face_line_no, const unsigned int face_no, const types::geometric_orientation face_orientation, const types::geometric_orientation line_orientation) const
Definition reference_cell.h:4183
ReferenceCell< 0 >::serialize
void serialize(Archive &archive, const unsigned int)
Definition reference_cell.h:1530
ReferenceCell< 0 >::face_measure
double face_measure(const unsigned int face_no) const
Definition reference_cell.h:3812
ReferenceCell< 0 >::child_cell_on_face
unsigned int child_cell_on_face(const unsigned int face, const unsigned int subface) const
Definition reference_cell.h:2819
ReferenceCell::is_hyper_cube
constexpr bool is_hyper_cube() const
Definition reference_cell.h:2158
ReferenceCell::line_indices
std_cxx20::ranges::iota_view< unsigned int, unsigned int > line_indices() const
Definition reference_cell.h:2671
ReferenceCell< 0 >::unit_tangential_vectors
Tensor< 1, dim > unit_tangential_vectors(const unsigned int face_no, const unsigned int i) const
Definition reference_cell.h:3989
ReferenceCell< 0 >::faces_for_given_vertex
ArrayView< const unsigned int > faces_for_given_vertex(const unsigned int vertex_index) const
Definition reference_cell.h:1548
ReferenceCell< 0 >::vtk_quadratic_type
unsigned int vtk_quadratic_type() const
Definition reference_cell.cc:733
ReferenceCell< 0 >::closest_point
Point< dim > closest_point(const Point< dim > &p) const
Definition reference_cell.cc:1281
ReferenceCell::get_midpoint_quadrature
Quadrature< dim > get_midpoint_quadrature() const
Definition reference_cell.h:2189
ReferenceCell::d_linear_shape_function
double d_linear_shape_function(const Point< dim > &xi, const unsigned int i) const
Definition reference_cell.h:3656
ReferenceCell::get_dimension
constexpr unsigned int get_dimension() const
Definition reference_cell.h:2180
ReferenceCell::n_vertices_to_type
static ReferenceCell n_vertices_to_type(const int dim_, const unsigned int n_vertices)
Definition reference_cell.h:3645
ReferenceCell< 0 >::vtk_lagrange_type
unsigned int vtk_lagrange_type() const
Definition reference_cell.cc:766
ReferenceCell< 0 >::get_combined_orientation
types::geometric_orientation get_combined_orientation(const ArrayView< const T > &vertices_0, const ArrayView< const T > &vertices_1) const
Definition reference_cell.h:4446
ReferenceCell< 0 >::default_combined_face_orientation
static constexpr types::geometric_orientation default_combined_face_orientation()
Definition reference_cell.h:2799
ReferenceCell< 0 >::standard_vertex_to_face_and_vertex_index
std::array< unsigned int, 2 > standard_vertex_to_face_and_vertex_index(const unsigned int vertex) const
Definition reference_cell.h:2905
ReferenceCell::refinement_cases
ArrayView< const RefinementCase< dim > > refinement_cases() const
Definition reference_cell.h:2681
ReferenceCell::get_gauss_type_quadrature
Quadrature< dim > get_gauss_type_quadrature(const unsigned n_points_1d) const
Definition reference_cell.cc:506
ReferenceCell< 0 >::line_to_cell_vertices
unsigned int line_to_cell_vertices(const unsigned int line, const unsigned int vertex) const
Definition reference_cell.h:3038
ReferenceCell::kind
std::uint8_t kind
Definition reference_cell.h:1206
ReferenceCell::vertex_indices
std_cxx20::ranges::iota_view< unsigned int, unsigned int > vertex_indices() const
Definition reference_cell.h:2661
ReferenceCell::face_reference_cell
constexpr ReferenceCell< dim - 1 > face_reference_cell(const unsigned int face_index) const
Definition reference_cell.h:2759
ReferenceCell::operator>>
friend std::istream & operator>>(std::istream &in, ReferenceCell< dim_ > &reference_cell)
ReferenceCell::n_children
unsigned int n_children(const RefinementCase< dim > ref_case=RefinementCase< dim >::isotropic_refinement) const
Definition reference_cell.h:2580
ReferenceCell< 0 >::new_isotropic_child_cell_vertices
constexpr ::ndarray< unsigned int, 10, 8 > new_isotropic_child_cell_vertices(const unsigned int refinement_choice) const
Definition reference_cell.h:2027
ReferenceCell::n_faces
constexpr unsigned int n_faces() const
Definition reference_cell.h:2381
ReferenceCell::ReferenceCell
constexpr ReferenceCell()
Definition reference_cell.h:1521
ReferenceCell< 0 >::standard_to_real_face_line
unsigned int standard_to_real_face_line(const unsigned int line, const unsigned int face, const types::geometric_orientation face_orientation) const
Definition reference_cell.h:3453
ReferenceCell< 0 >::barycenter
Point< dim > barycenter() const
Definition reference_cell.h:3850
ReferenceCell::n_isotropic_refinement_choices
constexpr unsigned int n_isotropic_refinement_choices() const
Definition reference_cell.h:2491
ReferenceCell::quadrilateral_line_permutations
static constexpr ndarray< unsigned int, 8, 4 > quadrilateral_line_permutations
Definition reference_cell.h:1273
ReferenceCell< 0 >::vtk_vertex_to_deal_vertex
unsigned int vtk_vertex_to_deal_vertex(const unsigned int vertex_index) const
Definition reference_cell.cc:999
ReferenceCell::line_vertex_permutations
static constexpr ndarray< unsigned int, 3, 4 > line_vertex_permutations
Definition reference_cell.h:1227
ReferenceCell::n_lines
constexpr unsigned int n_lines() const
Definition reference_cell.h:2230
ReferenceCell::vertex
Point< dim > vertex(const unsigned int v) const
Definition reference_cell.h:2261
ReferenceCell< 0 >::standard_to_real_face_vertex
unsigned int standard_to_real_face_vertex(const unsigned int vertex, const unsigned int face, const types::geometric_orientation face_orientation) const
Definition reference_cell.h:3419
ReferenceCell::equivalent_refinement_case
std::pair< unsigned int, RefinementCase< dim - 1 > > equivalent_refinement_case(const types::geometric_orientation combined_face_orientation, const internal::SubfaceCase< dim > subface_case, const unsigned int subface_no) const
Definition reference_cell.cc:268
ReferenceCell::triangle_line_permutations
static constexpr ndarray< unsigned int, 6, 3 > triangle_line_permutations
Definition reference_cell.h:1261
ReferenceCell< 0 >::opposite_face_index
unsigned int opposite_face_index(const unsigned int face_no) const
Definition reference_cell.h:4283
ReferenceCell::get_default_mapping
std::unique_ptr< Mapping< dim, spacedim > > get_default_mapping(const unsigned int degree) const
Definition reference_cell.cc:442
ReferenceCell::vertex_vertex_permutations
static constexpr ndarray< unsigned int, 1, 1 > vertex_vertex_permutations
Definition reference_cell.h:1221
ReferenceCell::d_linear_shape_function_gradient
Tensor< 1, dim > d_linear_shape_function_gradient(const Point< dim > &xi, const unsigned int i) const
Definition reference_cell.h:3747
ReferenceCell< 0 >::uint8_t
constexpr operator std::uint8_t() const
Definition reference_cell.h:1336
ReferenceCell< 0 >::to_string
std::string to_string() const
Definition reference_cell.cc:82
ReferenceCell< 0 >::n_face_orientations
unsigned int n_face_orientations(const unsigned int face_no) const
Definition reference_cell.h:4141
ReferenceCell< 0 >::vtk_lexicographic_to_node_index
unsigned int vtk_lexicographic_to_node_index(const std::array< unsigned, dim > &node_indices, const std::array< unsigned, dim > &nodes_per_direction, const bool legacy_format) const
Definition reference_cell.cc:799
ReferenceCell::triangle_vertex_permutations
static constexpr ndarray< unsigned int, 6, 4 > triangle_vertex_permutations
Definition reference_cell.h:1234
ReferenceCell< 0 >::gmsh_element_type
unsigned int gmsh_element_type() const
Definition reference_cell.cc:1056
ReferenceCell::operator!=
constexpr bool operator!=(const ReferenceCell< dim > &type) const
Definition reference_cell.h:1354
ReferenceCell::isotropic_child_indices
std_cxx20::ranges::iota_view< unsigned int, unsigned int > isotropic_child_indices() const
Definition reference_cell.h:2651
ReferenceCell< 0 >::new_isotropic_child_face_lines
constexpr ::ndarray< unsigned int, 13, 4 > new_isotropic_child_face_lines(const unsigned int refinement_choice) const
Definition reference_cell.h:1607
ReferenceCell::operator<<
friend std::ostream & operator<<(std::ostream &out, const ReferenceCell< dim_ > &reference_cell)
ReferenceCell< 0 >::standard_vs_true_line_orientation
types::geometric_orientation standard_vs_true_line_orientation(const unsigned int line, const unsigned int face, const types::geometric_orientation face_orientation, const types::geometric_orientation line_orientation) const
Definition reference_cell.h:4167
ReferenceCell< 0 >::standard_line_to_face_and_line_index
std::array< unsigned int, 2 > standard_line_to_face_and_line_index(const unsigned int line) const
Definition reference_cell.h:2974
ReferenceCell< 0 >::face_vertex_location
Point< dim > face_vertex_location(const unsigned int face, const unsigned int vertex) const
Definition reference_cell.h:3408
ReferenceCell< 0 >::new_isotropic_child_face_line_vertices
constexpr ::ndarray< unsigned int, 13, 4, 2 > new_isotropic_child_face_line_vertices(const unsigned int refinement_choice) const
Definition reference_cell.h:1745
ReferenceCell< 0 >::face_tangent_vector
Tensor< 1, dim > face_tangent_vector(const unsigned int face_no, const unsigned int i) const
Definition reference_cell.h:3999
ReferenceCell< 0 >::face_to_cell_vertices
unsigned int face_to_cell_vertices(const unsigned int face, const unsigned int vertex, const types::geometric_orientation face_orientation) const
Definition reference_cell.h:3206
ReferenceCell< 0 >::exodusii_vertex_to_deal_vertex
unsigned int exodusii_vertex_to_deal_vertex(const unsigned int vertex_n) const
Definition reference_cell.cc:570
ReferenceCell::face_indices_by_type
std_cxx20::ranges::iota_view< unsigned int, unsigned int > face_indices_by_type(const ReferenceCell< dim - 1 > &face_ref_type) const
Definition reference_cell.h:2422
ReferenceCell::get_default_linear_mapping
const Mapping< dim, spacedim > & get_default_linear_mapping() const
Definition reference_cell.cc:471
ReferenceCell< 0 >::reversed_combined_line_orientation
static constexpr types::geometric_orientation reversed_combined_line_orientation()
Definition reference_cell.h:2808
ReferenceCell< 0 >::permute_by_combined_orientation
boost::container::small_vector< T, 8 > permute_by_combined_orientation(const ArrayView< const T > &vertices, const types::geometric_orientation orientation) const
Definition reference_cell.h:4532
ReferenceCell< 0 >::get_inverse_combined_orientation
types::geometric_orientation get_inverse_combined_orientation(const types::geometric_orientation orientation) const
Definition reference_cell.h:4570
ReferenceCell< 0 >::memory_consumption
static constexpr std::size_t memory_consumption()
Definition reference_cell.h:1539
ReferenceCell< 0 >::face_normal_vector
Tensor< 1, dim > face_normal_vector(const unsigned int face_no) const
Definition reference_cell.h:4112
ReferenceCell< 0 >::new_isotropic_child_cell_faces
constexpr ::ndarray< unsigned int, 10, 6 > new_isotropic_child_cell_faces(const unsigned int refinement_choice) const
Definition reference_cell.h:1893
ReferenceCell::n_isotropic_children
constexpr unsigned int n_isotropic_children() const
Definition reference_cell.h:2549
ReferenceCell< 0 >::subface_vertex_location
Point< dim > subface_vertex_location(const unsigned int face_no, const unsigned int subface_no, const unsigned int subface_vertex_no, const RefinementCase< dim - 1 > face_refinement_case) const
Definition reference_cell.cc:232
ReferenceCell< 0 >::contains_point
bool contains_point(const Point< dim > &p, const double tolerance=0) const
Definition reference_cell.h:3881
ReferenceCell< 0 >::exodusii_face_to_deal_face
unsigned int exodusii_face_to_deal_face(const unsigned int face_n) const
Definition reference_cell.cc:615
ReferenceCell< 0 >::face_and_line_to_cell_vertices
unsigned int face_and_line_to_cell_vertices(const unsigned int face, const unsigned int line, const unsigned int vertex, const types::geometric_orientation face_orientation) const
Definition reference_cell.h:3301
ReferenceCell< 0 >::vtk_linear_type
unsigned int vtk_linear_type() const
Definition reference_cell.cc:700
ReferenceCell< 0 >::permute_according_orientation
std::array< T, N > permute_according_orientation(const std::array< T, N > &vertices, const unsigned int orientation) const
Definition reference_cell.h:4504
ReferenceCell::operator==
constexpr bool operator==(const ReferenceCell< dim > &type) const
Definition reference_cell.h:1345
ReferenceCell::face_indices
std_cxx20::ranges::iota_view< unsigned int, unsigned int > face_indices() const
Definition reference_cell.h:2412
internal::NoPermutation::vertices_1
const ArrayView< const T > vertices_1
Definition reference_cell.h:4413
internal::NoPermutation::print_info
virtual void print_info(std::ostream &out) const override
Definition reference_cell.h:4375
internal::NoPermutation::entity_type
const ReferenceCell< dim > entity_type
Definition reference_cell.h:4403
internal::NoPermutation::NoPermutation
NoPermutation(const ReferenceCell< dim > &entity_type, const ArrayView< const T > &vertices_0, const ArrayView< const T > &vertices_1)
Definition reference_cell.h:4355
internal::NoPermutation::~NoPermutation
virtual ~NoPermutation() noexcept override=default
internal::NoPermutation::vertices_0
const ArrayView< const T > vertices_0
Definition reference_cell.h:4408
DEAL_II_DEPRECATED
#define DEAL_II_DEPRECATED
Definition config.h:286
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:38
DEAL_II_DEPRECATED_WITH_COMMENT
#define DEAL_II_DEPRECATED_WITH_COMMENT(comment)
Definition config.h:287
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:39
DEAL_II_ASSERT_UNREACHABLE
#define DEAL_II_ASSERT_UNREACHABLE()
Definition exception_macros.h:781
DEAL_II_NOT_IMPLEMENTED
#define DEAL_II_NOT_IMPLEMENTED()
Definition exception_macros.h:705
geometry_info.h
StandardExceptions::ExcNotImplemented
static ::ExceptionBase & ExcNotImplemented()
Assert
#define Assert(cond, exc)
Definition exception_macros.h:543
AssertDimension
#define AssertDimension(dim1, dim2)
Definition exception_macros.h:829
AssertIndexRange
#define AssertIndexRange(index, range)
Definition exception_macros.h:901
StandardExceptions::ExcInternalError
static ::ExceptionBase & ExcInternalError()
StandardExceptions::ExcMessage
static ::ExceptionBase & ExcMessage(std::string arg1)
ReferenceCells::max_n_children
constexpr unsigned int max_n_children()
Definition reference_cell.h:3634
ReferenceCells::Hexahedron
constexpr ReferenceCell< 3 > Hexahedron
Definition reference_cell.h:1405
ReferenceCells::Quadrilateral
constexpr ReferenceCell< 2 > Quadrilateral
Definition reference_cell.h:1397
ReferenceCells::n_vertices_to_reference_cell
ReferenceCell< dim > n_vertices_to_reference_cell(const unsigned int n_vertices)
Definition reference_cell.h:3564
ReferenceCells::Line
constexpr ReferenceCell< 1 > Line
Definition reference_cell.h:1393
ReferenceCells::max_n_lines
constexpr unsigned int max_n_lines()
Definition reference_cell.h:3616
ReferenceCells::get_reference_cells_in_dim
constexpr const std::vector< ReferenceCell< dim > > get_reference_cells_in_dim()
Definition reference_cell.h:3485
ReferenceCells::Triangle
constexpr ReferenceCell< 2 > Triangle
Definition reference_cell.h:1395
ReferenceCells::max_n_vertices
constexpr unsigned int max_n_vertices()
Definition reference_cell.h:3607
ReferenceCells::Tetrahedron
constexpr ReferenceCell< 3 > Tetrahedron
Definition reference_cell.h:1399
ReferenceCells::get_simplex
constexpr const ReferenceCell< dim > & get_simplex()
Definition reference_cell.h:3508
ReferenceCells::max_n_faces
constexpr unsigned int max_n_faces()
Definition reference_cell.h:3625
ReferenceCells::Invalid
constexpr ReferenceCell< dim > Invalid
Definition reference_cell.h:1409
ReferenceCells::Pyramid
constexpr ReferenceCell< 3 > Pyramid
Definition reference_cell.h:1401
ReferenceCells::get_hypercube
constexpr const ReferenceCell< dim > & get_hypercube()
Definition reference_cell.h:3528
ReferenceCells::n_reference_cells_in_dim
constexpr unsigned int n_reference_cells_in_dim()
Definition reference_cell.h:3547
ReferenceCells::Wedge
constexpr ReferenceCell< 3 > Wedge
Definition reference_cell.h:1403
ReferenceCells::Vertex
constexpr ReferenceCell< 0 > Vertex
Definition reference_cell.h:1391
internal::split_face_orientation
std::tuple< bool, bool, bool > split_face_orientation(const types::geometric_orientation combined_orientation)
Definition tria_orientation.h:44
internal::make_reference_cell_from_int
constexpr ReferenceCell< dim > make_reference_cell_from_int(const std::uint8_t kind)
Definition reference_cell.h:1365
numbers::invalid_geometric_orientation
constexpr types::geometric_orientation invalid_geometric_orientation
Definition types.h:377
numbers::invalid_unsigned_int
constexpr unsigned int invalid_unsigned_int
Definition types.h:236
numbers::SQRT1_2
constexpr double SQRT1_2
Definition numbers.h:260
numbers::reverse_line_orientation
constexpr types::geometric_orientation reverse_line_orientation
Definition types.h:363
numbers::default_geometric_orientation
constexpr types::geometric_orientation default_geometric_orientation
Definition types.h:350
std
STL namespace.
std::min
::VectorizedArray< Number, width > min(const ::VectorizedArray< Number, width > &, const ::VectorizedArray< Number, width > &)
Definition vectorization.h:6758
std::max
::VectorizedArray< Number, width > max(const ::VectorizedArray< Number, width > &, const ::VectorizedArray< Number, width > &)
Definition vectorization.h:6741
std::sqrt
::VectorizedArray< Number, width > sqrt(const ::VectorizedArray< Number, width > &)
Definition vectorization.h:6667
std::abs
::VectorizedArray< Number, width > abs(const ::VectorizedArray< Number, width > &)
Definition vectorization.h:6725
types
Definition types.h:30
types::geometric_orientation
std::uint8_t geometric_orientation
Definition types.h:38
ndarray
typename internal::ndarray::HelperArray< T, Ns... >::type ndarray
Definition ndarray.h:105
IsotropicRefinementChoice
IsotropicRefinementChoice
Definition reference_cell.h:76
IsotropicRefinementChoice::cut_tet_49
@ cut_tet_49
Definition reference_cell.h:92
IsotropicRefinementChoice::cut_tet_57
@ cut_tet_57
Definition reference_cell.h:88
IsotropicRefinementChoice::cut_tet_68
@ cut_tet_68
Definition reference_cell.h:84
IsotropicRefinementChoice::isotropic_refinement
@ isotropic_refinement
Definition reference_cell.h:80
operator>>
std::istream & operator>>(std::istream &in, ReferenceCell< dim > &reference_cell)
Definition reference_cell.cc:1485
operator<<
std::ostream & operator<<(std::ostream &out, const ReferenceCell< dim > &reference_cell)
Definition reference_cell.cc:1471
GeometryInfo::child_cell_on_face
static unsigned int child_cell_on_face(const RefinementCase< dim > &ref_case, const unsigned int face, const unsigned int subface, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false, const RefinementCase< dim - 1 > &face_refinement_case=RefinementCase< dim - 1 >::isotropic_refinement)
GeometryInfo::unit_tangential_vectors
static constexpr ndarray< Tensor< 1, dim >, faces_per_cell, dim - 1 > unit_tangential_vectors
Definition geometry_info.h:2636
GeometryInfo::face_to_cell_vertices
static unsigned int face_to_cell_vertices(const unsigned int face, const unsigned int vertex, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false)
GeometryInfo::vertices_per_cell
static constexpr unsigned int vertices_per_cell
Definition geometry_info.h:2018
GeometryInfo::vertex_to_face
static constexpr ndarray< unsigned int, vertices_per_cell, dim > vertex_to_face
Definition geometry_info.h:2134
GeometryInfo::lines_per_cell
static constexpr unsigned int lines_per_cell
Definition geometry_info.h:2065
GeometryInfo::standard_hex_line_to_quad_line_index
static std::array< unsigned int, 2 > standard_hex_line_to_quad_line_index(const unsigned int line)
GeometryInfo::faces_per_cell
static constexpr unsigned int faces_per_cell
Definition geometry_info.h:1984
GeometryInfo::standard_hex_vertex_to_quad_vertex_index
static std::array< unsigned int, 2 > standard_hex_vertex_to_quad_vertex_index(const unsigned int vertex)
GeometryInfo::standard_quad_vertex_to_line_vertex_index
static std::array< unsigned int, 2 > standard_quad_vertex_to_line_vertex_index(const unsigned int vertex)
GeometryInfo::d_linear_shape_function
static double d_linear_shape_function(const Point< dim > &xi, const unsigned int i)
GeometryInfo::opposite_face
static constexpr std::array< unsigned int, faces_per_cell > opposite_face
Definition geometry_info.h:2644
GeometryInfo::n_children
static unsigned int n_children(const RefinementCase< dim > &refinement_case)
GeometryInfo::face_to_cell_lines
static unsigned int face_to_cell_lines(const unsigned int face, const unsigned int line, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false)
GeometryInfo::unit_normal_vector
static constexpr std::array< Tensor< 1, dim >, faces_per_cell > unit_normal_vector
Definition geometry_info.h:2619
GeometryInfo::d_linear_shape_function_gradient
static Tensor< 1, dim > d_linear_shape_function_gradient(const Point< dim > &xi, const unsigned int i)
GeometryInfo::max_children_per_cell
static constexpr unsigned int max_children_per_cell
Definition geometry_info.h:1979
cross_product_2d
constexpr Tensor< 1, dim, Number > cross_product_2d(const Tensor< 1, dim, Number > &src)
Definition tensor.h:2639
cross_product_3d
constexpr Tensor< 1, dim, typename ProductType< Number1, Number2 >::type > cross_product_3d(const Tensor< 1, dim, Number1 > &src1, const Tensor< 1, dim, Number2 > &src2)
Definition tensor.h:2664
tria_orientation.h
Generated by doxygen 1.16.1