35 reflect(
const std::vector<
Point<2>> &points)
37 std::vector<Point<2>> q_points;
38 q_points.reserve(points.size());
40 q_points.emplace_back(p[1], p[0]);
49 rotate(
const std::vector<
Point<2>> &points,
const unsigned int n_times)
51 std::vector<Point<2>> q_points;
52 q_points.reserve(points.size());
58 q_points.push_back(p);
63 q_points.emplace_back(1.0 - p[1], p[0]);
68 q_points.emplace_back(1.0 - p[0], 1.0 - p[1]);
73 q_points.emplace_back(p[1], 1.0 - p[0]);
87 project_to_hex_face_and_append(
89 const unsigned int face_no,
92 const unsigned int subface_no = 0)
96 const double const_value = face_no % 2;
101 const unsigned int xi_index = (1 + face_no / 2) % 3,
102 eta_index = (2 + face_no / 2) % 3,
103 const_index = face_no / 2;
110 double xi_scale = 1.0, eta_scale = 1.0, xi_translation = 0.0,
111 eta_translation = 0.0;
120 xi_translation = subface_no % 2 * 0.5;
124 eta_translation = subface_no % 2 * 0.5;
129 xi_translation =
int(subface_no % 2) * 0.5;
130 eta_translation =
int(subface_no / 2) * 0.5;
142 cell_point[xi_index] = xi_scale * p[0] + xi_translation;
143 cell_point[eta_index] = eta_scale * p[1] + eta_translation;
144 cell_point[const_index] = const_value;
145 q_points.push_back(cell_point);
149 std::vector<Point<2>>
150 mutate_points_with_offset(
const std::vector<
Point<2>> &points,
151 const unsigned char combined_orientation)
163 switch (combined_orientation)
166 return reflect(points);
168 return rotate(reflect(points), 3);
170 return rotate(reflect(points), 2);
172 return rotate(reflect(points), 1);
176 return rotate(points, 1);
178 return rotate(points, 2);
180 return rotate(points, 3);
189 const unsigned char combined_orientation)
192 combined_orientation),
196 std::pair<unsigned int, RefinementCase<2>>
197 select_subface_no_and_refinement_case(
198 const unsigned int subface_no,
199 const bool face_orientation,
200 const bool face_flip,
201 const bool face_rotation,
204 constexpr int dim = 3;
274 static const unsigned int
310 equivalent_refine_case[ref_case][subface_no];
311 const unsigned int equ_subface_no =
312 equivalent_subface_number[ref_case][subface_no];
319 (face_orientation == face_rotation ?
320 ref_case_permutation[equ_ref_case] :
323 const unsigned int final_subface_no =
333 return std::make_pair(final_subface_no, final_ref_case);
345 const unsigned int face_no,
349 (void)reference_cell;
351 const unsigned int dim = 1;
355 q_points[0] =
Point<dim>(
static_cast<double>(face_no));
364 const unsigned int face_no,
367 const unsigned int dim = 2;
376 for (
unsigned int p = 0; p < quadrature.
size(); ++p)
395 for (
unsigned int p = 0; p < quadrature.
size(); ++p)
426 const unsigned int face_no,
430 (void)reference_cell;
436 internal::QProjector::project_to_hex_face_and_append(quadrature.
get_points(),
446 const unsigned int face_no,
460 const unsigned int face_no,
461 const bool face_orientation,
462 const bool face_flip,
463 const bool face_rotation)
467 const Quadrature<2> mutation = internal::QProjector::mutate_quadrature(
482 const unsigned int face_no,
488 (void)reference_cell;
490 const unsigned int dim = 1;
494 q_points[0] =
Point<dim>(
static_cast<double>(face_no));
503 const unsigned int face_no,
504 const unsigned int subface_no,
508 const unsigned int dim = 2;
519 for (
unsigned int p = 0; p < quadrature.
size(); ++p)
541 quadrature.
point(p)[0] / 2);
545 0.5 + quadrature.
point(p)[0] / 2);
571 for (
unsigned int p = 0; p < quadrature.
size(); ++p)
647 const unsigned int face_no,
648 const unsigned int subface_no,
653 (void)reference_cell;
661 internal::QProjector::project_to_hex_face_and_append(
662 quadrature.
get_points(), face_no, q_points, ref_case, subface_no);
672 const unsigned int face_no,
673 const unsigned int subface_no,
694 const unsigned int face_no,
695 const unsigned int subface_no,
696 const bool face_orientation,
697 const bool face_flip,
698 const bool face_rotation,
703 const Quadrature<2> mutation = internal::QProjector::mutate_quadrature(
709 const std::pair<unsigned int, RefinementCase<2>>
710 final_subface_no_and_ref_case =
711 internal::QProjector::select_subface_no_and_refinement_case(
712 subface_no, face_orientation, face_flip, face_rotation, ref_case);
718 final_subface_no_and_ref_case.first,
719 final_subface_no_and_ref_case.second);
731 (void)reference_cell;
733 const unsigned int dim = 1;
738 std::vector<Point<dim>> q_points;
739 q_points.reserve(n_points * n_faces);
740 std::vector<Point<dim>> help(n_points);
745 for (
unsigned int face = 0; face < n_faces; ++face)
747 project_to_face(reference_cell,
748 quadrature[quadrature.
size() == 1 ? 0 : face],
751 std::copy(help.begin(), help.end(), std::back_inserter(q_points));
755 std::vector<double> weights;
756 weights.reserve(n_points * n_faces);
757 for (
unsigned int face = 0; face < n_faces; ++face)
759 quadrature[quadrature.
size() == 1 ? 0 : face].get_weights().
begin(),
760 quadrature[quadrature.
size() == 1 ? 0 : face].get_weights().
end(),
761 std::back_inserter(weights));
778 const auto support_points_line =
779 [](
const auto &face,
const auto &orientation) -> std::vector<
Point<2>> {
786 return std::vector<Point<2>>(temp.begin(),
787 temp.begin() + face.first.size());
791 const std::array<std::pair<std::array<Point<2>, 2>,
double>, 3> faces = {
801 std::vector<Point<2>> points;
802 std::vector<double> weights;
805 for (
unsigned int face_no = 0; face_no < faces.size(); ++face_no)
807 for (
unsigned int orientation = 0; orientation < 2; ++orientation)
809 const auto &face = faces[face_no];
813 std::vector<Point<2>> support_points =
814 support_points_line(face, orientation);
817 const auto &sub_quadrature_points =
818 quadrature[quadrature.
size() == 1 ? 0 : face_no].get_points();
819 const auto &sub_quadrature_weights =
820 quadrature[quadrature.
size() == 1 ? 0 : face_no].get_weights();
823 for (
unsigned int j = 0; j < sub_quadrature_points.size(); ++j)
828 for (
unsigned int i = 0; i < 2; ++i)
831 poly.compute_value(i, sub_quadrature_points[j]);
833 points.emplace_back(mapped_point);
836 weights.emplace_back(sub_quadrature_weights[j] * face.second);
846 const unsigned int dim = 2;
850 unsigned int n_points_total = 0;
852 if (quadrature.
size() == 1)
857 for (
const auto &q : quadrature)
858 n_points_total += q.size();
862 std::vector<Point<dim>> q_points;
863 q_points.reserve(n_points_total);
864 std::vector<Point<dim>> help;
869 for (
unsigned int face = 0; face < n_faces; ++face)
871 help.resize(quadrature[quadrature.
size() == 1 ? 0 : face].
size());
872 project_to_face(reference_cell,
873 quadrature[quadrature.
size() == 1 ? 0 : face],
876 std::copy(help.begin(), help.end(), std::back_inserter(q_points));
880 std::vector<double> weights;
881 weights.reserve(n_points_total);
882 for (
unsigned int face = 0; face < n_faces; ++face)
884 quadrature[quadrature.
size() == 1 ? 0 : face].get_weights().
begin(),
885 quadrature[quadrature.
size() == 1 ? 0 : face].get_weights().
end(),
886 std::back_inserter(weights));
901 const auto process = [&](
const std::vector<std::vector<Point<3>>> &faces) {
903 std::vector<Point<3>> points;
904 std::vector<double> weights;
912 for (
unsigned int face_no = 0; face_no < faces.size(); ++face_no)
915 reference_cell.face_reference_cell(face_no);
919 const unsigned int n_linear_shape_functions = faces[face_no].size();
920 std::vector<Tensor<1, 2>> shape_derivatives;
923 (n_linear_shape_functions == 3 ?
928 for (
unsigned char orientation = 0;
929 orientation < reference_cell.n_face_orientations(face_no);
932 const auto &face = faces[face_no];
953 const boost::container::small_vector<Point<3>, 8> support_points =
960 const auto &sub_quadrature_points =
961 quadrature[quadrature.
size() == 1 ? 0 : face_no].get_points();
962 const auto &sub_quadrature_weights =
963 quadrature[quadrature.
size() == 1 ? 0 : face_no].get_weights();
966 for (
unsigned int j = 0; j < sub_quadrature_points.size(); ++j)
971 for (
unsigned int i = 0; i < n_linear_shape_functions; ++i)
974 poly.compute_value(i, sub_quadrature_points[j]);
976 points.push_back(mapped_point);
979 const double scaling = [&]() {
980 const unsigned int dim_ = 2;
981 const unsigned int spacedim = 3;
985 shape_derivatives.resize(n_linear_shape_functions);
987 for (
unsigned int i = 0; i < n_linear_shape_functions; ++i)
988 shape_derivatives[i] =
989 poly.compute_1st_derivative(i, sub_quadrature_points[j]);
991 for (
unsigned int k = 0; k < n_linear_shape_functions; ++k)
992 for (
unsigned int i = 0; i < spacedim; ++i)
993 for (
unsigned int j = 0; j < dim_; ++j)
995 shape_derivatives[k][j] * support_points[k][i];
998 for (
unsigned int i = 0; i < dim_; ++i)
999 for (
unsigned int j = 0; j < dim_; ++j)
1000 G[i][j] = DX_t[i] * DX_t[j];
1005 weights.push_back(sub_quadrature_weights[j] * scaling);
1011 return Quadrature<3>(std::move(points), std::move(weights));
1018 std::vector<std::vector<Point<3>>> face_vertex_locations(
1019 reference_cell.n_faces());
1020 for (
const unsigned int f : reference_cell.face_indices())
1022 face_vertex_locations[f].resize(
1023 reference_cell.face_reference_cell(f).n_vertices());
1024 for (
const unsigned int v :
1025 reference_cell.face_reference_cell(f).vertex_indices())
1026 face_vertex_locations[f][v] =
1027 reference_cell.face_vertex_location<3>(f, v);
1030 return process(face_vertex_locations);
1036 const unsigned int dim = 3;
1038 unsigned int n_points_total = 0;
1040 if (quadrature.
size() == 1)
1046 for (
const auto &q : quadrature)
1047 n_points_total += q.size();
1050 n_points_total *= 8;
1053 std::vector<Point<dim>> q_points;
1054 q_points.reserve(n_points_total);
1056 std::vector<double> weights;
1057 weights.reserve(n_points_total);
1059 for (
unsigned char offset = 0; offset < 8; ++offset)
1061 const auto mutation = internal::QProjector::mutate_points_with_offset(
1062 quadrature[0].get_points(), offset);
1064 for (
unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell;
1067 const unsigned int q_index = quadrature.
size() == 1 ? 0 : face;
1069 internal::QProjector::project_to_hex_face_and_append(
1070 q_index > 0 ? internal::QProjector::mutate_points_with_offset(
1071 quadrature[face].get_points(), offset) :
1076 std::copy(quadrature[q_index].get_weights().begin(),
1077 quadrature[q_index].get_weights().end(),
1078 std::back_inserter(weights));
1097 (void)reference_cell;
1099 const unsigned int dim = 1;
1106 std::vector<Point<dim>> q_points;
1107 q_points.reserve(n_points * n_faces * subfaces_per_face);
1108 std::vector<Point<dim>> help(n_points);
1112 for (
unsigned int face = 0; face < n_faces; ++face)
1113 for (
unsigned int subface = 0; subface < subfaces_per_face; ++subface)
1115 project_to_subface(reference_cell, quadrature, face, subface, help);
1116 std::copy(help.begin(), help.end(), std::back_inserter(q_points));
1120 std::vector<double> weights;
1121 weights.reserve(n_points * n_faces * subfaces_per_face);
1122 for (
unsigned int face = 0; face < n_faces; ++face)
1123 for (
unsigned int subface = 0; subface < subfaces_per_face; ++subface)
1126 std::back_inserter(weights));
1128 Assert(q_points.size() == n_points * n_faces * subfaces_per_face,
1130 Assert(weights.size() == n_points * n_faces * subfaces_per_face,
1149 const unsigned int dim = 2;
1151 const unsigned int n_points = quadrature.
size(),
1157 std::vector<Point<dim>> q_points;
1158 q_points.reserve(n_points * n_faces * subfaces_per_face);
1159 std::vector<Point<dim>> help(n_points);
1163 for (
unsigned int face = 0; face < n_faces; ++face)
1164 for (
unsigned int subface = 0; subface < subfaces_per_face; ++subface)
1166 project_to_subface(reference_cell, quadrature, face, subface, help);
1167 std::copy(help.begin(), help.end(), std::back_inserter(q_points));
1171 std::vector<double> weights;
1172 weights.reserve(n_points * n_faces * subfaces_per_face);
1173 for (
unsigned int face = 0; face < n_faces; ++face)
1174 for (
unsigned int subface = 0; subface < subfaces_per_face; ++subface)
1177 std::back_inserter(weights));
1179 Assert(q_points.size() == n_points * n_faces * subfaces_per_face,
1181 Assert(weights.size() == n_points * n_faces * subfaces_per_face,
1200 const unsigned int dim = 3;
1202 const unsigned int n_points = quadrature.
size(),
1204 total_subfaces_per_face = 2 + 2 + 4;
1207 std::vector<Point<dim>> q_points;
1208 q_points.reserve(n_points * n_faces * total_subfaces_per_face * 8);
1210 std::vector<double> weights;
1211 weights.reserve(n_points * n_faces * total_subfaces_per_face * 8);
1215 for (
unsigned char offset = 0; offset < 8; ++offset)
1217 const auto mutation =
1218 internal::QProjector::mutate_points_with_offset(quadrature.
get_points(),
1222 for (
unsigned int face = 0; face < n_faces; ++face)
1226 for (
unsigned int subface = 0;
1231 internal::QProjector::project_to_hex_face_and_append(
1241 std::back_inserter(weights));
1245 Assert(q_points.size() == n_points * n_faces * total_subfaces_per_face * 8,
1247 Assert(weights.size() == n_points * n_faces * total_subfaces_per_face * 8,
1259 const unsigned int child_no)
1261 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1263 (void)reference_cell;
1267 const unsigned int n_q_points = quadrature.
size();
1269 std::vector<Point<dim>> q_points(n_q_points);
1270 for (
unsigned int i = 0; i < n_q_points; ++i)
1278 std::vector<double> weights = quadrature.
get_weights();
1279 for (
unsigned int i = 0; i < n_q_points; ++i)
1292 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1294 (void)reference_cell;
1296 const unsigned int n_points = quadrature.
size(),
1299 std::vector<Point<dim>> q_points(n_points * n_children);
1300 std::vector<double> weights(n_points * n_children);
1304 for (
unsigned int child = 0; child < n_children; ++child)
1307 project_to_child(reference_cell, quadrature, child);
1308 for (
unsigned int i = 0; i < n_points; ++i)
1310 q_points[child * n_points + i] = help.
point(i);
1311 weights[child * n_points + i] = help.
weight(i);
1326 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1328 (void)reference_cell;
1330 const unsigned int n = quadrature.
size();
1331 std::vector<Point<dim>> points(n);
1332 std::vector<double> weights(n);
1333 const double length = p1.
distance(p2);
1335 for (
unsigned int k = 0; k < n; ++k)
1337 const double alpha = quadrature.
point(k)[0];
1338 points[k] = alpha * p2;
1339 points[k] += (1. - alpha) * p1;
1340 weights[k] = length * quadrature.
weight(k);
1350 const unsigned int face_no,
1351 const bool face_orientation,
1352 const bool face_flip,
1353 const bool face_rotation,
1354 const unsigned int n_quadrature_points)
1356 return face(reference_cell,
1361 n_quadrature_points);
1370 const unsigned int face_no,
1371 const unsigned char combined_orientation,
1372 const unsigned int n_quadrature_points)
1377 (combined_orientation < reference_cell.n_face_orientations(face_no)),
1383 return {(2 * face_no +
1384 (combined_orientation ==
1388 n_quadrature_points};
1391 return {(reference_cell.n_face_orientations(face_no) * face_no +
1392 combined_orientation) *
1393 n_quadrature_points};
1397 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1406 return face_no * n_quadrature_points;
1410 n_quadrature_points;
1423 const unsigned int face_no,
1424 const bool face_orientation,
1425 const bool face_flip,
1426 const bool face_rotation,
1429 return face(reference_cell,
1443 const unsigned int face_no,
1444 const unsigned char combined_orientation,
1452 unsigned int offset = 0;
1453 Assert(combined_orientation < reference_cell.n_face_orientations(face_no),
1457 static const std::array<unsigned int, 5> scale_tri = {{2, 2, 2, X, X}};
1458 static const std::array<unsigned int, 5> scale_tet = {{6, 6, 6, 6, X}};
1459 static const std::array<unsigned int, 5> scale_wedge = {{6, 6, 8, 8, 8}};
1460 static const std::array<unsigned int, 5> scale_pyramid = {
1471 if (quadrature.
size() == 1)
1472 offset = scale[0] * quadrature[0].size() * face_no;
1474 for (
unsigned int i = 0; i < face_no; ++i)
1475 offset += scale[i] * quadrature[i].size();
1479 (combined_orientation ==
1481 quadrature[quadrature.
size() == 1 ? 0 : face_no].
size()};
1485 combined_orientation *
1486 quadrature[quadrature.
size() == 1 ? 0 : face_no].
size()};
1490 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1500 if (quadrature.
size() == 1)
1501 return quadrature[0].
size() * face_no;
1504 unsigned int result = 0;
1505 for (
unsigned int i = 0; i < face_no; ++i)
1506 result += quadrature[i].size();
1512 if (quadrature.
size() == 1)
1515 quadrature[0].
size();
1518 unsigned int n_points_i = 0;
1519 for (
unsigned int i = 0; i < face_no; ++i)
1520 n_points_i += quadrature[i].size();
1522 unsigned int n_points = 0;
1523 for (
unsigned int i = 0; i < GeometryInfo<dim>::faces_per_cell;
1525 n_points += quadrature[i].size();
1527 return n_points_i + combined_orientation * n_points;
1543 const unsigned int face_no,
1544 const unsigned int subface_no,
1545 const bool face_orientation,
1546 const bool face_flip,
1547 const bool face_rotation,
1548 const unsigned int n_quadrature_points,
1558 n_quadrature_points,
1568 const unsigned int face_no,
1569 const unsigned int subface_no,
1570 const unsigned char ,
1571 const unsigned int n_quadrature_points,
1575 (void)reference_cell;
1582 n_quadrature_points);
1591 const unsigned int face_no,
1592 const unsigned int subface_no,
1593 const unsigned char ,
1594 const unsigned int n_quadrature_points,
1598 (void)reference_cell;
1605 n_quadrature_points);
1614 const unsigned int face_no,
1615 const unsigned int subface_no,
1616 const unsigned char combined_orientation,
1617 const unsigned int n_quadrature_points,
1620 const unsigned int dim = 3;
1622 const auto [face_orientation, face_rotation, face_flip] =
1626 (void)reference_cell;
1640 const unsigned int total_subfaces_per_face = 8;
1657 static const unsigned int ref_case_offset[3] = {
1663 const std::pair<unsigned int, RefinementCase<2>>
1664 final_subface_no_and_ref_case =
1665 internal::QProjector::select_subface_no_and_refinement_case(
1666 subface_no, face_orientation, face_flip, face_rotation, ref_case);
1668 return ((face_no * total_subfaces_per_face +
1669 ref_case_offset[final_subface_no_and_ref_case.second - 1] +
1670 final_subface_no_and_ref_case.first) +
1672 combined_orientation) *
1673 n_quadrature_points;
1682 const unsigned int face_no)
1684 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1686 (void)reference_cell;
1688 std::vector<Point<dim>> points(quadrature.
size());
1699 const unsigned int face_no,
1700 const unsigned int subface_no,
1703 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1705 (void)reference_cell;
1707 std::vector<Point<dim>> points(quadrature.
size());
1709 reference_cell, quadrature, face_no, subface_no, points, ref_case);
static BarycentricPolynomials< dim > get_fe_p_basis(const unsigned int degree)
numbers::NumberTraits< Number >::real_type distance(const Point< dim, Number > &p) const
static DataSetDescriptor subface(const ReferenceCell &reference_cell, const unsigned int face_no, const unsigned int subface_no, const bool face_orientation, const bool face_flip, const bool face_rotation, const unsigned int n_quadrature_points, const internal::SubfaceCase< dim > ref_case=internal::SubfaceCase< dim >::case_isotropic)
static DataSetDescriptor face(const ReferenceCell &reference_cell, const unsigned int face_no, const bool face_orientation, const bool face_flip, const bool face_rotation, const unsigned int n_quadrature_points)
static Quadrature< dim > project_to_all_subfaces(const ReferenceCell &reference_cell, const SubQuadrature &quadrature)
static Quadrature< dim > project_to_child(const ReferenceCell &reference_cell, const Quadrature< dim > &quadrature, const unsigned int child_no)
static Quadrature< dim > project_to_oriented_subface(const ReferenceCell &reference_cell, const SubQuadrature &quadrature, const unsigned int face_no, const unsigned int subface_no, const bool face_orientation, const bool face_flip, const bool face_rotation, const internal::SubfaceCase< dim > ref_case)
static Quadrature< dim > project_to_all_faces(const ReferenceCell &reference_cell, const hp::QCollection< dim - 1 > &quadrature)
static Quadrature< dim > project_to_oriented_face(const ReferenceCell &reference_cell, const SubQuadrature &quadrature, const unsigned int face_no, const bool face_orientation, const bool face_flip, const bool face_rotation)
static Quadrature< dim > project_to_line(const ReferenceCell &reference_cell, const Quadrature< 1 > &quadrature, const Point< dim > &p1, const Point< dim > &p2)
static void project_to_subface(const ReferenceCell &reference_cell, const SubQuadrature &quadrature, const unsigned int face_no, const unsigned int subface_no, std::vector< Point< dim > > &q_points, const RefinementCase< dim - 1 > &ref_case=RefinementCase< dim - 1 >::isotropic_refinement)
static Quadrature< dim > project_to_all_children(const ReferenceCell &reference_cell, const Quadrature< dim > &quadrature)
static void project_to_face(const ReferenceCell &reference_cell, const SubQuadrature &quadrature, const unsigned int face_no, std::vector< Point< dim > > &q_points)
const Point< dim > & point(const unsigned int i) const
double weight(const unsigned int i) const
const std::vector< double > & get_weights() const
const std::vector< Point< dim > > & get_points() const
unsigned int size() const
boost::container::small_vector< T, 8 > permute_by_combined_orientation(const ArrayView< const T > &vertices, const unsigned char orientation) const
unsigned char get_inverse_combined_orientation(const unsigned char orientation) const
static constexpr unsigned char default_combined_face_orientation()
CollectionIterator< T > begin() const
unsigned int size() const
CollectionIterator< T > end() const
unsigned int max_n_quadrature_points() const
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_CLOSE
static ::ExceptionBase & ExcNotImplemented()
#define Assert(cond, exc)
#define AssertDimension(dim1, dim2)
#define AssertIndexRange(index, range)
static ::ExceptionBase & ExcInternalError()
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
#define DEAL_II_ASSERT_UNREACHABLE()
std::vector< Polynomial< double > > generate_complete_Lagrange_basis(const std::vector< Point< 1 > > &points)
constexpr const ReferenceCell Tetrahedron
constexpr const ReferenceCell Quadrilateral
constexpr const ReferenceCell Wedge
constexpr const ReferenceCell Pyramid
constexpr const ReferenceCell Triangle
constexpr const ReferenceCell Hexahedron
constexpr const ReferenceCell Line
std::tuple< bool, bool, bool > split_face_orientation(const unsigned char combined_face_orientation)
unsigned char combined_face_orientation(const bool face_orientation, const bool face_rotation, const bool face_flip)
static const unsigned int invalid_unsigned_int
::VectorizedArray< Number, width > sqrt(const ::VectorizedArray< Number, width > &)
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)
static unsigned int n_children(const RefinementCase< dim > &refinement_case)
DEAL_II_HOST constexpr Number determinant(const SymmetricTensor< 2, dim, Number > &)