37 #include <boost/container/small_vector.hpp>
50 template <
int dim,
int spacedim>
52 const unsigned int polynomial_degree)
53 : polynomial_degree(polynomial_degree)
55 , line_support_points(
QGaussLobatto<1>(polynomial_degree + 1))
56 , tensor_product_quadrature(false)
61 template <
int dim,
int spacedim>
82 template <
int dim,
int spacedim>
87 const unsigned int n_original_q_points)
91 this->update_each = update_flags;
93 const unsigned int n_q_points = q.
size();
95 const bool needs_higher_order_terms =
103 covariant.resize(n_original_q_points);
106 contravariant.resize(n_original_q_points);
109 volume_elements.resize(n_original_q_points);
116 tensor_product_quadrature =
false;
122 if (tensor_product_quadrature)
124 const std::array<Quadrature<1>, dim> &quad_array =
126 for (
unsigned int i = 1; i < dim && tensor_product_quadrature; ++i)
128 if (quad_array[i - 1].size() != quad_array[i].size())
130 tensor_product_quadrature =
false;
135 const std::vector<Point<1>> &points_1 =
136 quad_array[i - 1].get_points();
137 const std::vector<Point<1>> &points_2 =
138 quad_array[i].get_points();
139 const std::vector<double> &weights_1 =
140 quad_array[i - 1].get_weights();
141 const std::vector<double> &weights_2 =
142 quad_array[i].get_weights();
143 for (
unsigned int j = 0; j < quad_array[i].size(); ++j)
145 if (std::abs(points_1[j][0] - points_2[j][0]) > 1.e-10 ||
146 std::abs(weights_1[j] - weights_2[j]) > 1.e-10)
148 tensor_product_quadrature =
false;
155 if (tensor_product_quadrature)
162 shape_info.lexicographic_numbering =
163 FETools::lexicographic_to_hierarchic_numbering<dim>(
165 shape_info.n_q_points = q.
size();
166 shape_info.dofs_per_component_on_cell =
174 if (dim == 1 || !tensor_product_quadrature || needs_higher_order_terms)
179 shape_values.resize(n_shape_functions * n_q_points);
181 if (this->update_each &
191 shape_derivatives.resize(n_shape_functions * n_q_points);
193 if (this->update_each &
195 shape_second_derivatives.resize(n_shape_functions * n_q_points);
199 shape_third_derivatives.resize(n_shape_functions * n_q_points);
203 shape_fourth_derivatives.resize(n_shape_functions * n_q_points);
206 compute_shape_function_values(q.
get_points());
212 template <
int dim,
int spacedim>
217 const unsigned int n_original_q_points)
219 initialize(update_flags, q, n_original_q_points);
221 if (dim > 1 && tensor_product_quadrature)
223 constexpr
unsigned int facedim = dim - 1;
226 shape_info.lexicographic_numbering =
227 FETools::lexicographic_to_hierarchic_numbering<facedim>(
229 shape_info.n_q_points = n_original_q_points;
230 shape_info.dofs_per_component_on_cell =
236 if (this->update_each &
246 unit_tangentials[i].resize(n_original_q_points);
247 std::fill(unit_tangentials[i].
begin(),
248 unit_tangentials[i].
end(),
253 .resize(n_original_q_points);
268 template <
int dim,
int spacedim>
273 const unsigned int n_points = unit_points.size();
284 const std::vector<unsigned int> renumber =
287 std::vector<double>
values;
288 std::vector<Tensor<1, dim>> grads;
289 if (shape_values.size() != 0)
291 Assert(shape_values.size() == n_shape_functions * n_points,
293 values.resize(n_shape_functions);
295 if (shape_derivatives.size() != 0)
297 Assert(shape_derivatives.size() == n_shape_functions * n_points,
299 grads.resize(n_shape_functions);
302 std::vector<Tensor<2, dim>> grad2;
303 if (shape_second_derivatives.size() != 0)
305 Assert(shape_second_derivatives.size() == n_shape_functions * n_points,
307 grad2.resize(n_shape_functions);
310 std::vector<Tensor<3, dim>> grad3;
311 if (shape_third_derivatives.size() != 0)
313 Assert(shape_third_derivatives.size() == n_shape_functions * n_points,
315 grad3.resize(n_shape_functions);
318 std::vector<Tensor<4, dim>> grad4;
319 if (shape_fourth_derivatives.size() != 0)
321 Assert(shape_fourth_derivatives.size() == n_shape_functions * n_points,
323 grad4.resize(n_shape_functions);
327 if (shape_values.size() != 0 || shape_derivatives.size() != 0 ||
328 shape_second_derivatives.size() != 0 ||
329 shape_third_derivatives.size() != 0 ||
330 shape_fourth_derivatives.size() != 0)
334 unit_points[
point],
values, grads, grad2, grad3, grad4);
336 if (shape_values.size() != 0)
337 for (
unsigned int i = 0; i < n_shape_functions; ++i)
340 if (shape_derivatives.size() != 0)
341 for (
unsigned int i = 0; i < n_shape_functions; ++i)
342 derivative(
point, i) = grads[renumber[i]];
344 if (shape_second_derivatives.size() != 0)
345 for (
unsigned int i = 0; i < n_shape_functions; ++i)
346 second_derivative(
point, i) = grad2[renumber[i]];
348 if (shape_third_derivatives.size() != 0)
349 for (
unsigned int i = 0; i < n_shape_functions; ++i)
350 third_derivative(
point, i) = grad3[renumber[i]];
352 if (shape_fourth_derivatives.size() != 0)
353 for (
unsigned int i = 0; i < n_shape_functions; ++i)
354 fourth_derivative(
point, i) = grad4[renumber[i]];
360 template <
int dim,
int spacedim>
383 ExcMessage(
"It only makes sense to create polynomial mappings "
384 "with a polynomial degree greater or equal to one."));
389 template <
int dim,
int spacedim>
391 : polynomial_degree(p)
392 , line_support_points(
396 , renumber_lexicographic_to_hierarchic(
398 , unit_cell_support_points(
401 renumber_lexicographic_to_hierarchic))
402 , support_point_weights_perimeter_to_interior(
405 this->polynomial_degree,
407 , support_point_weights_cell(
409 this->polynomial_degree))
412 ExcMessage(
"It only makes sense to create polynomial mappings "
413 "with a polynomial degree greater or equal to one."));
418 template <
int dim,
int spacedim>
420 : polynomial_degree(mapping.polynomial_degree)
421 , line_support_points(mapping.line_support_points)
422 , polynomials_1d(mapping.polynomials_1d)
423 , renumber_lexicographic_to_hierarchic(
424 mapping.renumber_lexicographic_to_hierarchic)
425 , support_point_weights_perimeter_to_interior(
426 mapping.support_point_weights_perimeter_to_interior)
427 , support_point_weights_cell(mapping.support_point_weights_cell)
432 template <
int dim,
int spacedim>
433 std::unique_ptr<Mapping<dim, spacedim>>
436 return std::make_unique<MappingQ<dim, spacedim>>(*this);
441 template <
int dim,
int spacedim>
445 return polynomial_degree;
450 template <
int dim,
int spacedim>
458 this->compute_mapping_support_points(cell),
460 polynomials_1d.size() == 2,
461 renumber_lexicographic_to_hierarchic)
485 template <
int dim,
int spacedim>
504 const Point<1> & initial_p_unit)
const
508 return internal::MappingQImplementation::
509 do_transform_real_to_unit_cell_internal<1>(
512 this->compute_mapping_support_points(cell),
514 renumber_lexicographic_to_hierarchic);
524 const Point<2> & initial_p_unit)
const
526 return internal::MappingQImplementation::
527 do_transform_real_to_unit_cell_internal<2>(
530 this->compute_mapping_support_points(cell),
532 renumber_lexicographic_to_hierarchic);
542 const Point<3> & initial_p_unit)
const
544 return internal::MappingQImplementation::
545 do_transform_real_to_unit_cell_internal<3>(
548 this->compute_mapping_support_points(cell),
550 renumber_lexicographic_to_hierarchic);
563 const int spacedim = 2;
570 auto mdata = Utilities::dynamic_unique_cast<InternalData>(
571 get_data(update_flags, point_quadrature));
573 mdata->mapping_support_points = this->compute_mapping_support_points(cell);
577 return internal::MappingQImplementation::
578 do_transform_real_to_unit_cell_internal_codim1<1>(cell,
591 const Point<2> & initial_p_unit)
const
594 const int spacedim = 3;
601 auto mdata = Utilities::dynamic_unique_cast<InternalData>(
602 get_data(update_flags, point_quadrature));
604 mdata->mapping_support_points = this->compute_mapping_support_points(cell);
608 return internal::MappingQImplementation::
609 do_transform_real_to_unit_cell_internal_codim1<2>(cell,
628 template <
int dim,
int spacedim>
636 if (this->preserves_vertex_locations() && (polynomial_degree == 1) &&
637 ((dim == 1) || ((dim == 2) && (dim == spacedim))))
660 const auto vertices_ = this->get_vertices(cell);
664 for (
unsigned int i = 0; i <
vertices.size(); ++i)
690 const double eps = 1
e-15;
723 if (this->preserves_vertex_locations())
725 initial_p_unit = cell->real_to_unit_cell_affine_approximation(p);
727 if (dim == 1 && polynomial_degree == 1)
728 return initial_p_unit;
733 for (
unsigned int d = 0;
d < dim; ++
d)
734 initial_p_unit[
d] = 0.5;
741 if (p_unit[0] == std::numeric_limits<double>::infinity())
749 template <
int dim,
int spacedim>
767 const std::vector<Point<spacedim>> support_points =
768 this->compute_mapping_support_points(cell);
773 inverse_approximation(support_points, unit_cell_support_points);
775 const unsigned int n_points = real_points.size();
780 for (
unsigned int i = 0; i < n_points; i += n_lanes)
781 if (n_points - i > 1)
784 for (
unsigned int j = 0; j < n_lanes; ++j)
785 if (i + j < n_points)
786 for (
unsigned int d = 0;
d < spacedim; ++
d)
787 p_vec[
d][j] = real_points[i + j][
d];
789 for (
unsigned int d = 0;
d < spacedim; ++
d)
790 p_vec[
d][j] = real_points[i][
d];
793 internal::MappingQImplementation::
794 do_transform_real_to_unit_cell_internal<dim, spacedim>(
796 inverse_approximation.compute(p_vec),
799 renumber_lexicographic_to_hierarchic);
806 for (
unsigned int j = 0; j < n_lanes && i + j < n_points; ++j)
807 if (unit_point[0][j] == std::numeric_limits<double>::infinity())
808 unit_points[i + j] = internal::MappingQImplementation::
809 do_transform_real_to_unit_cell_internal<dim, spacedim>(
811 inverse_approximation.compute(real_points[i + j]),
814 renumber_lexicographic_to_hierarchic);
816 for (
unsigned int d = 0;
d < dim; ++
d)
817 unit_points[i + j][
d] = unit_point[
d][j];
820 unit_points[i] = internal::MappingQImplementation::
821 do_transform_real_to_unit_cell_internal<dim, spacedim>(
823 inverse_approximation.compute(real_points[i]),
826 renumber_lexicographic_to_hierarchic);
831 template <
int dim,
int spacedim>
842 for (
unsigned int i = 0; i < 5; ++i)
887 template <
int dim,
int spacedim>
888 std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
892 std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
893 std::make_unique<InternalData>(polynomial_degree);
895 data.
initialize(this->requires_update_flags(update_flags), q, q.
size());
902 template <
int dim,
int spacedim>
903 std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
910 std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
911 std::make_unique<InternalData>(polynomial_degree);
915 ReferenceCells::get_hypercube<dim>(), quadrature[0]),
916 quadrature[0].size());
923 template <
int dim,
int spacedim>
924 std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
929 std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
930 std::make_unique<InternalData>(polynomial_degree);
934 ReferenceCells::get_hypercube<dim>(), quadrature),
942 template <
int dim,
int spacedim>
957 const unsigned int n_q_points = quadrature.
size();
977 (polynomial_degree == 1 && this->preserves_vertex_locations() ?
983 internal::MappingQImplementation::
984 maybe_update_q_points_Jacobians_and_grads_tensor<dim, spacedim>(
985 computed_cell_similarity,
992 internal::MappingQImplementation::maybe_compute_q_points<dim, spacedim>(
997 internal::MappingQImplementation::maybe_update_Jacobians<dim, spacedim>(
998 computed_cell_similarity,
1004 computed_cell_similarity,
1012 spacedim>(computed_cell_similarity,
1019 spacedim>(computed_cell_similarity,
1024 internal::MappingQImplementation::
1025 maybe_update_jacobian_pushed_forward_2nd_derivatives<dim, spacedim>(
1026 computed_cell_similarity,
1033 spacedim>(computed_cell_similarity,
1038 internal::MappingQImplementation::
1039 maybe_update_jacobian_pushed_forward_3rd_derivatives<dim, spacedim>(
1040 computed_cell_similarity,
1045 const UpdateFlags update_flags = data.update_each;
1046 const std::vector<double> &weights = quadrature.
get_weights();
1064 if (dim == spacedim)
1074 1
e-12 * Utilities::fixed_power<dim>(
1075 cell->diameter() / std::sqrt(
double(dim))),
1077 cell->center(), det,
point)));
1087 for (
unsigned int i = 0; i < spacedim; ++i)
1088 for (
unsigned int j = 0; j < dim; ++j)
1092 for (
unsigned int i = 0; i < dim; ++i)
1093 for (
unsigned int j = 0; j < dim; ++j)
1094 G[i][j] = DX_t[i] * DX_t[j];
1099 if (computed_cell_similarity ==
1110 Assert(spacedim == dim + 1,
1112 "There is no (unique) cell normal for " +
1114 "-dimensional cells in " +
1116 "-dimensional space. This only works if the "
1117 "space dimension is one greater than the "
1118 "dimensionality of the mesh cells."));
1122 cross_product_2d(-DX_t[0]);
1125 cross_product_3d(DX_t[0], DX_t[1]);
1130 if (cell->direction_flag() ==
false)
1159 return computed_cell_similarity;
1164 template <
int dim,
int spacedim>
1168 const unsigned int face_no,
1200 ReferenceCells::get_hypercube<dim>(),
1202 cell->face_orientation(face_no),
1203 cell->face_flip(face_no),
1204 cell->face_rotation(face_no),
1205 quadrature[0].
size()),
1213 template <
int dim,
int spacedim>
1217 const unsigned int face_no,
1218 const unsigned int subface_no,
1248 ReferenceCells::get_hypercube<dim>(),
1251 cell->face_orientation(face_no),
1252 cell->face_flip(face_no),
1253 cell->face_rotation(face_no),
1255 cell->subface_case(face_no)),
1263 template <
int dim,
int spacedim>
1279 const unsigned int n_q_points = quadrature.
size();
1284 internal::MappingQImplementation::maybe_compute_q_points<dim, spacedim>(
1289 internal::MappingQImplementation::maybe_update_Jacobians<dim, spacedim>(
1292 internal::MappingQImplementation::maybe_update_jacobian_grads<dim, spacedim>(
1312 internal::MappingQImplementation::
1313 maybe_update_jacobian_pushed_forward_2nd_derivatives<dim, spacedim>(
1326 internal::MappingQImplementation::
1327 maybe_update_jacobian_pushed_forward_3rd_derivatives<dim, spacedim>(
1333 const UpdateFlags update_flags = data.update_each;
1334 const std::vector<double> &weights = quadrature.
get_weights();
1355 Assert(det > 1
e-12 * Utilities::fixed_power<dim>(
1356 cell->diameter() / std::sqrt(
double(dim))),
1358 cell->center(), det,
point)));
1362 for (
unsigned int d = 0;
d < spacedim;
d++)
1370 normal /= normal.
norm();
1396 template <
int dim,
int spacedim>
1413 output_data.
initialize(unit_points.size(), update_flags);
1414 const std::vector<Point<spacedim>> support_points =
1415 this->compute_mapping_support_points(cell);
1417 const unsigned int n_points = unit_points.size();
1422 for (
unsigned int i = 0; i < n_points; i += n_lanes)
1423 if (n_points - i > 1)
1426 for (
unsigned int j = 0; j < n_lanes; ++j)
1427 if (i + j < n_points)
1428 for (
unsigned int d = 0;
d < dim; ++
d)
1429 p_vec[
d][j] = unit_points[i + j][
d];
1431 for (
unsigned int d = 0;
d < dim; ++
d)
1432 p_vec[
d][j] = unit_points[i][
d];
1439 polynomial_degree == 1,
1440 renumber_lexicographic_to_hierarchic);
1443 for (
unsigned int j = 0; j < n_lanes && i + j < n_points; ++j)
1444 for (
unsigned int d = 0;
d < spacedim; ++
d)
1448 for (
unsigned int j = 0; j < n_lanes && i + j < n_points; ++j)
1449 for (
unsigned int d = 0;
d < spacedim; ++
d)
1450 for (
unsigned int e = 0;
e < dim; ++
e)
1451 output_data.
jacobians[i + j][
d][
e] = result.second[
e][
d][j];
1459 for (
unsigned int j = 0; j < n_lanes && i + j < n_points; ++j)
1460 for (
unsigned int d = 0;
d < dim; ++
d)
1461 for (
unsigned int e = 0;
e < spacedim; ++
e)
1472 polynomial_degree == 1,
1473 renumber_lexicographic_to_hierarchic);
1488 for (
unsigned int d = 0;
d < dim; ++
d)
1489 for (
unsigned int e = 0;
e < spacedim; ++
e)
1497 template <
int dim,
int spacedim>
1513 template <
int dim,
int spacedim>
1529 template <
int dim,
int spacedim>
1537 switch (mapping_kind)
1561 template <
int dim,
int spacedim>
1574 switch (mapping_kind)
1580 "update_covariant_transformation"));
1582 for (
unsigned int q = 0; q < output.
size(); ++q)
1583 for (
unsigned int i = 0; i < spacedim; ++i)
1584 for (
unsigned int j = 0; j < spacedim; ++j)
1587 for (
unsigned int K = 0;
K < dim; ++
K)
1589 tmp[
K] = data.
covariant[q][j][0] * input[q][i][0][
K];
1590 for (
unsigned int J = 1; J < dim; ++J)
1591 tmp[
K] += data.
covariant[q][j][J] * input[q][i][J][
K];
1593 for (
unsigned int k = 0; k < spacedim; ++k)
1595 output[q][i][j][k] = data.
covariant[q][k][0] * tmp[0];
1596 for (
unsigned int K = 1;
K < dim; ++
K)
1597 output[q][i][j][k] += data.
covariant[q][k][
K] * tmp[
K];
1610 template <
int dim,
int spacedim>
1618 switch (mapping_kind)
1635 template <
int dim,
int spacedim>
1642 if (this->polynomial_degree == 2)
1644 for (
unsigned int line_no = 0;
1645 line_no < GeometryInfo<dim>::lines_per_cell;
1652 cell->line(line_no));
1666 std::vector<Point<spacedim>> tmp_points;
1667 for (
unsigned int line_no = 0;
1668 line_no < GeometryInfo<dim>::lines_per_cell;
1675 cell->line(line_no));
1683 const auto reference_cell = ReferenceCells::get_hypercube<dim>();
1684 const std::array<Point<spacedim>, 2>
vertices{
1686 cell->vertex(
reference_cell.line_to_cell_vertices(line_no, 1))}};
1688 const std::size_t n_rows =
1689 support_point_weights_perimeter_to_interior[0].size(0);
1690 a.resize(a.size() + n_rows);
1694 support_point_weights_perimeter_to_interior[0],
1711 std::vector<Point<3>> tmp_points;
1714 for (
unsigned int face_no = 0; face_no < faces_per_cell; ++face_no)
1719 const bool face_orientation = cell->face_orientation(face_no),
1720 face_flip = cell->face_flip(face_no),
1721 face_rotation = cell->face_rotation(face_no);
1726 for (
unsigned int i = 0; i < vertices_per_face; ++i)
1727 Assert(face->vertex_index(i) ==
1729 face_no, i, face_orientation, face_flip, face_rotation)),
1734 for (
unsigned int i = 0; i < lines_per_face; ++i)
1737 face_no, i, face_orientation, face_flip, face_rotation)),
1743 boost::container::small_vector<Point<3>, 200> tmp_points(
1748 if (polynomial_degree > 1)
1749 for (
unsigned int line = 0; line < GeometryInfo<2>::lines_per_cell;
1751 for (
unsigned int i = 0; i < polynomial_degree - 1; ++i)
1752 tmp_points[4 + line * (polynomial_degree - 1) + i] =
1754 (polynomial_degree - 1) *
1758 const std::size_t n_rows =
1759 support_point_weights_perimeter_to_interior[1].size(0);
1760 a.resize(a.size() + n_rows);
1762 face->get_manifold().get_new_points(
1764 support_point_weights_perimeter_to_interior[1],
1783 for (
unsigned int q = 0, q2 = 0; q2 < polynomial_degree - 1; ++q2)
1784 for (
unsigned int q1 = 0; q1 < polynomial_degree - 1; ++q1, ++q)
1787 line_support_points[q2 + 1][0]);
1792 const std::size_t n_rows = weights.size(0);
1793 a.resize(a.size() + n_rows);
1795 cell->get_manifold().get_new_points(
1801 template <
int dim,
int spacedim>
1812 template <
int dim,
int spacedim>
1813 std::vector<Point<spacedim>>
1818 std::vector<Point<spacedim>> a;
1819 a.reserve(Utilities::fixed_power<dim>(polynomial_degree + 1));
1821 a.push_back(cell->vertex(i));
1823 if (this->polynomial_degree > 1)
1830 bool all_manifold_ids_are_equal = (dim == spacedim);
1831 if (all_manifold_ids_are_equal &&
1837 all_manifold_ids_are_equal =
false;
1840 for (
unsigned int l = 0; l < GeometryInfo<dim>::lines_per_cell; ++
l)
1842 all_manifold_ids_are_equal =
false;
1845 if (all_manifold_ids_are_equal)
1847 const std::size_t n_rows = support_point_weights_cell.size(0);
1848 a.resize(a.size() + n_rows);
1852 support_point_weights_cell,
1859 add_line_support_points(cell, a);
1864 add_line_support_points(cell, a);
1867 if (dim != spacedim)
1868 add_quad_support_points(cell, a);
1871 const std::size_t n_rows =
1872 support_point_weights_perimeter_to_interior[1].size(0);
1873 a.resize(a.size() + n_rows);
1877 support_point_weights_perimeter_to_interior[1],
1884 add_line_support_points(cell, a);
1885 add_quad_support_points(cell, a);
1889 const std::size_t n_rows =
1890 support_point_weights_perimeter_to_interior[2].size(0);
1891 a.resize(a.size() + n_rows);
1895 support_point_weights_perimeter_to_interior[2],
1911 template <
int dim,
int spacedim>
1921 template <
int dim,
int spacedim>
1927 ExcMessage(
"The dimension of your mapping (" +
1929 ") and the reference cell cell_type (" +
1931 " ) do not agree."));
1939 #include "mapping_q.inst"
ArrayView< typename std::remove_reference< typename std::iterator_traits< Iterator >::reference >::type, MemorySpaceType > make_array_view(const Iterator begin, const Iterator end)
virtual void get_new_points(const ArrayView< const Point< spacedim >> &surrounding_points, const Table< 2, double > &weights, ArrayView< Point< spacedim >> new_points) const
virtual Point< spacedim > get_new_point_on_line(const typename Triangulation< dim, spacedim >::line_iterator &line) const
Triangulation< dim, spacedim >::cell_iterator cell_of_current_support_points
AlignedVector< DerivativeForm< 1, dim, spacedim > > covariant
virtual std::size_t memory_consumption() const override
std::vector< Point< spacedim > > mapping_support_points
AlignedVector< DerivativeForm< 1, dim, spacedim > > contravariant
bool tensor_product_quadrature
void initialize_face(const UpdateFlags update_flags, const Quadrature< dim > &quadrature, const unsigned int n_original_q_points)
InternalData(const unsigned int polynomial_degree)
void compute_shape_function_values(const std::vector< Point< dim >> &unit_points)
void initialize(const UpdateFlags update_flags, const Quadrature< dim > &quadrature, const unsigned int n_original_q_points)
virtual void add_line_support_points(const typename Triangulation< dim, spacedim >::cell_iterator &cell, std::vector< Point< spacedim >> &a) const
const std::vector< unsigned int > renumber_lexicographic_to_hierarchic
const Table< 2, double > support_point_weights_cell
virtual std::vector< Point< spacedim > > compute_mapping_support_points(const typename Triangulation< dim, spacedim >::cell_iterator &cell) const
virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > get_data(const UpdateFlags, const Quadrature< dim > &quadrature) const override
void fill_mapping_data_for_generic_points(const typename Triangulation< dim, spacedim >::cell_iterator &cell, const ArrayView< const Point< dim >> &unit_points, const UpdateFlags update_flags, internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data) const
virtual BoundingBox< spacedim > get_bounding_box(const typename Triangulation< dim, spacedim >::cell_iterator &cell) const override
virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > get_subface_data(const UpdateFlags flags, const Quadrature< dim - 1 > &quadrature) const override
virtual void fill_fe_subface_values(const typename Triangulation< dim, spacedim >::cell_iterator &cell, const unsigned int face_no, const unsigned int subface_no, const Quadrature< dim - 1 > &quadrature, const typename Mapping< dim, spacedim >::InternalDataBase &internal_data, internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data) const override
virtual CellSimilarity::Similarity fill_fe_values(const typename Triangulation< dim, spacedim >::cell_iterator &cell, const CellSimilarity::Similarity cell_similarity, const Quadrature< dim > &quadrature, const typename Mapping< dim, spacedim >::InternalDataBase &internal_data, internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data) const override
virtual void fill_fe_immersed_surface_values(const typename Triangulation< dim, spacedim >::cell_iterator &cell, const NonMatching::ImmersedSurfaceQuadrature< dim > &quadrature, const typename Mapping< dim, spacedim >::InternalDataBase &internal_data, internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data) const override
const unsigned int polynomial_degree
virtual void transform(const ArrayView< const Tensor< 1, dim >> &input, const MappingKind kind, const typename Mapping< dim, spacedim >::InternalDataBase &internal, const ArrayView< Tensor< 1, spacedim >> &output) const override
virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > get_face_data(const UpdateFlags flags, const hp::QCollection< dim - 1 > &quadrature) const override
Point< dim > transform_real_to_unit_cell_internal(const typename Triangulation< dim, spacedim >::cell_iterator &cell, const Point< spacedim > &p, const Point< dim > &initial_p_unit) const
const std::vector< Table< 2, double > > support_point_weights_perimeter_to_interior
const std::vector< Point< 1 > > line_support_points
virtual Point< spacedim > transform_unit_to_real_cell(const typename Triangulation< dim, spacedim >::cell_iterator &cell, const Point< dim > &p) const override
const std::vector< Polynomials::Polynomial< double > > polynomials_1d
virtual std::unique_ptr< Mapping< dim, spacedim > > clone() const override
const std::vector< Point< dim > > unit_cell_support_points
virtual void transform_points_real_to_unit_cell(const typename Triangulation< dim, spacedim >::cell_iterator &cell, const ArrayView< const Point< spacedim >> &real_points, const ArrayView< Point< dim >> &unit_points) const override
virtual Point< dim > transform_real_to_unit_cell(const typename Triangulation< dim, spacedim >::cell_iterator &cell, const Point< spacedim > &p) const override
MappingQ(const unsigned int polynomial_degree)
virtual UpdateFlags requires_update_flags(const UpdateFlags update_flags) const override
virtual void fill_fe_face_values(const typename Triangulation< dim, spacedim >::cell_iterator &cell, const unsigned int face_no, const hp::QCollection< dim - 1 > &quadrature, const typename Mapping< dim, spacedim >::InternalDataBase &internal_data, internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data) const override
virtual bool is_compatible_with(const ReferenceCell &reference_cell) const override
virtual void add_quad_support_points(const typename Triangulation< dim, spacedim >::cell_iterator &cell, std::vector< Point< spacedim >> &a) const
unsigned int get_degree() const
Abstract base class for mapping classes.
virtual void transform_points_real_to_unit_cell(const typename Triangulation< dim, spacedim >::cell_iterator &cell, const ArrayView< const Point< spacedim >> &real_points, const ArrayView< Point< dim >> &unit_points) const
const Tensor< 1, spacedim > & normal_vector(const unsigned int i) const
static DataSetDescriptor cell()
const std::vector< Point< dim > > & get_points() const
bool is_tensor_product() const
const std::vector< double > & get_weights() const
const std::array< Quadrature< 1 >, dim > & get_tensor_basis() const
unsigned int size() const
constexpr DEAL_II_HOST Number determinant(const SymmetricTensor< 2, dim, Number > &)
void evaluate(const Point< dim > &unit_point, std::vector< double > &values, std::vector< Tensor< 1, dim >> &grads, std::vector< Tensor< 2, dim >> &grad_grads, std::vector< Tensor< 3, dim >> &third_derivatives, std::vector< Tensor< 4, dim >> &fourth_derivatives) const override
numbers::NumberTraits< Number >::real_type norm() const
Triangulation< dim, spacedim > & get_triangulation()
static constexpr std::size_t size()
unsigned int size() const
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_CLOSE
static ::ExceptionBase & ExcInternalError()
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
#define Assert(cond, exc)
static ::ExceptionBase & ExcNotImplemented()
static ::ExceptionBase & ExcImpossibleInDim(int arg1)
#define AssertDimension(dim1, dim2)
static ::ExceptionBase & ExcMessage(std::string arg1)
#define AssertThrow(cond, exc)
@ update_jacobian_pushed_forward_2nd_derivatives
@ update_volume_elements
Determinant of the Jacobian.
@ update_contravariant_transformation
Contravariant transformation.
@ update_jacobian_pushed_forward_grads
@ update_jacobian_3rd_derivatives
@ update_jacobian_grads
Gradient of volume element.
@ update_normal_vectors
Normal vectors.
@ update_JxW_values
Transformed quadrature weights.
@ update_covariant_transformation
Covariant transformation.
@ update_jacobians
Volume element.
@ update_inverse_jacobians
Volume element.
@ update_quadrature_points
Transformed quadrature points.
@ update_default
No update.
@ update_jacobian_pushed_forward_3rd_derivatives
@ update_boundary_forms
Outer normal vector, not normalized.
@ update_jacobian_2nd_derivatives
const Manifold< dim, spacedim > & get_manifold(const types::manifold_id number) const
@ mapping_covariant_gradient
@ mapping_contravariant_hessian
@ mapping_covariant_hessian
@ mapping_contravariant_gradient
CGAL::Exact_predicates_exact_constructions_kernel_with_sqrt K
void reference_cell(Triangulation< dim, spacedim > &tria, const ReferenceCell &reference_cell)
std::enable_if_t< std::is_fundamental< T >::value, std::size_t > memory_consumption(const T &t)
Point< spacedim > point(const gp_Pnt &p, const double tolerance=1e-10)
SymmetricTensor< 2, dim, Number > d(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
SymmetricTensor< 2, dim, Number > e(const Tensor< 2, dim, Number > &F)
Tensor< 2, dim, Number > l(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
std::vector< Polynomial< double > > generate_complete_Lagrange_basis(const std::vector< Point< 1 >> &points)
VectorType::value_type * begin(VectorType &V)
VectorType::value_type * end(VectorType &V)
constexpr T pow(const T base, const int iexp)
std::string to_string(const number value, const unsigned int digits=numbers::invalid_unsigned_int)
std::string int_to_string(const unsigned int value, const unsigned int digits=numbers::invalid_unsigned_int)
Point< 1 > transform_real_to_unit_cell(const std::array< Point< spacedim >, GeometryInfo< 1 >::vertices_per_cell > &vertices, const Point< spacedim > &p)
void transform_gradients(const ArrayView< const Tensor< rank, dim >> &input, const MappingKind mapping_kind, const typename Mapping< dim, spacedim >::InternalDataBase &mapping_data, const ArrayView< Tensor< rank, spacedim >> &output)
std::vector< Point< dim > > unit_support_points(const std::vector< Point< 1 >> &line_support_points, const std::vector< unsigned int > &renumbering)
void transform_differential_forms(const ArrayView< const DerivativeForm< rank, dim, spacedim >> &input, const MappingKind mapping_kind, const typename Mapping< dim, spacedim >::InternalDataBase &mapping_data, const ArrayView< Tensor< rank+1, spacedim >> &output)
void do_fill_fe_face_values(const ::MappingQ< dim, spacedim > &mapping, const typename ::Triangulation< dim, spacedim >::cell_iterator &cell, const unsigned int face_no, const unsigned int subface_no, const typename QProjector< dim >::DataSetDescriptor data_set, const Quadrature< dim - 1 > &quadrature, const typename ::MappingQ< dim, spacedim >::InternalData &data, internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data)
void maybe_update_jacobian_grads(const CellSimilarity::Similarity cell_similarity, const typename QProjector< dim >::DataSetDescriptor data_set, const typename ::MappingQ< dim, spacedim >::InternalData &data, std::vector< DerivativeForm< 2, dim, spacedim >> &jacobian_grads)
void maybe_update_jacobian_3rd_derivatives(const CellSimilarity::Similarity cell_similarity, const typename QProjector< dim >::DataSetDescriptor data_set, const typename ::MappingQ< dim, spacedim >::InternalData &data, std::vector< DerivativeForm< 4, dim, spacedim >> &jacobian_3rd_derivatives)
inline ::Table< 2, double > compute_support_point_weights_cell(const unsigned int polynomial_degree)
std::vector<::Table< 2, double > > compute_support_point_weights_perimeter_to_interior(const unsigned int polynomial_degree, const unsigned int dim)
void maybe_update_jacobian_pushed_forward_grads(const CellSimilarity::Similarity cell_similarity, const typename QProjector< dim >::DataSetDescriptor data_set, const typename ::MappingQ< dim, spacedim >::InternalData &data, std::vector< Tensor< 3, spacedim >> &jacobian_pushed_forward_grads)
void transform_hessians(const ArrayView< const Tensor< 3, dim >> &input, const MappingKind mapping_kind, const typename Mapping< dim, spacedim >::InternalDataBase &mapping_data, const ArrayView< Tensor< 3, spacedim >> &output)
void transform_fields(const ArrayView< const Tensor< rank, dim >> &input, const MappingKind mapping_kind, const typename Mapping< dim, spacedim >::InternalDataBase &mapping_data, const ArrayView< Tensor< rank, spacedim >> &output)
void maybe_update_jacobian_2nd_derivatives(const CellSimilarity::Similarity cell_similarity, const typename QProjector< dim >::DataSetDescriptor data_set, const typename ::MappingQ< dim, spacedim >::InternalData &data, std::vector< DerivativeForm< 3, dim, spacedim >> &jacobian_2nd_derivatives)
std::pair< typename ProductTypeNoPoint< Number, Number2 >::type, Tensor< 1, dim, typename ProductTypeNoPoint< Number, Number2 >::type > > evaluate_tensor_product_value_and_gradient(const std::vector< Polynomials::Polynomial< double >> &poly, const std::vector< Number > &values, const Point< dim, Number2 > &p, const bool d_linear=false, const std::vector< unsigned int > &renumber={})
static const unsigned int invalid_unsigned_int
const types::manifold_id flat_manifold_id
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)
static double d_linear_shape_function(const Point< dim > &xi, const unsigned int i)