17 #include <deal.II/base/array_view.h> 18 #include <deal.II/base/derivative_form.h> 19 #include <deal.II/base/memory_consumption.h> 20 #include <deal.II/base/qprojector.h> 21 #include <deal.II/base/quadrature.h> 22 #include <deal.II/base/quadrature_lib.h> 23 #include <deal.II/base/std_cxx14/memory.h> 24 #include <deal.II/base/table.h> 25 #include <deal.II/base/tensor_product_polynomials.h> 27 #include <deal.II/dofs/dof_accessor.h> 29 #include <deal.II/fe/fe.h> 30 #include <deal.II/fe/fe_tools.h> 31 #include <deal.II/fe/fe_values.h> 32 #include <deal.II/fe/mapping_q1.h> 33 #include <deal.II/fe/mapping_q_generic.h> 35 #include <deal.II/grid/manifold_lib.h> 36 #include <deal.II/grid/tria.h> 37 #include <deal.II/grid/tria_iterator.h> 39 #include <deal.II/lac/full_matrix.h> 40 #include <deal.II/lac/tensor_product_matrix.h> 42 #include <deal.II/matrix_free/evaluation_kernels.h> 43 #include <deal.II/matrix_free/evaluation_selector.h> 44 #include <deal.II/matrix_free/shape_info.h> 45 #include <deal.II/matrix_free/tensor_product_kernels.h> 54 DEAL_II_NAMESPACE_OPEN
59 namespace MappingQGenericImplementation
64 std::vector<unsigned int>
65 get_dpo_vector(
const unsigned int degree)
67 std::vector<unsigned int> dpo(dim + 1, 1U);
68 for (
unsigned int i = 1; i < dpo.size(); ++i)
69 dpo[i] = dpo[i - 1] * (degree - 1);
84 template <
int spacedim>
86 transform_real_to_unit_cell(
92 return Point<1>((p[0] - vertices[0](0)) /
93 (vertices[1](0) - vertices[0](0)));
98 template <
int spacedim>
100 transform_real_to_unit_cell(
110 const long double x = p(0);
111 const long double y = p(1);
113 const long double x0 = vertices[0](0);
114 const long double x1 = vertices[1](0);
115 const long double x2 = vertices[2](0);
116 const long double x3 = vertices[3](0);
118 const long double y0 = vertices[0](1);
119 const long double y1 = vertices[1](1);
120 const long double y2 = vertices[2](1);
121 const long double y3 = vertices[3](1);
123 const long double a = (x1 - x3) * (y0 - y2) - (x0 - x2) * (y1 - y3);
124 const long double b = -(x0 - x1 - x2 + x3) * y +
125 (x - 2 * x1 + x3) * y0 - (x - 2 * x0 + x2) * y1 -
126 (x - x1) * y2 + (x - x0) * y3;
127 const long double c = (x0 - x1) * y - (x - x1) * y0 + (x - x0) * y1;
129 const long double discriminant = b * b - 4 * a * c;
138 const long double sqrt_discriminant = std::sqrt(discriminant);
141 if (b != 0.0 && std::abs(b) == sqrt_discriminant)
148 else if (std::abs(a) < 1e-8 * std::abs(b))
152 eta1 = 2 * c / (-b - sqrt_discriminant);
153 eta2 = 2 * c / (-b + sqrt_discriminant);
158 eta1 = (-b - sqrt_discriminant) / (2 * a);
159 eta2 = (-b + sqrt_discriminant) / (2 * a);
162 const long double eta =
163 (std::abs(eta1 - 0.5) < std::abs(eta2 - 0.5)) ? eta1 : eta2;
169 const long double subexpr0 = -eta * x2 + x0 * (eta - 1);
170 const long double xi_denominator0 =
171 eta * x3 - x1 * (eta - 1) + subexpr0;
172 const long double max_x =
173 std::max(std::max(std::abs(x0), std::abs(x1)),
174 std::max(std::abs(x2), std::abs(x3)));
176 if (std::abs(xi_denominator0) > 1e-10 * max_x)
178 const double xi = (x + subexpr0) / xi_denominator0;
183 const long double max_y =
184 std::max(std::max(std::abs(y0), std::abs(y1)),
185 std::max(std::abs(y2), std::abs(y3)));
186 const long double subexpr1 = -eta * y2 + y0 * (eta - 1);
187 const long double xi_denominator1 =
188 eta * y3 - y1 * (eta - 1) + subexpr1;
189 if (std::abs(xi_denominator1) > 1
e-10 * max_y)
191 const double xi = (subexpr1 + y) / xi_denominator1;
199 spacedim>::ExcTransformationFailed()));
205 return Point<2>(std::numeric_limits<double>::quiet_NaN(),
206 std::numeric_limits<double>::quiet_NaN());
211 template <
int spacedim>
213 transform_real_to_unit_cell(
225 template <
int dim,
int spacedim>
227 compute_shape_function_values_general(
228 const unsigned int n_shape_functions,
230 typename ::MappingQGeneric<dim, spacedim>::InternalData &data)
232 const unsigned int n_points = unit_points.size();
238 data.line_support_points.get_points()));
243 const std::vector<unsigned int> renumber(
245 internal::MappingQGenericImplementation::get_dpo_vector<dim>(
246 data.polynomial_degree),
248 data.polynomial_degree)));
250 std::vector<double> values;
251 std::vector<Tensor<1, dim>> grads;
252 if (data.shape_values.size() != 0)
254 Assert(data.shape_values.size() == n_shape_functions * n_points,
256 values.resize(n_shape_functions);
258 if (data.shape_derivatives.size() != 0)
260 Assert(data.shape_derivatives.size() ==
261 n_shape_functions * n_points,
263 grads.resize(n_shape_functions);
266 std::vector<Tensor<2, dim>> grad2;
267 if (data.shape_second_derivatives.size() != 0)
269 Assert(data.shape_second_derivatives.size() ==
270 n_shape_functions * n_points,
272 grad2.resize(n_shape_functions);
275 std::vector<Tensor<3, dim>> grad3;
276 if (data.shape_third_derivatives.size() != 0)
278 Assert(data.shape_third_derivatives.size() ==
279 n_shape_functions * n_points,
281 grad3.resize(n_shape_functions);
284 std::vector<Tensor<4, dim>> grad4;
285 if (data.shape_fourth_derivatives.size() != 0)
287 Assert(data.shape_fourth_derivatives.size() ==
288 n_shape_functions * n_points,
290 grad4.resize(n_shape_functions);
294 if (data.shape_values.size() != 0 ||
295 data.shape_derivatives.size() != 0 ||
296 data.shape_second_derivatives.size() != 0 ||
297 data.shape_third_derivatives.size() != 0 ||
298 data.shape_fourth_derivatives.size() != 0)
299 for (
unsigned int point = 0;
point < n_points; ++
point)
302 unit_points[point], values, grads, grad2, grad3, grad4);
304 if (data.shape_values.size() != 0)
305 for (
unsigned int i = 0; i < n_shape_functions; ++i)
306 data.shape(point, renumber[i]) = values[i];
308 if (data.shape_derivatives.size() != 0)
309 for (
unsigned int i = 0; i < n_shape_functions; ++i)
310 data.derivative(point, renumber[i]) = grads[i];
312 if (data.shape_second_derivatives.size() != 0)
313 for (
unsigned int i = 0; i < n_shape_functions; ++i)
314 data.second_derivative(point, renumber[i]) = grad2[i];
316 if (data.shape_third_derivatives.size() != 0)
317 for (
unsigned int i = 0; i < n_shape_functions; ++i)
318 data.third_derivative(point, renumber[i]) = grad3[i];
320 if (data.shape_fourth_derivatives.size() != 0)
321 for (
unsigned int i = 0; i < n_shape_functions; ++i)
322 data.fourth_derivative(point, renumber[i]) = grad4[i];
328 compute_shape_function_values_hardcode(
329 const unsigned int n_shape_functions,
330 const std::vector<
Point<1>> & unit_points,
333 (void)n_shape_functions;
334 const unsigned int n_points = unit_points.size();
335 for (
unsigned int k = 0; k < n_points; ++k)
337 double x = unit_points[k](0);
343 data.
shape(k, 0) = 1. - x;
344 data.
shape(k, 1) = x;
349 n_shape_functions * n_points,
357 n_shape_functions * n_points,
365 n_shape_functions * n_points,
375 n_shape_functions * n_points,
387 compute_shape_function_values_hardcode(
388 const unsigned int n_shape_functions,
389 const std::vector<
Point<2>> & unit_points,
392 (void)n_shape_functions;
393 const unsigned int n_points = unit_points.size();
394 for (
unsigned int k = 0; k < n_points; ++k)
396 double x = unit_points[k](0);
397 double y = unit_points[k](1);
403 data.
shape(k, 0) = (1. - x) * (1. - y);
404 data.
shape(k, 1) = x * (1. - y);
405 data.
shape(k, 2) = (1. - x) * y;
406 data.
shape(k, 3) = x * y;
411 n_shape_functions * n_points,
425 n_shape_functions * n_points,
447 n_shape_functions * n_points,
451 for (
unsigned int i = 0; i < 4; ++i)
457 n_shape_functions * n_points,
460 for (
unsigned int i = 0; i < 4; ++i)
469 compute_shape_function_values_hardcode(
470 const unsigned int n_shape_functions,
471 const std::vector<
Point<3>> & unit_points,
474 (void)n_shape_functions;
475 const unsigned int n_points = unit_points.size();
476 for (
unsigned int k = 0; k < n_points; ++k)
478 double x = unit_points[k](0);
479 double y = unit_points[k](1);
480 double z = unit_points[k](2);
486 data.
shape(k, 0) = (1. - x) * (1. - y) * (1. - z);
487 data.
shape(k, 1) = x * (1. - y) * (1. - z);
488 data.
shape(k, 2) = (1. - x) * y * (1. - z);
489 data.
shape(k, 3) = x * y * (1. - z);
490 data.
shape(k, 4) = (1. - x) * (1. - y) * z;
491 data.
shape(k, 5) = x * (1. - y) * z;
492 data.
shape(k, 6) = (1. - x) * y * z;
493 data.
shape(k, 7) = x * y * z;
498 n_shape_functions * n_points,
500 data.
derivative(k, 0)[0] = (y - 1.) * (1. - z);
501 data.
derivative(k, 1)[0] = (1. - y) * (1. - z);
508 data.
derivative(k, 0)[1] = (x - 1.) * (1. - z);
510 data.
derivative(k, 2)[1] = (1. - x) * (1. - z);
516 data.
derivative(k, 0)[2] = (x - 1) * (1. - y);
520 data.
derivative(k, 4)[2] = (1. - x) * (1. - y);
528 n_shape_functions * n_points,
609 n_shape_functions * n_points,
612 for (
unsigned int i = 0; i < 3; ++i)
613 for (
unsigned int j = 0; j < 3; ++j)
614 for (
unsigned int l = 0;
l < 3; ++
l)
615 if ((i == j) || (j ==
l) || (l == i))
617 for (
unsigned int m = 0; m < 8; ++m)
635 n_shape_functions * n_points,
638 for (
unsigned int i = 0; i < 8; ++i)
649 template <
int dim,
int spacedim>
651 const unsigned int polynomial_degree)
652 : polynomial_degree(polynomial_degree)
653 , n_shape_functions(
Utilities::fixed_power<dim>(polynomial_degree + 1))
654 , line_support_points(
QGaussLobatto<1>(polynomial_degree + 1))
655 , tensor_product_quadrature(false)
660 template <
int dim,
int spacedim>
680 template <
int dim,
int spacedim>
685 const unsigned int n_original_q_points)
691 const unsigned int n_q_points = q.
size();
729 const std::vector<Point<dim>> &ref_q_points = q.
get_points();
741 const std::array<Quadrature<1>, dim> quad_array =
745 if (quad_array[i - 1].size() != quad_array[i].size())
747 tensor_product_quadrature =
false;
752 const std::vector<Point<1>> &points_1 =
753 quad_array[i - 1].get_points();
754 const std::vector<Point<1>> &points_2 =
755 quad_array[i].get_points();
756 const std::vector<double> &weights_1 =
757 quad_array[i - 1].get_weights();
758 const std::vector<double> &weights_2 =
759 quad_array[i].get_weights();
760 for (
unsigned int j = 0; j < quad_array[i].size(); ++j)
762 if (std::abs(points_1[j][0] - points_2[j][0]) > 1.e-10 ||
763 std::abs(weights_1[j] - weights_2[j]) > 1.e-10)
765 tensor_product_quadrature =
false;
772 if (tensor_product_quadrature)
778 const unsigned int max_size =
779 std::max(n_q_points, n_shape_values);
780 const unsigned int vec_length =
782 const unsigned int n_comp = 1 + (spacedim - 1) / vec_length;
793 template <
int dim,
int spacedim>
798 const unsigned int n_original_q_points)
800 initialize(update_flags, q, n_original_q_points);
804 const unsigned int facedim = dim > 1 ? dim - 1 : 1;
809 const unsigned int n_q_points = q.
size();
810 const unsigned int max_size = std::max(n_q_points, n_shape_values);
812 const unsigned int n_comp = 1 + (spacedim - 1) / vec_length;
835 static const int tangential_orientation[4] = {-1, 1, 1, -1};
836 for (
unsigned int i = 0;
837 i < GeometryInfo<dim>::faces_per_cell;
841 tang[1 - i / 2] = tangential_orientation[i];
852 for (
unsigned int i = 0;
853 i < GeometryInfo<dim>::faces_per_cell;
858 const unsigned int nd =
866 tang1[(nd + 1) % dim] =
871 tang2[(nd + 2) % dim] = 1.;
902 const std::vector<
Point<1>> &unit_points)
907 internal::MappingQ1::compute_shape_function_values_hardcode(
908 n_shape_functions, unit_points, *
this);
912 internal::MappingQ1::compute_shape_function_values_general<1, 1>(
920 const std::vector<
Point<2>> &unit_points)
925 internal::MappingQ1::compute_shape_function_values_hardcode(
926 n_shape_functions, unit_points, *
this);
930 internal::MappingQ1::compute_shape_function_values_general<2, 2>(
938 const std::vector<
Point<3>> &unit_points)
943 internal::MappingQ1::compute_shape_function_values_hardcode(
944 n_shape_functions, unit_points, *
this);
948 internal::MappingQ1::compute_shape_function_values_general<3, 3>(
953 template <
int dim,
int spacedim>
960 internal::MappingQ1::compute_shape_function_values_general<dim, spacedim>(
967 namespace MappingQGenericImplementation
979 compute_support_point_weights_on_quad(
986 if (polynomial_degree == 1)
989 const unsigned int M = polynomial_degree - 1;
990 const unsigned int n_inner_2d = M * M;
991 const unsigned int n_outer_2d = 4 + 4 * M;
994 loqvs.
reinit(n_inner_2d, n_outer_2d);
996 for (
unsigned int i = 0; i < M; ++i)
997 for (
unsigned int j = 0; j < M; ++j)
1000 gl.
point((i + 1) * (polynomial_degree + 1) + (j + 1));
1001 const unsigned int index_table = i * M + j;
1002 for (
unsigned int v = 0; v < 4; ++v)
1003 loqvs(index_table, v) =
1005 loqvs(index_table, 4 + i) = 1. - p[0];
1006 loqvs(index_table, 4 + i + M) = p[0];
1007 loqvs(index_table, 4 + j + 2 * M) = 1. - p[1];
1008 loqvs(index_table, 4 + j + 3 * M) = p[1];
1013 for (
unsigned int unit_point = 0; unit_point < n_inner_2d; ++unit_point)
1014 Assert(std::fabs(std::accumulate(loqvs[unit_point].begin(),
1015 loqvs[unit_point].end(),
1017 1) < 1e-13 * polynomial_degree,
1032 compute_support_point_weights_on_hex(
const unsigned int polynomial_degree)
1038 if (polynomial_degree == 1)
1041 const unsigned int M = polynomial_degree - 1;
1043 const unsigned int n_inner = Utilities::fixed_power<3>(M);
1044 const unsigned int n_outer = 8 + 12 * M + 6 * M * M;
1047 lohvs.
reinit(n_inner, n_outer);
1049 for (
unsigned int i = 0; i < M; ++i)
1050 for (
unsigned int j = 0; j < M; ++j)
1051 for (
unsigned int k = 0; k < M; ++k)
1054 (j + 1) * (M + 2) + (k + 1));
1055 const unsigned int index_table = i * M * M + j * M + k;
1058 for (
unsigned int v = 0; v < 8; ++v)
1059 lohvs(index_table, v) =
1064 constexpr std::array<unsigned int, 4> line_coordinates_y(
1067 for (
unsigned int l = 0; l < 4; ++l)
1068 lohvs(index_table, 8 + line_coordinates_y[l] * M + j) =
1073 constexpr std::array<unsigned int, 4> line_coordinates_x(
1076 for (
unsigned int l = 0; l < 4; ++l)
1077 lohvs(index_table, 8 + line_coordinates_x[l] * M + k) =
1082 constexpr std::array<unsigned int, 4> line_coordinates_z(
1085 for (
unsigned int l = 0; l < 4; ++l)
1086 lohvs(index_table, 8 + line_coordinates_z[l] * M + i) =
1091 lohvs(index_table, 8 + 12 * M + 0 * M * M + i * M + j) =
1093 lohvs(index_table, 8 + 12 * M + 1 * M * M + i * M + j) = p[0];
1094 lohvs(index_table, 8 + 12 * M + 2 * M * M + k * M + i) =
1096 lohvs(index_table, 8 + 12 * M + 3 * M * M + k * M + i) = p[1];
1097 lohvs(index_table, 8 + 12 * M + 4 * M * M + j * M + k) =
1099 lohvs(index_table, 8 + 12 * M + 5 * M * M + j * M + k) = p[2];
1104 for (
unsigned int unit_point = 0; unit_point < n_inner; ++unit_point)
1105 Assert(std::fabs(std::accumulate(lohvs[unit_point].begin(),
1106 lohvs[unit_point].end(),
1108 1) < 1e-13 * polynomial_degree,
1120 std::vector<::Table<2, double>>
1121 compute_support_point_weights_perimeter_to_interior(
1122 const unsigned int polynomial_degree,
1123 const unsigned int dim)
1126 std::vector<::Table<2, double>> output(dim);
1127 if (polynomial_degree <= 1)
1132 output[0].reinit(polynomial_degree - 1,
1134 for (
unsigned int q = 0; q < polynomial_degree - 1; ++q)
1135 for (
unsigned int i = 0; i < GeometryInfo<1>::vertices_per_cell; ++i)
1141 output[1] = compute_support_point_weights_on_quad(polynomial_degree);
1144 output[2] = compute_support_point_weights_on_hex(polynomial_degree);
1154 compute_support_point_weights_cell(
const unsigned int polynomial_degree)
1157 if (polynomial_degree <= 1)
1158 return ::Table<2, double>();
1161 std::vector<unsigned int> h2l(quadrature.size());
1168 for (
unsigned int q = 0; q < output.size(0); ++q)
1169 for (
unsigned int i = 0; i < GeometryInfo<dim>::vertices_per_cell;
1187 template <
int dim,
int spacedim>
1189 compute_mapped_location_of_point(
1190 const typename ::MappingQGeneric<dim, spacedim>::InternalData
1194 data.mapping_support_points.size());
1198 for (
unsigned int i = 0; i < data.mapping_support_points.size(); ++i)
1199 p_real += data.mapping_support_points[i] * data.shape(0, i);
1211 do_transform_real_to_unit_cell_internal(
1212 const typename ::Triangulation<dim, dim>::cell_iterator &cell,
1215 typename ::MappingQGeneric<dim, dim>::InternalData &mdata)
1217 const unsigned int spacedim = dim;
1219 const unsigned int n_shapes = mdata.shape_values.size();
1224 std::vector<Point<spacedim>> &points = mdata.mapping_support_points;
1240 mdata.compute_shape_function_values(std::vector<
Point<dim>>(1, p_unit));
1243 compute_mapped_location_of_point<dim, spacedim>(mdata);
1247 if (f.norm_square() < 1e-24 * cell->diameter() * cell->diameter())
1283 const double eps = 1.e-11;
1284 const unsigned int newton_iteration_limit = 20;
1286 unsigned int newton_iteration = 0;
1287 double last_f_weighted_norm;
1290 #ifdef DEBUG_TRANSFORM_REAL_TO_UNIT_CELL 1291 std::cout <<
"Newton iteration " << newton_iteration << std::endl;
1296 for (
unsigned int k = 0; k < mdata.n_shape_functions; ++k)
1301 for (
unsigned int i = 0; i < spacedim; ++i)
1302 for (
unsigned int j = 0; j < dim; ++j)
1303 df[i][j] += point[i] * grad_transform[j];
1314 #ifdef DEBUG_TRANSFORM_REAL_TO_UNIT_CELL 1315 std::cout <<
" delta=" << delta << std::endl;
1319 double step_length = 1;
1327 for (
unsigned int i = 0; i < dim; ++i)
1328 p_unit_trial[i] -= step_length * delta[i];
1332 mdata.compute_shape_function_values(
1337 internal::MappingQGenericImplementation::
1338 compute_mapped_location_of_point<dim, spacedim>(mdata);
1341 #ifdef DEBUG_TRANSFORM_REAL_TO_UNIT_CELL 1342 std::cout <<
" step_length=" << step_length << std::endl
1343 <<
" ||f || =" << f.
norm() << std::endl
1344 <<
" ||f*|| =" << f_trial.norm() << std::endl
1346 << (df_inverse * f_trial).norm() << std::endl;
1356 if (f_trial.norm() < f.norm())
1358 p_real = p_real_trial;
1359 p_unit = p_unit_trial;
1363 else if (step_length > 0.05)
1374 if (newton_iteration > newton_iteration_limit)
1378 last_f_weighted_norm = (df_inverse * f).norm();
1380 while (last_f_weighted_norm > eps);
1392 do_transform_real_to_unit_cell_internal_codim1(
1393 const typename ::Triangulation<dim, dim + 1>::cell_iterator &cell,
1396 typename ::MappingQGeneric<dim, dim + 1>::InternalData &mdata)
1398 const unsigned int spacedim = dim + 1;
1400 const unsigned int n_shapes = mdata.shape_values.size();
1404 Assert(mdata.shape_second_derivatives.size() == n_shapes,
1407 std::vector<Point<spacedim>> &points = mdata.mapping_support_points;
1420 mdata.compute_shape_function_values(std::vector<
Point<dim>>(1, p_unit));
1422 for (
unsigned int k = 0; k < mdata.n_shape_functions; ++k)
1425 const Tensor<2, dim> & hessian_k = mdata.second_derivative(0, k);
1428 for (
unsigned int j = 0; j < dim; ++j)
1430 DF[j] += grad_phi_k[j] * point_k;
1431 for (
unsigned int l = 0; l < dim; ++l)
1432 D2F[j][l] += hessian_k[j][l] * point_k;
1437 p_minus_F -= compute_mapped_location_of_point<dim, spacedim>(mdata);
1440 for (
unsigned int j = 0; j < dim; ++j)
1441 f[j] = DF[j] * p_minus_F;
1443 for (
unsigned int j = 0; j < dim; ++j)
1445 f[j] = DF[j] * p_minus_F;
1446 for (
unsigned int l = 0; l < dim; ++l)
1447 df[j][l] = -DF[j] * DF[l] + D2F[j][l] * p_minus_F;
1451 const double eps = 1.e-12 * cell->diameter();
1452 const unsigned int loop_limit = 10;
1454 unsigned int loop = 0;
1456 while (f.
norm() > eps && loop++ < loop_limit)
1463 for (
unsigned int j = 0; j < dim; ++j)
1466 for (
unsigned int l = 0; l < dim; ++l)
1470 mdata.compute_shape_function_values(
1473 for (
unsigned int k = 0; k < mdata.n_shape_functions; ++k)
1479 for (
unsigned int j = 0; j < dim; ++j)
1481 DF[j] += grad_phi_k[j] * point_k;
1482 for (
unsigned int l = 0; l < dim; ++l)
1483 D2F[j][l] += hessian_k[j][l] * point_k;
1490 p_minus_F -= compute_mapped_location_of_point<dim, spacedim>(mdata);
1492 for (
unsigned int j = 0; j < dim; ++j)
1494 f[j] = DF[j] * p_minus_F;
1495 for (
unsigned int l = 0; l < dim; ++l)
1496 df[j][l] = -DF[j] * DF[l] + D2F[j][l] * p_minus_F;
1517 template <
int dim,
int spacedim>
1519 maybe_update_q_points_Jacobians_and_grads_tensor(
1521 const typename ::MappingQGeneric<dim, spacedim>::InternalData
1526 const UpdateFlags update_flags = data.update_each;
1528 const unsigned int n_shape_values = data.n_shape_functions;
1529 const unsigned int n_q_points = data.shape_info.n_q_points;
1530 const unsigned int vec_length =
1532 const unsigned int n_comp = 1 + (spacedim - 1) / vec_length;
1533 const unsigned int n_hessians = (dim * (dim + 1)) / 2;
1536 const bool evaluate_gradients =
1539 const bool evaluate_hessians =
1544 Assert(!evaluate_values || n_q_points == quadrature_points.size(),
1546 Assert(!evaluate_gradients || data.n_shape_functions > 0,
1548 Assert(!evaluate_gradients || n_q_points == data.contravariant.size(),
1550 Assert(!evaluate_hessians || n_q_points == jacobian_grads.size(),
1554 if (evaluate_values || evaluate_gradients || evaluate_hessians)
1556 data.values_dofs.resize(n_comp * n_shape_values);
1557 data.values_quad.resize(n_comp * n_q_points);
1558 data.gradients_quad.resize(n_comp * n_q_points * dim);
1560 if (evaluate_hessians)
1561 data.hessians_quad.resize(n_comp * n_q_points * n_hessians);
1563 const std::vector<unsigned int> &renumber_to_lexicographic =
1564 data.shape_info.lexicographic_numbering;
1565 for (
unsigned int i = 0; i < n_shape_values; ++i)
1566 for (
unsigned int d = 0; d < spacedim; ++d)
1568 const unsigned int in_comp = d % vec_length;
1569 const unsigned int out_comp = d / vec_length;
1570 data.values_dofs[out_comp * n_shape_values + i][in_comp] =
1572 .mapping_support_points[renumber_to_lexicographic[i]][d];
1577 evaluate(data.shape_info,
1578 data.values_dofs.begin(),
1579 data.values_quad.begin(),
1580 data.gradients_quad.begin(),
1581 data.hessians_quad.begin(),
1582 data.scratch.begin(),
1589 if (evaluate_values)
1591 for (
unsigned int out_comp = 0; out_comp < n_comp; ++out_comp)
1592 for (
unsigned int i = 0; i < n_q_points; ++i)
1593 for (
unsigned int in_comp = 0;
1594 in_comp < vec_length &&
1595 in_comp < spacedim - out_comp * vec_length;
1597 quadrature_points[i][out_comp * vec_length + in_comp] =
1598 data.values_quad[out_comp * n_q_points + i][in_comp];
1601 if (evaluate_gradients)
1603 std::fill(data.contravariant.begin(),
1604 data.contravariant.end(),
1607 for (
unsigned int out_comp = 0; out_comp < n_comp; ++out_comp)
1608 for (
unsigned int point = 0; point < n_q_points; ++point)
1609 for (
unsigned int j = 0; j < dim; ++j)
1610 for (
unsigned int in_comp = 0;
1611 in_comp < vec_length &&
1612 in_comp < spacedim - out_comp * vec_length;
1615 const unsigned int total_number = point * dim + j;
1616 const unsigned int new_comp = total_number / n_q_points;
1617 const unsigned int new_point = total_number % n_q_points;
1618 data.contravariant[new_point][out_comp * vec_length +
1619 in_comp][new_comp] =
1620 data.gradients_quad[(out_comp * n_q_points + point) *
1627 for (
unsigned int point = 0; point < n_q_points; ++point)
1628 data.covariant[point] =
1629 (data.contravariant[point]).covariant_form();
1633 for (
unsigned int point = 0; point < n_q_points; ++point)
1634 data.volume_elements[point] =
1635 data.contravariant[point].determinant();
1637 if (evaluate_hessians)
1639 constexpr
int desymmetrize_3d[6][2] = {
1640 {0, 0}, {1, 1}, {2, 2}, {0, 1}, {0, 2}, {1, 2}};
1641 constexpr
int desymmetrize_2d[3][2] = {{0, 0}, {1, 1}, {0, 1}};
1644 for (
unsigned int out_comp = 0; out_comp < n_comp; ++out_comp)
1645 for (
unsigned int point = 0; point < n_q_points; ++point)
1646 for (
unsigned int j = 0; j < n_hessians; ++j)
1647 for (
unsigned int in_comp = 0;
1648 in_comp < vec_length &&
1649 in_comp < spacedim - out_comp * vec_length;
1652 const unsigned int total_number = point * n_hessians + j;
1653 const unsigned int new_point = total_number % n_q_points;
1654 const unsigned int new_hessian_comp =
1655 total_number / n_q_points;
1656 const unsigned int new_hessian_comp_i =
1657 dim == 2 ? desymmetrize_2d[new_hessian_comp][0] :
1658 desymmetrize_3d[new_hessian_comp][0];
1659 const unsigned int new_hessian_comp_j =
1660 dim == 2 ? desymmetrize_2d[new_hessian_comp][1] :
1661 desymmetrize_3d[new_hessian_comp][1];
1662 const double value =
1663 data.hessians_quad[(out_comp * n_q_points + point) *
1666 jacobian_grads[new_point][out_comp * vec_length + in_comp]
1667 [new_hessian_comp_i][new_hessian_comp_j] =
1669 jacobian_grads[new_point][out_comp * vec_length + in_comp]
1670 [new_hessian_comp_j][new_hessian_comp_i] =
1683 template <
int dim,
int spacedim>
1685 maybe_compute_q_points(
1687 const typename ::MappingQGeneric<dim, spacedim>::InternalData
1691 const UpdateFlags update_flags = data.update_each;
1694 for (
unsigned int point = 0; point < quadrature_points.size();
1697 const double *
shape = &data.shape(point + data_set, 0);
1699 (shape[0] * data.mapping_support_points[0]);
1700 for (
unsigned int k = 1; k < data.n_shape_functions; ++k)
1701 for (
unsigned int i = 0; i < spacedim; ++i)
1702 result[i] += shape[k] * data.mapping_support_points[k][i];
1703 quadrature_points[point] = result;
1717 template <
int dim,
int spacedim>
1719 maybe_update_Jacobians(
1721 const typename ::QProjector<dim>::DataSetDescriptor data_set,
1722 const typename ::MappingQGeneric<dim, spacedim>::InternalData
1725 const UpdateFlags update_flags = data.update_each;
1733 const unsigned int n_q_points = data.contravariant.size();
1735 std::fill(data.contravariant.begin(),
1736 data.contravariant.end(),
1742 &data.mapping_support_points[0];
1744 for (
unsigned int point = 0; point < n_q_points; ++point)
1747 &data.derivative(point + data_set, 0);
1749 double result[spacedim][dim];
1753 for (
unsigned int i = 0; i < spacedim; ++i)
1754 for (
unsigned int j = 0; j < dim; ++j)
1755 result[i][j] = data_derv[0][j] * supp_pts[0][i];
1756 for (
unsigned int k = 1; k < data.n_shape_functions; ++k)
1757 for (
unsigned int i = 0; i < spacedim; ++i)
1758 for (
unsigned int j = 0; j < dim; ++j)
1759 result[i][j] += data_derv[k][j] * supp_pts[k][i];
1766 for (
unsigned int i = 0; i < spacedim; ++i)
1767 for (
unsigned int j = 0; j < dim; ++j)
1768 data.contravariant[point][i][j] = result[i][j];
1775 const unsigned int n_q_points = data.contravariant.size();
1776 for (
unsigned int point = 0; point < n_q_points; ++point)
1778 data.covariant[point] =
1779 (data.contravariant[point]).covariant_form();
1786 const unsigned int n_q_points = data.contravariant.size();
1787 for (
unsigned int point = 0; point < n_q_points; ++point)
1788 data.volume_elements[point] =
1789 data.contravariant[point].determinant();
1799 template <
int dim,
int spacedim>
1801 maybe_update_jacobian_grads(
1804 const typename ::MappingQGeneric<dim, spacedim>::InternalData
1808 const UpdateFlags update_flags = data.update_each;
1811 const unsigned int n_q_points = jacobian_grads.size();
1814 for (
unsigned int point = 0; point < n_q_points; ++point)
1817 &data.second_derivative(point + data_set, 0);
1818 double result[spacedim][dim][dim];
1819 for (
unsigned int i = 0; i < spacedim; ++i)
1820 for (
unsigned int j = 0; j < dim; ++j)
1821 for (
unsigned int l = 0; l < dim; ++l)
1823 (second[0][j][l] * data.mapping_support_points[0][i]);
1824 for (
unsigned int k = 1; k < data.n_shape_functions; ++k)
1825 for (
unsigned int i = 0; i < spacedim; ++i)
1826 for (
unsigned int j = 0; j < dim; ++j)
1827 for (
unsigned int l = 0; l < dim; ++l)
1830 data.mapping_support_points[k][i]);
1832 for (
unsigned int i = 0; i < spacedim; ++i)
1833 for (
unsigned int j = 0; j < dim; ++j)
1834 for (
unsigned int l = 0; l < dim; ++l)
1835 jacobian_grads[point][i][j][l] = result[i][j][l];
1846 template <
int dim,
int spacedim>
1848 maybe_update_jacobian_pushed_forward_grads(
1851 const typename ::MappingQGeneric<dim, spacedim>::InternalData
1855 const UpdateFlags update_flags = data.update_each;
1858 const unsigned int n_q_points =
1859 jacobian_pushed_forward_grads.size();
1863 double tmp[spacedim][spacedim][spacedim];
1864 for (
unsigned int point = 0; point < n_q_points; ++point)
1867 &data.second_derivative(point + data_set, 0);
1868 double result[spacedim][dim][dim];
1869 for (
unsigned int i = 0; i < spacedim; ++i)
1870 for (
unsigned int j = 0; j < dim; ++j)
1871 for (
unsigned int l = 0; l < dim; ++l)
1872 result[i][j][l] = (second[0][j][l] *
1873 data.mapping_support_points[0][i]);
1874 for (
unsigned int k = 1; k < data.n_shape_functions; ++k)
1875 for (
unsigned int i = 0; i < spacedim; ++i)
1876 for (
unsigned int j = 0; j < dim; ++j)
1877 for (
unsigned int l = 0; l < dim; ++l)
1880 data.mapping_support_points[k][i]);
1883 for (
unsigned int i = 0; i < spacedim; ++i)
1884 for (
unsigned int j = 0; j < spacedim; ++j)
1885 for (
unsigned int l = 0; l < dim; ++l)
1888 result[i][0][l] * data.covariant[point][j][0];
1889 for (
unsigned int jr = 1; jr < dim; ++jr)
1891 tmp[i][j][l] += result[i][jr][l] *
1892 data.covariant[point][j][jr];
1897 for (
unsigned int i = 0; i < spacedim; ++i)
1898 for (
unsigned int j = 0; j < spacedim; ++j)
1899 for (
unsigned int l = 0; l < spacedim; ++l)
1901 jacobian_pushed_forward_grads[point][i][j][l] =
1902 tmp[i][j][0] * data.covariant[point][l][0];
1903 for (
unsigned int lr = 1; lr < dim; ++lr)
1905 jacobian_pushed_forward_grads[point][i][j][l] +=
1906 tmp[i][j][lr] * data.covariant[point][l][lr];
1920 template <
int dim,
int spacedim>
1922 maybe_update_jacobian_2nd_derivatives(
1925 const typename ::MappingQGeneric<dim, spacedim>::InternalData
1929 const UpdateFlags update_flags = data.update_each;
1932 const unsigned int n_q_points = jacobian_2nd_derivatives.size();
1936 for (
unsigned int point = 0; point < n_q_points; ++point)
1939 &data.third_derivative(point + data_set, 0);
1940 double result[spacedim][dim][dim][dim];
1941 for (
unsigned int i = 0; i < spacedim; ++i)
1942 for (
unsigned int j = 0; j < dim; ++j)
1943 for (
unsigned int l = 0; l < dim; ++l)
1944 for (
unsigned int m = 0; m < dim; ++m)
1945 result[i][j][l][m] =
1946 (third[0][j][l][m] *
1947 data.mapping_support_points[0][i]);
1948 for (
unsigned int k = 1; k < data.n_shape_functions; ++k)
1949 for (
unsigned int i = 0; i < spacedim; ++i)
1950 for (
unsigned int j = 0; j < dim; ++j)
1951 for (
unsigned int l = 0; l < dim; ++l)
1952 for (
unsigned int m = 0; m < dim; ++m)
1953 result[i][j][l][m] +=
1954 (third[k][j][l][m] *
1955 data.mapping_support_points[k][i]);
1957 for (
unsigned int i = 0; i < spacedim; ++i)
1958 for (
unsigned int j = 0; j < dim; ++j)
1959 for (
unsigned int l = 0; l < dim; ++l)
1960 for (
unsigned int m = 0; m < dim; ++m)
1961 jacobian_2nd_derivatives[point][i][j][l][m] =
1975 template <
int dim,
int spacedim>
1977 maybe_update_jacobian_pushed_forward_2nd_derivatives(
1980 const typename ::MappingQGeneric<dim, spacedim>::InternalData
1983 &jacobian_pushed_forward_2nd_derivatives)
1985 const UpdateFlags update_flags = data.update_each;
1988 const unsigned int n_q_points =
1989 jacobian_pushed_forward_2nd_derivatives.size();
1993 double tmp[spacedim][spacedim][spacedim][spacedim];
1994 for (
unsigned int point = 0; point < n_q_points; ++point)
1997 &data.third_derivative(point + data_set, 0);
1998 double result[spacedim][dim][dim][dim];
1999 for (
unsigned int i = 0; i < spacedim; ++i)
2000 for (
unsigned int j = 0; j < dim; ++j)
2001 for (
unsigned int l = 0; l < dim; ++l)
2002 for (
unsigned int m = 0; m < dim; ++m)
2003 result[i][j][l][m] =
2004 (third[0][j][l][m] *
2005 data.mapping_support_points[0][i]);
2006 for (
unsigned int k = 1; k < data.n_shape_functions; ++k)
2007 for (
unsigned int i = 0; i < spacedim; ++i)
2008 for (
unsigned int j = 0; j < dim; ++j)
2009 for (
unsigned int l = 0; l < dim; ++l)
2010 for (
unsigned int m = 0; m < dim; ++m)
2011 result[i][j][l][m] +=
2012 (third[k][j][l][m] *
2013 data.mapping_support_points[k][i]);
2016 for (
unsigned int i = 0; i < spacedim; ++i)
2017 for (
unsigned int j = 0; j < spacedim; ++j)
2018 for (
unsigned int l = 0; l < dim; ++l)
2019 for (
unsigned int m = 0; m < dim; ++m)
2021 jacobian_pushed_forward_2nd_derivatives
2022 [point][i][j][l][m] =
2023 result[i][0][l][m] *
2024 data.covariant[point][j][0];
2025 for (
unsigned int jr = 1; jr < dim; ++jr)
2026 jacobian_pushed_forward_2nd_derivatives[point]
2029 result[i][jr][l][m] *
2030 data.covariant[point][j][jr];
2034 for (
unsigned int i = 0; i < spacedim; ++i)
2035 for (
unsigned int j = 0; j < spacedim; ++j)
2036 for (
unsigned int l = 0; l < spacedim; ++l)
2037 for (
unsigned int m = 0; m < dim; ++m)
2040 jacobian_pushed_forward_2nd_derivatives[point]
2043 data.covariant[point][l][0];
2044 for (
unsigned int lr = 1; lr < dim; ++lr)
2046 jacobian_pushed_forward_2nd_derivatives
2047 [point][i][j][lr][m] *
2048 data.covariant[point][l][lr];
2052 for (
unsigned int i = 0; i < spacedim; ++i)
2053 for (
unsigned int j = 0; j < spacedim; ++j)
2054 for (
unsigned int l = 0; l < spacedim; ++l)
2055 for (
unsigned int m = 0; m < spacedim; ++m)
2057 jacobian_pushed_forward_2nd_derivatives
2058 [point][i][j][l][m] =
2059 tmp[i][j][l][0] * data.covariant[point][m][0];
2060 for (
unsigned int mr = 1; mr < dim; ++mr)
2061 jacobian_pushed_forward_2nd_derivatives[point]
2065 data.covariant[point][m][mr];
2078 template <
int dim,
int spacedim>
2080 maybe_update_jacobian_3rd_derivatives(
2083 const typename ::MappingQGeneric<dim, spacedim>::InternalData
2087 const UpdateFlags update_flags = data.update_each;
2090 const unsigned int n_q_points = jacobian_3rd_derivatives.size();
2094 for (
unsigned int point = 0; point < n_q_points; ++point)
2097 &data.fourth_derivative(point + data_set, 0);
2098 double result[spacedim][dim][dim][dim][dim];
2099 for (
unsigned int i = 0; i < spacedim; ++i)
2100 for (
unsigned int j = 0; j < dim; ++j)
2101 for (
unsigned int l = 0; l < dim; ++l)
2102 for (
unsigned int m = 0; m < dim; ++m)
2103 for (
unsigned int n = 0; n < dim; ++n)
2104 result[i][j][l][m][n] =
2105 (fourth[0][j][l][m][n] *
2106 data.mapping_support_points[0][i]);
2107 for (
unsigned int k = 1; k < data.n_shape_functions; ++k)
2108 for (
unsigned int i = 0; i < spacedim; ++i)
2109 for (
unsigned int j = 0; j < dim; ++j)
2110 for (
unsigned int l = 0; l < dim; ++l)
2111 for (
unsigned int m = 0; m < dim; ++m)
2112 for (
unsigned int n = 0; n < dim; ++n)
2113 result[i][j][l][m][n] +=
2114 (fourth[k][j][l][m][n] *
2115 data.mapping_support_points[k][i]);
2117 for (
unsigned int i = 0; i < spacedim; ++i)
2118 for (
unsigned int j = 0; j < dim; ++j)
2119 for (
unsigned int l = 0; l < dim; ++l)
2120 for (
unsigned int m = 0; m < dim; ++m)
2121 for (
unsigned int n = 0; n < dim; ++n)
2122 jacobian_3rd_derivatives[point][i][j][l][m][n] =
2123 result[i][j][l][m][n];
2136 template <
int dim,
int spacedim>
2138 maybe_update_jacobian_pushed_forward_3rd_derivatives(
2141 const typename ::MappingQGeneric<dim, spacedim>::InternalData
2144 &jacobian_pushed_forward_3rd_derivatives)
2146 const UpdateFlags update_flags = data.update_each;
2149 const unsigned int n_q_points =
2150 jacobian_pushed_forward_3rd_derivatives.size();
2154 double tmp[spacedim][spacedim][spacedim][spacedim][spacedim];
2155 for (
unsigned int point = 0; point < n_q_points; ++point)
2158 &data.fourth_derivative(point + data_set, 0);
2159 double result[spacedim][dim][dim][dim][dim];
2160 for (
unsigned int i = 0; i < spacedim; ++i)
2161 for (
unsigned int j = 0; j < dim; ++j)
2162 for (
unsigned int l = 0; l < dim; ++l)
2163 for (
unsigned int m = 0; m < dim; ++m)
2164 for (
unsigned int n = 0; n < dim; ++n)
2165 result[i][j][l][m][n] =
2166 (fourth[0][j][l][m][n] *
2167 data.mapping_support_points[0][i]);
2168 for (
unsigned int k = 1; k < data.n_shape_functions; ++k)
2169 for (
unsigned int i = 0; i < spacedim; ++i)
2170 for (
unsigned int j = 0; j < dim; ++j)
2171 for (
unsigned int l = 0; l < dim; ++l)
2172 for (
unsigned int m = 0; m < dim; ++m)
2173 for (
unsigned int n = 0; n < dim; ++n)
2174 result[i][j][l][m][n] +=
2175 (fourth[k][j][l][m][n] *
2176 data.mapping_support_points[k][i]);
2179 for (
unsigned int i = 0; i < spacedim; ++i)
2180 for (
unsigned int j = 0; j < spacedim; ++j)
2181 for (
unsigned int l = 0; l < dim; ++l)
2182 for (
unsigned int m = 0; m < dim; ++m)
2183 for (
unsigned int n = 0; n < dim; ++n)
2185 tmp[i][j][l][m][n] =
2186 result[i][0][l][m][n] *
2187 data.covariant[point][j][0];
2188 for (
unsigned int jr = 1; jr < dim; ++jr)
2189 tmp[i][j][l][m][n] +=
2190 result[i][jr][l][m][n] *
2191 data.covariant[point][j][jr];
2195 for (
unsigned int i = 0; i < spacedim; ++i)
2196 for (
unsigned int j = 0; j < spacedim; ++j)
2197 for (
unsigned int l = 0; l < spacedim; ++l)
2198 for (
unsigned int m = 0; m < dim; ++m)
2199 for (
unsigned int n = 0; n < dim; ++n)
2201 jacobian_pushed_forward_3rd_derivatives
2202 [point][i][j][l][m][n] =
2203 tmp[i][j][0][m][n] *
2204 data.covariant[point][l][0];
2205 for (
unsigned int lr = 1; lr < dim; ++lr)
2206 jacobian_pushed_forward_3rd_derivatives
2207 [point][i][j][l][m][n] +=
2208 tmp[i][j][lr][m][n] *
2209 data.covariant[point][l][lr];
2213 for (
unsigned int i = 0; i < spacedim; ++i)
2214 for (
unsigned int j = 0; j < spacedim; ++j)
2215 for (
unsigned int l = 0; l < spacedim; ++l)
2216 for (
unsigned int m = 0; m < spacedim; ++m)
2217 for (
unsigned int n = 0; n < dim; ++n)
2219 tmp[i][j][l][m][n] =
2220 jacobian_pushed_forward_3rd_derivatives
2221 [point][i][j][l][0][n] *
2222 data.covariant[point][m][0];
2223 for (
unsigned int mr = 1; mr < dim; ++mr)
2224 tmp[i][j][l][m][n] +=
2225 jacobian_pushed_forward_3rd_derivatives
2226 [point][i][j][l][mr][n] *
2227 data.covariant[point][m][mr];
2231 for (
unsigned int i = 0; i < spacedim; ++i)
2232 for (
unsigned int j = 0; j < spacedim; ++j)
2233 for (
unsigned int l = 0; l < spacedim; ++l)
2234 for (
unsigned int m = 0; m < spacedim; ++m)
2235 for (
unsigned int n = 0; n < spacedim; ++n)
2237 jacobian_pushed_forward_3rd_derivatives
2238 [point][i][j][l][m][n] =
2239 tmp[i][j][l][m][0] *
2240 data.covariant[point][n][0];
2241 for (
unsigned int nr = 1; nr < dim; ++nr)
2242 jacobian_pushed_forward_3rd_derivatives
2243 [point][i][j][l][m][n] +=
2244 tmp[i][j][l][m][nr] *
2245 data.covariant[point][n][nr];
2257 template <
int dim,
int spacedim>
2263 internal::MappingQGenericImplementation::
2264 compute_support_point_weights_perimeter_to_interior(
2268 internal::MappingQGenericImplementation::
2272 ExcMessage(
"It only makes sense to create polynomial mappings " 2273 "with a polynomial degree greater or equal to one."));
2278 template <
int dim,
int spacedim>
2282 , line_support_points(mapping.line_support_points)
2283 ,
fe_q(dim == 3 ? new
FE_Q<dim>(*mapping.
fe_q) : nullptr)
2291 template <
int dim,
int spacedim>
2292 std::unique_ptr<Mapping<dim, spacedim>>
2295 return std_cxx14::make_unique<MappingQGeneric<dim, spacedim>>(*this);
2300 template <
int dim,
int spacedim>
2309 template <
int dim,
int spacedim>
2324 const std::vector<unsigned int> renumber(
2326 internal::MappingQGenericImplementation::get_dpo_vector<dim>(
2331 const std::vector<Point<spacedim>> support_points =
2335 for (
unsigned int i = 0; i < tensor_pols.
n(); ++i)
2337 support_points[renumber[i]] * tensor_pols.
compute_value(i, p);
2339 return mapped_point;
2362 template <
int dim,
int spacedim>
2379 const Point<1> & initial_p_unit)
const 2382 const int spacedim = 1;
2390 get_data(update_flags, point_quadrature));
2396 return internal::MappingQGenericImplementation::
2397 do_transform_real_to_unit_cell_internal<1>(cell, p, initial_p_unit, *mdata);
2405 const Point<2> & initial_p_unit)
const 2408 const int spacedim = 2;
2416 get_data(update_flags, point_quadrature));
2422 return internal::MappingQGenericImplementation::
2423 do_transform_real_to_unit_cell_internal<2>(cell, p, initial_p_unit, *mdata);
2431 const Point<3> & initial_p_unit)
const 2434 const int spacedim = 3;
2442 get_data(update_flags, point_quadrature));
2448 return internal::MappingQGenericImplementation::
2449 do_transform_real_to_unit_cell_internal<3>(cell, p, initial_p_unit, *mdata);
2459 const Point<1> & initial_p_unit)
const 2462 const int spacedim = 2;
2470 get_data(update_flags, point_quadrature));
2476 return internal::MappingQGenericImplementation::
2477 do_transform_real_to_unit_cell_internal_codim1<1>(cell,
2490 const Point<2> & initial_p_unit)
const 2493 const int spacedim = 3;
2501 get_data(update_flags, point_quadrature));
2507 return internal::MappingQGenericImplementation::
2508 do_transform_real_to_unit_cell_internal_codim1<2>(cell,
2527 template <
int dim,
int spacedim>
2536 ((dim == 1) || ((dim == 2) && (dim == spacedim))))
2569 return internal::MappingQ1::transform_real_to_unit_cell(
2578 internal::MappingQ1::transform_real_to_unit_cell(vertices,
2584 const double eps = 1e-15;
2585 if (-eps <= point(1) && point(1) <= 1 + eps &&
2586 -eps <= point(0) && point(0) <= 1 + eps)
2618 initial_p_unit = cell->real_to_unit_cell_affine_approximation(p);
2628 std::vector<Point<spacedim>> a =
2631 std::vector<CellData<dim>> cells(1);
2632 for (
unsigned int i = 0; i < GeometryInfo<dim>::vertices_per_cell; ++i)
2633 cells[0].vertices[i] = i;
2637 tria.
begin_active()->real_to_unit_cell_affine_approximation(p);
2642 return initial_p_unit;
2663 template <
int dim,
int spacedim>
2675 for (
unsigned int i = 0; i < 5; ++i)
2720 template <
int dim,
int spacedim>
2721 std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
2728 return std::move(data);
2733 template <
int dim,
int spacedim>
2734 std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
2744 return std::move(data);
2749 template <
int dim,
int spacedim>
2750 std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>
2760 return std::move(data);
2765 template <
int dim,
int spacedim>
2776 Assert(dynamic_cast<const InternalData *>(&internal_data) !=
nullptr,
2780 const unsigned int n_q_points = quadrature.
size();
2804 internal::MappingQGenericImplementation::
2805 maybe_update_q_points_Jacobians_and_grads_tensor<dim, spacedim>(
2806 computed_cell_similarity,
2813 internal::MappingQGenericImplementation::maybe_compute_q_points<dim,
2819 internal::MappingQGenericImplementation::maybe_update_Jacobians<dim,
2821 computed_cell_similarity,
2825 internal::MappingQGenericImplementation::maybe_update_jacobian_grads<
2827 spacedim>(computed_cell_similarity,
2833 internal::MappingQGenericImplementation::
2834 maybe_update_jacobian_pushed_forward_grads<dim, spacedim>(
2835 computed_cell_similarity,
2840 internal::MappingQGenericImplementation::
2841 maybe_update_jacobian_2nd_derivatives<dim, spacedim>(
2842 computed_cell_similarity,
2847 internal::MappingQGenericImplementation::
2848 maybe_update_jacobian_pushed_forward_2nd_derivatives<dim, spacedim>(
2849 computed_cell_similarity,
2854 internal::MappingQGenericImplementation::
2855 maybe_update_jacobian_3rd_derivatives<dim, spacedim>(
2856 computed_cell_similarity,
2861 internal::MappingQGenericImplementation::
2862 maybe_update_jacobian_pushed_forward_3rd_derivatives<dim, spacedim>(
2863 computed_cell_similarity,
2868 const UpdateFlags update_flags = data.update_each;
2869 const std::vector<double> &weights = quadrature.
get_weights();
2885 for (
unsigned int point = 0; point < n_q_points; ++point)
2887 if (dim == spacedim)
2889 const double det = data.contravariant[point].determinant();
2897 1e-12 * Utilities::fixed_power<dim>(
2898 cell->diameter() / std::sqrt(
double(dim))),
2900 cell->center(), det, point)));
2902 output_data.
JxW_values[point] = weights[point] * det;
2910 for (
unsigned int i = 0; i < spacedim; ++i)
2911 for (
unsigned int j = 0; j < dim; ++j)
2912 DX_t[j][i] = data.contravariant[point][i][j];
2915 for (
unsigned int i = 0; i < dim; ++i)
2916 for (
unsigned int j = 0; j < dim; ++j)
2917 G[i][j] = DX_t[i] * DX_t[j];
2922 if (computed_cell_similarity ==
2926 if (update_flags & update_normal_vectors)
2931 if (update_flags & update_normal_vectors)
2933 Assert(spacedim == dim + 1,
2935 "There is no (unique) cell normal for " +
2937 "-dimensional cells in " +
2939 "-dimensional space. This only works if the " 2940 "space dimension is one greater than the " 2941 "dimensionality of the mesh cells."));
2945 cross_product_2d(-DX_t[0]);
2948 cross_product_3d(DX_t[0], DX_t[1]);
2953 if (cell->direction_flag() ==
false)
2968 for (
unsigned int point = 0; point < n_q_points; ++point)
2969 output_data.
jacobians[point] = data.contravariant[point];
2977 for (
unsigned int point = 0; point < n_q_points; ++point)
2979 data.covariant[point].transpose();
2982 return computed_cell_similarity;
2989 namespace MappingQGenericImplementation
3002 template <
int dim,
int spacedim>
3004 maybe_compute_face_data(
3005 const ::MappingQGeneric<dim, spacedim> &mapping,
3006 const typename ::Triangulation<dim, spacedim>::cell_iterator
3008 const unsigned int face_no,
3009 const unsigned int subface_no,
3010 const unsigned int n_q_points,
3011 const std::vector<double> &weights,
3012 const typename ::MappingQGeneric<dim, spacedim>::InternalData
3017 const UpdateFlags update_flags = data.update_each;
3038 for (
unsigned int d = 0; d != dim - 1; ++d)
3041 data.unit_tangentials.size(),
3044 data.aux[d].size() <=
3046 .unit_tangentials[face_no +
3054 .unit_tangentials[face_no +
3058 make_array_view(data.aux[d]));
3061 if (update_flags & update_boundary_forms)
3065 if (dim == spacedim)
3067 for (
unsigned int i = 0; i < n_q_points; ++i)
3077 (face_no == 0 ? -1 : +1);
3081 cross_product_2d(data.aux[0][i]);
3085 cross_product_3d(data.aux[0][i], data.aux[1][i]);
3101 for (
unsigned int point = 0; point < n_q_points; ++point)
3107 data.contravariant[point].transpose()[0];
3109 (face_no == 0 ? -1. : +1.) *
3119 cross_product_3d(DX_t[0], DX_t[1]);
3120 cell_normal /= cell_normal.
norm();
3125 cross_product_3d(data.aux[0][point], cell_normal);
3131 if (update_flags & update_JxW_values)
3140 const double area_ratio =
3142 cell->subface_case(face_no), subface_no);
3147 if (update_flags & update_normal_vectors)
3155 for (
unsigned int point = 0; point < n_q_points; ++point)
3156 output_data.
jacobians[point] = data.contravariant[point];
3159 for (
unsigned int point = 0; point < n_q_points; ++point)
3161 data.covariant[point].transpose();
3172 template <
int dim,
int spacedim>
3174 do_fill_fe_face_values(
3175 const ::MappingQGeneric<dim, spacedim> &mapping,
3176 const typename ::Triangulation<dim, spacedim>::cell_iterator
3178 const unsigned int face_no,
3179 const unsigned int subface_no,
3182 const typename ::MappingQGeneric<dim, spacedim>::InternalData
3187 if (dim > 1 && data.tensor_product_quadrature)
3189 maybe_update_q_points_Jacobians_and_grads_tensor<dim, spacedim>(
3197 maybe_compute_q_points<dim, spacedim>(
3202 maybe_update_jacobian_grads<dim, spacedim>(
3205 maybe_update_jacobian_pushed_forward_grads<dim, spacedim>(
3210 maybe_update_jacobian_2nd_derivatives<dim, spacedim>(
3215 maybe_update_jacobian_pushed_forward_2nd_derivatives<dim, spacedim>(
3220 maybe_update_jacobian_3rd_derivatives<dim, spacedim>(
3225 maybe_update_jacobian_pushed_forward_3rd_derivatives<dim, spacedim>(
3231 maybe_compute_face_data(mapping,
3246 template <
int dim,
int spacedim>
3250 const unsigned int face_no,
3257 Assert((dynamic_cast<const InternalData *>(&internal_data) !=
nullptr),
3266 (&cell->get_triangulation() !=
3274 internal::MappingQGenericImplementation::do_fill_fe_face_values(
3280 cell->face_orientation(face_no),
3281 cell->face_flip(face_no),
3282 cell->face_rotation(face_no),
3291 template <
int dim,
int spacedim>
3295 const unsigned int face_no,
3296 const unsigned int subface_no,
3303 Assert((dynamic_cast<const InternalData *>(&internal_data) !=
nullptr),
3312 (&cell->get_triangulation() !=
3320 internal::MappingQGenericImplementation::do_fill_fe_face_values(
3327 cell->face_orientation(face_no),
3328 cell->face_flip(face_no),
3329 cell->face_rotation(face_no),
3331 cell->subface_case(face_no)),
3341 namespace MappingQGenericImplementation
3345 template <
int dim,
int spacedim,
int rank>
3354 Assert((
dynamic_cast<const typename ::
3355 MappingQGeneric<dim, spacedim>::InternalData *
>(
3356 &mapping_data) !=
nullptr),
3358 const typename ::MappingQGeneric<dim, spacedim>::InternalData
3360 static_cast<const typename ::MappingQGeneric<dim, spacedim>::
3363 switch (mapping_type)
3370 "update_contravariant_transformation"));
3372 for (
unsigned int i = 0; i < output.size(); ++i)
3374 apply_transformation(data.contravariant[i], input[i]);
3384 "update_contravariant_transformation"));
3388 "update_volume_elements"));
3393 for (
unsigned int i = 0; i < output.size(); ++i)
3396 apply_transformation(data.contravariant[i], input[i]);
3397 output[i] /= data.volume_elements[i];
3409 "update_covariant_transformation"));
3411 for (
unsigned int i = 0; i < output.size(); ++i)
3412 output[i] = apply_transformation(data.covariant[i], input[i]);
3423 template <
int dim,
int spacedim,
int rank>
3425 transform_gradients(
3432 Assert((
dynamic_cast<const typename ::
3433 MappingQGeneric<dim, spacedim>::InternalData *
>(
3434 &mapping_data) !=
nullptr),
3436 const typename ::MappingQGeneric<dim, spacedim>::InternalData
3438 static_cast<const typename ::MappingQGeneric<dim, spacedim>::
3441 switch (mapping_type)
3448 "update_covariant_transformation"));
3452 "update_contravariant_transformation"));
3455 for (
unsigned int i = 0; i < output.size(); ++i)
3458 apply_transformation(data.contravariant[i],
3461 apply_transformation(data.covariant[i], A.
transpose());
3472 "update_covariant_transformation"));
3475 for (
unsigned int i = 0; i < output.size(); ++i)
3478 apply_transformation(data.covariant[i],
3481 apply_transformation(data.covariant[i], A.
transpose());
3492 "update_covariant_transformation"));
3496 "update_contravariant_transformation"));
3500 "update_volume_elements"));
3503 for (
unsigned int i = 0; i < output.size(); ++i)
3506 apply_transformation(data.covariant[i], input[i]);
3508 apply_transformation(data.contravariant[i],
3512 output[i] /= data.volume_elements[i];
3525 template <
int dim,
int spacedim>
3534 Assert((
dynamic_cast<const typename ::
3535 MappingQGeneric<dim, spacedim>::InternalData *
>(
3536 &mapping_data) !=
nullptr),
3538 const typename ::MappingQGeneric<dim, spacedim>::InternalData
3540 static_cast<const typename ::MappingQGeneric<dim, spacedim>::
3543 switch (mapping_type)
3550 "update_covariant_transformation"));
3554 "update_contravariant_transformation"));
3556 for (
unsigned int q = 0; q < output.size(); ++q)
3557 for (
unsigned int i = 0; i < spacedim; ++i)
3559 double tmp1[dim][dim];
3560 for (
unsigned int J = 0; J < dim; ++J)
3561 for (
unsigned int K = 0; K < dim; ++K)
3564 data.contravariant[q][i][0] * input[q][0][J][K];
3565 for (
unsigned int I = 1; I < dim; ++I)
3567 data.contravariant[q][i][I] * input[q][I][J][K];
3569 for (
unsigned int j = 0; j < spacedim; ++j)
3572 for (
unsigned int K = 0; K < dim; ++K)
3574 tmp2[K] = data.covariant[q][j][0] * tmp1[0][K];
3575 for (
unsigned int J = 1; J < dim; ++J)
3576 tmp2[K] += data.covariant[q][j][J] * tmp1[J][K];
3578 for (
unsigned int k = 0; k < spacedim; ++k)
3580 output[q][i][j][k] =
3581 data.covariant[q][k][0] * tmp2[0];
3582 for (
unsigned int K = 1; K < dim; ++K)
3583 output[q][i][j][k] +=
3584 data.covariant[q][k][K] * tmp2[K];
3596 "update_covariant_transformation"));
3598 for (
unsigned int q = 0; q < output.size(); ++q)
3599 for (
unsigned int i = 0; i < spacedim; ++i)
3601 double tmp1[dim][dim];
3602 for (
unsigned int J = 0; J < dim; ++J)
3603 for (
unsigned int K = 0; K < dim; ++K)
3606 data.covariant[q][i][0] * input[q][0][J][K];
3607 for (
unsigned int I = 1; I < dim; ++I)
3609 data.covariant[q][i][I] * input[q][I][J][K];
3611 for (
unsigned int j = 0; j < spacedim; ++j)
3614 for (
unsigned int K = 0; K < dim; ++K)
3616 tmp2[K] = data.covariant[q][j][0] * tmp1[0][K];
3617 for (
unsigned int J = 1; J < dim; ++J)
3618 tmp2[K] += data.covariant[q][j][J] * tmp1[J][K];
3620 for (
unsigned int k = 0; k < spacedim; ++k)
3622 output[q][i][j][k] =
3623 data.covariant[q][k][0] * tmp2[0];
3624 for (
unsigned int K = 1; K < dim; ++K)
3625 output[q][i][j][k] +=
3626 data.covariant[q][k][K] * tmp2[K];
3639 "update_covariant_transformation"));
3643 "update_contravariant_transformation"));
3647 "update_volume_elements"));
3649 for (
unsigned int q = 0; q < output.size(); ++q)
3650 for (
unsigned int i = 0; i < spacedim; ++i)
3653 for (
unsigned int I = 0; I < dim; ++I)
3655 data.contravariant[q][i][I] / data.volume_elements[q];
3656 double tmp1[dim][dim];
3657 for (
unsigned int J = 0; J < dim; ++J)
3658 for (
unsigned int K = 0; K < dim; ++K)
3660 tmp1[J][K] = factor[0] * input[q][0][J][K];
3661 for (
unsigned int I = 1; I < dim; ++I)
3662 tmp1[J][K] += factor[I] * input[q][I][J][K];
3664 for (
unsigned int j = 0; j < spacedim; ++j)
3667 for (
unsigned int K = 0; K < dim; ++K)
3669 tmp2[K] = data.covariant[q][j][0] * tmp1[0][K];
3670 for (
unsigned int J = 1; J < dim; ++J)
3671 tmp2[K] += data.covariant[q][j][J] * tmp1[J][K];
3673 for (
unsigned int k = 0; k < spacedim; ++k)
3675 output[q][i][j][k] =
3676 data.covariant[q][k][0] * tmp2[0];
3677 for (
unsigned int K = 1; K < dim; ++K)
3678 output[q][i][j][k] +=
3679 data.covariant[q][k][K] * tmp2[K];
3694 template <
int dim,
int spacedim,
int rank>
3696 transform_differential_forms(
3703 Assert((
dynamic_cast<const typename ::
3704 MappingQGeneric<dim, spacedim>::InternalData *
>(
3705 &mapping_data) !=
nullptr),
3707 const typename ::MappingQGeneric<dim, spacedim>::InternalData
3709 static_cast<const typename ::MappingQGeneric<dim, spacedim>::
3712 switch (mapping_type)
3719 "update_covariant_transformation"));
3721 for (
unsigned int i = 0; i < output.size(); ++i)
3722 output[i] = apply_transformation(data.covariant[i], input[i]);
3736 template <
int dim,
int spacedim>
3744 internal::MappingQGenericImplementation::transform_fields(input,
3752 template <
int dim,
int spacedim>
3760 internal::MappingQGenericImplementation::transform_differential_forms(
3761 input, mapping_type, mapping_data, output);
3766 template <
int dim,
int spacedim>
3774 switch (mapping_type)
3777 internal::MappingQGenericImplementation::transform_fields(input,
3786 internal::MappingQGenericImplementation::transform_gradients(
3787 input, mapping_type, mapping_data, output);
3796 template <
int dim,
int spacedim>
3805 Assert(dynamic_cast<const InternalData *>(&mapping_data) !=
nullptr,
3809 switch (mapping_type)
3815 "update_covariant_transformation"));
3817 for (
unsigned int q = 0; q < output.size(); ++q)
3818 for (
unsigned int i = 0; i < spacedim; ++i)
3819 for (
unsigned int j = 0; j < spacedim; ++j)
3822 for (
unsigned int K = 0; K < dim; ++K)
3824 tmp[K] = data.
covariant[q][j][0] * input[q][i][0][K];
3825 for (
unsigned int J = 1; J < dim; ++J)
3826 tmp[K] += data.
covariant[q][j][J] * input[q][i][J][K];
3828 for (
unsigned int k = 0; k < spacedim; ++k)
3830 output[q][i][j][k] = data.
covariant[q][k][0] * tmp[0];
3831 for (
unsigned int K = 1; K < dim; ++K)
3832 output[q][i][j][k] += data.
covariant[q][k][K] * tmp[K];
3845 template <
int dim,
int spacedim>
3853 switch (mapping_type)
3858 internal::MappingQGenericImplementation::transform_hessians(
3859 input, mapping_type, mapping_data, output);
3868 template <
int dim,
int spacedim>
3877 for (
unsigned int line_no = 0;
3878 line_no < GeometryInfo<dim>::lines_per_cell;
3881 const typename Triangulation<dim, spacedim>::line_iterator line =
3884 typename Triangulation<dim, spacedim>::line_iterator
>(cell) :
3885 cell->line(line_no));
3890 cell->get_manifold() :
3899 std::vector<Point<spacedim>> tmp_points;
3900 for (
unsigned int line_no = 0;
3901 line_no < GeometryInfo<dim>::lines_per_cell;
3904 const typename Triangulation<dim, spacedim>::line_iterator line =
3907 typename Triangulation<dim, spacedim>::line_iterator
>(cell) :
3908 cell->line(line_no));
3913 cell->get_manifold() :
3916 const std::array<Point<spacedim>, 2> vertices{
3921 const std::size_t n_rows =
3923 a.resize(a.size() + n_rows);
3924 auto a_view = make_array_view(a.end() - n_rows, a.end());
3926 make_array_view(vertices.begin(), vertices.end()),
3944 std::vector<Point<3>> tmp_points;
3947 for (
unsigned int face_no = 0; face_no < faces_per_cell; ++face_no)
3952 const bool face_orientation = cell->face_orientation(face_no),
3953 face_flip = cell->face_flip(face_no),
3954 face_rotation = cell->face_rotation(face_no);
3959 for (
unsigned int i = 0; i < vertices_per_face; ++i)
3960 Assert(face->vertex_index(i) ==
3962 face_no, i, face_orientation, face_flip, face_rotation)),
3967 for (
unsigned int i = 0; i < lines_per_face; ++i)
3970 face_no, i, face_orientation, face_flip, face_rotation)),
3976 boost::container::small_vector<Point<3>, 200> tmp_points(
3979 for (
unsigned int v = 0; v < GeometryInfo<2>::vertices_per_cell; ++v)
3982 for (
unsigned int line = 0; line < GeometryInfo<2>::lines_per_cell;
3985 tmp_points[4 + line * (polynomial_degree - 1) + i] =
3987 (polynomial_degree - 1) *
3991 const std::size_t n_rows =
3993 a.resize(a.size() + n_rows);
3994 auto a_view = make_array_view(a.end() - n_rows, a.end());
3995 face->get_manifold().get_new_points(
3996 make_array_view(tmp_points.begin(), tmp_points.end()),
4011 for (
unsigned int i = 0; i < GeometryInfo<2>::vertices_per_cell; ++i)
4012 vertices[i] = cell->vertex(i);
4017 for (
unsigned int q1 = 0; q1 < polynomial_degree - 1; ++q1, ++q)
4019 Point<2> point(line_support_points.point(q1 + 1)[0],
4020 line_support_points.point(q2 + 1)[0]);
4021 for (
unsigned int i = 0; i < GeometryInfo<2>::vertices_per_cell; ++i)
4025 const std::size_t n_rows = weights.
size(0);
4026 a.resize(a.size() + n_rows);
4027 auto a_view = make_array_view(a.end() - n_rows, a.end());
4028 cell->get_manifold().get_new_points(
4029 make_array_view(vertices.begin(), vertices.end()), weights, a_view);
4034 template <
int dim,
int spacedim>
4045 template <
int dim,
int spacedim>
4046 std::vector<Point<spacedim>>
4051 std::vector<Point<spacedim>> a;
4053 for (
unsigned int i = 0; i < GeometryInfo<dim>::vertices_per_cell; ++i)
4054 a.push_back(cell->vertex(i));
4063 bool all_manifold_ids_are_equal = (dim == spacedim);
4064 if (all_manifold_ids_are_equal &&
4066 &cell->get_manifold()) ==
nullptr)
4068 for (
unsigned int f = 0; f < GeometryInfo<dim>::faces_per_cell; ++f)
4069 if (&cell->face(f)->get_manifold() != &cell->get_manifold())
4070 all_manifold_ids_are_equal =
false;
4073 for (
unsigned int l = 0; l < GeometryInfo<dim>::lines_per_cell; ++l)
4074 if (&cell->line(l)->get_manifold() != &cell->get_manifold())
4075 all_manifold_ids_are_equal =
false;
4078 if (all_manifold_ids_are_equal)
4081 a.resize(a.size() + n_rows);
4082 auto a_view = make_array_view(a.end() - n_rows, a.end());
4083 cell->get_manifold().get_new_points(make_array_view(a.begin(),
4100 if (dim != spacedim)
4104 const std::size_t n_rows =
4106 a.resize(a.size() + n_rows);
4107 auto a_view = make_array_view(a.end() - n_rows, a.end());
4108 cell->get_manifold().get_new_points(
4109 make_array_view(a.begin(), a.end() - n_rows),
4122 const std::size_t n_rows =
4124 a.resize(a.size() + n_rows);
4125 auto a_view = make_array_view(a.end() - n_rows, a.end());
4126 cell->get_manifold().get_new_points(
4127 make_array_view(a.begin(), a.end() - n_rows),
4145 #include "mapping_q_generic.inst" 4148 DEAL_II_NAMESPACE_CLOSE
Transformed quadrature weights.
std::vector< Tensor< 2, dim > > shape_second_derivatives
static::ExceptionBase & ExcTransformationFailed()
void loop(ITERATOR begin, typename identity< ITERATOR >::type end, DOFINFO &dinfo, INFOBOX &info, const std::function< void(DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker, const std::function< void(DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker, const std::function< void(DOFINFO &, DOFINFO &, typename INFOBOX::CellInfo &, typename INFOBOX::CellInfo &)> &face_worker, ASSEMBLER &assembler, const LoopControl &lctrl=LoopControl())
static const unsigned int invalid_unsigned_int
virtual std::array< Point< spacedim >, GeometryInfo< dim >::vertices_per_cell > get_vertices(const typename Triangulation< dim, spacedim >::cell_iterator &cell) const
#define AssertDimension(dim1, dim2)
Number determinant(const SymmetricTensor< 2, dim, Number > &)
const unsigned int polynomial_degree
Contravariant transformation.
std::conditional< dim==1, std::array< Quadrature< 1 >, dim >, const std::array< Quadrature< 1 >, dim > & >::type get_tensor_basis() const
Table< 2, double > support_point_weights_cell
double compute_value(const unsigned int i, const Point< dim > &p) const
void reinit(const Quadrature< 1 > &quad, const FiniteElement< dim > &fe_dim, const unsigned int base_element=0)
SymmetricTensor< 2, dim, Number > e(const Tensor< 2, dim, Number > &F)
Point< spacedim > point(const gp_Pnt &p, const double &tolerance=1e-10)
virtual void add_line_support_points(const typename Triangulation< dim, spacedim >::cell_iterator &cell, std::vector< Point< spacedim >> &a) const
virtual UpdateFlags requires_update_flags(const UpdateFlags update_flags) const override
virtual Point< spacedim > transform_unit_to_real_cell(const typename Triangulation< dim, spacedim >::cell_iterator &cell, const Point< dim > &p) 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
Outer normal vector, not normalized.
const Tensor< 4, dim > & fourth_derivative(const unsigned int qpoint, const unsigned int shape_nr) const
unsigned int get_degree() const
virtual std::unique_ptr< Mapping< dim, spacedim > > clone() const override
Determinant of the Jacobian.
Transformed quadrature points.
MappingQGeneric(const unsigned int polynomial_degree)
numbers::NumberTraits< Number >::real_type norm() const
#define AssertThrow(cond, exc)
bool tensor_product_quadrature
AlignedVector< VectorizedArray< double > > scratch
static DataSetDescriptor cell()
const std::unique_ptr< FE_Q< dim > > fe_q
void resize(const size_type size_in)
const Point< dim > & point(const unsigned int i) const
InternalData(const unsigned int polynomial_degree)
const unsigned int polynomial_degree
std::unique_ptr< To > dynamic_unique_cast(std::unique_ptr< From > &&p)
SymmetricTensor< 2, dim, Number > invert(const SymmetricTensor< 2, dim, Number > &)
std::vector< Table< 2, double > > support_point_weights_perimeter_to_interior
const std::vector< Point< dim > > & get_points() const
unsigned int size() const
static::ExceptionBase & ExcMessage(std::string arg1)
virtual void fill_fe_face_values(const typename Triangulation< dim, spacedim >::cell_iterator &cell, const unsigned int face_no, const Quadrature< dim-1 > &quadrature, const typename Mapping< dim, spacedim >::InternalDataBase &internal_data,::internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > &output_data) const override
static::ExceptionBase & ExcImpossibleInDim(int arg1)
void compute_shape_function_values(const std::vector< Point< dim >> &unit_points)
std::vector< std::vector< Tensor< 1, spacedim > > > aux
void reinit(const TableIndices< N > &new_size, const bool omit_default_initialization=false)
size_type size(const unsigned int i) const
virtual void create_triangulation(const std::vector< Point< spacedim >> &vertices, const std::vector< CellData< dim >> &cells, const SubCellData &subcelldata)
const Tensor< 2, dim > & second_derivative(const unsigned int qpoint, const unsigned int shape_nr) const
#define Assert(cond, exc)
const Tensor< 3, dim > & third_derivative(const unsigned int qpoint, const unsigned int shape_nr) const
static::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
Abstract base class for mapping classes.
virtual void get_new_points(const ArrayView< const Point< spacedim >> &surrounding_points, const Table< 2, double > &weights, ArrayView< Point< spacedim >> new_points) const
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
std::vector< Point< spacedim > > mapping_support_points
std::vector< Tensor< 3, dim > > shape_third_derivatives
const Manifold< dim, spacedim > & get_manifold(const types::manifold_id number) const
virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > get_data(const UpdateFlags, const Quadrature< dim > &quadrature) const override
virtual void transform(const ArrayView< const Tensor< 1, dim >> &input, const MappingType type, const typename Mapping< dim, spacedim >::InternalDataBase &internal, const ArrayView< Tensor< 1, spacedim >> &output) const override
SymmetricTensor< rank_, dim, Number > transpose(const SymmetricTensor< rank_, dim, Number > &t)
void initialize(const UpdateFlags update_flags, const Quadrature< dim > &quadrature, const unsigned int n_original_q_points)
std::vector< double > volume_elements
Gradient of volume element.
std::string int_to_string(const unsigned int value, const unsigned int digits=numbers::invalid_unsigned_int)
const unsigned int n_shape_functions
std::vector< Tensor< 1, dim > > shape_derivatives
SymmetricTensor< 2, dim, Number > b(const Tensor< 2, dim, Number > &F)
const std::vector< double > & get_weights() const
AlignedVector< VectorizedArray< double > > values_dofs
static Point< dim > project_to_unit_cell(const Point< dim > &p)
const types::manifold_id invalid_manifold_id
std::array< std::vector< Tensor< 1, dim > >, GeometryInfo< dim >::faces_per_cell *(dim-1)> unit_tangentials
virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > get_face_data(const UpdateFlags flags, const Quadrature< dim-1 > &quadrature) const override
virtual std::vector< Point< spacedim > > compute_mapping_support_points(const typename Triangulation< dim, spacedim >::cell_iterator &cell) const
static double d_linear_shape_function(const Point< dim > &xi, const unsigned int i)
virtual bool preserves_vertex_locations() const override
bool is_tensor_product() const
Triangulation< dim, spacedim >::cell_iterator cell_of_current_support_points
virtual std::size_t memory_consumption() const override
const double & shape(const unsigned int qpoint, const unsigned int shape_nr) const
unsigned int n_dofs_per_cell() const
static::ExceptionBase & ExcNotImplemented()
std::vector< DerivativeForm< 1, dim, spacedim > > contravariant
active_cell_iterator begin_active(const unsigned int level=0) const
virtual void add_quad_support_points(const typename Triangulation< dim, spacedim >::cell_iterator &cell, std::vector< Point< spacedim >> &a) const
std::vector< Tensor< 4, dim > > shape_fourth_derivatives
void initialize_face(const UpdateFlags update_flags, const Quadrature< dim > &quadrature, const unsigned int n_original_q_points)
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
std::vector< double > shape_values
virtual Point< dim > transform_real_to_unit_cell(const typename Triangulation< dim, spacedim >::cell_iterator &cell, const Point< spacedim > &p) const override
static double subface_ratio(const internal::SubfaceCase< dim > &subface_case, const unsigned int subface_no)
std::vector< Polynomial< double > > generate_complete_Lagrange_basis(const std::vector< Point< 1 >> &points)
Covariant transformation.
std::vector< DerivativeForm< 1, dim, spacedim > > covariant
internal::MatrixFreeFunctions::ShapeInfo< VectorizedArray< double > > shape_info
const Tensor< 1, dim > & derivative(const unsigned int qpoint, const unsigned int shape_nr) const
std::enable_if< std::is_fundamental< T >::value, std::size_t >::type memory_consumption(const T &t)
Tensor< 2, dim, Number > l(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
virtual Point< spacedim > get_new_point_on_line(const typename Triangulation< dim, spacedim >::line_iterator &line) const
static::ExceptionBase & ExcInternalError()
virtual std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > get_subface_data(const UpdateFlags flags, const Quadrature< dim-1 > &quadrature) const override