deal.II version GIT relicensing-2165-gc91f007519 2024-11-20 01:40:00+00:00
\(\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: LGPL-2.1-or-later
4// Copyright (C) 2020 - 2024 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Part of the source code is dual licensed under Apache-2.0 WITH
9// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10// governing the source code and code contributions can be found in
11// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12//
13// ------------------------------------------------------------------------
14
15#ifndef dealii_tria_reference_cell_h
16#define dealii_tria_reference_cell_h
17
18#include <deal.II/base/config.h>
19
20#include <deal.II/base/array_view.h>
21#include <deal.II/base/geometry_info.h>
22#include <deal.II/base/ndarray.h>
23#include <deal.II/base/point.h>
24#include <deal.II/base/tensor.h>
25#include <deal.II/base/utilities.h>
26
27#include <deal.II/grid/tria_orientation.h>
28
29#include <boost/container/small_vector.hpp>
30
31#include <iosfwd>
32#include <string>
33
34DEAL_II_NAMESPACE_OPEN
35
36// Forward declarations
37#ifndef DOXYGEN
38template <int dim, int spacedim>
39class Mapping;
40
41template <int dim>
42class Quadrature;
43
44class ReferenceCell;
45#endif
46
47
48namespace internal
49{
62 constexpr ReferenceCell
63 make_reference_cell_from_int(const std::uint8_t kind);
64} // namespace internal
65
66
67
74enum class IsotropicRefinementChoice : std::uint8_t
75{
79 isotropic_refinement = 0,
83 cut_tet_68 = 1,
87 cut_tet_57 = 2,
91 cut_tet_49 = 3,
92};
93
94
95
126class ReferenceCell
127{
128public:
136 static ReferenceCell
137 n_vertices_to_type(const int dim, const unsigned int n_vertices);
138
147 constexpr ReferenceCell();
148
159 bool
160 is_hyper_cube() const;
161
165 bool
166 is_simplex() const;
167
172 unsigned int
173 get_dimension() const;
174
188 template <int dim>
189 double
190 d_linear_shape_function(const Point<dim> &xi, const unsigned int i) const;
191
196 template <int dim>
197 Tensor<1, dim>
198 d_linear_shape_function_gradient(const Point<dim> &xi,
199 const unsigned int i) const;
200
210 template <int dim, int spacedim = dim>
211 std::unique_ptr<Mapping<dim, spacedim>>
212 get_default_mapping(const unsigned int degree) const;
213
225 template <int dim, int spacedim = dim>
226 const Mapping<dim, spacedim> &
227 get_default_linear_mapping() const;
228
237 template <int dim>
238 Quadrature<dim>
239 get_gauss_type_quadrature(const unsigned n_points_1d) const;
240
250 template <int dim>
251 Quadrature<dim>
252 get_midpoint_quadrature() const;
253
267 template <int dim>
268 const Quadrature<dim> &
269 get_nodal_type_quadrature() const;
270
285 unsigned int
286 n_vertices() const;
287
292 std_cxx20::ranges::iota_view<unsigned int, unsigned int>
293 vertex_indices() const;
294
302 template <int dim>
303 Point<dim>
304 vertex(const unsigned int v) const;
305
311 unsigned int
312 n_lines() const;
313
318 std_cxx20::ranges::iota_view<unsigned int, unsigned int>
319 line_indices() const;
320
326 unsigned int
327 n_faces() const;
328
333 std_cxx20::ranges::iota_view<unsigned int, unsigned int>
334 face_indices() const;
335
339 unsigned int
340 n_isotropic_refinement_choices() const;
341
345 IsotropicRefinementChoice
346 get_isotropic_refinement_choice(const unsigned int ref_choice) const;
347
359 unsigned int
360 n_isotropic_children() const;
361
366 template <int dim>
367 unsigned int
368 n_children(const RefinementCase<dim> ref_case =
369 RefinementCase<dim>::isotropic_refinement) const;
370
375 std_cxx20::ranges::iota_view<unsigned int, unsigned int>
376 isotropic_child_indices() const;
377
390 ReferenceCell
391 face_reference_cell(const unsigned int face_no) const;
392
406 static constexpr unsigned char
407 default_combined_face_orientation();
408
419 static constexpr unsigned char
420 reversed_combined_line_orientation();
421
463 unsigned int
464 child_cell_on_face(const unsigned int face,
465 const unsigned int subface,
466 const unsigned char face_orientation =
467 default_combined_face_orientation()) const;
468
478 std::array<unsigned int, 2>
479 standard_vertex_to_face_and_vertex_index(const unsigned int vertex) const;
480
490 std::array<unsigned int, 2>
491 standard_line_to_face_and_line_index(const unsigned int line) const;
492
501 unsigned int
502 line_to_cell_vertices(const unsigned int line,
503 const unsigned int vertex) const;
504
508 unsigned int
509 face_to_cell_lines(const unsigned int face,
510 const unsigned int line,
511 const unsigned char face_orientation) const;
512
516 unsigned int
517 face_to_cell_vertices(const unsigned int face,
518 const unsigned int vertex,
519 const unsigned char face_orientation) const;
520
540 template <int dim>
541 Point<dim>
542 face_vertex_location(const unsigned int face,
543 const unsigned int vertex) const;
544
548 unsigned int
549 standard_to_real_face_vertex(const unsigned int vertex,
550 const unsigned int face,
551 const unsigned char face_orientation) const;
552
556 unsigned int
557 standard_to_real_face_line(const unsigned int line,
558 const unsigned int face,
559 const unsigned char face_orientation) const;
560
571 bool
572 standard_vs_true_line_orientation(const unsigned int line,
573 const unsigned int face,
574 const unsigned char face_orientation,
575 const bool line_orientation) const;
576
600 double
601 volume() const;
602
615 template <int dim>
616 Point<dim>
617 barycenter() const;
618
638 template <int dim>
639 bool
640 contains_point(const Point<dim> &p, const double tolerance = 0) const;
641
646 template <int dim>
647 Point<dim>
648 closest_point(const Point<dim> &p) const;
649
657 template <int dim>
658 Tensor<1, dim>
659 unit_tangential_vectors(const unsigned int face_no,
660 const unsigned int i) const;
661
665 template <int dim>
666 Tensor<1, dim>
667 unit_normal_vectors(const unsigned int face_no) const;
668
674 unsigned int
675 n_face_orientations(const unsigned int face_no) const;
676
693 template <typename T, std::size_t N>
694 DEAL_II_DEPRECATED unsigned char
695 compute_orientation(const std::array<T, N> &vertices_0,
696 const std::array<T, N> &vertices_1) const;
697
723 template <typename T>
724 unsigned char
725 get_combined_orientation(const ArrayView<const T> &vertices_0,
726 const ArrayView<const T> &vertices_1) const;
727
728
742 template <typename T, std::size_t N>
743 DEAL_II_DEPRECATED std::array<T, N>
744 permute_according_orientation(const std::array<T, N> &vertices,
745 const unsigned int orientation) const;
746
758 template <typename T>
759 boost::container::small_vector<T, 8>
760 permute_by_combined_orientation(const ArrayView<const T> &vertices,
761 const unsigned char orientation) const;
762
768 unsigned char
769 get_inverse_combined_orientation(const unsigned char orientation) const;
770
774 ArrayView<const unsigned int>
775 faces_for_given_vertex(const unsigned int vertex_index) const;
776
781 constexpr ::ndarray<unsigned int, 12, 4>
782 new_isotropic_child_face_lines(const unsigned int refinement_choice) const;
783
788 constexpr ::ndarray<unsigned int, 12, 4, 2>
789 new_isotropic_child_face_line_vertices(
790 const unsigned int refinement_choice) const;
791
796 constexpr ::ndarray<unsigned int, 8, 6>
797 new_isotropic_child_cell_faces(const unsigned int refinement_choice) const;
798
803 constexpr ::ndarray<unsigned int, 8, 4>
804 new_isotropic_child_cell_vertices(const unsigned int refinement_choice) const;
805
818 unsigned int
819 exodusii_vertex_to_deal_vertex(const unsigned int vertex_n) const;
820
824 unsigned int
825 exodusii_face_to_deal_face(const unsigned int face_n) const;
826
830 unsigned int
831 unv_vertex_to_deal_vertex(const unsigned int vertex_n) const;
832
836 unsigned int
837 vtk_linear_type() const;
838
843 unsigned int
844 vtk_quadratic_type() const;
845
850 unsigned int
851 vtk_lagrange_type() const;
852
865 template <int dim>
866 unsigned int
867 vtk_lexicographic_to_node_index(
868 const std::array<unsigned, dim> &node_indices,
869 const std::array<unsigned, dim> &nodes_per_direction,
870 const bool legacy_format) const;
871
875 unsigned int
876 vtk_vertex_to_deal_vertex(const unsigned int vertex_index) const;
877
881 unsigned int
882 gmsh_element_type() const;
883
897 std::string
898 to_string() const;
899
903 constexpr operator std::uint8_t() const;
904
908 constexpr bool
909 operator==(const ReferenceCell &type) const;
910
914 constexpr bool
915 operator!=(const ReferenceCell &type) const;
916
922 template <class Archive>
923 void
924 serialize(Archive &archive, const unsigned int /*version*/);
925
929 static constexpr std::size_t
930 memory_consumption();
931
936private:
940 std::uint8_t kind;
941
948 constexpr ReferenceCell(const std::uint8_t kind);
949
955 static constexpr ndarray<unsigned int, 1, 1> vertex_vertex_permutations = {
956 {{{0}}}};
957
961 static constexpr ndarray<unsigned int, 2, 2> line_vertex_permutations = {
962 {{{1, 0}}, {{0, 1}}}};
963
967 static constexpr ndarray<unsigned int, 6, 3> triangle_vertex_permutations = {
968 {{{0, 2, 1}},
969 {{0, 1, 2}},
970 {{2, 1, 0}},
971 {{2, 0, 1}},
972 {{1, 0, 2}},
973 {{1, 2, 0}}}};
974
978 static constexpr ndarray<unsigned int, 8, 4>
979 quadrilateral_vertex_permutations = {{{{0, 2, 1, 3}},
980 {{0, 1, 2, 3}},
981 {{2, 3, 0, 1}},
982 {{2, 0, 3, 1}},
983 {{3, 1, 2, 0}},
984 {{3, 2, 1, 0}},
985 {{1, 0, 3, 2}},
986 {{1, 3, 0, 2}}}};
987
992 friend constexpr ReferenceCell
993 internal::make_reference_cell_from_int(const std::uint8_t);
994
995 friend std::ostream &
996 operator<<(std::ostream &out, const ReferenceCell &reference_cell);
997
998 friend std::istream &
999 operator>>(std::istream &in, ReferenceCell &reference_cell);
1000};
1001
1002
1010std::ostream &
1011operator<<(std::ostream &out, const ReferenceCell &reference_cell);
1012
1020std::istream &
1021operator>>(std::istream &in, ReferenceCell &reference_cell);
1022
1023
1024inline constexpr ReferenceCell::ReferenceCell(const std::uint8_t kind)
1025 : kind(kind)
1026{}
1027
1028
1029
1030inline constexpr ReferenceCell::operator std::uint8_t() const
1031{
1032 return kind;
1033}
1034
1035
1036
1037inline constexpr bool
1038ReferenceCell::operator==(const ReferenceCell &type) const
1039{
1040 return kind == type.kind;
1041}
1042
1043
1044
1045inline constexpr bool
1046ReferenceCell::operator!=(const ReferenceCell &type) const
1047{
1048 return kind != type.kind;
1049}
1050
1051
1052
1053namespace internal
1054{
1055 inline constexpr ReferenceCell
1056 make_reference_cell_from_int(const std::uint8_t kind)
1057 {
1058#ifndef DEAL_II_CXX14_CONSTEXPR_BUG
1059 // Make sure these are the only indices from which objects can be
1060 // created.
1061 Assert((kind == std::numeric_limits<std::uint8_t>::max()) || (kind < 8),
1062 ExcInternalError());
1063#endif
1064
1065 // Call the private constructor, which we can from here because this
1066 // function is a 'friend'.
1067 return {kind};
1068 }
1069} // namespace internal
1070
1071
1072
1080namespace ReferenceCells
1081{
1082 constexpr const ReferenceCell Vertex =
1083 internal::make_reference_cell_from_int(0);
1084 constexpr const ReferenceCell Line =
1085 internal::make_reference_cell_from_int(1);
1086 constexpr const ReferenceCell Triangle =
1087 internal::make_reference_cell_from_int(2);
1088 constexpr const ReferenceCell Quadrilateral =
1089 internal::make_reference_cell_from_int(3);
1090 constexpr const ReferenceCell Tetrahedron =
1091 internal::make_reference_cell_from_int(4);
1092 constexpr const ReferenceCell Pyramid =
1093 internal::make_reference_cell_from_int(5);
1094 constexpr const ReferenceCell Wedge =
1095 internal::make_reference_cell_from_int(6);
1096 constexpr const ReferenceCell Hexahedron =
1097 internal::make_reference_cell_from_int(7);
1098 constexpr const ReferenceCell Invalid =
1099 internal::make_reference_cell_from_int(
1100 std::numeric_limits<std::uint8_t>::max());
1101
1107 template <int dim>
1108 constexpr const ReferenceCell &
1109 get_simplex();
1110
1116 template <int dim>
1117 constexpr const ReferenceCell &
1118 get_hypercube();
1119} // namespace ReferenceCells
1120
1121
1122
1123inline constexpr ReferenceCell::ReferenceCell()
1124 : ReferenceCell(ReferenceCells::Invalid)
1125{}
1126
1127
1128
1129template <class Archive>
1130inline void
1131ReferenceCell::serialize(Archive &archive, const unsigned int /*version*/)
1132{
1133 archive &kind;
1134}
1135
1136
1137
1138inline constexpr std::size_t
1143
1144
1145
1146inline ArrayView<const unsigned int>
1147ReferenceCell::faces_for_given_vertex(const unsigned int vertex) const
1148{
1149 AssertIndexRange(vertex, n_vertices());
1150 switch (this->kind)
1151 {
1152 case ReferenceCells::Line:
1153 return {&GeometryInfo<2>::vertex_to_face[vertex][0], 1};
1154 case ReferenceCells::Quadrilateral:
1155 return {&GeometryInfo<2>::vertex_to_face[vertex][0], 2};
1156 case ReferenceCells::Triangle:
1157 {
1158 static constexpr ndarray<unsigned int, 3, 2> table = {
1159 {{{0, 2}}, {{0, 1}}, {{1, 2}}}};
1160 return table[vertex];
1161 }
1162 case ReferenceCells::Tetrahedron:
1163 {
1164 static constexpr ndarray<unsigned int, 4, 3> table = {
1165 {{{0, 1, 2}}, {{0, 1, 3}}, {{0, 2, 3}}, {{1, 2, 3}}}};
1166
1167 return table[vertex];
1168 }
1169 case ReferenceCells::Pyramid:
1170 {
1171 static constexpr unsigned int X = numbers::invalid_unsigned_int;
1172 static constexpr ndarray<unsigned int, 5, 4> table = {
1173 {{{0, 1, 3, X}},
1174 {{0, 2, 3, X}},
1175 {{0, 1, 4, X}},
1176 {{0, 2, 4, X}},
1177 {{1, 2, 3, 4}}}};
1178
1179 return {&table[vertex][0], vertex == 4 ? 4u : 3u};
1180 }
1181 case ReferenceCells::Wedge:
1182 {
1183 AssertIndexRange(vertex, 6);
1184 static constexpr ndarray<unsigned int, 6, 3> table = {{{{0, 2, 4}},
1185 {{0, 2, 3}},
1186 {{0, 3, 4}},
1187 {{1, 2, 4}},
1188 {{1, 2, 3}},
1189 {{1, 3, 4}}}};
1190
1191 return table[vertex];
1192 }
1193 case ReferenceCells::Hexahedron:
1194 return {&GeometryInfo<3>::vertex_to_face[vertex][0], 3};
1195 default:
1196 DEAL_II_NOT_IMPLEMENTED();
1197 }
1198
1199 return {};
1200}
1201
1202
1203constexpr ::ndarray<unsigned int, 12, 4>
1204ReferenceCell::new_isotropic_child_face_lines(
1205 const unsigned int refienement_choice) const
1206{
1207 // AssertIndexRange(refienement_choice, n_isotropic_refinement_choices());
1208 const unsigned int X = numbers::invalid_unsigned_int;
1209 switch (this->kind)
1210 {
1211 case ReferenceCells::Tetrahedron:
1212 {
1213 constexpr ::ndarray<unsigned int, 3, 12, 4> new_quad_lines_tet =
1214 {{// new line is (6,8)
1215 {{{{2, 3, 8, X}},
1216 {{0, 9, 5, X}},
1217 {{1, 6, 11, X}},
1218 {{4, 10, 7, X}},
1219 {{2, 12, 5, X}},
1220 {{1, 9, 12, X}},
1221 {{4, 8, 12, X}},
1222 {{6, 12, 10, X}},
1223 {{X, X, X, X}},
1224 {{X, X, X, X}},
1225 {{X, X, X, X}},
1226 {{X, X, X, X}}}},
1227 // new line is (5,7)
1228 {{{{2, 3, 8, X}},
1229 {{0, 9, 5, X}},
1230 {{1, 6, 11, X}},
1231 {{4, 10, 7, X}},
1232 {{0, 3, 12, X}},
1233 {{1, 12, 8, X}},
1234 {{4, 12, 9, X}},
1235 {{7, 11, 12, X}},
1236 {{X, X, X, X}},
1237 {{X, X, X, X}},
1238 {{X, X, X, X}},
1239 {{X, X, X, X}}}},
1240 // new line is (4,9)
1241 {{{{2, 3, 8, X}},
1242 {{0, 9, 5, X}},
1243 {{1, 6, 11, X}},
1244 {{4, 10, 7, X}},
1245 {{0, 12, 11, X}},
1246 {{2, 6, 12, X}},
1247 {{3, 12, 7, X}},
1248 {{5, 10, 12, X}},
1249 {{X, X, X, X}},
1250 {{X, X, X, X}},
1251 {{X, X, X, X}},
1252 {{X, X, X, X}}}}}};
1253 return new_quad_lines_tet[refienement_choice];
1254 }
1255
1256 case ReferenceCells::Hexahedron:
1257 {
1258 constexpr ::ndarray<unsigned int, 12, 4> new_quad_lines_hex = {
1259 {{{10, 28, 16, 24}},
1260 {{28, 14, 17, 25}},
1261 {{11, 29, 24, 20}},
1262 {{29, 15, 25, 21}},
1263 {{18, 26, 0, 28}},
1264 {{26, 22, 1, 29}},
1265 {{19, 27, 28, 4}},
1266 {{27, 23, 29, 5}},
1267 {{2, 24, 8, 26}},
1268 {{24, 6, 9, 27}},
1269 {{3, 25, 26, 12}},
1270 {{25, 7, 27, 13}}}};
1271 return new_quad_lines_hex;
1272 }
1273 default:
1274 DEAL_II_NOT_IMPLEMENTED();
1275 }
1276
1277 return {};
1278}
1279
1280
1281
1282constexpr ::ndarray<unsigned int, 12, 4, 2>
1283ReferenceCell::new_isotropic_child_face_line_vertices(
1284 const unsigned int refienement_choice) const
1285{
1286 // AssertIndexRange(refienement_choice, n_isotropic_refinement_choices());
1287 const unsigned int X = numbers::invalid_unsigned_int;
1288 switch (this->kind)
1289 {
1290 case ReferenceCells::Tetrahedron:
1291 {
1292 constexpr ::ndarray<unsigned int, 3, 12, 4, 2> table_tet = {
1293 {// new line is (6, 8)
1294 {{{{{{6, 4}}, {{4, 7}}, {{7, 6}}, {{X, X}}}},
1295 {{{{4, 5}}, {{5, 8}}, {{8, 4}}, {{X, X}}}},
1296 {{{{5, 6}}, {{6, 9}}, {{9, 5}}, {{X, X}}}},
1297 {{{{7, 8}}, {{8, 9}}, {{9, 7}}, {{X, X}}}},
1298 {{{{4, 6}}, {{6, 8}}, {{8, 4}}, {{X, X}}}},
1299 {{{{6, 5}}, {{5, 8}}, {{8, 6}}, {{X, X}}}},
1300 {{{{8, 7}}, {{7, 6}}, {{6, 8}}, {{X, X}}}},
1301 {{{{9, 6}}, {{6, 8}}, {{8, 9}}, {{X, X}}}},
1302 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1303 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1304 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1305 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}}}},
1306 // new line is (5, 7)
1307 {{{{{{6, 4}}, {{4, 7}}, {{7, 6}}, {{X, X}}}},
1308 {{{{4, 5}}, {{5, 8}}, {{8, 4}}, {{X, X}}}},
1309 {{{{5, 6}}, {{6, 9}}, {{9, 5}}, {{X, X}}}},
1310 {{{{7, 8}}, {{8, 9}}, {{9, 7}}, {{X, X}}}},
1311 {{{{5, 4}}, {{4, 7}}, {{7, 5}}, {{X, X}}}},
1312 {{{{6, 5}}, {{5, 7}}, {{7, 6}}, {{X, X}}}},
1313 {{{{8, 7}}, {{7, 5}}, {{5, 8}}, {{X, X}}}},
1314 {{{{7, 9}}, {{9, 5}}, {{5, 7}}, {{X, X}}}},
1315 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1316 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1317 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1318 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}}}},
1319 // new line is (4, 9)
1320 {{{{{{6, 4}}, {{4, 7}}, {{7, 6}}, {{X, X}}}},
1321 {{{{4, 5}}, {{5, 8}}, {{8, 4}}, {{X, X}}}},
1322 {{{{5, 6}}, {{6, 9}}, {{9, 5}}, {{X, X}}}},
1323 {{{{7, 8}}, {{8, 9}}, {{9, 7}}, {{X, X}}}},
1324 {{{{5, 4}}, {{4, 9}}, {{9, 5}}, {{X, X}}}},
1325 {{{{4, 6}}, {{6, 9}}, {{9, 4}}, {{X, X}}}},
1326 {{{{7, 4}}, {{4, 9}}, {{9, 7}}, {{X, X}}}},
1327 {{{{4, 8}}, {{8, 9}}, {{9, 4}}, {{X, X}}}},
1328 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1329 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1330 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}},
1331 {{{{X, X}}, {{X, X}}, {{X, X}}, {{X, X}}}}}}}};
1332 return table_tet[refienement_choice];
1333 }
1334
1335 case ReferenceCells::Hexahedron:
1336 {
1337 constexpr ::ndarray<unsigned int, 12, 4, 2> table_hex = {
1338 {{{{{10, 22}}, {{24, 26}}, {{10, 24}}, {{22, 26}}}},
1339 {{{{24, 26}}, {{11, 23}}, {{24, 11}}, {{26, 23}}}},
1340 {{{{22, 14}}, {{26, 25}}, {{22, 26}}, {{14, 25}}}},
1341 {{{{26, 25}}, {{23, 15}}, {{26, 23}}, {{25, 15}}}},
1342 {{{{8, 24}}, {{20, 26}}, {{8, 20}}, {{24, 26}}}},
1343 {{{{20, 26}}, {{12, 25}}, {{20, 12}}, {{26, 25}}}},
1344 {{{{24, 9}}, {{26, 21}}, {{24, 26}}, {{9, 21}}}},
1345 {{{{26, 21}}, {{25, 13}}, {{26, 25}}, {{21, 13}}}},
1346 {{{{16, 20}}, {{22, 26}}, {{16, 22}}, {{20, 26}}}},
1347 {{{{22, 26}}, {{17, 21}}, {{22, 17}}, {{26, 21}}}},
1348 {{{{20, 18}}, {{26, 23}}, {{20, 26}}, {{18, 23}}}},
1349 {{{{26, 23}}, {{21, 19}}, {{26, 21}}, {{23, 19}}}}}};
1350 return table_hex;
1351 }
1352 default:
1353 DEAL_II_NOT_IMPLEMENTED();
1354 }
1355
1356 return {};
1357}
1358
1359
1360
1361constexpr ::ndarray<unsigned int, 8, 6>
1362ReferenceCell::new_isotropic_child_cell_faces(
1363 const unsigned int refienement_choice) const
1364{
1365 // AssertIndexRange(refienement_choice, n_isotropic_refinement_choices());
1366 const unsigned int X = numbers::invalid_unsigned_int;
1367 switch (this->kind)
1368 {
1369 case ReferenceCells::Tetrahedron:
1370 {
1371 constexpr ::ndarray<unsigned int, 3, 8, 6> cell_quads_tet = {
1372 {// new line is (6, 8)
1373 {{{{8, 13, 16, 0, X, X}},
1374 {{9, 12, 1, 21, X, X}},
1375 {{10, 2, 17, 20, X, X}},
1376 {{3, 14, 18, 22, X, X}},
1377 {{11, 1, 4, 5, X, X}},
1378 {{15, 0, 4, 6, X, X}},
1379 {{19, 7, 6, 3, X, X}},
1380 {{23, 5, 2, 7, X, X}}}},
1381 // new line is (5, 7)
1382 {{
1383 {{8, 13, 16, 0, X, X}},
1384 {{9, 12, 1, 21, X, X}},
1385 {{10, 2, 17, 20, X, X}},
1386 {{3, 14, 18, 22, X, X}},
1387 {{11, 4, 0, 5, X, X}},
1388 {{15, 4, 1, 6, X, X}},
1389 {{19, 2, 5, 7, X, X}},
1390 {{23, 6, 7, 3, X, X}},
1391 }},
1392 // new line is (4, 9)
1393 {{
1394 {{8, 13, 16, 0, X, X}},
1395 {{9, 12, 1, 21, X, X}},
1396 {{10, 2, 17, 20, X, X}},
1397 {{3, 14, 18, 22, X, X}},
1398 {{11, 4, 5, 2, X, X}},
1399 {{15, 6, 7, 3, X, X}},
1400 {{19, 5, 0, 6, X, X}},
1401 {{23, 1, 4, 7, X, X}},
1402 }}}};
1403 return cell_quads_tet[refienement_choice];
1404 }
1405
1406 case ReferenceCells::Hexahedron:
1407 {
1408 constexpr ::ndarray<unsigned int, 8, 6> cell_quads_hex = {{
1409 {{12, 0, 20, 4, 28, 8}}, // bottom children
1410 {{0, 16, 22, 6, 29, 9}}, //
1411 {{13, 1, 4, 24, 30, 10}}, //
1412 {{1, 17, 6, 26, 31, 11}}, //
1413 {{14, 2, 21, 5, 8, 32}}, // top children
1414 {{2, 18, 23, 7, 9, 33}}, //
1415 {{15, 3, 5, 25, 10, 34}}, //
1416 {{3, 19, 7, 27, 11, 35}} //
1417 }};
1418 return cell_quads_hex;
1419 }
1420 default:
1421 DEAL_II_NOT_IMPLEMENTED();
1422 }
1423
1424 return {};
1425}
1426
1427
1428
1429constexpr ::ndarray<unsigned int, 8, 4>
1430ReferenceCell::new_isotropic_child_cell_vertices(
1431 const unsigned int refienement_choice) const
1432{
1433 // AssertIndexRange(refienement_choice, n_isotropic_refinement_choices());
1434
1435 switch (this->kind)
1436 {
1437 case ReferenceCells::Tetrahedron:
1438 {
1439 constexpr ::ndarray<unsigned int, 3, 8, 4> cell_vertices_tet = {
1440 {// new line is (6,8)
1441 {{{{0, 4, 6, 7}},
1442 {{4, 1, 5, 8}},
1443 {{6, 5, 2, 9}},
1444 {{7, 8, 9, 3}},
1445 {{4, 5, 6, 8}},
1446 {{4, 7, 8, 6}},
1447 {{6, 9, 7, 8}},
1448 {{5, 8, 9, 6}}}},
1449 // new line is (5,7)
1450 {{{{0, 4, 6, 7}},
1451 {{4, 1, 5, 8}},
1452 {{6, 5, 2, 9}},
1453 {{7, 8, 9, 3}},
1454 {{4, 5, 6, 7}},
1455 {{4, 7, 8, 5}},
1456 {{6, 9, 7, 5}},
1457 {{5, 8, 9, 7}}}},
1458 // new line is (4,9)
1459 {{{{0, 4, 6, 7}},
1460 {{4, 1, 5, 8}},
1461 {{6, 5, 2, 9}},
1462 {{7, 8, 9, 3}},
1463 {{4, 5, 6, 9}},
1464 {{4, 7, 8, 9}},
1465 {{6, 9, 7, 4}},
1466 {{5, 8, 9, 4}}}}}};
1467 return cell_vertices_tet[refienement_choice];
1468 }
1469 default:
1470 DEAL_II_NOT_IMPLEMENTED();
1471 }
1472
1473 return {};
1474}
1475
1476
1477
1478inline bool
1479ReferenceCell::is_hyper_cube() const
1480{
1481 return (*this == ReferenceCells::Vertex || *this == ReferenceCells::Line ||
1482 *this == ReferenceCells::Quadrilateral ||
1483 *this == ReferenceCells::Hexahedron);
1484}
1485
1486
1487
1488inline bool
1489ReferenceCell::is_simplex() const
1490{
1491 return (*this == ReferenceCells::Vertex || *this == ReferenceCells::Line ||
1492 *this == ReferenceCells::Triangle ||
1493 *this == ReferenceCells::Tetrahedron);
1494}
1495
1496
1497
1498inline unsigned int
1499ReferenceCell::get_dimension() const
1500{
1501 switch (this->kind)
1502 {
1503 case ReferenceCells::Vertex:
1504 return 0;
1505 case ReferenceCells::Line:
1506 return 1;
1507 case ReferenceCells::Triangle:
1508 case ReferenceCells::Quadrilateral:
1509 return 2;
1510 case ReferenceCells::Tetrahedron:
1511 case ReferenceCells::Pyramid:
1512 case ReferenceCells::Wedge:
1513 case ReferenceCells::Hexahedron:
1514 return 3;
1515 default:
1516 DEAL_II_NOT_IMPLEMENTED();
1517 }
1518
1519 return numbers::invalid_unsigned_int;
1520}
1521
1522
1523
1524template <int dim>
1525Quadrature<dim>
1526ReferenceCell::get_midpoint_quadrature() const
1527{
1528 return Quadrature<dim>(std::vector<Point<dim>>({barycenter<dim>()}),
1529 std::vector<double>({volume()}));
1530}
1531
1532
1533
1534inline unsigned int
1535ReferenceCell::n_vertices() const
1536{
1537 switch (this->kind)
1538 {
1539 case ReferenceCells::Vertex:
1540 return 1;
1541 case ReferenceCells::Line:
1542 return 2;
1543 case ReferenceCells::Triangle:
1544 return 3;
1545 case ReferenceCells::Quadrilateral:
1546 return 4;
1547 case ReferenceCells::Tetrahedron:
1548 return 4;
1549 case ReferenceCells::Pyramid:
1550 return 5;
1551 case ReferenceCells::Wedge:
1552 return 6;
1553 case ReferenceCells::Hexahedron:
1554 return 8;
1555 default:
1556 DEAL_II_NOT_IMPLEMENTED();
1557 }
1558
1559 return numbers::invalid_unsigned_int;
1560}
1561
1562
1563
1564inline unsigned int
1565ReferenceCell::n_lines() const
1566{
1567 switch (this->kind)
1568 {
1569 case ReferenceCells::Vertex:
1570 return 0;
1571 case ReferenceCells::Line:
1572 return 1;
1573 case ReferenceCells::Triangle:
1574 return 3;
1575 case ReferenceCells::Quadrilateral:
1576 return 4;
1577 case ReferenceCells::Tetrahedron:
1578 return 6;
1579 case ReferenceCells::Pyramid:
1580 return 8;
1581 case ReferenceCells::Wedge:
1582 return 9;
1583 case ReferenceCells::Hexahedron:
1584 return 12;
1585 default:
1586 DEAL_II_NOT_IMPLEMENTED();
1587 }
1588
1589 return numbers::invalid_unsigned_int;
1590}
1591
1592
1593
1594template <int dim>
1595Point<dim>
1596ReferenceCell::vertex(const unsigned int v) const
1597{
1598 AssertDimension(dim, get_dimension());
1599 AssertIndexRange(v, n_vertices());
1600
1601 switch (dim)
1602 {
1603 case 0:
1604 {
1605 if (*this == ReferenceCells::Vertex)
1606 return Point<dim>();
1607 break;
1608 }
1609 case 1:
1610 {
1611 static const Point<dim> vertices[2] = {
1612 Point<dim>(), // the origin
1613 Point<dim>::unit_vector(0) // unit point along x-axis
1614 };
1615 if (*this == ReferenceCells::Line)
1616 return vertices[v];
1617 break;
1618 }
1619 case 2:
1620 {
1621 switch (this->kind)
1622 {
1623 case ReferenceCells::Triangle:
1624 {
1625 static const Point<dim> vertices[3] = {
1626 Point<dim>(), // the origin
1627 Point<dim>::unit_vector(0), // unit point along x-axis
1628 Point<dim>::unit_vector(1) // unit point along y-axis
1629 };
1630 return vertices[v];
1631 }
1632 case ReferenceCells::Quadrilateral:
1633 {
1634 static const Point<dim> vertices[4] = {
1635 // First the two points on the x-axis
1636 Point<dim>(),
1637 Point<dim>::unit_vector(0),
1638 // Then these two points shifted in the y-direction
1639 Point<dim>() + Point<dim>::unit_vector(1),
1640 Point<dim>::unit_vector(0) + Point<dim>::unit_vector(1)};
1641 return vertices[v];
1642 }
1643 }
1644 break;
1645 }
1646 case 3:
1647 {
1648 switch (this->kind)
1649 {
1650 case ReferenceCells::Tetrahedron:
1651 {
1652 static const Point<dim> vertices[4] = {
1653 Point<dim>(), // the origin
1654 Point<dim>::unit_vector(0), // unit point along x-axis
1655 Point<dim>::unit_vector(1), // unit point along y-axis
1656 Point<dim>::unit_vector(2) // unit point along z-axis
1657 };
1658 return vertices[v];
1659 }
1660 case ReferenceCells::Pyramid:
1661 {
1662 static const Point<dim> vertices[5] = {
1663 Point<dim>{-1.0, -1.0, 0.0},
1664 Point<dim>{+1.0, -1.0, 0.0},
1665 Point<dim>{-1.0, +1.0, 0.0},
1666 Point<dim>{+1.0, +1.0, 0.0},
1667 Point<dim>{+0.0, +0.0, 1.0}};
1668 return vertices[v];
1669 }
1670 case ReferenceCells::Wedge:
1671 {
1672 static const Point<dim> vertices[6] = {
1673 // First the three points on the triangular base of the
1674 // wedge:
1675 Point<dim>(),
1676 Point<dim>::unit_vector(0),
1677 Point<dim>::unit_vector(1),
1678 // And now everything shifted in the z-direction again
1679 Point<dim>() + Point<dim>::unit_vector(2),
1680 Point<dim>::unit_vector(0) + Point<dim>::unit_vector(2),
1681 Point<dim>::unit_vector(1) + Point<dim>::unit_vector(2)};
1682 return vertices[v];
1683 }
1684 case ReferenceCells::Hexahedron:
1685 {
1686 static const Point<dim> vertices[8] = {
1687 // First the two points on the x-axis
1688 Point<dim>(),
1689 Point<dim>::unit_vector(0),
1690 // Then these two points shifted in the y-direction
1691 Point<dim>() + Point<dim>::unit_vector(1),
1692 Point<dim>::unit_vector(0) + Point<dim>::unit_vector(1),
1693 // And now all four points shifted in the z-direction
1694 Point<dim>() + Point<dim>::unit_vector(2),
1695 Point<dim>::unit_vector(0) + Point<dim>::unit_vector(2),
1696 Point<dim>() + Point<dim>::unit_vector(1) +
1697 Point<dim>::unit_vector(2),
1698 Point<dim>::unit_vector(0) + Point<dim>::unit_vector(1) +
1699 Point<dim>::unit_vector(2)};
1700 return vertices[v];
1701 }
1702 }
1703 break;
1704 }
1705 default:
1706 DEAL_II_NOT_IMPLEMENTED();
1707 }
1708
1709 DEAL_II_NOT_IMPLEMENTED();
1710 return Point<dim>();
1711}
1712
1713
1714inline unsigned int
1715ReferenceCell::n_faces() const
1716{
1717 switch (this->kind)
1718 {
1719 case ReferenceCells::Vertex:
1720 return 0;
1721 case ReferenceCells::Line:
1722 return 2;
1723 case ReferenceCells::Triangle:
1724 return 3;
1725 case ReferenceCells::Quadrilateral:
1726 return 4;
1727 case ReferenceCells::Tetrahedron:
1728 return 4;
1729 case ReferenceCells::Pyramid:
1730 return 5;
1731 case ReferenceCells::Wedge:
1732 return 5;
1733 case ReferenceCells::Hexahedron:
1734 return 6;
1735 default:
1736 DEAL_II_NOT_IMPLEMENTED();
1737 }
1738
1739 return numbers::invalid_unsigned_int;
1740}
1741
1742
1743
1744inline std_cxx20::ranges::iota_view<unsigned int, unsigned int>
1745ReferenceCell::face_indices() const
1746{
1747 return {0U, n_faces()};
1748}
1749
1750
1751
1752inline unsigned int
1753ReferenceCell::n_isotropic_refinement_choices() const
1754{
1755 switch (this->kind)
1756 {
1757 case ReferenceCells::Vertex:
1758 return 1;
1759 case ReferenceCells::Line:
1760 return 1;
1761 case ReferenceCells::Triangle:
1762 return 1;
1763 case ReferenceCells::Quadrilateral:
1764 return 1;
1765 case ReferenceCells::Tetrahedron:
1766 return 3;
1767 case ReferenceCells::Pyramid:
1768 return 1;
1769 case ReferenceCells::Wedge:
1770 return 1;
1771 case ReferenceCells::Hexahedron:
1772 return 1;
1773 default:
1774 DEAL_II_ASSERT_UNREACHABLE();
1775 }
1776
1777 return numbers::invalid_unsigned_int;
1778}
1779
1780
1781
1782inline IsotropicRefinementChoice
1783ReferenceCell::get_isotropic_refinement_choice(
1784 const unsigned int ref_choice) const
1785{
1786 AssertIndexRange(ref_choice, n_isotropic_refinement_choices());
1787 switch (this->kind)
1788 {
1789 case ReferenceCells::Tetrahedron:
1790 {
1791 static constexpr ndarray<IsotropicRefinementChoice, 3>
1792 isotropic_ref_choices = {{IsotropicRefinementChoice::cut_tet_68,
1793 IsotropicRefinementChoice::cut_tet_57,
1794 IsotropicRefinementChoice::cut_tet_49}};
1795 return isotropic_ref_choices[ref_choice];
1796 }
1797 default:
1798 {
1799 DEAL_II_NOT_IMPLEMENTED();
1800 }
1801 }
1802
1803 return IsotropicRefinementChoice::isotropic_refinement;
1804}
1805
1806
1807
1808inline unsigned int
1809ReferenceCell::n_isotropic_children() const
1810{
1811 switch (this->kind)
1812 {
1813 case ReferenceCells::Vertex:
1814 return 0;
1815 case ReferenceCells::Line:
1816 return 2;
1817 case ReferenceCells::Triangle:
1818 return 4;
1819 case ReferenceCells::Quadrilateral:
1820 return 4;
1821 case ReferenceCells::Tetrahedron:
1822 return 8;
1823 case ReferenceCells::Pyramid:
1824 // We haven't yet decided how to refine pyramids. Update this when we
1825 // have
1826 return 0;
1827 case ReferenceCells::Wedge:
1828 return 8;
1829 case ReferenceCells::Hexahedron:
1830 return 8;
1831 default:
1832 DEAL_II_ASSERT_UNREACHABLE();
1833 }
1834
1835 return numbers::invalid_unsigned_int;
1836}
1837
1838
1839
1840template <int dim>
1841unsigned int
1842ReferenceCell::n_children(const RefinementCase<dim> ref_case) const
1843{
1844 // Use GeometryInfo here to keep it the single source of truth
1845 if (this->is_hyper_cube())
1846 return GeometryInfo<dim>::n_children(ref_case);
1847 else
1848 return this->n_isotropic_children();
1849}
1850
1851
1852
1853inline std_cxx20::ranges::iota_view<unsigned int, unsigned int>
1854ReferenceCell::isotropic_child_indices() const
1855{
1856 return {0U, n_isotropic_children()};
1857}
1858
1859
1860
1861inline std_cxx20::ranges::iota_view<unsigned int, unsigned int>
1862ReferenceCell::vertex_indices() const
1863{
1864 return {0U, n_vertices()};
1865}
1866
1867
1868
1869inline std_cxx20::ranges::iota_view<unsigned int, unsigned int>
1870ReferenceCell::line_indices() const
1871{
1872 return {0U, n_lines()};
1873}
1874
1875
1876
1877inline ReferenceCell
1878ReferenceCell::face_reference_cell(const unsigned int face_no) const
1879{
1880 AssertIndexRange(face_no, n_faces());
1881
1882 switch (this->kind)
1883 {
1884 case ReferenceCells::Vertex:
1885 return ReferenceCells::Invalid;
1886 case ReferenceCells::Line:
1887 return ReferenceCells::Vertex;
1888 case ReferenceCells::Triangle:
1889 case ReferenceCells::Quadrilateral:
1890 return ReferenceCells::Line;
1891 case ReferenceCells::Tetrahedron:
1892 return ReferenceCells::Triangle;
1893 case ReferenceCells::Pyramid:
1894 if (face_no == 0)
1895 return ReferenceCells::Quadrilateral;
1896 else
1897 return ReferenceCells::Triangle;
1898 case ReferenceCells::Wedge:
1899 if (face_no > 1)
1900 return ReferenceCells::Quadrilateral;
1901 else
1902 return ReferenceCells::Triangle;
1903 case ReferenceCells::Hexahedron:
1904 return ReferenceCells::Quadrilateral;
1905 default:
1906 DEAL_II_NOT_IMPLEMENTED();
1907 }
1908
1909 return ReferenceCells::Invalid;
1910}
1911
1912
1913
1914inline constexpr unsigned char
1915ReferenceCell::default_combined_face_orientation()
1916{
1917 // Our convention is that 'orientation' has a default value of true and
1918 // occupies the least-significant bit while rotate and flip have default
1919 // values of 'false' and occupy the second and third bits.
1920 return 0b001;
1921}
1922
1923
1924
1925inline constexpr unsigned char
1926ReferenceCell::reversed_combined_line_orientation()
1927{
1928 // For a reversed line 'orientation' is false and neither flip nor rotate are
1929 // defined.
1930 return 0b000;
1931}
1932
1933
1934
1935inline unsigned int
1936ReferenceCell::child_cell_on_face(
1937 const unsigned int face,
1938 const unsigned int subface,
1939 const unsigned char combined_face_orientation) const
1940{
1941 AssertIndexRange(face, n_faces());
1942 AssertIndexRange(subface, face_reference_cell(face).n_isotropic_children());
1943
1944 switch (this->kind)
1945 {
1946 case ReferenceCells::Vertex:
1947 case ReferenceCells::Line:
1948 {
1949 DEAL_II_NOT_IMPLEMENTED();
1950 break;
1951 }
1952 case ReferenceCells::Triangle:
1953 {
1954 static constexpr ndarray<unsigned int, 3, 2> subcells = {
1955 {{{0, 1}}, {{1, 2}}, {{2, 0}}}};
1956
1957 return subcells[face][subface];
1958 }
1959 case ReferenceCells::Quadrilateral:
1960 {
1961 const auto [face_orientation, face_rotation, face_flip] =
1962 internal::split_face_orientation(combined_face_orientation);
1963
1964 return GeometryInfo<2>::child_cell_on_face(
1965 RefinementCase<2>(RefinementPossibilities<2>::isotropic_refinement),
1966 face,
1967 subface,
1968 face_orientation,
1969 face_flip,
1970 face_rotation);
1971 }
1972 case ReferenceCells::Tetrahedron:
1973 case ReferenceCells::Pyramid:
1974 case ReferenceCells::Wedge:
1975 {
1976 DEAL_II_NOT_IMPLEMENTED();
1977 break;
1978 }
1979 case ReferenceCells::Hexahedron:
1980 {
1981 const auto [face_orientation, face_rotation, face_flip] =
1982 internal::split_face_orientation(combined_face_orientation);
1983
1984 return GeometryInfo<3>::child_cell_on_face(
1985 RefinementCase<3>(RefinementPossibilities<3>::isotropic_refinement),
1986 face,
1987 subface,
1988 face_orientation,
1989 face_flip,
1990 face_rotation);
1991 }
1992 default:
1993 DEAL_II_NOT_IMPLEMENTED();
1994 }
1995
1996 return numbers::invalid_unsigned_int;
1997}
1998
1999
2000
2001inline std::array<unsigned int, 2>
2002ReferenceCell::standard_vertex_to_face_and_vertex_index(
2003 const unsigned int vertex) const
2004{
2005 AssertIndexRange(vertex, n_vertices());
2006 // Work around a GCC warning at higher optimization levels by making all of
2007 // these tables the same size
2008 constexpr unsigned int X = numbers::invalid_unsigned_int;
2009
2010 switch (this->kind)
2011 {
2012 case ReferenceCells::Vertex:
2013 case ReferenceCells::Line:
2014 DEAL_II_NOT_IMPLEMENTED();
2015 break;
2016 case ReferenceCells::Triangle:
2017 {
2018 static constexpr ndarray<unsigned int, 6, 2> table = {
2019 {{{0, 0}}, {{0, 1}}, {{1, 1}}, {{X, X}}, {{X, X}}, {{X, X}}}};
2020
2021 return table[vertex];
2022 }
2023 case ReferenceCells::Quadrilateral:
2024 {
2025 return GeometryInfo<2>::standard_quad_vertex_to_line_vertex_index(
2026 vertex);
2027 }
2028 case ReferenceCells::Tetrahedron:
2029 {
2030 static constexpr ndarray<unsigned int, 6, 2> table = {
2031 {{{0, 0}}, {{0, 1}}, {{0, 2}}, {{1, 2}}, {{X, X}}, {{X, X}}}};
2032
2033 return table[vertex];
2034 }
2035 case ReferenceCells::Pyramid:
2036 {
2037 static constexpr ndarray<unsigned int, 6, 2> table = {
2038 {{{0, 0}}, {{0, 1}}, {{0, 2}}, {{0, 3}}, {{1, 2}}, {{X, X}}}};
2039
2040 return table[vertex];
2041 }
2042 case ReferenceCells::Wedge:
2043 {
2044 static constexpr ndarray<unsigned int, 6, 2> table = {
2045 {{{0, 1}}, {{0, 0}}, {{0, 2}}, {{1, 0}}, {{1, 1}}, {{1, 2}}}};
2046
2047 return table[vertex];
2048 }
2049 case ReferenceCells::Hexahedron:
2050 {
2051 return GeometryInfo<3>::standard_hex_vertex_to_quad_vertex_index(
2052 vertex);
2053 }
2054 default:
2055 DEAL_II_NOT_IMPLEMENTED();
2056 }
2057
2058 return {};
2059}
2060
2061
2062
2063inline std::array<unsigned int, 2>
2064ReferenceCell::standard_line_to_face_and_line_index(
2065 const unsigned int line) const
2066{
2067 AssertIndexRange(line, n_lines());
2068
2069 switch (this->kind)
2070 {
2071 case ReferenceCells::Vertex:
2072 case ReferenceCells::Line:
2073 case ReferenceCells::Triangle:
2074 case ReferenceCells::Quadrilateral:
2075 {
2076 DEAL_II_NOT_IMPLEMENTED();
2077 break;
2078 }
2079 case ReferenceCells::Tetrahedron:
2080 {
2081 static const std::array<unsigned int, 2> table[6] = {
2082 {{0, 0}}, {{0, 1}}, {{0, 2}}, {{1, 1}}, {{1, 2}}, {{2, 1}}};
2083
2084 return table[line];
2085 }
2086 case ReferenceCells::Pyramid:
2087 {
2088 static const std::array<unsigned int, 2> table[8] = {{{0, 0}},
2089 {{0, 1}},
2090 {{0, 2}},
2091 {{0, 3}},
2092 {{1, 2}},
2093 {{2, 1}},
2094 {{1, 1}},
2095 {{2, 2}}};
2096
2097 return table[line];
2098 }
2099 case ReferenceCells::Wedge:
2100 {
2101 static const std::array<unsigned int, 2> table[9] = {{{0, 0}},
2102 {{0, 2}},
2103 {{0, 1}},
2104 {{1, 0}},
2105 {{1, 1}},
2106 {{1, 2}},
2107 {{2, 0}},
2108 {{2, 1}},
2109 {{3, 1}}};
2110
2111 return table[line];
2112 }
2113 case ReferenceCells::Hexahedron:
2114 {
2115 return GeometryInfo<3>::standard_hex_line_to_quad_line_index(line);
2116 }
2117 default:
2118 DEAL_II_NOT_IMPLEMENTED();
2119 }
2120
2121 return {};
2122}
2123
2124
2125inline unsigned int
2126ReferenceCell::line_to_cell_vertices(const unsigned int line,
2127 const unsigned int vertex) const
2128{
2129 AssertIndexRange(vertex, 2);
2130 AssertIndexRange(line, n_lines());
2131
2132 switch (this->kind)
2133 {
2134 case ReferenceCells::Vertex:
2135 case ReferenceCells::Line:
2136 return vertex;
2137 case ReferenceCells::Triangle:
2138 {
2139 static constexpr ndarray<unsigned int, 3, 2> table = {
2140 {{{0, 1}}, {{1, 2}}, {{2, 0}}}};
2141 return table[line][vertex];
2142 }
2143 case ReferenceCells::Quadrilateral:
2144 {
2145 static constexpr ndarray<unsigned int, 4, 2> table = {
2146 {{{0, 2}}, {{1, 3}}, {{0, 1}}, {{2, 3}}}};
2147 return table[line][vertex];
2148 }
2149 case ReferenceCells::Tetrahedron:
2150 {
2151 static constexpr ndarray<unsigned int, 6, 2> table = {
2152 {{{0, 1}}, {{1, 2}}, {{2, 0}}, {{0, 3}}, {{1, 3}}, {{2, 3}}}};
2153 return table[line][vertex];
2154 }
2155 case ReferenceCells::Pyramid:
2156 {
2157 static constexpr ndarray<unsigned int, 8, 2> table = {{{{0, 2}},
2158 {{1, 3}},
2159 {{0, 1}},
2160 {{2, 3}},
2161 {{4, 0}},
2162 {{1, 4}},
2163 {{2, 4}},
2164 {{4, 3}}}};
2165 return table[line][vertex];
2166 }
2167 case ReferenceCells::Wedge:
2168 {
2169 static constexpr ndarray<unsigned int, 9, 2> table = {{{{1, 0}},
2170 {{2, 1}},
2171 {{0, 2}},
2172 {{3, 4}},
2173 {{4, 5}},
2174 {{5, 3}},
2175 {{0, 3}},
2176 {{1, 4}},
2177 {{2, 5}}}};
2178 return table[line][vertex];
2179 }
2180 case ReferenceCells::Hexahedron:
2181 {
2182 // first four lines comprise the bottom face, next four are the top,
2183 // and the last four are 'bottom to top'
2184 static constexpr ndarray<unsigned int, 12, 2> table = {{{{0, 2}},
2185 {{1, 3}},
2186 {{0, 1}},
2187 {{2, 3}},
2188 {{4, 6}},
2189 {{5, 7}},
2190 {{4, 5}},
2191 {{6, 7}},
2192 {{0, 4}},
2193 {{1, 5}},
2194 {{2, 6}},
2195 {{3, 7}}}};
2196 return table[line][vertex];
2197 }
2198
2199 default:
2200 DEAL_II_NOT_IMPLEMENTED();
2201 }
2202
2203 return numbers::invalid_unsigned_int;
2204}
2205
2206
2207inline unsigned int
2208ReferenceCell::face_to_cell_lines(
2209 const unsigned int face,
2210 const unsigned int line,
2211 const unsigned char combined_face_orientation) const
2212{
2213 AssertIndexRange(face, n_faces());
2214 AssertIndexRange(line, face_reference_cell(face).n_lines());
2215
2216 static constexpr unsigned int X = numbers::invalid_unsigned_int;
2217
2218 switch (this->kind)
2219 {
2220 case ReferenceCells::Vertex:
2221 {
2222 DEAL_II_NOT_IMPLEMENTED();
2223 break;
2224 }
2225 case ReferenceCells::Line:
2226 {
2227 const auto [face_orientation, face_rotation, face_flip] =
2228 internal::split_face_orientation(combined_face_orientation);
2229
2230 return GeometryInfo<1>::face_to_cell_lines(
2231 face, line, face_orientation, face_flip, face_rotation);
2232 }
2233 case ReferenceCells::Triangle:
2234 {
2235 return face;
2236 }
2237 case ReferenceCells::Quadrilateral:
2238 {
2239 const auto [face_orientation, face_rotation, face_flip] =
2240 internal::split_face_orientation(combined_face_orientation);
2241
2242 return GeometryInfo<2>::face_to_cell_lines(
2243 face, line, face_orientation, face_flip, face_rotation);
2244 }
2245 case ReferenceCells::Tetrahedron:
2246 {
2247 static constexpr ndarray<unsigned int, 4, 3> table = {
2248 {{{0, 1, 2}}, {{0, 3, 4}}, {{2, 5, 3}}, {{1, 4, 5}}}};
2249
2250 return table[face][standard_to_real_face_line(
2251 line, face, combined_face_orientation)];
2252 }
2253 case ReferenceCells::Pyramid:
2254 {
2255 static constexpr ndarray<unsigned int, 5, 4> table = {
2256 {{{0, 1, 2, 3}},
2257 {{0, 6, 4, X}},
2258 {{1, 5, 7, X}},
2259 {{2, 4, 5, X}},
2260 {{3, 7, 6, X}}}};
2261
2262 return table[face][standard_to_real_face_line(
2263 line, face, combined_face_orientation)];
2264 }
2265 case ReferenceCells::Wedge:
2266 {
2267 static constexpr ndarray<unsigned int, 5, 4> table = {
2268 {{{0, 2, 1, X}},
2269 {{3, 4, 5, X}},
2270 {{6, 7, 0, 3}},
2271 {{7, 8, 1, 4}},
2272 {{8, 6, 5, 2}}}};
2273
2274 return table[face][standard_to_real_face_line(
2275 line, face, combined_face_orientation)];
2276 }
2277 case ReferenceCells::Hexahedron:
2278 {
2279 const auto [face_orientation, face_rotation, face_flip] =
2280 internal::split_face_orientation(combined_face_orientation);
2281
2282 return GeometryInfo<3>::face_to_cell_lines(
2283 face, line, face_orientation, face_flip, face_rotation);
2284 }
2285 default:
2286 DEAL_II_NOT_IMPLEMENTED();
2287 }
2288
2289 return numbers::invalid_unsigned_int;
2290}
2291
2292
2293
2294inline unsigned int
2295ReferenceCell::face_to_cell_vertices(
2296 const unsigned int face,
2297 const unsigned int vertex,
2298 const unsigned char combined_face_orientation) const
2299{
2300 AssertIndexRange(face, n_faces());
2301 AssertIndexRange(vertex, face_reference_cell(face).n_vertices());
2302 // TODO: once the default orientation is switched to 0 then we can remove this
2303 // special case for 1D.
2304 if (get_dimension() == 1)
2305 Assert(combined_face_orientation ==
2306 ReferenceCell::default_combined_face_orientation(),
2307 ExcMessage("In 1D, all faces must have the default orientation."));
2308 else
2309 AssertIndexRange(combined_face_orientation, n_face_orientations(face));
2310
2311 switch (this->kind)
2312 {
2313 case ReferenceCells::Vertex:
2314 {
2315 DEAL_II_NOT_IMPLEMENTED();
2316 break;
2317 }
2318 case ReferenceCells::Line:
2319 {
2320 const auto [face_orientation, face_rotation, face_flip] =
2321 internal::split_face_orientation(combined_face_orientation);
2322
2323 return GeometryInfo<1>::face_to_cell_vertices(
2324 face, vertex, face_orientation, face_flip, face_rotation);
2325 }
2326 case ReferenceCells::Triangle:
2327 {
2328 static constexpr ndarray<unsigned int, 3, 2> table = {
2329 {{{0, 1}}, {{1, 2}}, {{2, 0}}}};
2330
2331 return table[face][combined_face_orientation ==
2332 default_combined_face_orientation() ?
2333 vertex :
2334 (1 - vertex)];
2335 }
2336 case ReferenceCells::Quadrilateral:
2337 {
2338 const auto [face_orientation, face_rotation, face_flip] =
2339 internal::split_face_orientation(combined_face_orientation);
2340
2341 return GeometryInfo<2>::face_to_cell_vertices(
2342 face, vertex, face_orientation, face_flip, face_rotation);
2343 }
2344 case ReferenceCells::Tetrahedron:
2345 {
2346 static constexpr ndarray<unsigned int, 4, 3> table = {
2347 {{{0, 1, 2}}, {{1, 0, 3}}, {{0, 2, 3}}, {{2, 1, 3}}}};
2348
2349 return table[face][standard_to_real_face_vertex(
2350 vertex, face, combined_face_orientation)];
2351 }
2352 case ReferenceCells::Pyramid:
2353 {
2354 constexpr auto X = numbers::invalid_unsigned_int;
2355 static constexpr ndarray<unsigned int, 5, 4> table = {
2356 {{{0, 1, 2, 3}},
2357 {{0, 2, 4, X}},
2358 {{3, 1, 4, X}},
2359 {{1, 0, 4, X}},
2360 {{2, 3, 4, X}}}};
2361
2362 return table[face][standard_to_real_face_vertex(
2363 vertex, face, combined_face_orientation)];
2364 }
2365 case ReferenceCells::Wedge:
2366 {
2367 constexpr auto X = numbers::invalid_unsigned_int;
2368 static constexpr ndarray<unsigned int, 6, 4> table = {
2369 {{{1, 0, 2, X}},
2370 {{3, 4, 5, X}},
2371 {{0, 1, 3, 4}},
2372 {{1, 2, 4, 5}},
2373 {{2, 0, 5, 3}}}};
2374
2375 return table[face][standard_to_real_face_vertex(
2376 vertex, face, combined_face_orientation)];
2377 }
2378 case ReferenceCells::Hexahedron:
2379 {
2380 const auto [face_orientation, face_rotation, face_flip] =
2381 internal::split_face_orientation(combined_face_orientation);
2382
2383 return GeometryInfo<3>::face_to_cell_vertices(
2384 face, vertex, face_orientation, face_flip, face_rotation);
2385 }
2386 default:
2387 DEAL_II_NOT_IMPLEMENTED();
2388 }
2389
2390 return numbers::invalid_unsigned_int;
2391}
2392
2393
2394
2395template <int dim>
2396Point<dim>
2397ReferenceCell::face_vertex_location(const unsigned int face,
2398 const unsigned int vertex) const
2399{
2400 return this->template vertex<dim>(
2401 face_to_cell_vertices(face, vertex, default_combined_face_orientation()));
2402}
2403
2404
2405
2406inline unsigned int
2407ReferenceCell::standard_to_real_face_vertex(
2408 const unsigned int vertex,
2409 const unsigned int face,
2410 const unsigned char face_orientation) const
2411{
2412 AssertIndexRange(face, n_faces());
2413 AssertIndexRange(vertex, face_reference_cell(face).n_vertices());
2414
2415 switch (this->kind)
2416 {
2417 case ReferenceCells::Vertex:
2418 DEAL_II_NOT_IMPLEMENTED();
2419 break;
2420 case ReferenceCells::Line:
2421 Assert(face_orientation == default_combined_face_orientation(),
2422 ExcMessage(
2423 "In 1D, all faces must have the default orientation."));
2424 return vertex;
2425 case ReferenceCells::Triangle:
2426 case ReferenceCells::Quadrilateral:
2427 return line_vertex_permutations[face_orientation][vertex];
2428 case ReferenceCells::Tetrahedron:
2429 return triangle_vertex_permutations[face_orientation][vertex];
2430 case ReferenceCells::Pyramid:
2431 // face 0 is a quadrilateral
2432 if (face == 0)
2433 return quadrilateral_vertex_permutations[face_orientation][vertex];
2434 else
2435 return triangle_vertex_permutations[face_orientation][vertex];
2436 case ReferenceCells::Wedge:
2437 // faces 0 and 1 are triangles
2438 if (face > 1)
2439 return quadrilateral_vertex_permutations[face_orientation][vertex];
2440 else
2441 return triangle_vertex_permutations[face_orientation][vertex];
2442 case ReferenceCells::Hexahedron:
2443 return quadrilateral_vertex_permutations[face_orientation][vertex];
2444 default:
2445 DEAL_II_NOT_IMPLEMENTED();
2446 }
2447
2448 DEAL_II_NOT_IMPLEMENTED();
2449 return numbers::invalid_unsigned_int;
2450}
2451
2452
2453
2454inline unsigned int
2455ReferenceCell::standard_to_real_face_line(
2456 const unsigned int line,
2457 const unsigned int face,
2458 const unsigned char combined_face_orientation) const
2459{
2460 AssertIndexRange(face, n_faces());
2461 AssertIndexRange(line, face_reference_cell(face).n_lines());
2462
2463 static constexpr ndarray<unsigned int, 6, 3> triangle_table = {{{{2, 1, 0}},
2464 {{0, 1, 2}},
2465 {{1, 0, 2}},
2466 {{2, 0, 1}},
2467 {{0, 2, 1}},
2468 {{1, 2, 0}}}};
2469
2470
2471 switch (this->kind)
2472 {
2473 case ReferenceCells::Vertex:
2474 case ReferenceCells::Line:
2475 case ReferenceCells::Triangle:
2476 case ReferenceCells::Quadrilateral:
2477 DEAL_II_NOT_IMPLEMENTED();
2478 break;
2479 case ReferenceCells::Tetrahedron:
2480 return triangle_table[combined_face_orientation][line];
2481 case ReferenceCells::Pyramid:
2482 if (face == 0) // The quadrilateral face
2483 {
2484 const auto [face_orientation, face_rotation, face_flip] =
2485 internal::split_face_orientation(combined_face_orientation);
2486
2487 return GeometryInfo<3>::standard_to_real_face_line(line,
2488 face_orientation,
2489 face_flip,
2490 face_rotation);
2491 }
2492 else // One of the triangular faces
2493 {
2494 return triangle_table[combined_face_orientation][line];
2495 }
2496 case ReferenceCells::Wedge:
2497 if (face > 1) // One of the quadrilateral faces
2498 {
2499 const auto [face_orientation, face_rotation, face_flip] =
2500 internal::split_face_orientation(combined_face_orientation);
2501
2502 return GeometryInfo<3>::standard_to_real_face_line(line,
2503 face_orientation,
2504 face_flip,
2505 face_rotation);
2506 }
2507 else // One of the triangular faces
2508 return triangle_table[combined_face_orientation][line];
2509 case ReferenceCells::Hexahedron:
2510 {
2511 static constexpr ndarray<unsigned int, 8, 4> table = {
2512 {{{2, 3, 0, 1}},
2513 {{0, 1, 2, 3}},
2514 {{0, 1, 3, 2}},
2515 {{3, 2, 0, 1}},
2516 {{3, 2, 1, 0}},
2517 {{1, 0, 3, 2}},
2518 {{1, 0, 2, 3}},
2519 {{2, 3, 1, 0}}}};
2520 return table[combined_face_orientation][line];
2521 }
2522 default:
2523 DEAL_II_NOT_IMPLEMENTED();
2524 }
2525
2526 return numbers::invalid_unsigned_int;
2527}
2528
2529
2530
2531namespace ReferenceCells
2532{
2533 template <int dim>
2534 inline constexpr const ReferenceCell &
2535 get_simplex()
2536 {
2537 switch (dim)
2538 {
2539 case 0:
2540 return ReferenceCells::Vertex;
2541 case 1:
2542 return ReferenceCells::Line;
2543 case 2:
2544 return ReferenceCells::Triangle;
2545 case 3:
2546 return ReferenceCells::Tetrahedron;
2547 default:
2548 DEAL_II_NOT_IMPLEMENTED();
2549 }
2550 return ReferenceCells::Invalid;
2551 }
2552
2553
2554
2555 template <int dim>
2556 inline constexpr const ReferenceCell &
2557 get_hypercube()
2558 {
2559 switch (dim)
2560 {
2561 case 0:
2562 return ReferenceCells::Vertex;
2563 case 1:
2564 return ReferenceCells::Line;
2565 case 2:
2566 return ReferenceCells::Quadrilateral;
2567 case 3:
2568 return ReferenceCells::Hexahedron;
2569 default:
2570 DEAL_II_NOT_IMPLEMENTED();
2571 }
2572 return ReferenceCells::Invalid;
2573 }
2574} // namespace ReferenceCells
2575
2576
2577inline ReferenceCell
2578ReferenceCell::n_vertices_to_type(const int dim, const unsigned int n_vertices)
2579{
2580 AssertIndexRange(dim, 4);
2581 AssertIndexRange(n_vertices, 9);
2582
2583 const auto X = ReferenceCells::Invalid;
2584 static const ndarray<ReferenceCell, 4, 9> table = {
2585 {// dim 0
2586 {{X, ReferenceCells::Vertex, X, X, X, X, X, X, X}},
2587 // dim 1
2588 {{X, X, ReferenceCells::Line, X, X, X, X, X, X}},
2589 // dim 2
2590 {{X,
2591 X,
2592 X,
2593 ReferenceCells::Triangle,
2594 ReferenceCells::Quadrilateral,
2595 X,
2596 X,
2597 X,
2598 X}},
2599 // dim 3
2600 {{X,
2601 X,
2602 X,
2603 X,
2604 ReferenceCells::Tetrahedron,
2605 ReferenceCells::Pyramid,
2606 ReferenceCells::Wedge,
2607 X,
2608 ReferenceCells::Hexahedron}}}};
2609 Assert(table[dim][n_vertices] != ReferenceCells::Invalid,
2610 ExcMessage("The combination of dim = " + std::to_string(dim) +
2611 " and n_vertices = " + std::to_string(n_vertices) +
2612 " does not correspond to a known reference cell type."));
2613 return table[dim][n_vertices];
2614}
2615
2616
2617
2618template <int dim>
2619inline double
2620ReferenceCell::d_linear_shape_function(const Point<dim> &xi,
2621 const unsigned int i) const
2622{
2623 AssertDimension(dim, get_dimension());
2624 AssertIndexRange(i, n_vertices());
2625 switch (this->kind)
2626 {
2627 case ReferenceCells::Vertex:
2628 case ReferenceCells::Line:
2629 case ReferenceCells::Quadrilateral:
2630 case ReferenceCells::Hexahedron:
2631 return GeometryInfo<dim>::d_linear_shape_function(xi, i);
2632 // see also BarycentricPolynomials<2>::compute_value
2633 case ReferenceCells::Triangle:
2634 {
2635 switch (i)
2636 {
2637 case 0:
2638 return 1.0 - xi[std::min(0, dim - 1)] -
2639 xi[std::min(1, dim - 1)];
2640 case 1:
2641 return xi[std::min(0, dim - 1)];
2642 case 2:
2643 return xi[std::min(1, dim - 1)];
2644 default:
2645 DEAL_II_ASSERT_UNREACHABLE();
2646 }
2647 }
2648 // see also BarycentricPolynomials<3>::compute_value
2649 case ReferenceCells::Tetrahedron:
2650 {
2651 switch (i)
2652 {
2653 case 0:
2654 return 1.0 - xi[std::min(0, dim - 1)] -
2655 xi[std::min(1, dim - 1)] - xi[std::min(2, dim - 1)];
2656 case 1:
2657 return xi[std::min(0, dim - 1)];
2658 case 2:
2659 return xi[std::min(1, dim - 1)];
2660 case 3:
2661 return xi[std::min(2, dim - 1)];
2662 default:
2663 DEAL_II_ASSERT_UNREACHABLE();
2664 }
2665 }
2666 // see also ScalarLagrangePolynomialPyramid::compute_value()
2667 case ReferenceCells::Pyramid:
2668 {
2669 const double Q14 = 0.25;
2670
2671 const double r = xi[std::min(0, dim - 1)];
2672 const double s = xi[std::min(1, dim - 1)];
2673 const double t = xi[std::min(2, dim - 1)];
2674
2675 const double ratio =
2676 (std::fabs(t - 1.0) > 1.0e-14 ? (r * s * t) / (1.0 - t) : 0.0);
2677
2678 if (i == 0)
2679 return Q14 * ((1.0 - r) * (1.0 - s) - t + ratio);
2680 if (i == 1)
2681 return Q14 * ((1.0 + r) * (1.0 - s) - t - ratio);
2682 if (i == 2)
2683 return Q14 * ((1.0 - r) * (1.0 + s) - t - ratio);
2684 if (i == 3)
2685 return Q14 * ((1.0 + r) * (1.0 + s) - t + ratio);
2686 else
2687 return t;
2688 }
2689 // see also ScalarLagrangePolynomialWedge::compute_value()
2690 case ReferenceCells::Wedge:
2691 return ReferenceCell(ReferenceCells::Triangle)
2692 .d_linear_shape_function<2>(Point<2>(xi[std::min(0, dim - 1)],
2693 xi[std::min(1, dim - 1)]),
2694 i % 3) *
2695 ReferenceCell(ReferenceCells::Line)
2696 .d_linear_shape_function<1>(Point<1>(xi[std::min(2, dim - 1)]),
2697 i / 3);
2698 default:
2699 DEAL_II_NOT_IMPLEMENTED();
2700 }
2701
2702 return 0.0;
2703}
2704
2705
2706
2707template <int dim>
2708inline Tensor<1, dim>
2709ReferenceCell::d_linear_shape_function_gradient(const Point<dim> &xi,
2710 const unsigned int i) const
2711{
2712 AssertDimension(dim, get_dimension());
2713 switch (this->kind)
2714 {
2715 case ReferenceCells::Vertex:
2716 case ReferenceCells::Line:
2717 case ReferenceCells::Quadrilateral:
2718 case ReferenceCells::Hexahedron:
2719 return GeometryInfo<dim>::d_linear_shape_function_gradient(xi, i);
2720 // see also BarycentricPolynomials<2>::compute_grad()
2721 case ReferenceCells::Triangle:
2722 switch (i)
2723 {
2724 case 0:
2725 return Point<dim>(-1.0, -1.0);
2726 case 1:
2727 return Point<dim>(+1.0, +0.0);
2728 case 2:
2729 return Point<dim>(+0.0, +1.0);
2730 default:
2731 DEAL_II_ASSERT_UNREACHABLE();
2732 }
2733 default:
2734 DEAL_II_NOT_IMPLEMENTED();
2735 }
2736
2737 return Point<dim>(+0.0, +0.0, +0.0);
2738}
2739
2740
2741
2742inline double
2743ReferenceCell::volume() const
2744{
2745 switch (this->kind)
2746 {
2747 case ReferenceCells::Vertex:
2748 return 0;
2749 case ReferenceCells::Line:
2750 return 1;
2751 case ReferenceCells::Triangle:
2752 return 1. / 2.;
2753 case ReferenceCells::Quadrilateral:
2754 return 1;
2755 case ReferenceCells::Tetrahedron:
2756 return 1. / 6.;
2757 case ReferenceCells::Pyramid:
2758 return 4. / 3.;
2759 case ReferenceCells::Wedge:
2760 return 1. / 2.;
2761 case ReferenceCells::Hexahedron:
2762 return 1;
2763 default:
2764 DEAL_II_NOT_IMPLEMENTED();
2765 }
2766
2767 return 0.0;
2768}
2769
2770
2771
2772template <int dim>
2773inline Point<dim>
2774ReferenceCell::barycenter() const
2775{
2776 AssertDimension(dim, get_dimension());
2777
2778 switch (this->kind)
2779 {
2780 case ReferenceCells::Vertex:
2781 return Point<dim>();
2782 case ReferenceCells::Line:
2783 return Point<dim>(1. / 2.);
2784 case ReferenceCells::Triangle:
2785 return Point<dim>(1. / 3., 1. / 3.);
2786 case ReferenceCells::Quadrilateral:
2787 return Point<dim>(1. / 2., 1. / 2.);
2788 case ReferenceCells::Tetrahedron:
2789 return Point<dim>(1. / 4., 1. / 4., 1. / 4.);
2790 case ReferenceCells::Pyramid:
2791 return Point<dim>(0, 0, 1. / 4.);
2792 case ReferenceCells::Wedge:
2793 return Point<dim>(1. / 3, 1. / 3, 1. / 2.);
2794 case ReferenceCells::Hexahedron:
2795 return Point<dim>(1. / 2., 1. / 2., 1. / 2.);
2796 default:
2797 DEAL_II_NOT_IMPLEMENTED();
2798 }
2799
2800 return Point<dim>();
2801}
2802
2803
2804
2805template <int dim>
2806inline bool
2807ReferenceCell::contains_point(const Point<dim> &p, const double tolerance) const
2808{
2809 AssertDimension(dim, get_dimension());
2810
2811 // Introduce abbreviations to silence compiler warnings about invalid
2812 // array accesses (that can't happen, of course, but the compiler
2813 // doesn't know that).
2814 constexpr unsigned int x_coordinate = 0;
2815 constexpr unsigned int y_coordinate = (dim >= 2 ? 1 : 0);
2816 constexpr unsigned int z_coordinate = (dim >= 3 ? 2 : 0);
2817
2818 switch (this->kind)
2819 {
2820 case ReferenceCells::Vertex:
2821 {
2822 // Vertices are special cases in that they do not actually
2823 // have coordinates. Error out if this function is called
2824 // with a vertex:
2825 Assert(false,
2826 ExcMessage("Vertices are zero-dimensional objects and "
2827 "as a consequence have no coordinates. You "
2828 "cannot meaningfully ask whether a point is "
2829 "inside a vertex (within a certain tolerance) "
2830 "without coordinate values."));
2831 return false;
2832 }
2833 case ReferenceCells::Line:
2834 case ReferenceCells::Quadrilateral:
2835 case ReferenceCells::Hexahedron:
2836 {
2837 for (unsigned int d = 0; d < dim; ++d)
2838 if ((p[d] < -tolerance) || (p[d] > 1 + tolerance))
2839 return false;
2840 return true;
2841 }
2842 case ReferenceCells::Triangle:
2843 case ReferenceCells::Tetrahedron:
2844 {
2845 // First make sure that we are in the first quadrant or octant
2846 for (unsigned int d = 0; d < dim; ++d)
2847 if (p[d] < -tolerance)
2848 return false;
2849
2850 // Now we also need to make sure that we are below the diagonal line
2851 // or plane that delineates the simplex. This diagonal is given by
2852 // sum(p[d])<=1, and a diagonal a distance eps away is given by
2853 // sum(p[d])<=1+eps*sqrt(d). (For example, the point at (1,1) is a
2854 // distance of 1/sqrt(2) away from the diagonal. That is, its
2855 // sum satisfies
2856 // sum(p[d]) = 2 <= 1 + (1/sqrt(2)) * sqrt(2)
2857 // in other words, it satisfies the predicate with eps=1/sqrt(2).)
2858 double sum = 0;
2859 for (unsigned int d = 0; d < dim; ++d)
2860 sum += p[d];
2861 return (sum <= 1 + tolerance * std::sqrt(1. * dim));
2862 }
2863 case ReferenceCells::Pyramid:
2864 {
2865 // A pyramid only lives in the upper half-space:
2866 if (p[z_coordinate] < -tolerance)
2867 return false;
2868
2869 // It also only lives in the space below z=1:
2870 if (p[z_coordinate] > 1 + tolerance)
2871 return false;
2872
2873 // Within what's left of the space, a pyramid is a cone that tapers
2874 // towards the top. First compute the distance of the point to the
2875 // axis in the max norm (this is the right norm because the vertices
2876 // of the pyramid are at points +/-1, +/-1):
2877 const double distance_from_axis =
2878 std::max(std::fabs(p[x_coordinate]), std::fabs(p[y_coordinate]));
2879
2880 // We are inside the pyramid if the distance from the axis is less
2881 // than (1-z)
2882 return (distance_from_axis <= 1 + tolerance - p[z_coordinate]);
2883 }
2884 case ReferenceCells::Wedge:
2885 {
2886 // The wedge we use is a triangle extruded into the third
2887 // dimension by one unit. So we can use the same logic as for
2888 // triangles above (i.e., for the simplex above, using dim==2)
2889 // and then check the third dimension separately.
2890
2891 if ((p[x_coordinate] < -tolerance) || (p[y_coordinate] < -tolerance))
2892 return false;
2893
2894 const double sum = p[x_coordinate] + p[y_coordinate];
2895 if (sum > 1 + tolerance * std::sqrt(2.0))
2896 return false;
2897
2898 if (p[z_coordinate] < -tolerance)
2899 return false;
2900 if (p[z_coordinate] > 1 + tolerance)
2901 return false;
2902
2903 return true;
2904 }
2905 default:
2906 DEAL_II_NOT_IMPLEMENTED();
2907 }
2908
2909 return false;
2910}
2911
2912
2913
2914template <int dim>
2915inline Tensor<1, dim>
2916ReferenceCell::unit_tangential_vectors(const unsigned int face_no,
2917 const unsigned int i) const
2918{
2919 AssertDimension(dim, get_dimension());
2920 AssertIndexRange(i, dim - 1);
2921
2922 switch (this->kind)
2923 {
2924 case ReferenceCells::Vertex:
2925 case ReferenceCells::Line:
2926 case ReferenceCells::Quadrilateral:
2927 case ReferenceCells::Hexahedron:
2928 AssertIndexRange(face_no, GeometryInfo<dim>::faces_per_cell);
2929 return GeometryInfo<dim>::unit_tangential_vectors[face_no][i];
2930 case ReferenceCells::Triangle:
2931 {
2932 AssertIndexRange(face_no, 3);
2933 static const std::array<Tensor<1, dim>, 3> table = {
2934 {Point<dim>(1, 0),
2935 Point<dim>(-std::sqrt(0.5), +std::sqrt(0.5)),
2936 Point<dim>(0, -1)}};
2937
2938 return table[face_no];
2939 }
2940 case ReferenceCells::Tetrahedron:
2941 {
2942 AssertIndexRange(face_no, 4);
2943 static const ndarray<Tensor<1, dim>, 4, 2> table = {
2944 {{{Point<dim>(0, 1, 0), Point<dim>(1, 0, 0)}},
2945 {{Point<dim>(1, 0, 0), Point<dim>(0, 0, 1)}},
2946 {{Point<dim>(0, 0, 1), Point<dim>(0, 1, 0)}},
2947 {{Point<dim>(-std::pow(1.0 / 3.0, 1.0 / 4.0),
2948 +std::pow(1.0 / 3.0, 1.0 / 4.0),
2949 0),
2950 Point<dim>(-std::pow(1.0 / 3.0, 1.0 / 4.0),
2951 0,
2952 +std::pow(1.0 / 3.0, 1.0 / 4.0))}}}};
2953
2954 return table[face_no][i];
2955 }
2956 case ReferenceCells::Pyramid:
2957 {
2958 AssertIndexRange(face_no, 5);
2959 static const ndarray<Tensor<1, dim>, 5, 2> table = {
2960 {{{Point<dim>(0, 1, 0), Point<dim>(1, 0, 0)}},
2961 {{Point<dim>(+1.0 / sqrt(2.0), 0, +1.0 / sqrt(2.0)),
2962 Point<dim>(0, 1, 0)}},
2963 {{Point<dim>(+1.0 / sqrt(2.0), 0, -1.0 / sqrt(2.0)),
2964 Point<dim>(0, 1, 0)}},
2965 {{Point<dim>(1, 0, 0),
2966 Point<dim>(0, +1.0 / sqrt(2.0), +1.0 / sqrt(2.0))}},
2967 {{Point<dim>(1, 0, 0),
2968 Point<dim>(0, +1.0 / sqrt(2.0), -1.0 / sqrt(2.0))}}}};
2969
2970 return table[face_no][i];
2971 }
2972 case ReferenceCells::Wedge:
2973 {
2974 AssertIndexRange(face_no, 5);
2975 static const ndarray<Tensor<1, dim>, 5, 2> table = {
2976 {{{Point<dim>(0, 1, 0), Point<dim>(1, 0, 0)}},
2977 {{Point<dim>(1, 0, 0), Point<dim>(0, 1, 0)}},
2978 {{Point<dim>(1, 0, 0), Point<dim>(0, 0, 1)}},
2979 {{Point<dim>(-1 / std::sqrt(2.0), +1 / std::sqrt(2.0), 0),
2980 Point<dim>(0, 0, 1)}},
2981 {{Point<dim>(0, 0, 1), Point<dim>(0, 1, 0)}}}};
2982
2983 return table[face_no][i];
2984 }
2985 default:
2986 DEAL_II_NOT_IMPLEMENTED();
2987 }
2988
2989
2990 return {};
2991}
2992
2993
2994
2995template <int dim>
2996inline Tensor<1, dim>
2997ReferenceCell::unit_normal_vectors(const unsigned int face_no) const
2998{
2999 AssertDimension(dim, this->get_dimension());
3000
3001 if (is_hyper_cube())
3002 {
3003 AssertIndexRange(face_no, GeometryInfo<dim>::faces_per_cell);
3004 return GeometryInfo<dim>::unit_normal_vector[face_no];
3005 }
3006 else if (dim == 2)
3007 {
3008 Assert(*this == ReferenceCells::Triangle, ExcInternalError());
3009
3010 // Return the rotated vector
3011 return cross_product_2d(unit_tangential_vectors<dim>(face_no, 0));
3012 }
3013 else if (dim == 3)
3014 {
3015 return cross_product_3d(unit_tangential_vectors<dim>(face_no, 0),
3016 unit_tangential_vectors<dim>(face_no, 1));
3017 }
3018
3019 DEAL_II_NOT_IMPLEMENTED();
3020
3021 return {};
3022}
3023
3024
3025
3026inline unsigned int
3027ReferenceCell::n_face_orientations(const unsigned int face_no) const
3028{
3029 AssertIndexRange(face_no, n_faces());
3030 if (get_dimension() == 1)
3031 return 1;
3032 if (get_dimension() == 2)
3033 return 2;
3034 else if (face_reference_cell(face_no) == ReferenceCells::Quadrilateral)
3035 return 8;
3036 else if (face_reference_cell(face_no) == ReferenceCells::Triangle)
3037 return 6;
3038
3039 DEAL_II_ASSERT_UNREACHABLE();
3040 return numbers::invalid_unsigned_int;
3041}
3042
3043
3044
3045inline bool
3046ReferenceCell::standard_vs_true_line_orientation(
3047 const unsigned int line,
3048 const unsigned int face,
3049 const unsigned char combined_face_orientation,
3050 const bool line_orientation) const
3051{
3052 if (*this == ReferenceCells::Hexahedron)
3053 {
3054 static constexpr ::ndarray<bool, 2, 8> bool_table{
3055 {{{true, true, false, true, false, false, true, false}},
3056 {{true, true, true, false, false, false, false, true}}}};
3057
3058 return (line_orientation ==
3059 bool_table[line / 2][combined_face_orientation]);
3060 }
3061 else if (*this == ReferenceCells::Tetrahedron)
3062 {
3063 static constexpr unsigned int X = numbers::invalid_unsigned_int;
3064 static constexpr ::ndarray<unsigned int, 4, 3> combined_lines{
3065 {{{0, 0, 0}}, {{X, 0, 1}}, {{X, 0, X}}, {{X, X, X}}}};
3066
3067 const auto combined_line = combined_lines[face][line];
3068
3069 Assert(combined_line != X,
3070 ExcMessage(
3071 "This function can only be called for following face-line "
3072 "combinations: (0,0), (0,1), (0,2), (1,1), (1,2), (2,1),"));
3073
3074 static constexpr ::ndarray<bool, 2, 6> bool_table{
3075 {{{false, true, false, true, false, true}},
3076 {{true, false, true, false, true, false}}}};
3077
3078 return (line_orientation ==
3079 bool_table[combined_line][combined_face_orientation]);
3080 }
3081 else
3082 // TODO: This might actually be wrong for some of the other
3083 // kinds of objects. We should check this
3084 return true;
3085}
3086
3087
3088
3089namespace internal
3090{
3091 template <typename T>
3092 class NoPermutation : public ::ExceptionBase
3093 {
3094 public:
3108
3112 virtual ~NoPermutation() noexcept override = default;
3113
3117 virtual void
3118 print_info(std::ostream &out) const override
3119 {
3120 out << '[';
3121
3122 const unsigned int n_vertices = entity_type.n_vertices();
3123
3124 for (unsigned int i = 0; i < n_vertices; ++i)
3125 {
3126 out << vertices_0[i];
3127 if (i + 1 != n_vertices)
3128 out << ',';
3129 }
3130
3131 out << "] is not a valid permutation of [";
3132
3133 for (unsigned int i = 0; i < n_vertices; ++i)
3134 {
3135 out << vertices_1[i];
3136 if (i + 1 != n_vertices)
3137 out << ',';
3138 }
3139
3140 out << "]." << std::endl;
3141 }
3142
3146 const ReferenceCell entity_type;
3147
3151 const ArrayView<const T> vertices_0;
3152
3156 const ArrayView<const T> vertices_1;
3157 };
3158
3166 DeclException2(
3167 ExcNonMatchingReferenceCellTypes,
3168 ReferenceCell,
3169 ReferenceCell,
3170 << "The reference-cell type used on this cell (" << arg1.to_string()
3171 << ") does not match the reference-cell type of the finite element "
3172 << "associated with this cell (" << arg2.to_string() << "). "
3173 << "Did you accidentally use simplex elements on hypercube meshes "
3174 << "(or the other way around), or are you using a mixed mesh and "
3175 << "assigned a simplex element to a hypercube cell (or the other "
3176 << "way around) via the active_fe_index?");
3177} // namespace internal
3178
3179
3180
3181template <typename T, std::size_t N>
3182inline unsigned char
3183ReferenceCell::compute_orientation(const std::array<T, N> &vertices_0,
3184 const std::array<T, N> &vertices_1) const
3185{
3186 Assert(N >= n_vertices(),
3187 ExcMessage("The number of array elements must be equal to or "
3188 "greater than the number of vertices of the cell "
3189 "referenced by this object."));
3190
3191 // Call the non-deprecated function, taking care of calling it only with
3192 // those array elements that we actually care about (see the note
3193 // in the documentation about the arguments potentially being
3194 // larger arrays than necessary).
3195 return get_combined_orientation(
3196 make_array_view(vertices_0.begin(), vertices_0.begin() + n_vertices()),
3197 make_array_view(vertices_1.begin(), vertices_1.begin() + n_vertices()));
3198}
3199
3200
3201
3202template <typename T>
3203unsigned char
3204ReferenceCell::get_combined_orientation(
3205 const ArrayView<const T> &vertices_0,
3206 const ArrayView<const T> &vertices_1) const
3207{
3208 Assert(vertices_0.size() == n_vertices(),
3209 ExcMessage("The number of array elements must be equal to "
3210 "the number of vertices of the cell "
3211 "referenced by this object."));
3212 Assert(vertices_1.size() == n_vertices(),
3213 ExcMessage("The number of array elements must be equal to "
3214 "the number of vertices of the cell "
3215 "referenced by this object."));
3216
3217 auto compute_orientation = [&](const auto &table) {
3218 for (unsigned char o = 0; o < table.size(); ++o)
3219 {
3220 bool match = true;
3221 for (unsigned int j = 0; j < table[o].size(); ++j)
3222 match = (match && vertices_0[j] == vertices_1[table[o][j]]);
3223
3224 if (match)
3225 return o;
3226 }
3227
3228 Assert(false, (internal::NoPermutation<T>(*this, vertices_0, vertices_1)));
3229 return std::numeric_limits<unsigned char>::max();
3230 };
3231
3232 switch (this->kind)
3233 {
3234 case ReferenceCells::Vertex:
3235 // TODO: we can get rid of this special-case and use
3236 // vertex_vertex_permutations once we make 0 the default orientation.
3237 (void)vertex_vertex_permutations;
3238 if (vertices_0[0] == vertices_1[0])
3239 return default_combined_face_orientation();
3240 break;
3241 case ReferenceCells::Line:
3242 return compute_orientation(line_vertex_permutations);
3243 case ReferenceCells::Triangle:
3244 return compute_orientation(triangle_vertex_permutations);
3245 case ReferenceCells::Quadrilateral:
3246 return compute_orientation(quadrilateral_vertex_permutations);
3247 default:
3248 DEAL_II_NOT_IMPLEMENTED();
3249 }
3250
3251 Assert(false, (internal::NoPermutation<T>(*this, vertices_0, vertices_1)));
3252 return std::numeric_limits<unsigned char>::max();
3253}
3254
3255
3256
3257template <typename T, std::size_t N>
3258inline std::array<T, N>
3259ReferenceCell::permute_according_orientation(
3260 const std::array<T, N> &vertices,
3261 const unsigned int orientation) const
3262{
3263 Assert(N >= n_vertices(),
3264 ExcMessage("The number of array elements must be equal to or "
3265 "greater than the number of vertices of the cell "
3266 "referenced by this object."));
3267
3268 // Call the non-deprecated function, taking care of calling it only with
3269 // those array elements that we actually care about (see the note
3270 // in the documentation about the arguments potentially being
3271 // larger arrays than necessary).
3272 const auto permutation = permute_by_combined_orientation(
3273 make_array_view(vertices.begin(), vertices.begin() + n_vertices()),
3274 orientation);
3275
3276 std::array<T, N> temp;
3277 std::copy(permutation.begin(), permutation.end(), temp.begin());
3278
3279 return temp;
3280}
3281
3282
3283
3284template <typename T>
3285boost::container::small_vector<T, 8>
3286ReferenceCell::permute_by_combined_orientation(
3287 const ArrayView<const T> &vertices,
3288 const unsigned char orientation) const
3289{
3290 AssertDimension(vertices.size(), n_vertices());
3291 boost::container::small_vector<T, 8> result(n_vertices());
3292
3293 auto permute = [&](const auto &table) {
3294 AssertIndexRange(orientation, table.size());
3295 for (unsigned int j = 0; j < table[orientation].size(); ++j)
3296 result[j] = vertices[table[orientation][j]];
3297 };
3298
3299 switch (this->kind)
3300 {
3301 case ReferenceCells::Vertex:
3302 // TODO: we can get rid of this special-case and use
3303 // vertex_vertex_permutations once we make 0 the default orientation.
3304 std::copy(vertices.begin(), vertices.end(), result.begin());
3305 break;
3306 case ReferenceCells::Line:
3307 permute(line_vertex_permutations);
3308 break;
3309 case ReferenceCells::Triangle:
3310 permute(triangle_vertex_permutations);
3311 break;
3312 case ReferenceCells::Quadrilateral:
3313 permute(quadrilateral_vertex_permutations);
3314 break;
3315 default:
3316 DEAL_II_NOT_IMPLEMENTED();
3317 }
3318
3319 return result;
3320}
3321
3322
3323
3324inline unsigned char
3325ReferenceCell::get_inverse_combined_orientation(
3326 const unsigned char orientation) const
3327{
3328 switch (this->kind)
3329 {
3330 case ReferenceCells::Vertex:
3331 // Things are always default-oriented in 1D
3332 return orientation;
3333
3334 case ReferenceCells::Line:
3335 // the 1d orientations are the identity and a flip: i.e., the identity
3336 // and an involutory mapping
3337 return orientation;
3338
3339 case ReferenceCells::Triangle:
3340 {
3341 AssertIndexRange(orientation, 6);
3342 constexpr std::array<unsigned char, 6> inverses{{0, 1, 2, 5, 4, 3}};
3343 return inverses[orientation];
3344 }
3345 case ReferenceCells::Quadrilateral:
3346 {
3347 AssertIndexRange(orientation, 8);
3348 constexpr std::array<unsigned char, 8> inverses{
3349 {0, 1, 2, 7, 4, 5, 6, 3}};
3350 return inverses[orientation];
3351 }
3352 default:
3353 DEAL_II_NOT_IMPLEMENTED();
3354 }
3355
3356 return std::numeric_limits<unsigned char>::max();
3357}
3358
3359
3360
3361template <>
3362unsigned int
3363ReferenceCell::vtk_lexicographic_to_node_index<0>(
3364 const std::array<unsigned, 0> &node_indices,
3365 const std::array<unsigned, 0> &nodes_per_direction,
3366 const bool legacy_format) const;
3367
3368template <>
3369unsigned int
3370ReferenceCell::vtk_lexicographic_to_node_index<1>(
3371 const std::array<unsigned, 1> &node_indices,
3372 const std::array<unsigned, 1> &nodes_per_direction,
3373 const bool legacy_format) const;
3374
3375template <>
3376unsigned int
3377ReferenceCell::vtk_lexicographic_to_node_index<2>(
3378 const std::array<unsigned, 2> &node_indices,
3379 const std::array<unsigned, 2> &nodes_per_direction,
3380 const bool legacy_format) const;
3381
3382template <>
3383unsigned int
3384ReferenceCell::vtk_lexicographic_to_node_index<3>(
3385 const std::array<unsigned, 3> &node_indices,
3386 const std::array<unsigned, 3> &nodes_per_direction,
3387 const bool legacy_format) const;
3388
3389DEAL_II_NAMESPACE_CLOSE
3390
3391#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:949
ArrayView::begin
iterator begin() const
Definition array_view.h:702
ArrayView::end
iterator end() const
Definition array_view.h:711
ArrayView::size
std::size_t size() const
Definition array_view.h:684
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::faces_for_given_vertex
ArrayView< const unsigned int > faces_for_given_vertex(const unsigned int vertex_index) const
Definition reference_cell.h:1147
ReferenceCell::child_cell_on_face
unsigned int child_cell_on_face(const unsigned int face, const unsigned int subface, const unsigned char face_orientation=default_combined_face_orientation()) const
Definition reference_cell.h:1936
ReferenceCell::vertex_indices
std_cxx20::ranges::iota_view< unsigned int, unsigned int > vertex_indices() const
Definition reference_cell.h:1862
ReferenceCell::n_vertices
unsigned int n_vertices() const
Definition reference_cell.h:1535
ReferenceCell::permute_by_combined_orientation
boost::container::small_vector< T, 8 > permute_by_combined_orientation(const ArrayView< const T > &vertices, const unsigned char orientation) const
Definition reference_cell.h:3286
ReferenceCell::get_gauss_type_quadrature
Quadrature< dim > get_gauss_type_quadrature(const unsigned n_points_1d) const
Definition reference_cell.cc:186
ReferenceCell::is_hyper_cube
bool is_hyper_cube() const
Definition reference_cell.h:1479
ReferenceCell::vtk_linear_type
unsigned int vtk_linear_type() const
Definition reference_cell.cc:379
ReferenceCell::serialize
void serialize(Archive &archive, const unsigned int)
Definition reference_cell.h:1131
ReferenceCell::get_inverse_combined_orientation
unsigned char get_inverse_combined_orientation(const unsigned char orientation) const
Definition reference_cell.h:3325
ReferenceCell::n_isotropic_refinement_choices
unsigned int n_isotropic_refinement_choices() const
Definition reference_cell.h:1753
ReferenceCell::face_to_cell_vertices
unsigned int face_to_cell_vertices(const unsigned int face, const unsigned int vertex, const unsigned char face_orientation) const
Definition reference_cell.h:2295
ReferenceCell::default_combined_face_orientation
static constexpr unsigned char default_combined_face_orientation()
Definition reference_cell.h:1915
ReferenceCell::compute_orientation
unsigned char compute_orientation(const std::array< T, N > &vertices_0, const std::array< T, N > &vertices_1) const
Definition reference_cell.h:3183
ReferenceCell::standard_vs_true_line_orientation
bool standard_vs_true_line_orientation(const unsigned int line, const unsigned int face, const unsigned char face_orientation, const bool line_orientation) const
Definition reference_cell.h:3046
ReferenceCell::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:2002
ReferenceCell::vertex
Point< dim > vertex(const unsigned int v) const
Definition reference_cell.h:1596
ReferenceCell::standard_to_real_face_vertex
unsigned int standard_to_real_face_vertex(const unsigned int vertex, const unsigned int face, const unsigned char face_orientation) const
Definition reference_cell.h:2407
ReferenceCell::get_nodal_type_quadrature
const Quadrature< dim > & get_nodal_type_quadrature() const
Definition reference_cell.cc:208
ReferenceCell::face_vertex_location
Point< dim > face_vertex_location(const unsigned int face, const unsigned int vertex) const
Definition reference_cell.h:2397
ReferenceCell::new_isotropic_child_face_lines
constexpr ::ndarray< unsigned int, 12, 4 > new_isotropic_child_face_lines(const unsigned int refinement_choice) const
Definition reference_cell.h:1204
ReferenceCell::vertex_vertex_permutations
static constexpr ndarray< unsigned int, 1, 1 > vertex_vertex_permutations
Definition reference_cell.h:955
ReferenceCell::isotropic_child_indices
std_cxx20::ranges::iota_view< unsigned int, unsigned int > isotropic_child_indices() const
Definition reference_cell.h:1854
ReferenceCell::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:2064
ReferenceCell::new_isotropic_child_face_line_vertices
constexpr ::ndarray< unsigned int, 12, 4, 2 > new_isotropic_child_face_line_vertices(const unsigned int refinement_choice) const
Definition reference_cell.h:1283
ReferenceCell::d_linear_shape_function
double d_linear_shape_function(const Point< dim > &xi, const unsigned int i) const
Definition reference_cell.h:2620
ReferenceCell::unit_tangential_vectors
Tensor< 1, dim > unit_tangential_vectors(const unsigned int face_no, const unsigned int i) const
Definition reference_cell.h:2916
ReferenceCell::line_vertex_permutations
static constexpr ndarray< unsigned int, 2, 2 > line_vertex_permutations
Definition reference_cell.h:961
ReferenceCell::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
ReferenceCell::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:3259
ReferenceCell::new_isotropic_child_cell_vertices
constexpr ::ndarray< unsigned int, 8, 4 > new_isotropic_child_cell_vertices(const unsigned int refinement_choice) const
Definition reference_cell.h:1430
ReferenceCell::contains_point
bool contains_point(const Point< dim > &p, const double tolerance=0) const
Definition reference_cell.h:2807
ReferenceCell::new_isotropic_child_cell_faces
constexpr ::ndarray< unsigned int, 8, 6 > new_isotropic_child_cell_faces(const unsigned int refinement_choice) const
Definition reference_cell.h:1362
ReferenceCell::n_isotropic_children
unsigned int n_isotropic_children() const
Definition reference_cell.h:1809
ReferenceCell::gmsh_element_type
unsigned int gmsh_element_type() const
Definition reference_cell.cc:727
ReferenceCell::n_face_orientations
unsigned int n_face_orientations(const unsigned int face_no) const
Definition reference_cell.h:3027
ReferenceCell::quadrilateral_vertex_permutations
static constexpr ndarray< unsigned int, 8, 4 > quadrilateral_vertex_permutations
Definition reference_cell.h:979
ReferenceCell::volume
double volume() const
Definition reference_cell.h:2743
ReferenceCell::n_faces
unsigned int n_faces() const
Definition reference_cell.h:1715
ReferenceCell::line_to_cell_vertices
unsigned int line_to_cell_vertices(const unsigned int line, const unsigned int vertex) const
Definition reference_cell.h:2126
ReferenceCell::kind
std::uint8_t kind
Definition reference_cell.h:940
ReferenceCell::ReferenceCell
constexpr ReferenceCell()
Definition reference_cell.h:1123
ReferenceCell::exodusii_vertex_to_deal_vertex
unsigned int exodusii_vertex_to_deal_vertex(const unsigned int vertex_n) const
Definition reference_cell.cc:253
ReferenceCell::unv_vertex_to_deal_vertex
unsigned int unv_vertex_to_deal_vertex(const unsigned int vertex_n) const
Definition reference_cell.cc:343
ReferenceCell::vtk_vertex_to_deal_vertex
unsigned int vtk_vertex_to_deal_vertex(const unsigned int vertex_index) const
Definition reference_cell.cc:672
ReferenceCell::get_isotropic_refinement_choice
IsotropicRefinementChoice get_isotropic_refinement_choice(const unsigned int ref_choice) const
Definition reference_cell.h:1783
ReferenceCell::get_default_mapping
std::unique_ptr< Mapping< dim, spacedim > > get_default_mapping(const unsigned int degree) const
Definition reference_cell.cc:121
ReferenceCell::get_midpoint_quadrature
Quadrature< dim > get_midpoint_quadrature() const
Definition reference_cell.h:1526
ReferenceCell::vtk_quadratic_type
unsigned int vtk_quadratic_type() const
Definition reference_cell.cc:411
ReferenceCell::reversed_combined_line_orientation
static constexpr unsigned char reversed_combined_line_orientation()
Definition reference_cell.h:1926
ReferenceCell::n_lines
unsigned int n_lines() const
Definition reference_cell.h:1565
ReferenceCell::vtk_lagrange_type
unsigned int vtk_lagrange_type() const
Definition reference_cell.cc:443
ReferenceCell::line_indices
std_cxx20::ranges::iota_view< unsigned int, unsigned int > line_indices() const
Definition reference_cell.h:1870
ReferenceCell::get_dimension
unsigned int get_dimension() const
Definition reference_cell.h:1499
ReferenceCell::n_children
unsigned int n_children(const RefinementCase< dim > ref_case=RefinementCase< dim >::isotropic_refinement) const
Definition reference_cell.h:1842
ReferenceCell::face_reference_cell
ReferenceCell face_reference_cell(const unsigned int face_no) const
Definition reference_cell.h:1878
ReferenceCell::exodusii_face_to_deal_face
unsigned int exodusii_face_to_deal_face(const unsigned int face_n) const
Definition reference_cell.cc:296
ReferenceCell::n_vertices_to_type
static ReferenceCell n_vertices_to_type(const int dim, const unsigned int n_vertices)
Definition reference_cell.h:2578
ReferenceCell::standard_to_real_face_line
unsigned int standard_to_real_face_line(const unsigned int line, const unsigned int face, const unsigned char face_orientation) const
Definition reference_cell.h:2455
ReferenceCell::memory_consumption
static constexpr std::size_t memory_consumption()
Definition reference_cell.h:1139
ReferenceCell::operator>>
friend std::istream & operator>>(std::istream &in, ReferenceCell &reference_cell)
Definition reference_cell.cc:1145
ReferenceCell::get_default_linear_mapping
const Mapping< dim, spacedim > & get_default_linear_mapping() const
Definition reference_cell.cc:148
ReferenceCell::to_string
std::string to_string() const
Definition reference_cell.cc:88
ReferenceCell::is_simplex
bool is_simplex() const
Definition reference_cell.h:1489
ReferenceCell::face_to_cell_lines
unsigned int face_to_cell_lines(const unsigned int face, const unsigned int line, const unsigned char face_orientation) const
Definition reference_cell.h:2208
ReferenceCell::operator!=
constexpr bool operator!=(const ReferenceCell &type) const
Definition reference_cell.h:1046
ReferenceCell::get_combined_orientation
unsigned char get_combined_orientation(const ArrayView< const T > &vertices_0, const ArrayView< const T > &vertices_1) const
Definition reference_cell.h:3204
ReferenceCell::operator==
constexpr bool operator==(const ReferenceCell &type) const
Definition reference_cell.h:1038
ReferenceCell::barycenter
Point< dim > barycenter() const
Definition reference_cell.h:2774
ReferenceCell::unit_normal_vectors
Tensor< 1, dim > unit_normal_vectors(const unsigned int face_no) const
Definition reference_cell.h:2997
ReferenceCell::face_indices
std_cxx20::ranges::iota_view< unsigned int, unsigned int > face_indices() const
Definition reference_cell.h:1745
ReferenceCell::operator<<
friend std::ostream & operator<<(std::ostream &out, const ReferenceCell &reference_cell)
Definition reference_cell.cc:1132
ReferenceCell::closest_point
Point< dim > closest_point(const Point< dim > &p) const
Definition reference_cell.cc:950
ReferenceCell::triangle_vertex_permutations
static constexpr ndarray< unsigned int, 6, 3 > triangle_vertex_permutations
Definition reference_cell.h:967
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:2709
internal::NoPermutation::print_info
virtual void print_info(std::ostream &out) const override
Definition reference_cell.h:3118
internal::NoPermutation::entity_type
const ReferenceCell entity_type
Definition reference_cell.h:3146
internal::NoPermutation::~NoPermutation
virtual ~NoPermutation() noexcept override=default
internal::NoPermutation::vertices_0
const ArrayView< const T > vertices_0
Definition reference_cell.h:3151
internal::NoPermutation::vertices_1
const ArrayView< const T > vertices_1
Definition reference_cell.h:3156
internal::NoPermutation::NoPermutation
NoPermutation(const ReferenceCell &entity_type, const ArrayView< const T > &vertices_0, const ArrayView< const T > &vertices_1)
Definition reference_cell.h:3098
DEAL_II_DEPRECATED
#define DEAL_II_DEPRECATED
Definition config.h:205
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:498
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:499
geometry_info.h
internal::ExcNonMatchingReferenceCellTypes
static ::ExceptionBase & ExcNonMatchingReferenceCellTypes(ReferenceCell arg1, ReferenceCell arg2)
Assert
#define Assert(cond, exc)
Definition exceptions.h:1659
DeclException2
#define DeclException2(Exception2, type1, type2, outsequence)
Definition exceptions.h:534
AssertDimension
#define AssertDimension(dim1, dim2)
Definition exceptions.h:2026
AssertIndexRange
#define AssertIndexRange(index, range)
Definition exceptions.h:2115
StandardExceptions::ExcInternalError
static ::ExceptionBase & ExcInternalError()
StandardExceptions::ExcMessage
static ::ExceptionBase & ExcMessage(std::string arg1)
DEAL_II_ASSERT_UNREACHABLE
#define DEAL_II_ASSERT_UNREACHABLE()
Definition exceptions.h:1938
DEAL_II_NOT_IMPLEMENTED
#define DEAL_II_NOT_IMPLEMENTED()
Definition exceptions.h:1855
ReferenceCells::Tetrahedron
constexpr const ReferenceCell Tetrahedron
Definition reference_cell.h:1090
ReferenceCells::Quadrilateral
constexpr const ReferenceCell Quadrilateral
Definition reference_cell.h:1088
ReferenceCells::Wedge
constexpr const ReferenceCell Wedge
Definition reference_cell.h:1094
ReferenceCells::Pyramid
constexpr const ReferenceCell Pyramid
Definition reference_cell.h:1092
ReferenceCells::Invalid
constexpr const ReferenceCell Invalid
Definition reference_cell.h:1098
ReferenceCells::Triangle
constexpr const ReferenceCell Triangle
Definition reference_cell.h:1086
ReferenceCells::Hexahedron
constexpr const ReferenceCell Hexahedron
Definition reference_cell.h:1096
ReferenceCells::get_hypercube
constexpr const ReferenceCell & get_hypercube()
Definition reference_cell.h:2557
ReferenceCells::Vertex
constexpr const ReferenceCell Vertex
Definition reference_cell.h:1082
ReferenceCells::Line
constexpr const ReferenceCell Line
Definition reference_cell.h:1084
ReferenceCells::get_simplex
constexpr const ReferenceCell & get_simplex()
Definition reference_cell.h:2535
internal::make_reference_cell_from_int
constexpr ReferenceCell make_reference_cell_from_int(const std::uint8_t kind)
Definition reference_cell.h:1056
internal::split_face_orientation
std::tuple< bool, bool, bool > split_face_orientation(const unsigned char combined_face_orientation)
Definition tria_orientation.h:45
numbers::invalid_unsigned_int
static const unsigned int invalid_unsigned_int
Definition types.h:220
std_cxx20::ranges::iota_view
boost::integer_range< IncrementableType > iota_view
Definition iota_view.h:45
std
STL namespace.
std::min
::VectorizedArray< Number, width > min(const ::VectorizedArray< Number, width > &, const ::VectorizedArray< Number, width > &)
Definition vectorization.h:6960
std::max
::VectorizedArray< Number, width > max(const ::VectorizedArray< Number, width > &, const ::VectorizedArray< Number, width > &)
Definition vectorization.h:6943
std::sqrt
::VectorizedArray< Number, width > sqrt(const ::VectorizedArray< Number, width > &)
Definition vectorization.h:6869
std::pow
::VectorizedArray< Number, width > pow(const ::VectorizedArray< Number, width > &, const Number p)
Definition vectorization.h:6885
ndarray
typename internal::ndarray::HelperArray< T, Ns... >::type ndarray
Definition ndarray.h:107
IsotropicRefinementChoice
IsotropicRefinementChoice
Definition reference_cell.h:75
IsotropicRefinementChoice::cut_tet_49
@ cut_tet_49
IsotropicRefinementChoice::cut_tet_57
@ cut_tet_57
IsotropicRefinementChoice::cut_tet_68
@ cut_tet_68
IsotropicRefinementChoice::isotropic_refinement
@ isotropic_refinement
operator>>
std::istream & operator>>(std::istream &in, ReferenceCell &reference_cell)
Definition reference_cell.cc:1145
operator<<
std::ostream & operator<<(std::ostream &out, const ReferenceCell &reference_cell)
Definition reference_cell.cc:1132
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::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::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::standard_to_real_face_line
static unsigned int standard_to_real_face_line(const unsigned int line, const bool face_orientation=true, const bool face_flip=false, const bool face_rotation=false)
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::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::d_linear_shape_function_gradient
static Tensor< 1, dim > d_linear_shape_function_gradient(const Point< dim > &xi, const unsigned int i)
tria_orientation.h
Generated by doxygen 1.9.8