47 #include <boost/container/small_vector.hpp> 51 #include <type_traits> 58 template <
class VectorType>
77 template <
int dim,
int spacedim>
78 inline std::vector<unsigned int>
81 std::vector<unsigned int> shape_function_to_row_table(
90 unsigned int nth_nonzero_component = 0;
95 row + nth_nonzero_component;
96 ++nth_nonzero_component;
101 return shape_function_to_row_table;
108 template <
typename Number,
typename T =
void>
123 template <
typename Number>
126 typename std::enable_if<
127 Differentiation::AD::is_ad_number<Number>::value>::type>
130 value(
const Number & )
142 template <
int dim,
int spacedim>
144 const unsigned int component)
145 : fe_values(&fe_values)
146 , component(component)
147 , shape_function_data(this->fe_values->fe->n_dofs_per_cell())
155 const std::vector<unsigned int> shape_function_to_row_table =
162 if (is_primitive ==
true)
179 template <
int dim,
int spacedim>
187 template <
int dim,
int spacedim>
189 const unsigned int first_vector_component)
190 : fe_values(&fe_values)
191 , first_vector_component(first_vector_component)
200 const std::vector<unsigned int> shape_function_to_row_table =
203 for (
unsigned int d = 0;
d < spacedim; ++
d)
205 const unsigned int component = first_vector_component +
d;
211 if (is_primitive ==
true)
221 shape_function_to_row_table[i * fe.
n_components() + component];
230 unsigned int n_nonzero_components = 0;
231 for (
unsigned int d = 0;
d < spacedim; ++
d)
234 ++n_nonzero_components;
236 if (n_nonzero_components == 0)
238 else if (n_nonzero_components > 1)
242 for (
unsigned int d = 0;
d < spacedim; ++
d)
244 .is_nonzero_shape_function_component[
d] ==
true)
257 template <
int dim,
int spacedim>
265 template <
int dim,
int spacedim>
268 const unsigned int first_tensor_component)
269 : fe_values(&fe_values)
270 , first_tensor_component(first_tensor_component)
274 Assert(first_tensor_component + (dim * dim + dim) / 2 - 1 <
277 first_tensor_component +
284 const std::vector<unsigned int> shape_function_to_row_table =
287 for (
unsigned int d = 0;
288 d < ::SymmetricTensor<2, dim>::n_independent_components;
291 const unsigned int component = first_tensor_component +
d;
297 if (is_primitive ==
true)
298 shape_function_data[i].is_nonzero_shape_function_component[
d] =
301 shape_function_data[i].is_nonzero_shape_function_component[
d] =
304 if (shape_function_data[i].is_nonzero_shape_function_component[d] ==
306 shape_function_data[i].row_index[
d] =
307 shape_function_to_row_table[i * fe.
n_components() + component];
309 shape_function_data[i].row_index[
d] =
316 unsigned int n_nonzero_components = 0;
317 for (
unsigned int d = 0;
318 d < ::SymmetricTensor<2, dim>::n_independent_components;
320 if (shape_function_data[i].is_nonzero_shape_function_component[
d] ==
322 ++n_nonzero_components;
324 if (n_nonzero_components == 0)
325 shape_function_data[i].single_nonzero_component = -2;
326 else if (n_nonzero_components > 1)
327 shape_function_data[i].single_nonzero_component = -1;
330 for (
unsigned int d = 0;
331 d < ::SymmetricTensor<2, dim>::n_independent_components;
333 if (shape_function_data[i]
334 .is_nonzero_shape_function_component[
d] ==
true)
336 shape_function_data[i].single_nonzero_component =
337 shape_function_data[i].row_index[
d];
338 shape_function_data[i].single_nonzero_component_index =
d;
347 template <
int dim,
int spacedim>
355 template <
int dim,
int spacedim>
357 const unsigned int first_tensor_component)
358 : fe_values(&fe_values)
359 , first_tensor_component(first_tensor_component)
360 , shape_function_data(this->fe_values->fe->n_dofs_per_cell())
367 const std::vector<unsigned int> shape_function_to_row_table =
370 for (
unsigned int d = 0;
d < dim * dim; ++
d)
372 const unsigned int component = first_tensor_component +
d;
378 if (is_primitive ==
true)
379 shape_function_data[i].is_nonzero_shape_function_component[
d] =
382 shape_function_data[i].is_nonzero_shape_function_component[
d] =
385 if (shape_function_data[i].is_nonzero_shape_function_component[d] ==
387 shape_function_data[i].row_index[
d] =
388 shape_function_to_row_table[i * fe.
n_components() + component];
390 shape_function_data[i].row_index[
d] =
397 unsigned int n_nonzero_components = 0;
398 for (
unsigned int d = 0;
d < dim * dim; ++
d)
399 if (shape_function_data[i].is_nonzero_shape_function_component[
d] ==
401 ++n_nonzero_components;
403 if (n_nonzero_components == 0)
404 shape_function_data[i].single_nonzero_component = -2;
405 else if (n_nonzero_components > 1)
406 shape_function_data[i].single_nonzero_component = -1;
409 for (
unsigned int d = 0;
d < dim * dim; ++
d)
410 if (shape_function_data[i]
411 .is_nonzero_shape_function_component[
d] ==
true)
413 shape_function_data[i].single_nonzero_component =
414 shape_function_data[i].row_index[
d];
415 shape_function_data[i].single_nonzero_component_index =
d;
424 template <
int dim,
int spacedim>
438 template <
int dim,
int spacedim,
typename Number>
444 &shape_function_data,
447 const unsigned int dofs_per_cell = dof_values.
size();
448 const unsigned int n_quadrature_points =
values.size();
454 for (
unsigned int shape_function = 0; shape_function < dofs_per_cell;
456 if (shape_function_data[shape_function]
457 .is_nonzero_shape_function_component)
459 const Number &value = dof_values[shape_function];
466 const double *shape_value_ptr =
467 &shape_values(shape_function_data[shape_function].row_index, 0);
468 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
470 values[q_point] += value * (*shape_value_ptr++);
478 template <
int order,
int dim,
int spacedim,
typename Number>
484 &shape_function_data,
489 const unsigned int dofs_per_cell = dof_values.
size();
490 const unsigned int n_quadrature_points = derivatives.size();
497 for (
unsigned int shape_function = 0; shape_function < dofs_per_cell;
499 if (shape_function_data[shape_function]
500 .is_nonzero_shape_function_component)
502 const Number &value = dof_values[shape_function];
509 const ::Tensor<order, spacedim> *shape_derivative_ptr =
510 &shape_derivatives[shape_function_data[shape_function].row_index]
512 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
514 derivatives[q_point] += value * (*shape_derivative_ptr++);
520 template <
int dim,
int spacedim,
typename Number>
526 & shape_function_data,
528 Number>::laplacian_type> &laplacians)
530 const unsigned int dofs_per_cell = dof_values.
size();
531 const unsigned int n_quadrature_points = laplacians.size();
533 std::fill(laplacians.begin(),
536 Number>::laplacian_type());
538 for (
unsigned int shape_function = 0; shape_function < dofs_per_cell;
540 if (shape_function_data[shape_function]
541 .is_nonzero_shape_function_component)
543 const Number &value = dof_values[shape_function];
550 const ::Tensor<2, spacedim> *shape_hessian_ptr =
551 &shape_hessians[shape_function_data[shape_function].row_index][0];
552 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
554 laplacians[q_point] += value *
trace(*shape_hessian_ptr++);
562 template <
int dim,
int spacedim,
typename Number>
568 &shape_function_data,
573 const unsigned int dofs_per_cell = dof_values.
size();
574 const unsigned int n_quadrature_points =
values.size();
581 for (
unsigned int shape_function = 0; shape_function < dofs_per_cell;
585 shape_function_data[shape_function].single_nonzero_component;
591 const Number &value = dof_values[shape_function];
600 const unsigned int comp = shape_function_data[shape_function]
601 .single_nonzero_component_index;
602 const double *shape_value_ptr = &shape_values(snc, 0);
603 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
605 values[q_point][comp] += value * (*shape_value_ptr++);
608 for (
unsigned int d = 0;
d < spacedim; ++
d)
609 if (shape_function_data[shape_function]
610 .is_nonzero_shape_function_component[
d])
612 const double *shape_value_ptr = &shape_values(
613 shape_function_data[shape_function].row_index[d], 0);
614 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
616 values[q_point][d] += value * (*shape_value_ptr++);
623 template <
int order,
int dim,
int spacedim,
typename Number>
629 &shape_function_data,
634 const unsigned int dofs_per_cell = dof_values.
size();
635 const unsigned int n_quadrature_points = derivatives.size();
643 for (
unsigned int shape_function = 0; shape_function < dofs_per_cell;
647 shape_function_data[shape_function].single_nonzero_component;
653 const Number &value = dof_values[shape_function];
662 const unsigned int comp = shape_function_data[shape_function]
663 .single_nonzero_component_index;
664 const ::Tensor<order, spacedim> *shape_derivative_ptr =
665 &shape_derivatives[snc][0];
666 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
668 derivatives[q_point][comp] += value * (*shape_derivative_ptr++);
671 for (
unsigned int d = 0;
d < spacedim; ++
d)
672 if (shape_function_data[shape_function]
673 .is_nonzero_shape_function_component[
d])
675 const ::Tensor<order, spacedim> *shape_derivative_ptr =
676 &shape_derivatives[shape_function_data[shape_function]
678 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
680 derivatives[q_point][d] +=
681 value * (*shape_derivative_ptr++);
688 template <
int dim,
int spacedim,
typename Number>
694 &shape_function_data,
698 &symmetric_gradients)
700 const unsigned int dofs_per_cell = dof_values.
size();
701 const unsigned int n_quadrature_points = symmetric_gradients.size();
704 symmetric_gradients.begin(),
705 symmetric_gradients.end(),
709 for (
unsigned int shape_function = 0; shape_function < dofs_per_cell;
713 shape_function_data[shape_function].single_nonzero_component;
719 const Number &value = dof_values[shape_function];
728 const unsigned int comp = shape_function_data[shape_function]
729 .single_nonzero_component_index;
730 const ::Tensor<1, spacedim> *shape_gradient_ptr =
731 &shape_gradients[snc][0];
732 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
734 symmetric_gradients[q_point] +=
736 symmetrize_single_row(comp, *shape_gradient_ptr++));
739 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
744 for (
unsigned int d = 0;
d < spacedim; ++
d)
745 if (shape_function_data[shape_function]
746 .is_nonzero_shape_function_component[
d])
749 shape_gradients[shape_function_data[shape_function]
750 .row_index[
d]][q_point];
751 symmetric_gradients[q_point] +=
symmetrize(grad);
758 template <
int dim,
int spacedim,
typename Number>
764 & shape_function_data,
766 Number>::divergence_type> &divergences)
768 const unsigned int dofs_per_cell = dof_values.
size();
769 const unsigned int n_quadrature_points = divergences.size();
771 std::fill(divergences.begin(),
774 Number>::divergence_type());
776 for (
unsigned int shape_function = 0; shape_function < dofs_per_cell;
780 shape_function_data[shape_function].single_nonzero_component;
786 const Number &value = dof_values[shape_function];
795 const unsigned int comp = shape_function_data[shape_function]
796 .single_nonzero_component_index;
797 const ::Tensor<1, spacedim> *shape_gradient_ptr =
798 &shape_gradients[snc][0];
799 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
801 divergences[q_point] += value * (*shape_gradient_ptr++)[comp];
804 for (
unsigned int d = 0;
d < spacedim; ++
d)
805 if (shape_function_data[shape_function]
806 .is_nonzero_shape_function_component[
d])
808 const ::Tensor<1, spacedim> *shape_gradient_ptr =
809 &shape_gradients[shape_function_data[shape_function]
811 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
813 divergences[q_point] += value * (*shape_gradient_ptr++)[
d];
820 template <
int dim,
int spacedim,
typename Number>
826 &shape_function_data,
829 typename ::internal::CurlType<spacedim>::type>::type> &curls)
831 const unsigned int dofs_per_cell = dof_values.
size();
832 const unsigned int n_quadrature_points = curls.size();
834 std::fill(curls.begin(),
838 typename ::internal::CurlType<spacedim>::type>::type());
846 "Computing the curl in 1d is not a useful operation"));
852 for (
unsigned int shape_function = 0;
853 shape_function < dofs_per_cell;
856 const int snc = shape_function_data[shape_function]
857 .single_nonzero_component;
863 const Number &value = dof_values[shape_function];
873 const ::Tensor<1, spacedim> *shape_gradient_ptr =
874 &shape_gradients[snc][0];
876 Assert(shape_function_data[shape_function]
877 .single_nonzero_component >= 0,
880 if (shape_function_data[shape_function]
881 .single_nonzero_component_index == 0)
882 for (
unsigned int q_point = 0;
883 q_point < n_quadrature_points;
886 value * (*shape_gradient_ptr++)[1];
888 for (
unsigned int q_point = 0;
889 q_point < n_quadrature_points;
892 value * (*shape_gradient_ptr++)[0];
900 if (shape_function_data[shape_function]
901 .is_nonzero_shape_function_component[0])
904 spacedim> *shape_gradient_ptr =
905 &shape_gradients[shape_function_data[shape_function]
908 for (
unsigned int q_point = 0;
909 q_point < n_quadrature_points;
912 value * (*shape_gradient_ptr++)[1];
915 if (shape_function_data[shape_function]
916 .is_nonzero_shape_function_component[1])
919 spacedim> *shape_gradient_ptr =
920 &shape_gradients[shape_function_data[shape_function]
923 for (
unsigned int q_point = 0;
924 q_point < n_quadrature_points;
927 value * (*shape_gradient_ptr++)[0];
936 for (
unsigned int shape_function = 0;
937 shape_function < dofs_per_cell;
940 const int snc = shape_function_data[shape_function]
941 .single_nonzero_component;
947 const Number &value = dof_values[shape_function];
957 const ::Tensor<1, spacedim> *shape_gradient_ptr =
958 &shape_gradients[snc][0];
960 switch (shape_function_data[shape_function]
961 .single_nonzero_component_index)
965 for (
unsigned int q_point = 0;
966 q_point < n_quadrature_points;
970 value * (*shape_gradient_ptr)[2];
972 value * (*shape_gradient_ptr++)[1];
980 for (
unsigned int q_point = 0;
981 q_point < n_quadrature_points;
985 value * (*shape_gradient_ptr)[2];
987 value * (*shape_gradient_ptr++)[0];
995 for (
unsigned int q_point = 0;
996 q_point < n_quadrature_points;
1000 value * (*shape_gradient_ptr)[1];
1001 curls[q_point][1] -=
1002 value * (*shape_gradient_ptr++)[0];
1018 if (shape_function_data[shape_function]
1019 .is_nonzero_shape_function_component[0])
1022 spacedim> *shape_gradient_ptr =
1023 &shape_gradients[shape_function_data[shape_function]
1026 for (
unsigned int q_point = 0;
1027 q_point < n_quadrature_points;
1030 curls[q_point][1] +=
1031 value * (*shape_gradient_ptr)[2];
1032 curls[q_point][2] -=
1033 value * (*shape_gradient_ptr++)[1];
1037 if (shape_function_data[shape_function]
1038 .is_nonzero_shape_function_component[1])
1041 spacedim> *shape_gradient_ptr =
1042 &shape_gradients[shape_function_data[shape_function]
1045 for (
unsigned int q_point = 0;
1046 q_point < n_quadrature_points;
1049 curls[q_point][0] -=
1050 value * (*shape_gradient_ptr)[2];
1051 curls[q_point][2] +=
1052 value * (*shape_gradient_ptr++)[0];
1056 if (shape_function_data[shape_function]
1057 .is_nonzero_shape_function_component[2])
1060 spacedim> *shape_gradient_ptr =
1061 &shape_gradients[shape_function_data[shape_function]
1064 for (
unsigned int q_point = 0;
1065 q_point < n_quadrature_points;
1068 curls[q_point][0] +=
1069 value * (*shape_gradient_ptr)[1];
1070 curls[q_point][1] -=
1071 value * (*shape_gradient_ptr++)[0];
1082 template <
int dim,
int spacedim,
typename Number>
1088 & shape_function_data,
1090 Number>::laplacian_type> &laplacians)
1092 const unsigned int dofs_per_cell = dof_values.
size();
1093 const unsigned int n_quadrature_points = laplacians.size();
1095 std::fill(laplacians.begin(),
1098 Number>::laplacian_type());
1100 for (
unsigned int shape_function = 0; shape_function < dofs_per_cell;
1104 shape_function_data[shape_function].single_nonzero_component;
1110 const Number &value = dof_values[shape_function];
1119 const unsigned int comp = shape_function_data[shape_function]
1120 .single_nonzero_component_index;
1121 const ::Tensor<2, spacedim> *shape_hessian_ptr =
1122 &shape_hessians[snc][0];
1123 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
1125 laplacians[q_point][comp] +=
1126 value *
trace(*shape_hessian_ptr++);
1129 for (
unsigned int d = 0;
d < spacedim; ++
d)
1130 if (shape_function_data[shape_function]
1131 .is_nonzero_shape_function_component[
d])
1133 const ::Tensor<2, spacedim> *shape_hessian_ptr =
1134 &shape_hessians[shape_function_data[shape_function]
1136 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
1138 laplacians[q_point][d] +=
1139 value *
trace(*shape_hessian_ptr++);
1148 template <
int dim,
int spacedim,
typename Number>
1152 const ::Table<2, double> &shape_values,
1155 &shape_function_data,
1161 const unsigned int dofs_per_cell = dof_values.
size();
1162 const unsigned int n_quadrature_points =
values.size();
1170 for (
unsigned int shape_function = 0; shape_function < dofs_per_cell;
1174 shape_function_data[shape_function].single_nonzero_component;
1180 const Number &value = dof_values[shape_function];
1191 shape_function_data[shape_function]
1192 .single_nonzero_component_index);
1193 const double *shape_value_ptr = &shape_values(snc, 0);
1194 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
1196 values[q_point][comp] += value * (*shape_value_ptr++);
1199 for (
unsigned int d = 0;
1203 if (shape_function_data[shape_function]
1204 .is_nonzero_shape_function_component[
d])
1209 const double *shape_value_ptr = &shape_values(
1210 shape_function_data[shape_function].row_index[d], 0);
1211 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
1213 values[q_point][comp] += value * (*shape_value_ptr++);
1220 template <
int dim,
int spacedim,
typename Number>
1227 &shape_function_data,
1229 template OutputType<Number>::divergence_type> &divergences)
1231 const unsigned int dofs_per_cell = dof_values.
size();
1232 const unsigned int n_quadrature_points = divergences.size();
1234 std::fill(divergences.begin(),
1237 Number>::divergence_type());
1239 for (
unsigned int shape_function = 0; shape_function < dofs_per_cell;
1243 shape_function_data[shape_function].single_nonzero_component;
1249 const Number &value = dof_values[shape_function];
1258 const unsigned int comp = shape_function_data[shape_function]
1259 .single_nonzero_component_index;
1261 const ::Tensor<1, spacedim> *shape_gradient_ptr =
1262 &shape_gradients[snc][0];
1269 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
1270 ++q_point, ++shape_gradient_ptr)
1272 divergences[q_point][ii] += value * (*shape_gradient_ptr)[jj];
1275 divergences[q_point][jj] +=
1276 value * (*shape_gradient_ptr)[ii];
1281 for (
unsigned int d = 0;
1284 spacedim>::n_independent_components;
1286 if (shape_function_data[shape_function]
1287 .is_nonzero_shape_function_component[
d])
1299 const unsigned int comp =
1300 shape_function_data[shape_function]
1301 .single_nonzero_component_index;
1303 const ::Tensor<1, spacedim> *shape_gradient_ptr =
1304 &shape_gradients[shape_function_data[shape_function]
1306 for (
unsigned int q_point = 0;
1307 q_point < n_quadrature_points;
1308 ++q_point, ++shape_gradient_ptr)
1310 for (
unsigned int j = 0; j < spacedim; ++j)
1312 const unsigned int vector_component =
1316 divergences[q_point][vector_component] +=
1317 value * (*shape_gradient_ptr++)[j];
1327 template <
int dim,
int spacedim,
typename Number>
1331 const ::Table<2, double> &shape_values,
1333 &shape_function_data,
1338 const unsigned int dofs_per_cell = dof_values.
size();
1339 const unsigned int n_quadrature_points =
values.size();
1346 for (
unsigned int shape_function = 0; shape_function < dofs_per_cell;
1350 shape_function_data[shape_function].single_nonzero_component;
1356 const Number &value = dof_values[shape_function];
1365 const unsigned int comp = shape_function_data[shape_function]
1366 .single_nonzero_component_index;
1372 const double *shape_value_ptr = &shape_values(snc, 0);
1373 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
1375 values[q_point][indices] += value * (*shape_value_ptr++);
1378 for (
unsigned int d = 0;
d < dim * dim; ++
d)
1379 if (shape_function_data[shape_function]
1380 .is_nonzero_shape_function_component[
d])
1386 const double *shape_value_ptr = &shape_values(
1387 shape_function_data[shape_function].row_index[d], 0);
1388 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
1390 values[q_point][indices] += value * (*shape_value_ptr++);
1397 template <
int dim,
int spacedim,
typename Number>
1403 & shape_function_data,
1405 Number>::divergence_type> &divergences)
1407 const unsigned int dofs_per_cell = dof_values.
size();
1408 const unsigned int n_quadrature_points = divergences.size();
1410 std::fill(divergences.begin(),
1413 Number>::divergence_type());
1415 for (
unsigned int shape_function = 0; shape_function < dofs_per_cell;
1419 shape_function_data[shape_function].single_nonzero_component;
1425 const Number &value = dof_values[shape_function];
1434 const unsigned int comp = shape_function_data[shape_function]
1435 .single_nonzero_component_index;
1437 const ::Tensor<1, spacedim> *shape_gradient_ptr =
1438 &shape_gradients[snc][0];
1443 const unsigned int ii = indices[0];
1444 const unsigned int jj = indices[1];
1446 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
1447 ++q_point, ++shape_gradient_ptr)
1449 divergences[q_point][ii] += value * (*shape_gradient_ptr)[jj];
1454 for (
unsigned int d = 0;
d < dim * dim; ++
d)
1455 if (shape_function_data[shape_function]
1456 .is_nonzero_shape_function_component[
d])
1466 template <
int dim,
int spacedim,
typename Number>
1472 & shape_function_data,
1476 const unsigned int dofs_per_cell = dof_values.
size();
1477 const unsigned int n_quadrature_points =
gradients.size();
1482 Number>::gradient_type());
1484 for (
unsigned int shape_function = 0; shape_function < dofs_per_cell;
1488 shape_function_data[shape_function].single_nonzero_component;
1494 const Number &value = dof_values[shape_function];
1503 const unsigned int comp = shape_function_data[shape_function]
1504 .single_nonzero_component_index;
1506 const ::Tensor<1, spacedim> *shape_gradient_ptr =
1507 &shape_gradients[snc][0];
1512 const unsigned int ii = indices[0];
1513 const unsigned int jj = indices[1];
1515 for (
unsigned int q_point = 0; q_point < n_quadrature_points;
1516 ++q_point, ++shape_gradient_ptr)
1518 gradients[q_point][ii][jj] += value * (*shape_gradient_ptr);
1523 for (
unsigned int d = 0;
d < dim * dim; ++
d)
1524 if (shape_function_data[shape_function]
1525 .is_nonzero_shape_function_component[
d])
1537 template <
int dim,
int spacedim>
1538 template <
class InputVector>
1541 const InputVector &fe_function,
1549 Assert(fe_values->present_cell.get() !=
nullptr,
1550 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1552 fe_values->present_cell->n_dofs_for_dof_handler());
1557 fe_values->dofs_per_cell);
1558 fe_values->present_cell->get_interpolated_dof_values(fe_function,
1560 internal::do_function_values<dim, spacedim>(
1562 fe_values->finite_element_output.shape_values,
1563 shape_function_data,
1569 template <
int dim,
int spacedim>
1570 template <
class InputVector>
1573 const InputVector &dof_values,
1581 Assert(fe_values->present_cell.get() !=
nullptr,
1582 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1585 internal::do_function_values<dim, spacedim>(
1587 fe_values->finite_element_output.shape_values,
1588 shape_function_data,
1594 template <
int dim,
int spacedim>
1595 template <
class InputVector>
1598 const InputVector &fe_function,
1600 typename InputVector::value_type>::type>
1605 "update_gradients")));
1606 Assert(fe_values->present_cell.get() !=
nullptr,
1607 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1609 fe_values->present_cell->n_dofs_for_dof_handler());
1613 fe_values->dofs_per_cell);
1614 fe_values->present_cell->get_interpolated_dof_values(fe_function,
1616 internal::do_function_derivatives<1, dim, spacedim>(
1618 fe_values->finite_element_output.shape_gradients,
1619 shape_function_data,
1625 template <
int dim,
int spacedim>
1626 template <
class InputVector>
1629 const InputVector &dof_values,
1636 "update_gradients")));
1637 Assert(fe_values->present_cell.get() !=
nullptr,
1638 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1641 internal::do_function_derivatives<1, dim, spacedim>(
1643 fe_values->finite_element_output.shape_gradients,
1644 shape_function_data,
1650 template <
int dim,
int spacedim>
1651 template <
class InputVector>
1654 const InputVector &fe_function,
1656 typename InputVector::value_type>::type>
1661 "update_hessians")));
1662 Assert(fe_values->present_cell.get() !=
nullptr,
1663 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1665 fe_values->present_cell->n_dofs_for_dof_handler());
1669 fe_values->dofs_per_cell);
1670 fe_values->present_cell->get_interpolated_dof_values(fe_function,
1672 internal::do_function_derivatives<2, dim, spacedim>(
1674 fe_values->finite_element_output.shape_hessians,
1675 shape_function_data,
1681 template <
int dim,
int spacedim>
1682 template <
class InputVector>
1685 const InputVector &dof_values,
1692 "update_hessians")));
1693 Assert(fe_values->present_cell.get() !=
nullptr,
1694 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1697 internal::do_function_derivatives<2, dim, spacedim>(
1699 fe_values->finite_element_output.shape_hessians,
1700 shape_function_data,
1706 template <
int dim,
int spacedim>
1707 template <
class InputVector>
1710 const InputVector &fe_function,
1717 "update_hessians")));
1718 Assert(fe_values->present_cell.get() !=
nullptr,
1719 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1721 fe_values->present_cell->n_dofs_for_dof_handler());
1725 fe_values->dofs_per_cell);
1726 fe_values->present_cell->get_interpolated_dof_values(fe_function,
1728 internal::do_function_laplacians<dim, spacedim>(
1730 fe_values->finite_element_output.shape_hessians,
1731 shape_function_data,
1737 template <
int dim,
int spacedim>
1738 template <
class InputVector>
1741 const InputVector &dof_values,
1748 "update_hessians")));
1749 Assert(fe_values->present_cell.get() !=
nullptr,
1750 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1753 internal::do_function_laplacians<dim, spacedim>(
1755 fe_values->finite_element_output.shape_hessians,
1756 shape_function_data,
1762 template <
int dim,
int spacedim>
1763 template <
class InputVector>
1766 const InputVector &fe_function,
1768 typename InputVector::value_type>::type>
1769 &third_derivatives)
const 1773 "update_3rd_derivatives")));
1774 Assert(fe_values->present_cell.get() !=
nullptr,
1775 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1777 fe_values->present_cell->n_dofs_for_dof_handler());
1781 fe_values->dofs_per_cell);
1782 fe_values->present_cell->get_interpolated_dof_values(fe_function,
1784 internal::do_function_derivatives<3, dim, spacedim>(
1786 fe_values->finite_element_output.shape_3rd_derivatives,
1787 shape_function_data,
1793 template <
int dim,
int spacedim>
1794 template <
class InputVector>
1797 const InputVector & dof_values,
1803 "update_3rd_derivatives")));
1804 Assert(fe_values->present_cell.get() !=
nullptr,
1805 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1808 internal::do_function_derivatives<3, dim, spacedim>(
1810 fe_values->finite_element_output.shape_3rd_derivatives,
1811 shape_function_data,
1817 template <
int dim,
int spacedim>
1818 template <
class InputVector>
1821 const InputVector &fe_function,
1829 Assert(fe_values->present_cell.get() !=
nullptr,
1830 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1832 fe_values->present_cell->n_dofs_for_dof_handler());
1836 fe_values->dofs_per_cell);
1837 fe_values->present_cell->get_interpolated_dof_values(fe_function,
1839 internal::do_function_values<dim, spacedim>(
1841 fe_values->finite_element_output.shape_values,
1842 shape_function_data,
1848 template <
int dim,
int spacedim>
1849 template <
class InputVector>
1852 const InputVector &dof_values,
1860 Assert(fe_values->present_cell.get() !=
nullptr,
1861 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1864 internal::do_function_values<dim, spacedim>(
1866 fe_values->finite_element_output.shape_values,
1867 shape_function_data,
1873 template <
int dim,
int spacedim>
1874 template <
class InputVector>
1877 const InputVector &fe_function,
1879 typename InputVector::value_type>::type>
1884 "update_gradients")));
1885 Assert(fe_values->present_cell.get() !=
nullptr,
1886 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1888 fe_values->present_cell->n_dofs_for_dof_handler());
1892 fe_values->dofs_per_cell);
1893 fe_values->present_cell->get_interpolated_dof_values(fe_function,
1895 internal::do_function_derivatives<1, dim, spacedim>(
1897 fe_values->finite_element_output.shape_gradients,
1898 shape_function_data,
1904 template <
int dim,
int spacedim>
1905 template <
class InputVector>
1908 const InputVector &dof_values,
1915 "update_gradients")));
1916 Assert(fe_values->present_cell.get() !=
nullptr,
1917 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1920 internal::do_function_derivatives<1, dim, spacedim>(
1922 fe_values->finite_element_output.shape_gradients,
1923 shape_function_data,
1929 template <
int dim,
int spacedim>
1930 template <
class InputVector>
1933 const InputVector &fe_function,
1935 typename InputVector::value_type>::type>
1936 &symmetric_gradients)
const 1940 "update_gradients")));
1941 Assert(fe_values->present_cell.get() !=
nullptr,
1942 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1944 fe_values->present_cell->n_dofs_for_dof_handler());
1948 fe_values->dofs_per_cell);
1949 fe_values->present_cell->get_interpolated_dof_values(fe_function,
1951 internal::do_function_symmetric_gradients<dim, spacedim>(
1953 fe_values->finite_element_output.shape_gradients,
1954 shape_function_data,
1955 symmetric_gradients);
1960 template <
int dim,
int spacedim>
1961 template <
class InputVector>
1964 const InputVector & dof_values,
1970 "update_gradients")));
1971 Assert(fe_values->present_cell.get() !=
nullptr,
1972 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1975 internal::do_function_symmetric_gradients<dim, spacedim>(
1977 fe_values->finite_element_output.shape_gradients,
1978 shape_function_data,
1979 symmetric_gradients);
1984 template <
int dim,
int spacedim>
1985 template <
class InputVector>
1988 const InputVector &fe_function,
1990 typename InputVector::value_type>::type>
1995 "update_gradients")));
1996 Assert(fe_values->present_cell.get() !=
nullptr,
1997 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
1999 fe_values->present_cell->n_dofs_for_dof_handler());
2004 fe_values->dofs_per_cell);
2005 fe_values->present_cell->get_interpolated_dof_values(fe_function,
2007 internal::do_function_divergences<dim, spacedim>(
2009 fe_values->finite_element_output.shape_gradients,
2010 shape_function_data,
2016 template <
int dim,
int spacedim>
2017 template <
class InputVector>
2020 const InputVector &dof_values,
2027 "update_gradients")));
2028 Assert(fe_values->present_cell.get() !=
nullptr,
2029 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2032 internal::do_function_divergences<dim, spacedim>(
2034 fe_values->finite_element_output.shape_gradients,
2035 shape_function_data,
2041 template <
int dim,
int spacedim>
2042 template <
class InputVector>
2045 const InputVector &fe_function,
2052 "update_gradients")));
2053 Assert(fe_values->present_cell.get() !=
nullptr,
2054 ExcMessage(
"FEValues object is not reinited to any cell"));
2056 fe_values->present_cell->n_dofs_for_dof_handler());
2060 fe_values->dofs_per_cell);
2061 fe_values->present_cell->get_interpolated_dof_values(fe_function,
2063 internal::do_function_curls<dim, spacedim>(
2065 fe_values->finite_element_output.shape_gradients,
2066 shape_function_data,
2072 template <
int dim,
int spacedim>
2073 template <
class InputVector>
2076 const InputVector &dof_values,
2083 "update_gradients")));
2084 Assert(fe_values->present_cell.get() !=
nullptr,
2085 ExcMessage(
"FEValues object is not reinited to any cell"));
2088 internal::do_function_curls<dim, spacedim>(
2090 fe_values->finite_element_output.shape_gradients,
2091 shape_function_data,
2097 template <
int dim,
int spacedim>
2098 template <
class InputVector>
2101 const InputVector &fe_function,
2103 typename InputVector::value_type>::type>
2108 "update_hessians")));
2109 Assert(fe_values->present_cell.get() !=
nullptr,
2110 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2112 fe_values->present_cell->n_dofs_for_dof_handler());
2116 fe_values->dofs_per_cell);
2117 fe_values->present_cell->get_interpolated_dof_values(fe_function,
2119 internal::do_function_derivatives<2, dim, spacedim>(
2121 fe_values->finite_element_output.shape_hessians,
2122 shape_function_data,
2128 template <
int dim,
int spacedim>
2129 template <
class InputVector>
2132 const InputVector &dof_values,
2139 "update_hessians")));
2140 Assert(fe_values->present_cell.get() !=
nullptr,
2141 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2144 internal::do_function_derivatives<2, dim, spacedim>(
2146 fe_values->finite_element_output.shape_hessians,
2147 shape_function_data,
2153 template <
int dim,
int spacedim>
2154 template <
class InputVector>
2157 const InputVector &fe_function,
2164 "update_hessians")));
2165 Assert(laplacians.size() == fe_values->n_quadrature_points,
2167 fe_values->n_quadrature_points));
2168 Assert(fe_values->present_cell.get() !=
nullptr,
2169 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2171 fe_function.size() == fe_values->present_cell->n_dofs_for_dof_handler(),
2173 fe_values->present_cell->n_dofs_for_dof_handler()));
2177 fe_values->dofs_per_cell);
2178 fe_values->present_cell->get_interpolated_dof_values(fe_function,
2180 internal::do_function_laplacians<dim, spacedim>(
2182 fe_values->finite_element_output.shape_hessians,
2183 shape_function_data,
2189 template <
int dim,
int spacedim>
2190 template <
class InputVector>
2193 const InputVector &dof_values,
2200 "update_hessians")));
2201 Assert(laplacians.size() == fe_values->n_quadrature_points,
2203 fe_values->n_quadrature_points));
2204 Assert(fe_values->present_cell.get() !=
nullptr,
2205 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2208 internal::do_function_laplacians<dim, spacedim>(
2210 fe_values->finite_element_output.shape_hessians,
2211 shape_function_data,
2217 template <
int dim,
int spacedim>
2218 template <
class InputVector>
2221 const InputVector &fe_function,
2223 typename InputVector::value_type>::type>
2224 &third_derivatives)
const 2228 "update_3rd_derivatives")));
2229 Assert(fe_values->present_cell.get() !=
nullptr,
2230 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2232 fe_values->present_cell->n_dofs_for_dof_handler());
2236 fe_values->dofs_per_cell);
2237 fe_values->present_cell->get_interpolated_dof_values(fe_function,
2239 internal::do_function_derivatives<3, dim, spacedim>(
2241 fe_values->finite_element_output.shape_3rd_derivatives,
2242 shape_function_data,
2248 template <
int dim,
int spacedim>
2249 template <
class InputVector>
2252 const InputVector & dof_values,
2258 "update_3rd_derivatives")));
2259 Assert(fe_values->present_cell.get() !=
nullptr,
2260 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2263 internal::do_function_derivatives<3, dim, spacedim>(
2265 fe_values->finite_element_output.shape_3rd_derivatives,
2266 shape_function_data,
2272 template <
int dim,
int spacedim>
2273 template <
class InputVector>
2276 const InputVector &fe_function,
2284 Assert(fe_values->present_cell.get() !=
nullptr,
2285 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2287 fe_values->present_cell->n_dofs_for_dof_handler());
2291 fe_values->dofs_per_cell);
2292 fe_values->present_cell->get_interpolated_dof_values(fe_function,
2294 internal::do_function_values<dim, spacedim>(
2296 fe_values->finite_element_output.shape_values,
2297 shape_function_data,
2303 template <
int dim,
int spacedim>
2304 template <
class InputVector>
2307 const InputVector &dof_values,
2315 Assert(fe_values->present_cell.get() !=
nullptr,
2316 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2319 internal::do_function_values<dim, spacedim>(
2321 fe_values->finite_element_output.shape_values,
2322 shape_function_data,
2328 template <
int dim,
int spacedim>
2329 template <
class InputVector>
2332 const InputVector &fe_function,
2334 typename InputVector::value_type>::type>
2339 "update_gradients")));
2340 Assert(fe_values->present_cell.get() !=
nullptr,
2341 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2343 fe_values->present_cell->n_dofs_for_dof_handler());
2348 fe_values->dofs_per_cell);
2349 fe_values->present_cell->get_interpolated_dof_values(fe_function,
2351 internal::do_function_divergences<dim, spacedim>(
2353 fe_values->finite_element_output.shape_gradients,
2354 shape_function_data,
2360 template <
int dim,
int spacedim>
2361 template <
class InputVector>
2365 const InputVector &dof_values,
2372 "update_gradients")));
2373 Assert(fe_values->present_cell.get() !=
nullptr,
2374 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2377 internal::do_function_divergences<dim, spacedim>(
2379 fe_values->finite_element_output.shape_gradients,
2380 shape_function_data,
2386 template <
int dim,
int spacedim>
2387 template <
class InputVector>
2390 const InputVector &fe_function,
2398 Assert(fe_values->present_cell.get() !=
nullptr,
2399 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2401 fe_values->present_cell->n_dofs_for_dof_handler());
2405 fe_values->dofs_per_cell);
2406 fe_values->present_cell->get_interpolated_dof_values(fe_function,
2408 internal::do_function_values<dim, spacedim>(
2410 fe_values->finite_element_output.shape_values,
2411 shape_function_data,
2417 template <
int dim,
int spacedim>
2418 template <
class InputVector>
2421 const InputVector &dof_values,
2429 Assert(fe_values->present_cell.get() !=
nullptr,
2430 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2433 internal::do_function_values<dim, spacedim>(
2435 fe_values->finite_element_output.shape_values,
2436 shape_function_data,
2442 template <
int dim,
int spacedim>
2443 template <
class InputVector>
2446 const InputVector &fe_function,
2448 typename InputVector::value_type>::type>
2453 "update_gradients")));
2454 Assert(fe_values->present_cell.get() !=
nullptr,
2455 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2457 fe_values->present_cell->n_dofs_for_dof_handler());
2462 fe_values->dofs_per_cell);
2463 fe_values->present_cell->get_interpolated_dof_values(fe_function,
2465 internal::do_function_divergences<dim, spacedim>(
2467 fe_values->finite_element_output.shape_gradients,
2468 shape_function_data,
2474 template <
int dim,
int spacedim>
2475 template <
class InputVector>
2478 const InputVector &dof_values,
2485 "update_gradients")));
2486 Assert(fe_values->present_cell.get() !=
nullptr,
2487 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2490 internal::do_function_divergences<dim, spacedim>(
2492 fe_values->finite_element_output.shape_gradients,
2493 shape_function_data,
2499 template <
int dim,
int spacedim>
2500 template <
class InputVector>
2503 const InputVector &fe_function,
2505 typename InputVector::value_type>::type>
2510 "update_gradients")));
2511 Assert(fe_values->present_cell.get() !=
nullptr,
2512 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2514 fe_values->present_cell->n_dofs_for_dof_handler());
2519 fe_values->dofs_per_cell);
2520 fe_values->present_cell->get_interpolated_dof_values(fe_function,
2522 internal::do_function_gradients<dim, spacedim>(
2524 fe_values->finite_element_output.shape_gradients,
2525 shape_function_data,
2531 template <
int dim,
int spacedim>
2532 template <
class InputVector>
2535 const InputVector &dof_values,
2542 "update_gradients")));
2543 Assert(fe_values->present_cell.get() !=
nullptr,
2544 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
2547 internal::do_function_gradients<dim, spacedim>(
2549 fe_values->finite_element_output.shape_gradients,
2550 shape_function_data,
2561 template <
int dim,
int spacedim>
2567 scalars.reserve(n_scalars);
2568 for (
unsigned int component = 0; component < n_scalars; ++component)
2569 scalars.emplace_back(fe_values, component);
2574 const unsigned int n_vectors =
2576 vectors.reserve(n_vectors);
2577 for (
unsigned int component = 0; component < n_vectors; ++component)
2578 vectors.emplace_back(fe_values, component);
2581 const unsigned int n_symmetric_second_order_tensors =
2585 symmetric_second_order_tensors.reserve(n_symmetric_second_order_tensors);
2586 for (
unsigned int component = 0;
2587 component < n_symmetric_second_order_tensors;
2589 symmetric_second_order_tensors.emplace_back(fe_values, component);
2593 const unsigned int n_second_order_tensors =
2596 second_order_tensors.reserve(n_second_order_tensors);
2597 for (
unsigned int component = 0; component < n_second_order_tensors;
2599 second_order_tensors.emplace_back(fe_values, component);
2607 template <
int dim,
int spacedim>
2631 n_dofs_for_dof_handler()
const = 0;
2633 #include "fe_values.decl.1.inst" 2640 get_interpolated_dof_values(
const IndexSet & in,
2641 Vector<IndexSet::value_type> &out)
const = 0;
2651 template <
int dim,
int spacedim>
2652 template <
typename CI>
2676 n_dofs_for_dof_handler()
const override;
2678 #include "fe_values.decl.2.inst" 2685 get_interpolated_dof_values(
const IndexSet & in,
2686 Vector<IndexSet::value_type> &out)
const override;
2714 template <
int dim,
int spacedim>
2740 n_dofs_for_dof_handler()
const override;
2742 #include "fe_values.decl.2.inst" 2749 get_interpolated_dof_values(
const IndexSet & in,
2750 Vector<IndexSet::value_type> &out)
const override;
2771 template <
int dim,
int spacedim>
2772 template <
typename CI>
2779 template <
int dim,
int spacedim>
2780 template <
typename CI>
2789 template <
int dim,
int spacedim>
2790 template <
typename CI>
2794 return cell->get_dof_handler().n_dofs();
2799 #include "fe_values.impl.1.inst" 2803 template <
int dim,
int spacedim>
2804 template <
typename CI>
2808 Vector<IndexSet::value_type> &out)
const 2813 cell->get_fe().n_dofs_per_cell());
2816 for (
unsigned int i = 0; i <
cell->get_fe().n_dofs_per_cell(); ++i)
2823 template <
int dim,
int spacedim>
2825 spacedim>::TriaCellIterator::message_string =
2826 (
"You have previously called the FEValues::reinit function with a\n" 2827 "cell iterator of type Triangulation<dim,spacedim>::cell_iterator. However,\n" 2828 "when you do this, you cannot call some functions in the FEValues\n" 2829 "class, such as the get_function_values/gradients/hessians/third_derivatives\n" 2830 "functions. If you need these functions, then you need to call\n" 2831 "FEValues::reinit with an iterator type that allows to extract\n" 2832 "degrees of freedom, such as DoFHandler<dim,spacedim>::cell_iterator.");
2836 template <
int dim,
int spacedim>
2844 template <
int dim,
int spacedim>
2853 template <
int dim,
int spacedim>
2863 #include "fe_values.impl.2.inst" 2867 template <
int dim,
int spacedim>
2871 Vector<IndexSet::value_type> &)
const 2880 namespace FEValuesImplementation
2882 template <
int dim,
int spacedim>
2890 n_quadrature_points,
2894 this->JxW_values.resize(n_quadrature_points,
2895 numbers::signaling_nan<double>());
2898 this->jacobians.resize(
2899 n_quadrature_points,
2903 this->jacobian_grads.resize(
2904 n_quadrature_points,
2908 this->jacobian_pushed_forward_grads.resize(
2912 this->jacobian_2nd_derivatives.resize(
2913 n_quadrature_points,
2917 this->jacobian_pushed_forward_2nd_derivatives.resize(
2921 this->jacobian_3rd_derivatives.resize(n_quadrature_points);
2924 this->jacobian_pushed_forward_3rd_derivatives.resize(
2928 this->inverse_jacobians.resize(
2929 n_quadrature_points,
2933 this->boundary_forms.resize(
2937 this->normal_vectors.resize(
2943 template <
int dim,
int spacedim>
2954 jacobian_pushed_forward_2nd_derivatives) +
2957 jacobian_pushed_forward_3rd_derivatives) +
2966 template <
int dim,
int spacedim>
2976 this->shape_function_to_row_table =
2981 unsigned int n_nonzero_shape_components = 0;
2991 this->shape_values.reinit(n_nonzero_shape_components,
2992 n_quadrature_points);
2993 this->shape_values.fill(numbers::signaling_nan<double>());
2998 this->shape_gradients.reinit(n_nonzero_shape_components,
2999 n_quadrature_points);
3000 this->shape_gradients.fill(
3006 this->shape_hessians.reinit(n_nonzero_shape_components,
3007 n_quadrature_points);
3008 this->shape_hessians.fill(
3014 this->shape_3rd_derivatives.reinit(n_nonzero_shape_components,
3015 n_quadrature_points);
3016 this->shape_3rd_derivatives.fill(
3023 template <
int dim,
int spacedim>
3042 template <
int dim,
int spacedim>
3044 const unsigned int n_q_points,
3051 , dofs_per_cell(dofs_per_cell)
3052 , mapping(&mapping, typeid(*this).name())
3053 , fe(&fe, typeid(*this).name())
3058 ExcMessage(
"There is nothing useful you can do with an FEValues " 3059 "object when using a quadrature formula with zero " 3060 "quadrature points!"));
3066 template <
int dim,
int spacedim>
3084 template <
typename Number,
typename Number2>
3087 const ::Table<2, double> &shape_values,
3088 std::vector<Number> &
values)
3095 std::fill_n(values.begin(),
3106 for (
unsigned int shape_func = 0; shape_func <
dofs_per_cell; ++shape_func)
3108 const Number2
value = dof_values_ptr[shape_func];
3116 const double *shape_value_ptr = &shape_values(shape_func, 0);
3118 values[
point] += value * (*shape_value_ptr++);
3124 template <
int dim,
int spacedim,
typename VectorType>
3127 const typename VectorType::value_type *dof_values_ptr,
3128 const ::Table<2, double> & shape_values,
3130 const std::vector<unsigned int> & shape_function_to_row_table,
3132 const bool quadrature_points_fastest =
false,
3133 const unsigned int component_multiple = 1)
3135 using Number =
typename VectorType::value_type;
3137 for (
unsigned int i = 0; i < values.
size(); ++i)
3138 std::fill_n(values[i].
begin(),
3140 typename VectorType::value_type());
3145 if (dofs_per_cell == 0)
3149 quadrature_points_fastest ? values[0].
size() : values.
size();
3153 const unsigned result_components = n_components * component_multiple;
3154 (void)result_components;
3155 if (quadrature_points_fastest)
3158 for (
unsigned int i = 0; i < values.
size(); ++i)
3164 for (
unsigned int i = 0; i < values.
size(); ++i)
3171 for (
unsigned int mc = 0; mc < component_multiple; ++mc)
3172 for (
unsigned int shape_func = 0; shape_func <
dofs_per_cell;
3184 const unsigned int comp =
3187 const unsigned int row =
3188 shape_function_to_row_table[shape_func * n_components + comp];
3190 const double *shape_value_ptr = &shape_values(row, 0);
3192 if (quadrature_points_fastest)
3197 values_comp[
point] += value * (*shape_value_ptr++);
3202 values[
point][comp] += value * (*shape_value_ptr++);
3205 for (
unsigned int c = 0; c < n_components; ++c)
3210 const unsigned int row =
3211 shape_function_to_row_table[shape_func * n_components + c];
3213 const double * shape_value_ptr = &shape_values(row, 0);
3214 const unsigned int comp = c + mc * n_components;
3216 if (quadrature_points_fastest)
3221 values_comp[
point] += value * (*shape_value_ptr++);
3226 values[
point][comp] += value * (*shape_value_ptr++);
3235 template <
int order,
int spacedim,
typename Number>
3238 const Number * dof_values_ptr,
3242 const unsigned int dofs_per_cell = shape_derivatives.size()[0];
3246 std::fill_n(derivatives.begin(),
3257 for (
unsigned int shape_func = 0; shape_func <
dofs_per_cell; ++shape_func)
3259 const Number &
value = dof_values_ptr[shape_func];
3267 &shape_derivatives[shape_func][0];
3269 derivatives[
point] += value * (*shape_derivative_ptr++);
3275 template <
int order,
int dim,
int spacedim,
typename Number>
3278 const Number * dof_values_ptr,
3281 const std::vector<unsigned int> &shape_function_to_row_table,
3283 const bool quadrature_points_fastest =
false,
3284 const unsigned int component_multiple = 1)
3287 for (
unsigned int i = 0; i < derivatives.size(); ++i)
3288 std::fill_n(derivatives[i].
begin(),
3289 derivatives[i].size(),
3295 if (dofs_per_cell == 0)
3300 quadrature_points_fastest ? derivatives[0].size() : derivatives.size();
3304 const unsigned result_components = n_components * component_multiple;
3305 (void)result_components;
3306 if (quadrature_points_fastest)
3309 for (
unsigned int i = 0; i < derivatives.size(); ++i)
3315 for (
unsigned int i = 0; i < derivatives.size(); ++i)
3322 for (
unsigned int mc = 0; mc < component_multiple; ++mc)
3323 for (
unsigned int shape_func = 0; shape_func <
dofs_per_cell;
3335 const unsigned int comp =
3338 const unsigned int row =
3339 shape_function_to_row_table[shape_func * n_components + comp];
3342 &shape_derivatives[row][0];
3344 if (quadrature_points_fastest)
3347 derivatives[comp][
point] += value * (*shape_derivative_ptr++);
3351 derivatives[
point][comp] += value * (*shape_derivative_ptr++);
3354 for (
unsigned int c = 0; c < n_components; ++c)
3359 const unsigned int row =
3360 shape_function_to_row_table[shape_func * n_components + c];
3363 &shape_derivatives[row][0];
3364 const unsigned int comp = c + mc * n_components;
3366 if (quadrature_points_fastest)
3369 derivatives[comp][
point] +=
3370 value * (*shape_derivative_ptr++);
3374 derivatives[
point][comp] +=
3375 value * (*shape_derivative_ptr++);
3382 template <
int spacedim,
typename Number,
typename Number2>
3385 const Number2 * dof_values_ptr,
3387 std::vector<Number> & laplacians)
3389 const unsigned int dofs_per_cell = shape_hessians.size()[0];
3393 std::fill_n(laplacians.begin(),
3400 for (
unsigned int shape_func = 0; shape_func <
dofs_per_cell; ++shape_func)
3402 const Number2
value = dof_values_ptr[shape_func];
3411 &shape_hessians[shape_func][0];
3413 laplacians[
point] += value *
trace(*shape_hessian_ptr++);
3419 template <
int dim,
int spacedim,
typename VectorType,
typename Number>
3422 const Number * dof_values_ptr,
3425 const std::vector<unsigned int> & shape_function_to_row_table,
3426 std::vector<VectorType> & laplacians,
3427 const bool quadrature_points_fastest =
false,
3428 const unsigned int component_multiple = 1)
3431 for (
unsigned int i = 0; i < laplacians.size(); ++i)
3432 std::fill_n(laplacians[i].
begin(),
3433 laplacians[i].size(),
3434 typename VectorType::value_type());
3439 if (dofs_per_cell == 0)
3447 const unsigned result_components = n_components * component_multiple;
3448 (void)result_components;
3449 if (quadrature_points_fastest)
3452 for (
unsigned int i = 0; i < laplacians.size(); ++i)
3458 for (
unsigned int i = 0; i < laplacians.size(); ++i)
3465 for (
unsigned int mc = 0; mc < component_multiple; ++mc)
3466 for (
unsigned int shape_func = 0; shape_func <
dofs_per_cell;
3478 const unsigned int comp =
3481 const unsigned int row =
3482 shape_function_to_row_table[shape_func * n_components + comp];
3485 &shape_hessians[row][0];
3486 if (quadrature_points_fastest)
3488 VectorType &laplacians_comp = laplacians[comp];
3491 laplacians_comp[
point] +=
3492 value *
trace(*shape_hessian_ptr++);
3497 laplacians[
point][comp] +=
3498 value *
trace(*shape_hessian_ptr++);
3501 for (
unsigned int c = 0; c < n_components; ++c)
3506 const unsigned int row =
3507 shape_function_to_row_table[shape_func * n_components + c];
3510 &shape_hessians[row][0];
3511 const unsigned int comp = c + mc * n_components;
3513 if (quadrature_points_fastest)
3515 VectorType &laplacians_comp = laplacians[comp];
3518 laplacians_comp[
point] +=
3519 value *
trace(*shape_hessian_ptr++);
3524 laplacians[
point][comp] +=
3525 value *
trace(*shape_hessian_ptr++);
3533 template <
int dim,
int spacedim>
3534 template <
class InputVector>
3537 const InputVector & fe_function,
3538 std::vector<typename InputVector::value_type> &
values)
const 3540 using Number =
typename InputVector::value_type;
3545 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
3550 present_cell->get_interpolated_dof_values(fe_function, dof_values);
3558 template <
int dim,
int spacedim>
3559 template <
class InputVector>
3562 const InputVector & fe_function,
3564 std::vector<typename InputVector::value_type> &
values)
const 3566 using Number =
typename InputVector::value_type;
3572 boost::container::small_vector<Number, 200> dof_values(
dofs_per_cell);
3582 template <
int dim,
int spacedim>
3583 template <
class InputVector>
3586 const InputVector & fe_function,
3587 std::vector<Vector<typename InputVector::value_type>> &
values)
const 3589 using Number =
typename InputVector::value_type;
3591 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
3599 present_cell->get_interpolated_dof_values(fe_function, dof_values);
3610 template <
int dim,
int spacedim>
3611 template <
class InputVector>
3614 const InputVector & fe_function,
3616 std::vector<Vector<typename InputVector::value_type>> &
values)
const 3618 using Number =
typename InputVector::value_type;
3626 boost::container::small_vector<Number, 200> dof_values(
dofs_per_cell);
3641 template <
int dim,
int spacedim>
3642 template <
class InputVector>
3645 const InputVector & fe_function,
3648 const bool quadrature_points_fastest)
const 3650 using Number =
typename InputVector::value_type;
3659 boost::container::small_vector<Number, 200> dof_values(indices.
size());
3660 for (
unsigned int i = 0; i < indices.
size(); ++i)
3668 quadrature_points_fastest,
3674 template <
int dim,
int spacedim>
3675 template <
class InputVector>
3678 const InputVector &fe_function,
3682 using Number =
typename InputVector::value_type;
3687 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
3692 present_cell->get_interpolated_dof_values(fe_function, dof_values);
3700 template <
int dim,
int spacedim>
3701 template <
class InputVector>
3704 const InputVector & fe_function,
3709 using Number =
typename InputVector::value_type;
3715 boost::container::small_vector<Number, 200> dof_values(
dofs_per_cell);
3725 template <
int dim,
int spacedim>
3726 template <
class InputVector>
3729 const InputVector &fe_function,
3734 using Number =
typename InputVector::value_type;
3738 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
3743 present_cell->get_interpolated_dof_values(fe_function, dof_values);
3754 template <
int dim,
int spacedim>
3755 template <
class InputVector>
3758 const InputVector & fe_function,
3762 const bool quadrature_points_fastest)
const 3764 using Number =
typename InputVector::value_type;
3772 boost::container::small_vector<Number, 200> dof_values(indices.
size());
3773 for (
unsigned int i = 0; i < indices.
size(); ++i)
3781 quadrature_points_fastest,
3787 template <
int dim,
int spacedim>
3788 template <
class InputVector>
3791 const InputVector &fe_function,
3795 using Number =
typename InputVector::value_type;
3800 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
3805 present_cell->get_interpolated_dof_values(fe_function, dof_values);
3813 template <
int dim,
int spacedim>
3814 template <
class InputVector>
3817 const InputVector & fe_function,
3822 using Number =
typename InputVector::value_type;
3828 boost::container::small_vector<Number, 200> dof_values(
dofs_per_cell);
3838 template <
int dim,
int spacedim>
3839 template <
class InputVector>
3842 const InputVector &fe_function,
3846 const bool quadrature_points_fastest)
const 3848 using Number =
typename InputVector::value_type;
3852 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
3857 present_cell->get_interpolated_dof_values(fe_function, dof_values);
3864 quadrature_points_fastest);
3869 template <
int dim,
int spacedim>
3870 template <
class InputVector>
3873 const InputVector & fe_function,
3877 const bool quadrature_points_fastest)
const 3879 using Number =
typename InputVector::value_type;
3885 boost::container::small_vector<Number, 200> dof_values(indices.
size());
3886 for (
unsigned int i = 0; i < indices.
size(); ++i)
3894 quadrature_points_fastest,
3900 template <
int dim,
int spacedim>
3901 template <
class InputVector>
3904 const InputVector & fe_function,
3905 std::vector<typename InputVector::value_type> &laplacians)
const 3907 using Number =
typename InputVector::value_type;
3912 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
3917 present_cell->get_interpolated_dof_values(fe_function, dof_values);
3925 template <
int dim,
int spacedim>
3926 template <
class InputVector>
3929 const InputVector & fe_function,
3931 std::vector<typename InputVector::value_type> & laplacians)
const 3933 using Number =
typename InputVector::value_type;
3939 boost::container::small_vector<Number, 200> dof_values(
dofs_per_cell);
3949 template <
int dim,
int spacedim>
3950 template <
class InputVector>
3953 const InputVector & fe_function,
3954 std::vector<Vector<typename InputVector::value_type>> &laplacians)
const 3956 using Number =
typename InputVector::value_type;
3958 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
3965 present_cell->get_interpolated_dof_values(fe_function, dof_values);
3976 template <
int dim,
int spacedim>
3977 template <
class InputVector>
3980 const InputVector & fe_function,
3982 std::vector<Vector<typename InputVector::value_type>> &laplacians)
const 3984 using Number =
typename InputVector::value_type;
3992 boost::container::small_vector<Number, 200> dof_values(indices.
size());
3993 for (
unsigned int i = 0; i < indices.
size(); ++i)
4007 template <
int dim,
int spacedim>
4008 template <
class InputVector>
4011 const InputVector & fe_function,
4013 std::vector<std::vector<typename InputVector::value_type>> &laplacians,
4014 const bool quadrature_points_fastest)
const 4016 using Number =
typename InputVector::value_type;
4022 boost::container::small_vector<Number, 200> dof_values(indices.
size());
4023 for (
unsigned int i = 0; i < indices.
size(); ++i)
4031 quadrature_points_fastest,
4037 template <
int dim,
int spacedim>
4038 template <
class InputVector>
4041 const InputVector &fe_function,
4043 &third_derivatives)
const 4045 using Number =
typename InputVector::value_type;
4050 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
4055 present_cell->get_interpolated_dof_values(fe_function, dof_values);
4064 template <
int dim,
int spacedim>
4065 template <
class InputVector>
4068 const InputVector & fe_function,
4071 &third_derivatives)
const 4073 using Number =
typename InputVector::value_type;
4079 boost::container::small_vector<Number, 200> dof_values(
dofs_per_cell);
4090 template <
int dim,
int spacedim>
4091 template <
class InputVector>
4094 const InputVector &fe_function,
4097 & third_derivatives,
4098 const bool quadrature_points_fastest)
const 4100 using Number =
typename InputVector::value_type;
4104 ExcMessage(
"FEValues object is not reinit'ed to any cell"));
4109 present_cell->get_interpolated_dof_values(fe_function, dof_values);
4116 quadrature_points_fastest);
4121 template <
int dim,
int spacedim>
4122 template <
class InputVector>
4125 const InputVector & fe_function,
4129 const bool quadrature_points_fastest)
const 4131 using Number =
typename InputVector::value_type;
4137 boost::container::small_vector<Number, 200> dof_values(indices.
size());
4138 for (
unsigned int i = 0; i < indices.
size(); ++i)
4146 quadrature_points_fastest,
4152 template <
int dim,
int spacedim>
4161 template <
int dim,
int spacedim>
4162 const std::vector<Tensor<1, spacedim>> &
4167 "update_normal_vectors")));
4174 template <
int dim,
int spacedim>
4195 template <
int dim,
int spacedim>
4206 UpdateFlags flags = update_flags |
fe->requires_update_flags(update_flags);
4207 flags |=
mapping->requires_update_flags(flags);
4214 template <
int dim,
int spacedim>
4232 template <
int dim,
int spacedim>
4239 if (&cell->get_triangulation() !=
4243 ->get_triangulation())
4252 cell->get_triangulation().signals.any_change.connect(
4255 cell->get_triangulation().signals.mesh_movement.connect(
4265 cell->get_triangulation().signals.post_refinement.connect(
4268 cell->get_triangulation().signals.mesh_movement.connect(
4275 template <
int dim,
int spacedim>
4311 (cell->is_translation_of(
4321 ->direction_flag() != cell->direction_flag())
4330 template <
int dim,
int spacedim>
4339 template <
int dim,
int spacedim>
4344 template <
int dim,
int spacedim>
4349 template <
int dim,
int spacedim>
4354 template <
int dim,
int spacedim>
4360 fe.n_dofs_per_cell(),
4371 template <
int dim,
int spacedim>
4376 :
FEValues(mapping, fe, q[0], update_flags)
4383 template <
int dim,
int spacedim>
4389 fe.n_dofs_per_cell(),
4392 fe.reference_cell_type()),
4401 template <
int dim,
int spacedim>
4412 template <
int dim,
int spacedim>
4418 if (dim != spacedim - 1)
4420 ExcMessage(
"You can only pass the 'update_normal_vectors' " 4421 "flag to FEFaceValues or FESubfaceValues objects, " 4422 "but not to an FEValues object unless the " 4423 "triangulation it refers to is embedded in a higher " 4424 "dimensional space."));
4438 std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>>
4440 return this->
fe->get_data(flags,
4447 std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>>
4449 if (flags & update_mapping)
4453 this->update_flags = flags;
4456 this->
fe_data = std::move(fe_get_data.return_value());
4457 if (flags & update_mapping)
4458 this->
mapping_data = std::move(mapping_get_data.return_value());
4461 std::make_unique<typename Mapping<dim, spacedim>::InternalDataBase>();
4472 template <
typename Type,
typename Po
inter,
typename Iterator>
4474 reset_pointer_in_place_if_possible(std::unique_ptr<Pointer> &
present_cell,
4475 const Iterator & new_cell)
4480 if (present_cell.get() && (
typeid(*present_cell.get()) ==
typeid(Type)))
4483 static_cast<const Type *
>(present_cell.get())->~Type();
4486 new (
const_cast<void *
>(
static_cast<const void *
>(present_cell.get())))
4491 present_cell = std::make_unique<Type>(new_cell);
4497 template <
int dim,
int spacedim>
4507 reset_pointer_in_place_if_possible<
4519 template <
int dim,
int spacedim>
4534 reset_pointer_in_place_if_possible<
4547 template <
int dim,
int spacedim>
4581 template <
int dim,
int spacedim>
4593 template <
int dim,
int spacedim>
4604 hp::QCollection<dim - 1>(quadrature))
4609 template <
int dim,
int spacedim>
4622 , quadrature(quadrature)
4625 quadrature.
size() ==
4633 template <
int dim,
int spacedim>
4634 const std::vector<Tensor<1, spacedim>> &
4639 "update_boundary_forms")));
4645 template <
int dim,
int spacedim>
4656 template <
int dim,
int spacedim>
4661 template <
int dim,
int spacedim>
4666 template <
int dim,
int spacedim>
4674 hp::QCollection<dim - 1>(quadrature),
4680 template <
int dim,
int spacedim>
4697 template <
int dim,
int spacedim>
4703 hp::QCollection<dim - 1>(quadrature),
4709 template <
int dim,
int spacedim>
4715 fe.n_dofs_per_cell(),
4718 fe.reference_cell_type()),
4727 template <
int dim,
int spacedim>
4743 std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase> (
4752 std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> (
4759 std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>>
4767 std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>>
4769 if (flags & update_mapping)
4775 this->update_flags = flags;
4778 this->
fe_data = std::move(fe_get_data.return_value());
4779 if (flags & update_mapping)
4780 this->
mapping_data = std::move(mapping_get_data.return_value());
4783 std::make_unique<typename Mapping<dim, spacedim>::InternalDataBase>();
4788 template <
int dim,
int spacedim>
4793 const unsigned int face_no)
4799 cell->get_dof_handler().get_fe(cell->active_fe_index())),
4805 reset_pointer_in_place_if_possible<
4818 template <
int dim,
int spacedim>
4825 const auto face_n = cell->face_iterator_to_index(face);
4831 template <
int dim,
int spacedim>
4835 const unsigned int face_no)
4840 reset_pointer_in_place_if_possible<
4852 template <
int dim,
int spacedim>
4858 const auto face_n = cell->face_iterator_to_index(face);
4864 template <
int dim,
int spacedim>
4901 template <
int dim,
int spacedim>
4906 template <
int dim,
int spacedim>
4911 template <
int dim,
int spacedim>
4928 template <
int dim,
int spacedim>
4941 template <
int dim,
int spacedim>
4947 fe.n_dofs_per_cell(),
4950 fe.reference_cell_type()),
4959 template <
int dim,
int spacedim>
4971 template <
int dim,
int spacedim>
4988 std::unique_ptr<typename FiniteElement<dim, spacedim>::InternalDataBase>>
4997 std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase>>
4999 if (flags & update_mapping)
5006 this->update_flags = flags;
5009 this->
fe_data = std::move(fe_get_data.return_value());
5010 if (flags & update_mapping)
5011 this->
mapping_data = std::move(mapping_get_data.return_value());
5014 std::make_unique<typename Mapping<dim, spacedim>::InternalDataBase>();
5019 template <
int dim,
int spacedim>
5024 const unsigned int face_no,
5025 const unsigned int subface_no)
5031 cell->get_dof_handler().get_fe(cell->active_fe_index())),
5038 Assert(cell->face(face_no)->has_children() ||
5039 subface_no < GeometryInfo<dim>::max_children_per_face,
5043 Assert(!cell->face(face_no)->has_children() ||
5044 subface_no < cell->face(face_no)->number_of_children(),
5047 cell->face(face_no)->number_of_children()));
5048 Assert(cell->has_children() ==
false,
5049 ExcMessage(
"You can't use subface data for cells that are " 5050 "already refined. Iterate over their children " 5051 "instead in these cases."));
5054 reset_pointer_in_place_if_possible<
5067 template <
int dim,
int spacedim>
5076 cell->face_iterator_to_index(face),
5077 face->child_iterator_to_index(subface));
5082 template <
int dim,
int spacedim>
5086 const unsigned int face_no,
5087 const unsigned int subface_no)
5095 (cell->has_periodic_neighbor(face_no) ?
5096 cell->periodic_neighbor(face_no)
5097 ->face(cell->periodic_neighbor_face_no(face_no))
5099 cell->face(face_no)->n_children()));
5102 reset_pointer_in_place_if_possible<
5114 template <
int dim,
int spacedim>
5122 cell->face_iterator_to_index(face),
5123 face->child_iterator_to_index(subface));
5128 template <
int dim,
int spacedim>
5131 const unsigned int subface_no)
5139 if (!cell->face(face_no)->has_children())
5150 switch (cell->subface_case(face_no))
5155 subface_index = cell->face(face_no)->child_index(subface_no);
5159 subface_index = cell->face(face_no)
5160 ->child(subface_no / 2)
5161 ->child_index(subface_no % 2);
5170 cell->face(face_no)->child(0)->child_index(subface_no);
5173 subface_index = cell->face(face_no)->child_index(1);
5184 subface_index = cell->face(face_no)->child_index(0);
5189 cell->face(face_no)->child(1)->child_index(subface_no - 1);
5228 #define SPLIT_INSTANTIATIONS_COUNT 6 5229 #ifndef SPLIT_INSTANTIATIONS_INDEX 5230 # define SPLIT_INSTANTIATIONS_INDEX 0 5232 #include "fe_values.inst" void get_function_third_derivatives(const InputVector &fe_function, std::vector< typename ProductType< third_derivative_type, typename InputVector::value_type >::type > &third_derivatives) const
Transformed quadrature weights.
virtual ~FEValuesBase() override
typename ProductType< Number, typename Vector< dim, spacedim >::curl_type >::type curl_type
void do_function_curls(const ArrayView< Number > &dof_values, const Table< 2, ::Tensor< 1, spacedim >> &shape_gradients, const std::vector< typename Vector< dim, spacedim >::ShapeFunctionData > &shape_function_data, std::vector< typename ProductType< Number, typename ::internal::CurlType< spacedim >::type >::type > &curls)
const Mapping< dim, spacedim > & get_default_linear_mapping(const Type &reference_cell)
typename FEValuesViews::View< dim, spacedim, Extractor >::template OutputType< NumberType > OutputType
static const unsigned int invalid_unsigned_int
std::unique_ptr< typename FiniteElement< dim, spacedim >::InternalDataBase > fe_data
CellSimilarity::Similarity cell_similarity
typename ProductType< Number, typename Tensor< 2, dim, spacedim >::gradient_type >::type gradient_type
typename ProductType< Number, typename SymmetricTensor< 2, dim, spacedim >::value_type >::type value_type
static constexpr unsigned int component_to_unrolled_index(const TableIndices< rank_ > &indices)
#define AssertDimension(dim1, dim2)
unsigned int present_face_no
unsigned int present_face_index
void do_function_values(const typename VectorType::value_type *dof_values_ptr, const ::Table< 2, double > &shape_values, const FiniteElement< dim, spacedim > &fe, const std::vector< unsigned int > &shape_function_to_row_table, ArrayView< VectorType > values, const bool quadrature_points_fastest=false, const unsigned int component_multiple=1)
void quadrature_points(const Triangulation< dim, spacedim > &triangulation, const Quadrature< dim > &quadrature, const std::vector< std::vector< BoundingBox< spacedim >>> &global_bounding_boxes, ParticleHandler< dim, spacedim > &particle_handler, const Mapping< dim, spacedim > &mapping=ReferenceCell::get_default_linear_mapping< dim, spacedim >(ReferenceCell::Type::get_hypercube< dim >()), const std::vector< std::vector< double >> &properties={})
static constexpr const T & value(const T &t)
unsigned int n_nonzero_components(const unsigned int i) const
constexpr SymmetricTensor< 2, dim, Number > symmetrize(const Tensor< 2, dim, Number > &t)
const SmartPointer< const FEValuesBase< dim, spacedim > > fe_values
typename internal::ProductTypeImpl< typename std::decay< T >::type, typename std::decay< U >::type >::type type
Task< RT > new_task(const std::function< RT()> &function)
virtual void get_interpolated_dof_values(const Vector< double > &in, Vector< Vector< double > ::value_type > &out) const override
const unsigned int dofs_per_cell
const unsigned int component
void get_function_symmetric_gradients_from_local_dof_values(const InputVector &dof_values, std::vector< typename OutputType< typename InputVector::value_type >::symmetric_gradient_type > &symmetric_gradients) const
void get_function_values(const InputVector &fe_function, std::vector< typename ProductType< value_type, typename InputVector::value_type >::type > &values) const
FEValuesBase(const unsigned int n_q_points, const unsigned int dofs_per_cell, const UpdateFlags update_flags, const Mapping< dim, spacedim > &mapping, const FiniteElement< dim, spacedim > &fe)
void get_function_third_derivatives(const InputVector &fe_function, std::vector< typename ProductType< third_derivative_type, typename InputVector::value_type >::type > &third_derivatives) const
const ReferenceCell::internal::Info::Base & get_cell(const ReferenceCell::Type &type)
#define AssertIndexRange(index, range)
static ::ExceptionBase & ExcAccessToUninitializedField(std::string arg1)
const Mapping< dim, spacedim > & get_mapping() const
void get_function_values(const InputVector &fe_function, std::vector< typename InputVector::value_type > &values) const
Outer normal vector, not normalized.
static constexpr TableIndices< rank_ > unrolled_to_component_indices(const unsigned int i)
typename ProductType< Number, typename Scalar< dim, spacedim >::hessian_type >::type hessian_type
const FiniteElement< dim, spacedim > & get_fe() const
std::unique_ptr< const CellIteratorBase > present_cell
static ::ExceptionBase & ExcFEDontMatch()
void get_function_divergences(const InputVector &fe_function, std::vector< typename ProductType< divergence_type, typename InputVector::value_type >::type > &divergences) const
void get_function_laplacians(const InputVector &fe_function, std::vector< typename ProductType< value_type, typename InputVector::value_type >::type > &laplacians) const
TriaCellIterator(const typename Triangulation< dim, spacedim >::cell_iterator &cell)
Transformed quadrature points.
void do_reinit(const unsigned int face_no)
std::size_t memory_consumption() const
typename ProductType< Number, typename Scalar< dim, spacedim >::value_type >::type value_type
bool is_primitive() const
void check_cell_similarity(const typename Triangulation< dim, spacedim >::cell_iterator &cell)
const SmartPointer< const Mapping< dim, spacedim >, FEValuesBase< dim, spacedim > > mapping
static ::ExceptionBase & ExcIndexRange(int arg1, int arg2, int arg3)
::internal::FEValuesViews::Cache< dim, spacedim > fe_values_views_cache
void do_reinit(const unsigned int face_no, const unsigned int subface_no)
void get_function_divergences_from_local_dof_values(const InputVector &dof_values, std::vector< typename OutputType< typename InputVector::value_type >::divergence_type > &divergences) const
ReferenceCell::Type reference_cell_type() const
void get_function_curls_from_local_dof_values(const InputVector &dof_values, std::vector< typename OutputType< typename InputVector::value_type >::curl_type > &curls) const
typename ProductType< Number, typename Vector< dim, spacedim >::gradient_type >::type gradient_type
void get_function_laplacians(const InputVector &fe_function, std::vector< typename ProductType< value_type, typename InputVector::value_type >::type > &laplacians) const
void get_function_hessians_from_local_dof_values(const InputVector &dof_values, std::vector< typename OutputType< typename InputVector::value_type >::hessian_type > &hessians) const
void do_function_derivatives(const Number *dof_values_ptr, const ::Table< 2, Tensor< order, spacedim >> &shape_derivatives, const FiniteElement< dim, spacedim > &fe, const std::vector< unsigned int > &shape_function_to_row_table, ArrayView< std::vector< Tensor< order, spacedim, Number >>> derivatives, const bool quadrature_points_fastest=false, const unsigned int component_multiple=1)
const Triangulation< dim, spacedim >::cell_iterator cell
void get_function_gradients(const InputVector &fe_function, std::vector< typename ProductType< gradient_type, typename InputVector::value_type >::type > &gradients) const
typename ProductType< Number, typename Scalar< dim, spacedim >::gradient_type >::type gradient_type
void get_function_hessians(const InputVector &fe_function, std::vector< typename ProductType< hessian_type, typename InputVector::value_type >::type > &hessians) const
const hp::QCollection< dim - 1 > quadrature
void get_function_laplacians(const InputVector &fe_function, std::vector< typename InputVector::value_type > &laplacians) const
typename ProductType< Number, typename Tensor< 2, dim, spacedim >::value_type >::type value_type
static ::ExceptionBase & ExcMessage(std::string arg1)
void get_function_gradients_from_local_dof_values(const InputVector &dof_values, std::vector< typename OutputType< typename InputVector::value_type >::gradient_type > &gradients) const
constexpr SymmetricTensor()=default
static constexpr TableIndices< rank_ > unrolled_to_component_indices(const unsigned int i)
void do_function_laplacians(const Number *dof_values_ptr, const ::Table< 2, Tensor< 2, spacedim >> &shape_hessians, const FiniteElement< dim, spacedim > &fe, const std::vector< unsigned int > &shape_function_to_row_table, std::vector< VectorType > &laplacians, const bool quadrature_points_fastest=false, const unsigned int component_multiple=1)
CellSimilarity::Similarity get_cell_similarity() const
Third derivatives of shape functions.
UpdateFlags compute_update_flags(const UpdateFlags update_flags) const
void get_function_laplacians_from_local_dof_values(const InputVector &dof_values, std::vector< typename OutputType< typename InputVector::value_type >::laplacian_type > &laplacians) const
void do_function_values(const Number2 *dof_values_ptr, const ::Table< 2, double > &shape_values, std::vector< Number > &values)
std::vector< unsigned int > make_shape_function_to_row_table(const FiniteElement< dim, spacedim > &fe)
#define Assert(cond, exc)
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
FESubfaceValues(const Mapping< dim, spacedim > &mapping, const FiniteElement< dim, spacedim > &fe, const Quadrature< dim - 1 > &face_quadrature, const UpdateFlags update_flags)
Abstract base class for mapping classes.
const ComponentMask & get_nonzero_components(const unsigned int i) const
std::vector< ShapeFunctionData > shape_function_data
const Quadrature< dim > quadrature
const unsigned int first_vector_component
ArrayView< typename std::remove_reference< typename std::iterator_traits< Iterator >::reference >::type, MemorySpaceType > make_array_view(const Iterator begin, const Iterator end)
unsigned int size() const
virtual types::global_dof_index n_dofs_for_dof_handler() const override
void do_function_laplacians(const Number2 *dof_values_ptr, const ::Table< 2, Tensor< 2, spacedim >> &shape_hessians, std::vector< Number > &laplacians)
#define DEAL_II_NAMESPACE_CLOSE
void reinit(const TriaIterator< DoFCellAccessor< dim, spacedim, level_dof_access >> &cell, const unsigned int face_no)
void invalidate_present_cell()
std::unique_ptr< typename Mapping< dim, spacedim >::InternalDataBase > mapping_data
static const char *const message_string
void get_function_hessians_from_local_dof_values(const InputVector &dof_values, std::vector< typename OutputType< typename InputVector::value_type >::hessian_type > &hessians) const
void get_function_symmetric_gradients(const InputVector &fe_function, std::vector< typename ProductType< symmetric_gradient_type, typename InputVector::value_type >::type > &symmetric_gradients) const
Second derivatives of shape functions.
Gradient of volume element.
FEFaceValuesBase(const unsigned int dofs_per_cell, const UpdateFlags update_flags, const Mapping< dim, spacedim > &mapping, const FiniteElement< dim, spacedim > &fe, const Quadrature< dim - 1 > &quadrature)
Point< spacedim > point(const gp_Pnt &p, const double tolerance=1e-10)
typename ProductType< Number, typename SymmetricTensor< 2, dim, spacedim >::divergence_type >::type divergence_type
SymmetricTensor< 2, dim, Number > d(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
std::size_t memory_consumption() const
void get_function_hessians(const InputVector &fe_function, std::vector< typename ProductType< hessian_type, typename InputVector::value_type >::type > &hessians) const
void do_function_divergences(const ArrayView< Number > &dof_values, const Table< 2, ::Tensor< 1, spacedim >> &shape_gradients, const std::vector< typename Tensor< 2, dim, spacedim >::ShapeFunctionData > &shape_function_data, std::vector< typename Tensor< 2, dim, spacedim >::template OutputType< Number >::divergence_type > &divergences)
const unsigned int n_quadrature_points
void do_function_gradients(const ArrayView< Number > &dof_values, const Table< 2, ::Tensor< 1, spacedim >> &shape_gradients, const std::vector< typename Tensor< 2, dim, spacedim >::ShapeFunctionData > &shape_function_data, std::vector< typename Tensor< 2, dim, spacedim >::template OutputType< Number >::gradient_type > &gradients)
void get_function_hessians(const InputVector &fe_function, std::vector< Tensor< 2, spacedim, typename InputVector::value_type >> &hessians) const
VectorType::value_type get_vector_element(const VectorType &vector, const types::global_dof_index cell_number)
std_cxx20::ranges::iota_view< unsigned int, unsigned int > dof_indices() const
FEFaceValues(const Mapping< dim, spacedim > &mapping, const FiniteElement< dim, spacedim > &fe, const Quadrature< dim - 1 > &quadrature, const UpdateFlags update_flags)
void get_function_curls(const InputVector &fe_function, std::vector< typename ProductType< curl_type, typename InputVector::value_type >::type > &curls) const
void get_function_third_derivatives(const InputVector &fe_function, std::vector< Tensor< 3, spacedim, typename InputVector::value_type >> &third_derivatives) const
static VectorType::value_type get(const VectorType &V, const types::global_dof_index i)
boost::signals2::connection tria_listener_mesh_transform
typename ProductType< Number, typename Vector< dim, spacedim >::value_type >::type value_type
std::pair< unsigned int, unsigned int > system_to_component_index(const unsigned int index) const
void do_function_derivatives(const Number *dof_values_ptr, const ::Table< 2, Tensor< order, spacedim >> &shape_derivatives, std::vector< Tensor< order, spacedim, Number >> &derivatives)
void get_function_laplacians_from_local_dof_values(const InputVector &dof_values, std::vector< typename OutputType< typename InputVector::value_type >::laplacian_type > &laplacians) const
unsigned int n_components() const
unsigned int n_dofs_per_cell() const
typename ProductType< Number, typename Vector< dim, spacedim >::divergence_type >::type divergence_type
#define DEAL_II_NAMESPACE_OPEN
void initialize(const UpdateFlags update_flags)
VectorType::value_type * begin(VectorType &V)
typename ProductType< Number, typename Vector< dim, spacedim >::hessian_type >::type hessian_type
Shape function gradients.
void get_function_third_derivatives_from_local_dof_values(const InputVector &dof_values, std::vector< typename OutputType< typename InputVector::value_type >::third_derivative_type > &third_derivatives) const
void maybe_invalidate_previous_present_cell(const typename Triangulation< dim, spacedim >::cell_iterator &cell)
typename ProductType< Number, typename Tensor< 2, dim, spacedim >::divergence_type >::type divergence_type
void reinit(const TriaIterator< DoFCellAccessor< dim, spacedim, level_dof_access >> &cell, const unsigned int face_no, const unsigned int subface_no)
void get_function_gradients(const InputVector &fe_function, std::vector< Tensor< 1, spacedim, typename InputVector::value_type >> &gradients) const
void do_function_symmetric_gradients(const ArrayView< Number > &dof_values, const Table< 2, ::Tensor< 1, spacedim >> &shape_gradients, const std::vector< typename Vector< dim, spacedim >::ShapeFunctionData > &shape_function_data, std::vector< typename ProductType< Number, ::SymmetricTensor< 2, spacedim >>::type > &symmetric_gradients)
void initialize(const UpdateFlags update_flags)
void get_function_gradients_from_local_dof_values(const InputVector &dof_values, std::vector< typename OutputType< typename InputVector::value_type >::gradient_type > &gradients) const
static ::ExceptionBase & ExcNotMultiple(int arg1, int arg2)
constexpr Number trace(const SymmetricTensor< 2, dim2, Number > &)
static ::ExceptionBase & ExcNotImplemented()
static unsigned int n_threads()
const Triangulation< dim, spacedim >::cell_iterator get_cell() const
bool is_element(const size_type index) const
const SmartPointer< const FEValuesBase< dim, spacedim > > fe_values
void get_function_values(const InputVector &fe_function, std::vector< typename ProductType< value_type, typename InputVector::value_type >::type > &values) const
boost::signals2::connection tria_listener_refinement
::internal::FEValuesImplementation::FiniteElementRelatedData< dim, spacedim > finite_element_output
TriaIterator< CellAccessor< dim, spacedim > > cell_iterator
typename ProductType< Number, typename Vector< dim, spacedim >::value_type >::type laplacian_type
const std::vector< Tensor< 1, spacedim > > & get_boundary_forms() const
void initialize(const UpdateFlags update_flags)
::internal::FEValuesImplementation::MappingRelatedData< dim, spacedim > mapping_output
FEValues(const Mapping< dim, spacedim > &mapping, const FiniteElement< dim, spacedim > &fe, const Quadrature< dim > &quadrature, const UpdateFlags update_flags)
void get_function_gradients(const InputVector &fe_function, std::vector< typename ProductType< gradient_type, typename InputVector::value_type >::type > &gradients) const
void get_function_third_derivatives_from_local_dof_values(const InputVector &dof_values, std::vector< typename OutputType< typename InputVector::value_type >::third_derivative_type > &third_derivatives) const
const std::vector< Tensor< 1, spacedim > > & get_normal_vectors() const
const unsigned int max_n_quadrature_points
void get_function_values_from_local_dof_values(const InputVector &dof_values, std::vector< typename OutputType< typename InputVector::value_type >::value_type > &values) const
typename ProductType< Number, typename Scalar< dim, spacedim >::value_type >::type laplacian_type
std::size_t memory_consumption() const
void get_function_values_from_local_dof_values(const InputVector &dof_values, std::vector< typename OutputType< typename InputVector::value_type >::value_type > &values) const
std::vector< ShapeFunctionData > shape_function_data
std::enable_if< std::is_fundamental< T >::value, std::size_t >::type memory_consumption(const T &t)
static ::ExceptionBase & ExcInternalError()
const SmartPointer< const FiniteElement< dim, spacedim >, FEValuesBase< dim, spacedim > > fe
void reinit(const TriaIterator< DoFCellAccessor< dim, spacedim, level_dof_access >> &cell)