24#include <boost/container/small_vector.hpp>
38 reflect(
const std::vector<
Point<2>> &points)
40 std::vector<Point<2>> q_points;
41 q_points.reserve(points.size());
43 q_points.emplace_back(p[1], p[0]);
52 rotate(
const std::vector<
Point<2>> &points,
const unsigned int n_times)
54 std::vector<Point<2>> q_points;
55 q_points.reserve(points.size());
61 q_points.push_back(p);
66 q_points.emplace_back(1.0 - p[1], p[0]);
71 q_points.emplace_back(1.0 - p[0], 1.0 - p[1]);
76 q_points.emplace_back(p[1], 1.0 - p[0]);
90 project_to_hex_face_and_append(
92 const unsigned int face_no,
95 const unsigned int subface_no = 0)
99 const double const_value = face_no % 2;
104 const unsigned int xi_index = (1 + face_no / 2) % 3,
105 eta_index = (2 + face_no / 2) % 3,
106 const_index = face_no / 2;
113 double xi_scale = 1.0, eta_scale = 1.0, xi_translation = 0.0,
114 eta_translation = 0.0;
123 xi_translation = subface_no % 2 * 0.5;
127 eta_translation = subface_no % 2 * 0.5;
132 xi_translation =
int(subface_no % 2) * 0.5;
133 eta_translation =
int(subface_no / 2) * 0.5;
145 cell_point[xi_index] = xi_scale * p[0] + xi_translation;
146 cell_point[eta_index] = eta_scale * p[1] + eta_translation;
147 cell_point[const_index] = const_value;
148 q_points.push_back(cell_point);
152 std::vector<Point<2>>
153 mutate_points_with_offset(
154 const std::vector<
Point<2>> &points,
167 switch (combined_orientation)
170 return reflect(points);
172 return rotate(reflect(points), 3);
174 return rotate(reflect(points), 2);
176 return rotate(reflect(points), 1);
180 return rotate(points, 1);
182 return rotate(points, 2);
184 return rotate(points, 3);
196 combined_orientation),
200 std::pair<unsigned int, RefinementCase<2>>
201 select_subface_no_and_refinement_case(
202 const unsigned int subface_no,
203 const bool face_orientation,
204 const bool face_flip,
205 const bool face_rotation,
208 constexpr int dim = 3;
278 static const unsigned int
314 equivalent_refine_case[ref_case][subface_no];
315 const unsigned int equ_subface_no =
316 equivalent_subface_number[ref_case][subface_no];
323 (face_orientation == face_rotation ?
324 ref_case_permutation[equ_ref_case] :
327 const unsigned int final_subface_no =
337 return std::make_pair(final_subface_no, final_ref_case);
349 const unsigned int face_no,
353 const auto face_quadrature =
358 q_points = face_quadrature.get_points();
367 const unsigned int face_no,
371 const auto face_quadrature =
376 q_points = face_quadrature.get_points();
385 const unsigned int face_no,
389 (void)reference_cell;
395 internal::QProjector::project_to_hex_face_and_append(quadrature.
get_points(),
406 const unsigned int face_no,
407 const bool face_orientation,
408 const bool face_flip,
409 const bool face_rotation)
426 const unsigned int face_no,
432 reference_cell.n_face_orientations(face_no));
435 std::vector<Point<dim>> q_points;
436 std::vector<double> q_weights = quadrature.
get_weights();
437 q_points.reserve(quadrature.
size());
438 if constexpr (dim == 1)
441 q_points.emplace_back(
static_cast<double>(face_no));
443 else if constexpr (dim == 2)
448 for (
unsigned int p = 0; p < quadrature.
size(); ++p)
451 q_points.emplace_back(quadrature.
point(p)[0], 0);
452 else if (face_no == 1)
453 q_points.emplace_back(1.0 - quadrature.
point(p)[0],
454 quadrature.
point(p)[0]);
455 else if (face_no == 2)
456 q_points.emplace_back(0, 1.0 - quadrature.
point(p)[0]);
461 for (
unsigned int p = 0; p < quadrature.
size(); ++p)
464 q_points.emplace_back(0, quadrature.
point(p)[0]);
465 else if (face_no == 1)
466 q_points.emplace_back(1, quadrature.
point(p)[0]);
467 else if (face_no == 2)
468 q_points.emplace_back(quadrature.
point(p)[0], 0);
469 else if (face_no == 3)
470 q_points.emplace_back(quadrature.
point(p)[0], 1);
479 std::reverse(q_points.begin(), q_points.end());
480 std::reverse(q_weights.begin(), q_weights.end());
483 else if constexpr (dim == 3)
487 internal::QProjector::mutate_quadrature(quadrature, orientation);
504 const unsigned int face_no,
510 (void)reference_cell;
512 const unsigned int dim = 1;
516 q_points[0] =
Point<dim>(
static_cast<double>(face_no));
525 const unsigned int face_no,
526 const unsigned int subface_no,
530 const unsigned int dim = 2;
541 for (
unsigned int p = 0; p < quadrature.
size(); ++p)
563 quadrature.
point(p)[0] / 2);
567 0.5 + quadrature.
point(p)[0] / 2);
593 for (
unsigned int p = 0; p < quadrature.
size(); ++p)
669 const unsigned int face_no,
670 const unsigned int subface_no,
675 (void)reference_cell;
683 internal::QProjector::project_to_hex_face_and_append(
684 quadrature.
get_points(), face_no, q_points, ref_case, subface_no);
694 const unsigned int face_no,
695 const unsigned int subface_no,
716 const unsigned int face_no,
717 const unsigned int subface_no,
718 const bool face_orientation,
719 const bool face_flip,
720 const bool face_rotation,
725 const Quadrature<2> mutation = internal::QProjector::mutate_quadrature(
731 const std::pair<unsigned int, RefinementCase<2>>
732 final_subface_no_and_ref_case =
733 internal::QProjector::select_subface_no_and_refinement_case(
734 subface_no, face_orientation, face_flip, face_rotation, ref_case);
740 final_subface_no_and_ref_case.first,
741 final_subface_no_and_ref_case.second);
753 (void)reference_cell;
755 const unsigned int dim = 1;
760 std::vector<Point<dim>> q_points;
761 q_points.reserve(n_points * n_faces);
762 std::vector<Point<dim>> help(n_points);
767 for (
unsigned int face = 0; face < n_faces; ++face)
769 project_to_face(reference_cell,
770 quadrature[quadrature.
size() == 1 ? 0 : face],
773 std::copy(help.begin(), help.end(), std::back_inserter(q_points));
777 std::vector<double> weights;
778 weights.reserve(n_points * n_faces);
779 for (
unsigned int face = 0; face < n_faces; ++face)
781 quadrature[quadrature.
size() == 1 ? 0 : face].get_weights().
begin(),
782 quadrature[quadrature.
size() == 1 ? 0 : face].get_weights().
end(),
783 std::back_inserter(weights));
800 const auto support_points_line =
801 [](
const auto &face,
const auto &orientation) -> std::vector<
Point<2>> {
808 return std::vector<Point<2>>(temp.begin(),
809 temp.begin() + face.first.size());
813 const std::array<std::pair<std::array<Point<2>, 2>,
double>, 3> faces = {
823 std::vector<Point<2>> points;
824 std::vector<double> weights;
827 for (
unsigned int face_no = 0; face_no < faces.size(); ++face_no)
829 for (
unsigned int orientation = 0; orientation < 2; ++orientation)
831 const auto &face = faces[face_no];
835 std::vector<Point<2>> support_points =
836 support_points_line(face, orientation);
839 const auto &sub_quadrature_points =
840 quadrature[quadrature.
size() == 1 ? 0 : face_no].get_points();
841 const auto &sub_quadrature_weights =
842 quadrature[quadrature.
size() == 1 ? 0 : face_no].get_weights();
845 for (
unsigned int j = 0; j < sub_quadrature_points.size(); ++j)
850 for (
unsigned int i = 0; i < 2; ++i)
853 poly.compute_value(i, sub_quadrature_points[j]);
855 points.emplace_back(mapped_point);
858 weights.emplace_back(sub_quadrature_weights[j] * face.second);
868 const unsigned int dim = 2;
872 unsigned int n_points_total = 0;
874 if (quadrature.
size() == 1)
879 for (
const auto &q : quadrature)
880 n_points_total += q.size();
884 std::vector<Point<dim>> q_points;
885 q_points.reserve(n_points_total);
886 std::vector<Point<dim>> help;
891 for (
unsigned int face = 0; face < n_faces; ++face)
893 help.resize(quadrature[quadrature.
size() == 1 ? 0 : face].
size());
894 project_to_face(reference_cell,
895 quadrature[quadrature.
size() == 1 ? 0 : face],
898 std::copy(help.begin(), help.end(), std::back_inserter(q_points));
902 std::vector<double> weights;
903 weights.reserve(n_points_total);
904 for (
unsigned int face = 0; face < n_faces; ++face)
906 quadrature[quadrature.
size() == 1 ? 0 : face].get_weights().
begin(),
907 quadrature[quadrature.
size() == 1 ? 0 : face].get_weights().
end(),
908 std::back_inserter(weights));
923 const auto process = [&](
const std::vector<std::vector<Point<3>>> &faces) {
925 std::vector<Point<3>> points;
926 std::vector<double> weights;
934 for (
unsigned int face_no = 0; face_no < faces.size(); ++face_no)
937 reference_cell.face_reference_cell(face_no);
941 const unsigned int n_linear_shape_functions = faces[face_no].size();
942 std::vector<Tensor<1, 2>> shape_derivatives;
945 (n_linear_shape_functions == 3 ?
951 orientation < reference_cell.n_face_orientations(face_no);
954 const auto &face = faces[face_no];
975 const boost::container::small_vector<Point<3>, 8> support_points =
982 const auto &sub_quadrature_points =
983 quadrature[quadrature.
size() == 1 ? 0 : face_no].get_points();
984 const auto &sub_quadrature_weights =
985 quadrature[quadrature.
size() == 1 ? 0 : face_no].get_weights();
988 for (
unsigned int j = 0; j < sub_quadrature_points.size(); ++j)
993 for (
unsigned int i = 0; i < n_linear_shape_functions; ++i)
996 poly.compute_value(i, sub_quadrature_points[j]);
998 points.push_back(mapped_point);
1001 const double scaling = [&]() {
1002 const unsigned int dim_ = 2;
1003 const unsigned int spacedim = 3;
1007 shape_derivatives.resize(n_linear_shape_functions);
1009 for (
unsigned int i = 0; i < n_linear_shape_functions; ++i)
1010 shape_derivatives[i] =
1011 poly.compute_1st_derivative(i, sub_quadrature_points[j]);
1013 for (
unsigned int k = 0; k < n_linear_shape_functions; ++k)
1014 for (
unsigned int i = 0; i < spacedim; ++i)
1015 for (
unsigned int j = 0; j < dim_; ++j)
1017 shape_derivatives[k][j] * support_points[k][i];
1020 for (
unsigned int i = 0; i < dim_; ++i)
1021 for (
unsigned int j = 0; j < dim_; ++j)
1022 G[i][j] = DX_t[i] * DX_t[j];
1027 weights.push_back(sub_quadrature_weights[j] * scaling);
1033 return Quadrature<3>(std::move(points), std::move(weights));
1040 std::vector<std::vector<Point<3>>> face_vertex_locations(
1041 reference_cell.n_faces());
1042 for (
const unsigned int f : reference_cell.face_indices())
1044 face_vertex_locations[f].resize(
1045 reference_cell.face_reference_cell(f).n_vertices());
1046 for (
const unsigned int v :
1047 reference_cell.face_reference_cell(f).vertex_indices())
1048 face_vertex_locations[f][v] =
1049 reference_cell.face_vertex_location<3>(f, v);
1052 return process(face_vertex_locations);
1058 const unsigned int dim = 3;
1060 unsigned int n_points_total = 0;
1062 if (quadrature.
size() == 1)
1068 for (
const auto &q : quadrature)
1069 n_points_total += q.size();
1072 n_points_total *= 8;
1075 std::vector<Point<dim>> q_points;
1076 q_points.reserve(n_points_total);
1078 std::vector<double> weights;
1079 weights.reserve(n_points_total);
1081 for (
unsigned char offset = 0; offset < 8; ++offset)
1083 const auto mutation = internal::QProjector::mutate_points_with_offset(
1084 quadrature[0].get_points(), offset);
1086 for (
unsigned int face = 0; face < GeometryInfo<dim>::faces_per_cell;
1089 const unsigned int q_index = quadrature.
size() == 1 ? 0 : face;
1091 internal::QProjector::project_to_hex_face_and_append(
1092 q_index > 0 ? internal::QProjector::mutate_points_with_offset(
1093 quadrature[face].get_points(), offset) :
1098 std::copy(quadrature[q_index].get_weights().begin(),
1099 quadrature[q_index].get_weights().end(),
1100 std::back_inserter(weights));
1119 (void)reference_cell;
1121 const unsigned int dim = 1;
1128 std::vector<Point<dim>> q_points;
1129 q_points.reserve(n_points * n_faces * subfaces_per_face);
1130 std::vector<Point<dim>> help(n_points);
1134 for (
unsigned int face = 0; face < n_faces; ++face)
1135 for (
unsigned int subface = 0; subface < subfaces_per_face; ++subface)
1137 project_to_subface(reference_cell, quadrature, face, subface, help);
1138 std::copy(help.begin(), help.end(), std::back_inserter(q_points));
1142 std::vector<double> weights;
1143 weights.reserve(n_points * n_faces * subfaces_per_face);
1144 for (
unsigned int face = 0; face < n_faces; ++face)
1145 for (
unsigned int subface = 0; subface < subfaces_per_face; ++subface)
1148 std::back_inserter(weights));
1150 Assert(q_points.size() == n_points * n_faces * subfaces_per_face,
1152 Assert(weights.size() == n_points * n_faces * subfaces_per_face,
1171 const unsigned int dim = 2;
1173 const unsigned int n_points = quadrature.
size(),
1179 std::vector<Point<dim>> q_points;
1180 q_points.reserve(n_points * n_faces * subfaces_per_face);
1181 std::vector<Point<dim>> help(n_points);
1185 for (
unsigned int face = 0; face < n_faces; ++face)
1186 for (
unsigned int subface = 0; subface < subfaces_per_face; ++subface)
1188 project_to_subface(reference_cell, quadrature, face, subface, help);
1189 std::copy(help.begin(), help.end(), std::back_inserter(q_points));
1193 std::vector<double> weights;
1194 weights.reserve(n_points * n_faces * subfaces_per_face);
1195 for (
unsigned int face = 0; face < n_faces; ++face)
1196 for (
unsigned int subface = 0; subface < subfaces_per_face; ++subface)
1199 std::back_inserter(weights));
1201 Assert(q_points.size() == n_points * n_faces * subfaces_per_face,
1203 Assert(weights.size() == n_points * n_faces * subfaces_per_face,
1222 const unsigned int dim = 3;
1224 const unsigned int n_points = quadrature.
size(),
1226 total_subfaces_per_face = 2 + 2 + 4;
1229 std::vector<Point<dim>> q_points;
1230 q_points.reserve(n_points * n_faces * total_subfaces_per_face * 8);
1232 std::vector<double> weights;
1233 weights.reserve(n_points * n_faces * total_subfaces_per_face * 8);
1237 for (
unsigned char offset = 0; offset < 8; ++offset)
1239 const auto mutation =
1240 internal::QProjector::mutate_points_with_offset(quadrature.
get_points(),
1244 for (
unsigned int face = 0; face < n_faces; ++face)
1248 for (
unsigned int subface = 0;
1253 internal::QProjector::project_to_hex_face_and_append(
1263 std::back_inserter(weights));
1267 Assert(q_points.size() == n_points * n_faces * total_subfaces_per_face * 8,
1269 Assert(weights.size() == n_points * n_faces * total_subfaces_per_face * 8,
1281 const unsigned int child_no)
1283 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1285 (void)reference_cell;
1289 const unsigned int n_q_points = quadrature.
size();
1291 std::vector<Point<dim>> q_points(n_q_points);
1292 for (
unsigned int i = 0; i < n_q_points; ++i)
1300 std::vector<double> weights = quadrature.
get_weights();
1301 for (
unsigned int i = 0; i < n_q_points; ++i)
1314 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1316 (void)reference_cell;
1318 const unsigned int n_points = quadrature.
size(),
1321 std::vector<Point<dim>> q_points(n_points * n_children);
1322 std::vector<double> weights(n_points * n_children);
1326 for (
unsigned int child = 0; child < n_children; ++child)
1329 project_to_child(reference_cell, quadrature, child);
1330 for (
unsigned int i = 0; i < n_points; ++i)
1332 q_points[child * n_points + i] = help.
point(i);
1333 weights[child * n_points + i] = help.
weight(i);
1348 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1350 (void)reference_cell;
1352 const unsigned int n = quadrature.
size();
1353 std::vector<Point<dim>> points(n);
1354 std::vector<double> weights(n);
1355 const double length = p1.
distance(p2);
1357 for (
unsigned int k = 0; k < n; ++k)
1359 const double alpha = quadrature.
point(k)[0];
1360 points[k] = alpha * p2;
1361 points[k] += (1. - alpha) * p1;
1362 weights[k] = length * quadrature.
weight(k);
1372 const unsigned int face_no,
1373 const bool face_orientation,
1374 const bool face_flip,
1375 const bool face_rotation,
1376 const unsigned int n_quadrature_points)
1378 return face(reference_cell,
1383 n_quadrature_points);
1392 const unsigned int face_no,
1394 const unsigned int n_quadrature_points)
1399 (combined_orientation < reference_cell.n_face_orientations(face_no)),
1405 return {(2 * face_no + (combined_orientation ==
1409 n_quadrature_points};
1412 return {(reference_cell.n_face_orientations(face_no) * face_no +
1413 combined_orientation) *
1414 n_quadrature_points};
1418 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1427 return face_no * n_quadrature_points;
1431 n_quadrature_points;
1444 const unsigned int face_no,
1445 const bool face_orientation,
1446 const bool face_flip,
1447 const bool face_rotation,
1450 return face(reference_cell,
1464 const unsigned int face_no,
1473 unsigned int offset = 0;
1474 Assert(combined_orientation < reference_cell.n_face_orientations(face_no),
1478 static const std::array<unsigned int, 5> scale_tri = {{2, 2, 2, X, X}};
1479 static const std::array<unsigned int, 5> scale_tet = {{6, 6, 6, 6, X}};
1480 static const std::array<unsigned int, 5> scale_wedge = {{6, 6, 8, 8, 8}};
1481 static const std::array<unsigned int, 5> scale_pyramid = {
1492 if (quadrature.
size() == 1)
1493 offset = scale[0] * quadrature[0].
size() * face_no;
1495 for (
unsigned int i = 0; i < face_no; ++i)
1496 offset += scale[i] * quadrature[i].
size();
1502 quadrature[quadrature.
size() == 1 ? 0 : face_no].
size()};
1506 combined_orientation *
1507 quadrature[quadrature.
size() == 1 ? 0 : face_no].
size()};
1511 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1521 if (quadrature.
size() == 1)
1522 return quadrature[0].
size() * face_no;
1525 unsigned int result = 0;
1526 for (
unsigned int i = 0; i < face_no; ++i)
1527 result += quadrature[i].
size();
1533 if (quadrature.
size() == 1)
1536 quadrature[0].
size();
1539 unsigned int n_points_i = 0;
1540 for (
unsigned int i = 0; i < face_no; ++i)
1541 n_points_i += quadrature[i].
size();
1543 unsigned int n_points = 0;
1544 for (
unsigned int i = 0; i < GeometryInfo<dim>::faces_per_cell;
1546 n_points += quadrature[i].
size();
1548 return n_points_i + combined_orientation * n_points;
1564 const unsigned int face_no,
1565 const unsigned int subface_no,
1566 const bool face_orientation,
1567 const bool face_flip,
1568 const bool face_rotation,
1569 const unsigned int n_quadrature_points,
1579 n_quadrature_points,
1589 const unsigned int face_no,
1590 const unsigned int subface_no,
1592 const unsigned int n_quadrature_points,
1596 (void)reference_cell;
1603 n_quadrature_points);
1612 const unsigned int face_no,
1613 const unsigned int subface_no,
1615 const unsigned int n_quadrature_points,
1619 (void)reference_cell;
1626 n_quadrature_points);
1635 const unsigned int face_no,
1636 const unsigned int subface_no,
1638 const unsigned int n_quadrature_points,
1641 const unsigned int dim = 3;
1643 const auto [face_orientation, face_rotation, face_flip] =
1647 (void)reference_cell;
1661 const unsigned int total_subfaces_per_face = 8;
1678 static const unsigned int ref_case_offset[3] = {
1684 const std::pair<unsigned int, RefinementCase<2>>
1685 final_subface_no_and_ref_case =
1686 internal::QProjector::select_subface_no_and_refinement_case(
1687 subface_no, face_orientation, face_flip, face_rotation, ref_case);
1689 return ((face_no * total_subfaces_per_face +
1690 ref_case_offset[final_subface_no_and_ref_case.second - 1] +
1691 final_subface_no_and_ref_case.first) +
1693 combined_orientation) *
1694 n_quadrature_points;
1703 const unsigned int face_no)
1705 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1707 (void)reference_cell;
1709 std::vector<Point<dim>> points(quadrature.
size());
1720 const unsigned int face_no,
1721 const unsigned int subface_no,
1724 Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
1726 (void)reference_cell;
1728 std::vector<Point<dim>> points(quadrature.
size());
1730 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
types::geometric_orientation get_inverse_combined_orientation(const types::geometric_orientation orientation) const
boost::container::small_vector< T, 8 > permute_by_combined_orientation(const ArrayView< const T > &vertices, const types::geometric_orientation orientation) const
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
types::geometric_orientation combined_face_orientation(const bool face_orientation, const bool face_rotation, const bool face_flip)
std::tuple< bool, bool, bool > split_face_orientation(const types::geometric_orientation combined_face_orientation)
constexpr unsigned int invalid_unsigned_int
constexpr types::geometric_orientation reverse_line_orientation
constexpr types::geometric_orientation default_geometric_orientation
::VectorizedArray< Number, width > sqrt(const ::VectorizedArray< Number, width > &)
unsigned char geometric_orientation
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 > &)