15#ifndef dealii_fe_point_evaluation_h
16#define dealii_fe_point_evaluation_h
47 <<
"You are requesting information from an FEPointEvaluationBase "
48 <<
"object for which this kind of information has not been computed. "
49 <<
"What information these objects compute is determined by the update_* "
50 <<
"flags you pass to MappingInfo() in the Constructor. Here, "
51 <<
"the operation you are attempting requires the <" << arg1
52 <<
"> flag to be set, but it was apparently not specified "
53 <<
"upon initialization.");
63 typename Enable =
void>
69 typename ::internal::VectorizedArrayTrait<
78 n_components == spacedim,
90 const unsigned int component,
94 result[component] = vector_entry;
108 for (
unsigned int c = 0; c < n_components; ++c)
109 result_scalar[c] = result[c].sum();
111 return result_scalar;
119 return result[component].
sum();
124 const unsigned int vector_lane,
127 for (
unsigned int i = 0; i < n_components; ++i)
128 for (
unsigned int d = 0; d < dim; ++d)
131 value[d][i], vector_lane);
136 const unsigned int vector_lane,
139 for (
unsigned int i = 0; i < n_components; ++i)
140 for (
unsigned int d = 0; d < dim; ++d)
142 value[d][i], vector_lane) = result[i][d];
147 const unsigned int vector_lane,
150 for (
unsigned int i = 0; i < n_components; ++i)
151 for (
unsigned int d = 0; d < dim; ++d)
153 value[d][i], vector_lane) = result[i][d];
158 const unsigned int vector_lane)
160 for (
unsigned int i = 0; i < n_components; ++i)
161 for (
unsigned int d = 0; d < spacedim; ++d)
168 const unsigned int vector_lane,
171 for (
unsigned int i = 0; i < n_components; ++i)
172 result[i] =
value[i][vector_lane];
185 const unsigned int vector_lane,
188 for (
unsigned int i = 0; i < n_components; ++i)
189 value[i][vector_lane] = result[i];
203 for (
unsigned int i = 0; i < n_components; ++i)
210 const unsigned int vector_lane,
211 const unsigned int component,
215 vector_lane) += shape_value;
220 const unsigned int vector_lane,
221 const unsigned int component)
229 const unsigned int vector_lane,
230 const unsigned int component,
233 for (
unsigned int d = 0; d < spacedim; ++d)
241 const unsigned int vector_lane,
242 const unsigned int component)
245 for (
unsigned int d = 0; d < spacedim; ++d)
253 template <
int dim,
int spacedim,
typename Number>
259 typename ::internal::VectorizedArrayTrait<
276 result = vector_entry;
299 const unsigned int vector_lane,
302 for (
unsigned int d = 0; d < dim; ++d)
303 result[d] =
value[d][vector_lane];
316 const unsigned int vector_lane,
319 for (
unsigned int d = 0; d < dim; ++d)
320 value[d][vector_lane] = result[d];
333 const unsigned int vector_lane)
335 for (
unsigned int d = 0; d < spacedim; ++d)
342 const unsigned int vector_lane,
345 result =
value[vector_lane];
358 const unsigned int vector_lane,
361 value[vector_lane] = result;
380 const unsigned int vector_lane,
390 const unsigned int vector_lane,
398 const unsigned int vector_lane,
402 for (
unsigned int d = 0; d < spacedim; ++d)
409 const unsigned int vector_lane,
413 for (
unsigned int d = 0; d < spacedim; ++d)
420 template <
int dim,
typename Number>
425 std::enable_if_t<dim != 1>>
430 typename ::internal::VectorizedArrayTrait<
444 const unsigned int component,
448 result[component] = vector_entry;
462 for (
unsigned int c = 0; c < dim; ++c)
463 result_scalar[c] = result[c].sum();
465 return result_scalar;
473 return result[component].
sum();
478 const unsigned int vector_lane,
481 for (
unsigned int i = 0; i < dim; ++i)
482 for (
unsigned int d = 0; d < dim; ++d)
485 value[d][i], vector_lane);
490 const unsigned int vector_lane,
493 for (
unsigned int i = 0; i < dim; ++i)
494 for (
unsigned int d = 0; d < dim; ++d)
496 value[d][i], vector_lane) = result[i][d];
501 const unsigned int vector_lane)
503 for (
unsigned int i = 0; i < dim; ++i)
504 for (
unsigned int d = 0; d < dim; ++d)
511 const unsigned int vector_lane,
514 for (
unsigned int i = 0; i < dim; ++i)
515 result[i] =
value[i][vector_lane];
528 const unsigned int vector_lane,
531 for (
unsigned int i = 0; i < dim; ++i)
532 value[i][vector_lane] = result[i];
546 for (
unsigned int i = 0; i < dim; ++i)
553 const unsigned int vector_lane,
554 const unsigned int component,
558 vector_lane) += shape_value;
563 const unsigned int vector_lane,
564 const unsigned int component)
572 const unsigned int vector_lane,
573 const unsigned int component,
576 for (
unsigned int d = 0; d < dim; ++d)
584 const unsigned int vector_lane,
585 const unsigned int component)
588 for (
unsigned int d = 0; d < dim; ++d)
596 template <
int dim,
int spacedim>
599 const unsigned int base_element_number);
601 template <
int dim,
int spacedim>
605 template <
int dim,
int spacedim>
606 std::vector<Polynomials::Polynomial<double>>
619template <
int n_components_,
622 typename Number =
double>
635 using ETT =
typename internal::FEPointEvaluation::
636 EvaluatorTypeTraits<dim, spacedim, n_components, Number>;
642 typename ETT::interface_vectorized_unit_gradient_type;
666 const unsigned int first_selected_component = 0);
690 const unsigned int first_selected_component = 0,
782 Tensor<1, (dim == 2 ? 1 : dim), Number>
808 JxW(
const unsigned int point_index)
const;
874 setup(
const unsigned int first_selected_component);
881 template <
bool is_face,
bool is_linear>
914 std::vector<Polynomials::Polynomial<double>>
poly;
1050 std::unique_ptr<NonMatching::MappingInfo<dim, spacedim, Number>>
1130template <
int n_components_,
1133 typename Number =
double>
1147 using ETT =
typename internal::FEPointEvaluation::
1148 EvaluatorTypeTraits<dim, spacedim, n_components, Number>;
1155 typename ETT::interface_vectorized_unit_gradient_type;
1186 const unsigned int first_selected_component = 0,
1187 const bool force_lexicographic_numbering =
false);
1216 const unsigned int first_selected_component = 0,
1217 const bool force_lexicographic_numbering =
false);
1260 template <std::
size_t str
ide_view>
1303 template <std::
size_t str
ide_view>
1307 const bool sum_into_values =
false);
1334 const bool sum_into_values =
false);
1362 template <std::
size_t str
ide_view>
1367 const bool sum_into_values =
false);
1398 const bool sum_into_values =
false);
1438 template <
bool is_linear, std::
size_t str
ide_view>
1447 template <
bool is_linear, std::
size_t str
ide_view>
1452 const unsigned int n_shapes,
1453 const unsigned int qb,
1460 template <
bool is_linear, std::
size_t str
ide_view>
1469 template <std::
size_t str
ide_view>
1480 template <
bool is_linear>
1484 const unsigned int n_shapes,
1485 const unsigned int qb,
1495 template <
bool is_linear, std::
size_t str
ide_view>
1500 const bool sum_into_values);
1505 template <
bool do_JxW,
bool is_linear, std::
size_t str
ide_view>
1510 const bool sum_into_values);
1515 template <
bool do_JxW, std::
size_t str
ide_view>
1520 const bool sum_into_values);
1525 template <
bool do_JxW, std::
size_t str
ide_view>
1530 const bool sum_into_values);
1560template <
int n_components_,
1563 typename Number =
double>
1577 using ETT =
typename internal::FEPointEvaluation::
1578 EvaluatorTypeTraits<dim, spacedim, n_components, Number>;
1585 typename ETT::interface_vectorized_unit_gradient_type;
1594 const unsigned int first_selected_component = 0);
1608 reinit(
const unsigned int face_index);
1621 template <std::
size_t str
ide_view>
1664 template <std::
size_t str
ide_view>
1668 const bool sum_into_values =
false);
1695 const bool sum_into_values =
false);
1719 template <std::
size_t str
ide_view>
1724 const bool sum_into_values =
false);
1751 const bool sum_into_values =
false);
1759 template <
int str
ide_face_dof = VectorizedArrayType::size()>
1770 template <
int str
ide_face_dof = VectorizedArrayType::size()>
1774 const bool sum_into_values =
false);
1808 template <
bool is_linear, std::
size_t str
ide_view>
1814 template <
bool do_JxW,
bool is_linear, std::
size_t str
ide_view>
1819 const bool sum_into_values);
1825 template <
bool is_linear,
int str
ide_face_dof>
1834 template <
bool do_JxW,
bool is_linear,
int str
ide_face_dof>
1839 const bool sum_into_values);
1847template <
int n_components_,
int dim,
int spacedim,
typename Number>
1852 const unsigned int first_selected_component)
1853 : n_q_batches(
numbers::invalid_unsigned_int)
1854 , n_q_points(
numbers::invalid_unsigned_int)
1855 , n_q_points_scalar(
numbers::invalid_unsigned_int)
1859 , update_flags(update_flags)
1860 , mapping_info_on_the_fly(
1861 std::make_unique<
NonMatching::MappingInfo<dim, spacedim, Number>>(
1864 , mapping_info(mapping_info_on_the_fly.get())
1865 , current_cell_index(
numbers::invalid_unsigned_int)
1866 , current_face_number(
numbers::invalid_unsigned_int)
1867 , must_reinitialize_pointers(false)
1870 setup(first_selected_component);
1875template <
int n_components_,
int dim,
int spacedim,
typename Number>
1880 const unsigned int first_selected_component,
1881 const bool is_interior)
1882 : n_q_batches(
numbers::invalid_unsigned_int)
1883 , n_q_points(
numbers::invalid_unsigned_int)
1884 , n_q_points_scalar(
numbers::invalid_unsigned_int)
1885 , mapping(&mapping_info.get_mapping())
1888 , update_flags(mapping_info.get_update_flags())
1889 , mapping_info(&mapping_info)
1890 , current_cell_index(
numbers::invalid_unsigned_int)
1891 , current_face_number(
numbers::invalid_unsigned_int)
1892 , must_reinitialize_pointers(true)
1893 , is_interior(is_interior)
1895 setup(first_selected_component);
1900template <
int n_components_,
int dim,
int spacedim,
typename Number>
1904 : n_q_batches(other.n_q_batches)
1905 , n_q_points(other.n_q_points)
1906 , n_q_points_scalar(other.n_q_points_scalar)
1907 , mapping(other.mapping)
1910 , use_linear_path(other.use_linear_path)
1911 , renumber(other.renumber)
1912 , solution_renumbered(other.solution_renumbered)
1913 , solution_renumbered_vectorized(other.solution_renumbered_vectorized)
1914 , values(other.values)
1915 , gradients(other.gradients)
1916 , dofs_per_component(other.dofs_per_component)
1917 , dofs_per_component_face(other.dofs_per_component_face)
1918 , component_in_base_element(other.component_in_base_element)
1919 , nonzero_shape_function_component(other.nonzero_shape_function_component)
1920 , update_flags(other.update_flags)
1921 , fe_values(other.fe_values)
1922 , mapping_info_on_the_fly(
1923 other.mapping_info_on_the_fly ?
1928 , mapping_info(other.mapping_info)
1929 , current_cell_index(other.current_cell_index)
1930 , current_face_number(other.current_face_number)
1931 , fast_path(other.fast_path)
1932 , must_reinitialize_pointers(true)
1933 , is_interior(other.is_interior)
1938template <
int n_components_,
int dim,
int spacedim,
typename Number>
1944template <
int n_components_,
int dim,
int spacedim,
typename Number>
1947 const unsigned int first_selected_component)
1950 fe->n_components() + 1);
1952 shapes.reserve(100);
1954 bool same_base_element =
true;
1955 unsigned int base_element_number = 0;
1956 component_in_base_element = 0;
1957 unsigned int component = 0;
1958 for (; base_element_number < fe->n_base_elements(); ++base_element_number)
1959 if (component + fe->element_multiplicity(base_element_number) >
1960 first_selected_component)
1962 if (first_selected_component + n_components >
1963 component + fe->element_multiplicity(base_element_number))
1964 same_base_element =
false;
1965 component_in_base_element = first_selected_component - component;
1969 component += fe->element_multiplicity(base_element_number);
1973 *fe, base_element_number) &&
1976 shape_info.reinit(
QMidpoint<1>(), *fe, base_element_number);
1977 renumber = shape_info.lexicographic_numbering;
1978 dofs_per_component = shape_info.dofs_per_component_on_cell;
1979 dofs_per_component_face = shape_info.dofs_per_component_on_face;
1981 fe->base_element(base_element_number));
1983 bool is_lexicographic =
true;
1984 for (
unsigned int i = 0; i < renumber.size(); ++i)
1985 if (i != renumber[i])
1986 is_lexicographic =
false;
1988 if (is_lexicographic)
1991 use_linear_path = (poly.size() == 2 && poly[0].value(0.) == 1. &&
1992 poly[0].value(1.) == 0. && poly[1].value(0.) == 0. &&
1993 poly[1].value(1.) == 1.) &&
1994 (fe->n_components() == n_components);
1996 const unsigned int size_face = 3 * dofs_per_component_face * n_components;
1997 const unsigned int size_cell = dofs_per_component * n_components;
1998 scratch_data_scalar.resize(size_face + size_cell);
2000 solution_renumbered.resize(dofs_per_component);
2001 solution_renumbered_vectorized.resize(dofs_per_component);
2007 nonzero_shape_function_component.resize(fe->n_dofs_per_cell());
2008 for (
unsigned int d = 0; d < n_components; ++d)
2010 const unsigned int component = first_selected_component + d;
2011 for (
unsigned int i = 0; i < fe->n_dofs_per_cell(); ++i)
2013 const bool is_primitive =
2014 fe->is_primitive() || fe->is_primitive(i);
2016 nonzero_shape_function_component[i][d] =
2017 (component == fe->system_to_component_index(i).first);
2019 nonzero_shape_function_component[i][d] =
2020 (fe->get_nonzero_components(i)[component] ==
true);
2030template <
int n_components_,
int dim,
int spacedim,
typename Number>
2031template <
bool is_face,
bool is_linear>
2035 const unsigned int geometry_index =
2036 mapping_info->template compute_geometry_index_offset<is_face>(
2037 current_cell_index, current_face_number);
2039 cell_type = mapping_info->get_cell_type(geometry_index);
2041 const_cast<unsigned int &
>(n_q_points_scalar) =
2042 mapping_info->get_n_q_points_unvectorized(geometry_index);
2045 const_cast<unsigned int &
>(n_q_batches) =
2046 (n_q_points_scalar + n_lanes_internal - 1) / n_lanes_internal;
2048 const unsigned int n_q_points_before = n_q_points;
2050 const_cast<unsigned int &
>(n_q_points) =
2051 (stride == 1) ? n_q_batches : n_q_points_scalar;
2053 if (n_q_points != n_q_points_before)
2056 values.resize(n_q_points);
2058 gradients.resize(n_q_points);
2061 if (n_q_points == 0)
2065 const unsigned int unit_point_offset =
2066 mapping_info->compute_unit_point_index_offset(geometry_index);
2069 unit_point_faces_ptr =
2070 mapping_info->get_unit_point_faces(unit_point_offset);
2072 unit_point_ptr = mapping_info->get_unit_point(unit_point_offset);
2075 const unsigned int data_offset =
2076 mapping_info->compute_data_index_offset(geometry_index);
2077 const unsigned int compressed_data_offset =
2078 mapping_info->compute_compressed_data_index_offset(geometry_index);
2082 mapping_info->get_update_flags_mapping();
2084 real_point_ptr = mapping_info->get_real_point(data_offset);
2087 mapping_info->get_jacobian(compressed_data_offset, is_interior);
2089 inverse_jacobian_ptr =
2090 mapping_info->get_inverse_jacobian(compressed_data_offset,
2093 normal_ptr = mapping_info->get_normal_vector(data_offset);
2095 JxW_ptr = mapping_info->get_JxW(data_offset);
2099 real_point_ptr = mapping_info->get_real_point(data_offset);
2101 mapping_info->get_jacobian(compressed_data_offset, is_interior);
2102 inverse_jacobian_ptr =
2103 mapping_info->get_inverse_jacobian(compressed_data_offset, is_interior);
2104 normal_ptr = mapping_info->get_normal_vector(data_offset);
2105 JxW_ptr = mapping_info->get_JxW(data_offset);
2108 if (!is_linear && fast_path)
2110 const std::size_t n_shapes = poly.size();
2112 shapes_faces.resize_fast(n_q_batches * n_shapes);
2114 shapes.resize_fast(n_q_batches * n_shapes);
2116 for (
unsigned int qb = 0; qb < n_q_batches; ++qb)
2122 shapes_faces.data() + qb * n_shapes,
2124 unit_point_faces_ptr[qb],
2137 else if (qb + 1 < n_q_batches)
2142 shapes.data() + qb * n_shapes,
2145 unit_point_ptr[qb + 1]);
2161template <
int n_components_,
int dim,
int spacedim,
typename Number>
2165 Number>::value_type &
2167 const unsigned int point_index)
const
2170 return values[point_index];
2175template <
int n_components_,
int dim,
int spacedim,
typename Number>
2179 Number>::gradient_type &
2181 const unsigned int point_index)
const
2184 return gradients[point_index];
2189template <
int n_components_,
int dim,
int spacedim,
typename Number>
2192 const unsigned int point_index)
const
2194 static_assert(n_components == dim,
2195 "Only makes sense for a vector field with dim components");
2198 return trace(gradients[point_index]);
2203template <
int n_components_,
int dim,
int spacedim,
typename Number>
2207 const unsigned int point_index)
2210 values[point_index] = value;
2215template <
int n_components_,
int dim,
int spacedim,
typename Number>
2219 const unsigned int point_index)
2222 gradients[point_index] = gradient;
2227template <
int n_components_,
int dim,
int spacedim,
typename Number>
2230 const Number &value,
2231 const unsigned int point_index)
2233 static_assert(n_components == dim,
2234 "Only makes sense for a vector field with dim components");
2238 for (
unsigned int d = 0; d < dim; ++d)
2239 gradients[point_index][d][d] = value;
2244template <
int n_components_,
int dim,
int spacedim,
typename Number>
2245Tensor<1, (dim == 2 ? 1 : dim), Number>
2247 const unsigned int point_index)
const
2250 dim > 1 && n_components == dim,
2251 "Only makes sense for a vector field with dim components and dim > 1");
2254 Tensor<1, (dim == 2 ? 1 : dim), Number> curl;
2258 curl[0] = grad[1][0] - grad[0][1];
2261 curl[0] = grad[2][1] - grad[1][2];
2262 curl[1] = grad[0][2] - grad[2][0];
2263 curl[2] = grad[1][0] - grad[0][1];
2273template <
int n_components_,
int dim,
int spacedim,
typename Number>
2276 const unsigned int point_index)
const
2279 Assert(jacobian_ptr !=
nullptr,
2281 ExcFEPointEvaluationAccessToUninitializedMappingField(
2282 "update_jacobians"));
2283 return jacobian_ptr[cell_type <= ::internal::MatrixFreeFunctions::
2284 GeometryType::affine ?
2291template <
int n_components_,
int dim,
int spacedim,
typename Number>
2294 const unsigned int point_index)
const
2297 Assert(inverse_jacobian_ptr !=
nullptr,
2299 ExcFEPointEvaluationAccessToUninitializedMappingField(
2300 "update_inverse_jacobians"));
2301 return inverse_jacobian_ptr
2310template <
int n_components_,
int dim,
int spacedim,
typename Number>
2313 const unsigned int point_index)
const
2316 Assert(JxW_ptr !=
nullptr,
2318 ExcFEPointEvaluationAccessToUninitializedMappingField(
2319 "update_JxW_values"));
2320 return JxW_ptr[point_index];
2325template <
int n_components_,
int dim,
int spacedim,
typename Number>
2328 const unsigned int point_index)
const
2330 return quadrature_point(point_index);
2335template <
int n_components_,
int dim,
int spacedim,
typename Number>
2338 const unsigned int point_index)
const
2341 Assert(real_point_ptr !=
nullptr,
2343 ExcFEPointEvaluationAccessToUninitializedMappingField(
2344 "update_quadrature_points"));
2345 return real_point_ptr[point_index];
2350template <
int n_components_,
int dim,
int spacedim,
typename Number>
2353 const unsigned int point_index)
const
2356 Assert(unit_point_ptr !=
nullptr,
ExcMessage(
"unit_point_ptr is not set!"));
2358 for (
unsigned int d = 0; d < dim; ++d)
2360 unit_point_ptr[point_index / stride][d], point_index % stride);
2366template <
int n_components_,
int dim,
int spacedim,
typename Number>
2377template <
int n_components_,
int dim,
int spacedim,
typename Number>
2381 const unsigned int first_selected_component,
2382 const bool force_lexicographic_numbering)
2386 first_selected_component)
2387 , lexicographic_numbering(force_lexicographic_numbering ||
2388 this->renumber.empty())
2393template <
int n_components_,
int dim,
int spacedim,
typename Number>
2398 const unsigned int first_selected_component,
2399 const bool force_lexicographic_numbering)
2404 first_selected_component)
2405 , lexicographic_numbering(force_lexicographic_numbering ||
2406 this->renumber.empty())
2411template <
int n_components_,
int dim,
int spacedim,
typename Number>
2419 if (this->use_linear_path)
2420 this->
template do_reinit<false, true>();
2422 this->
template do_reinit<false, false>();
2427template <
int n_components_,
int dim,
int spacedim,
typename Number>
2431 internal_reinit_single_cell_state_mapping_info();
2432 this->must_reinitialize_pointers =
false;
2437template <
int n_components_,
int dim,
int spacedim,
typename Number>
2444 AssertThrow(this->mapping_info_on_the_fly.get() !=
nullptr,
2447 this->mapping_info_on_the_fly->reinit(cell, unit_points);
2448 this->must_reinitialize_pointers =
false;
2450 if (!this->fast_path)
2452 this->fe_values = std::make_shared<FEValues<dim, spacedim>>(
2456 std::vector<
Point<dim>>(unit_points.begin(), unit_points.end())),
2457 this->update_flags);
2458 this->fe_values->reinit(cell);
2461 if (this->use_linear_path)
2462 this->
template do_reinit<false, true>();
2464 this->
template do_reinit<false, false>();
2469template <
int n_components_,
int dim,
int spacedim,
typename Number>
2476 this->must_reinitialize_pointers =
false;
2478 if (this->use_linear_path)
2479 this->
template do_reinit<false, true>();
2481 this->
template do_reinit<false, false>();
2483 if (!this->fast_path)
2485 std::vector<Point<dim>> unit_points(this->n_q_points_scalar);
2487 for (
unsigned int v = 0; v < this->n_q_points_scalar; ++v)
2488 for (
unsigned int d = 0; d < dim; ++d)
2490 this->unit_point_ptr[v / n_lanes_internal][d][v % n_lanes_internal];
2492 this->fe_values = std::make_shared<FEValues<dim, spacedim>>(
2496 std::vector<
Point<dim>>(unit_points.begin(), unit_points.end())),
2497 this->update_flags);
2499 this->fe_values->reinit(
2500 this->mapping_info->get_cell_iterator(this->current_cell_index));
2506template <
int n_components_,
int dim,
int spacedim,
typename Number>
2507template <std::
size_t str
ide_view>
2519 if (this->must_reinitialize_pointers)
2520 internal_reinit_single_cell_state_mapping_info();
2522 if (this->n_q_points == 0)
2526 if (this->fast_path)
2528 if (this->use_linear_path)
2529 evaluate_fast<true>(solution_values, evaluation_flags);
2531 evaluate_fast<false>(solution_values, evaluation_flags);
2534 evaluate_slow(solution_values, evaluation_flags);
2539template <
int n_components_,
int dim,
int spacedim,
typename Number>
2546 solution_values.
size()),
2552template <
int n_components_,
int dim,
int spacedim,
typename Number>
2553template <std::
size_t str
ide_view>
2558 const bool sum_into_values)
2560 do_integrate<true>(solution_values, integration_flags, sum_into_values);
2565template <
int n_components_,
int dim,
int spacedim,
typename Number>
2570 const bool sum_into_values)
2573 solution_values.
size()),
2580template <
int n_components_,
int dim,
int spacedim,
typename Number>
2588 for (
const auto point_index : this->quadrature_point_indices())
2589 return_value += values[point_index] * this->JxW(point_index);
2591 return ETT::sum_value(return_value);
2596template <
int n_components_,
int dim,
int spacedim,
typename Number>
2603 "Calling this function only makes sense in fully vectorized mode."));
2604 if (q == n_q_batches - 1)
2606 const unsigned int n_filled_lanes =
2607 n_q_points_scalar & (n_lanes_user_interface - 1);
2608 if (n_filled_lanes == 0)
2609 return n_lanes_user_interface;
2611 return n_filled_lanes;
2614 return n_lanes_user_interface;
2619template <
int n_components_,
int dim,
int spacedim,
typename Number>
2620template <std::
size_t str
ide_view>
2625 const bool sum_into_values)
2627 do_integrate<false>(solution_values, integration_flags, sum_into_values);
2632template <
int n_components_,
int dim,
int spacedim,
typename Number>
2637 const bool sum_into_values)
2640 solution_values.
size()),
2647template <
int n_components_,
int dim,
int spacedim,
typename Number>
2648template <
bool is_linear, std::
size_t str
ide_view>
2653 const unsigned int dofs_per_comp =
2656 for (
unsigned int comp = 0; comp < n_components; ++comp)
2658 const std::size_t offset =
2659 (this->component_in_base_element + comp) * dofs_per_comp;
2661 if ((is_linear && n_components == 1) || lexicographic_numbering)
2663 for (
unsigned int i = 0; i < dofs_per_comp; ++i)
2664 ETT::read_value(solution_values[i + offset],
2666 this->solution_renumbered[i]);
2670 const unsigned int *renumber_ptr = this->renumber.data() + offset;
2671 for (
unsigned int i = 0; i < dofs_per_comp; ++i)
2672 ETT::read_value(solution_values[renumber_ptr[i]],
2674 this->solution_renumbered[i]);
2681template <
int n_components_,
int dim,
int spacedim,
typename Number>
2682template <
bool is_linear, std::
size_t str
ide_view>
2687 const unsigned int n_shapes,
2688 const unsigned int qb,
2694 std::array<vectorized_value_type, dim + 1> result;
2695 if constexpr (is_linear)
2697 if constexpr (n_components == 1)
2704 stride_view>(solution_values.
data(), this->unit_point_ptr[qb]);
2708 this->solution_renumbered.data(), this->unit_point_ptr[qb]);
2716 false>(this->shapes.data() + qb * n_shapes,
2718 this->solution_renumbered.data());
2719 gradient[0] = result[0];
2721 gradient[1] = result[1];
2723 gradient[2] = result[2];
2724 value = result[dim];
2728 if constexpr (is_linear)
2730 if constexpr (n_components == 1)
2735 stride_view>(solution_values.
data(), this->unit_point_ptr[qb]);
2738 this->solution_renumbered.data(), this->unit_point_ptr[qb]);
2746 this->shapes.data() + qb * n_shapes,
2748 this->solution_renumbered.data());
2754template <
int n_components_,
int dim,
int spacedim,
typename Number>
2755template <
bool is_linear, std::
size_t str
ide_view>
2761 if (!(is_linear && n_components == 1))
2762 prepare_evaluate_fast<is_linear>(solution_values);
2765 const unsigned int n_shapes = is_linear ? 2 : this->poly.size();
2767 for (
unsigned int qb = 0; qb < this->n_q_batches; ++qb)
2772 compute_evaluate_fast<is_linear>(
2773 solution_values, evaluation_flags, n_shapes, qb, value, gradient);
2777 for (
unsigned int v = 0, offset = qb * stride;
2778 v < stride && (stride == 1 || offset < this->n_q_points_scalar);
2780 ETT::set_value(value, v, this->values[offset]);
2788 for (
unsigned int v = 0, offset = qb * stride;
2789 v < stride && (stride == 1 || offset < this->n_q_points_scalar);
2793 ETT::set_gradient(gradient, v, unit_gradient);
2794 this->gradients[offset] =
2798 this->inverse_jacobian_ptr[0].
transpose(), unit_gradient) :
2801 ->inverse_jacobian_ptr[this->cell_type <=
2803 GeometryType::affine ?
2815template <
int n_components_,
int dim,
int spacedim,
typename Number>
2816template <std::
size_t str
ide_view>
2823 Assert(this->fe_values.get() !=
nullptr,
2825 "Not initialized. Please call FEPointEvaluation::reinit()!"));
2827 const std::size_t n_points = this->fe_values->get_quadrature().size();
2831 this->values.resize(this->n_q_points);
2832 std::fill(this->values.begin(), this->values.end(),
value_type());
2833 for (
unsigned int i = 0; i < this->fe->n_dofs_per_cell(); ++i)
2836 for (
unsigned int d = 0; d < n_components; ++d)
2837 if (this->nonzero_shape_function_component[i][d] &&
2838 (this->fe->is_primitive(i) || this->fe->is_primitive()))
2839 for (
unsigned int qb = 0, q = 0; q < n_points;
2840 ++qb, q += n_lanes_user_interface)
2841 for (
unsigned int v = 0;
2842 v < n_lanes_user_interface && q + v < n_points;
2844 ETT::access(this->values[qb],
2847 this->fe_values->shape_value(i, q + v) * value);
2848 else if (this->nonzero_shape_function_component[i][d])
2849 for (
unsigned int qb = 0, q = 0; q < n_points;
2850 ++qb, q += n_lanes_user_interface)
2851 for (
unsigned int v = 0;
2852 v < n_lanes_user_interface && q + v < n_points;
2854 ETT::access(this->values[qb],
2857 this->fe_values->shape_value_component(i,
2866 this->gradients.resize(this->n_q_points);
2867 std::fill(this->gradients.begin(),
2868 this->gradients.end(),
2870 for (
unsigned int i = 0; i < this->fe->n_dofs_per_cell(); ++i)
2873 for (
unsigned int d = 0; d < n_components; ++d)
2874 if (this->nonzero_shape_function_component[i][d] &&
2875 (this->fe->is_primitive(i) || this->fe->is_primitive()))
2876 for (
unsigned int qb = 0, q = 0; q < n_points;
2877 ++qb, q += n_lanes_user_interface)
2878 for (
unsigned int v = 0;
2879 v < n_lanes_user_interface && q + v < n_points;
2881 ETT::access(this->gradients[qb],
2884 this->fe_values->shape_grad(i, q + v) * value);
2885 else if (this->nonzero_shape_function_component[i][d])
2886 for (
unsigned int qb = 0, q = 0; q < n_points;
2887 ++qb, q += n_lanes_user_interface)
2888 for (
unsigned int v = 0;
2889 v < n_lanes_user_interface && q + v < n_points;
2892 this->gradients[qb],
2895 this->fe_values->shape_grad_component(i, q + v, d) * value);
2902template <
int n_components_,
int dim,
int spacedim,
typename Number>
2903template <
bool is_linear>
2907 const unsigned int n_shapes,
2908 const unsigned int qb,
2923 solution_values_vectorized_linear :
2924 this->solution_renumbered_vectorized.data(),
2925 this->unit_point_ptr[qb],
2932 this->shapes.data() + qb * n_shapes,
2935 is_linear ? solution_values_vectorized_linear :
2936 this->solution_renumbered_vectorized.data(),
2937 this->unit_point_ptr[qb],
2943template <
int n_components_,
int dim,
int spacedim,
typename Number>
2944template <
bool is_linear, std::
size_t str
ide_view>
2949 const bool sum_into_values)
2951 if (!sum_into_values && this->fe->n_components() > n_components)
2952 for (
unsigned int i = 0; i < solution_values.
size(); ++i)
2953 solution_values[i] = 0;
2955 const unsigned int dofs_per_comp =
2958 for (
unsigned int comp = 0; comp < n_components; ++comp)
2960 const std::size_t offset =
2961 (this->component_in_base_element + comp) * dofs_per_comp;
2963 if (is_linear || lexicographic_numbering)
2965 for (
unsigned int i = 0; i < dofs_per_comp; ++i)
2966 if (sum_into_values)
2967 solution_values[i + offset] +=
2968 ETT::sum_value(comp,
2970 *(solution_values_vectorized_linear + i) :
2971 this->solution_renumbered_vectorized[i]);
2973 solution_values[i + offset] =
2974 ETT::sum_value(comp,
2976 *(solution_values_vectorized_linear + i) :
2977 this->solution_renumbered_vectorized[i]);
2981 const unsigned int *renumber_ptr = this->renumber.
data() + offset;
2982 for (
unsigned int i = 0; i < dofs_per_comp; ++i)
2983 if (sum_into_values)
2984 solution_values[renumber_ptr[i]] +=
2985 ETT::sum_value(comp, this->solution_renumbered_vectorized[i]);
2987 solution_values[renumber_ptr[i]] =
2988 ETT::sum_value(comp, this->solution_renumbered_vectorized[i]);
2995template <
int n_components_,
int dim,
int spacedim,
typename Number>
2996template <
bool do_JxW,
bool is_linear, std::
size_t str
ide_view>
3001 const bool sum_into_values)
3004 if constexpr (stride == 1)
3005 if (
const unsigned int n_filled_lanes =
3006 this->n_q_points_scalar & (n_lanes_internal - 1);
3010 for (
unsigned int v = n_filled_lanes; v < n_lanes_internal; ++v)
3011 ETT::set_zero_value(this->values.back(), v);
3013 for (
unsigned int v = n_filled_lanes; v < n_lanes_internal; ++v)
3014 ETT::set_zero_gradient(this->gradients.back(), v);
3018 solution_values_vectorized_linear = {};
3021 const unsigned int n_shapes = is_linear ? 2 : this->poly.size();
3023 const bool cartesian_cell =
3025 const bool affine_cell =
3027 for (
unsigned int qb = 0; qb < this->n_q_batches; ++qb)
3033 for (
unsigned int v = 0, offset = qb * stride;
3034 v < stride && (stride == 1 || offset < this->n_q_points_scalar);
3036 ETT::get_value(value,
3038 do_JxW ? this->values[offset] * this->JxW_ptr[offset] :
3039 this->values[offset]);
3042 for (
unsigned int v = 0, offset = qb * stride;
3043 v < stride && (stride == 1 || offset < this->n_q_points_scalar);
3047 do_JxW ? this->gradients[offset] * this->JxW_ptr[offset] :
3048 this->gradients[offset];
3056 this->inverse_jacobian_ptr[affine_cell ? 0 : offset],
3060 compute_integrate_fast<is_linear>(
3066 solution_values_vectorized_linear.data());
3070 finish_integrate_fast<is_linear>(solution_values,
3071 solution_values_vectorized_linear.
data(),
3077template <
int n_components_,
int dim,
int spacedim,
typename Number>
3078template <
bool do_JxW, std::
size_t str
ide_view>
3083 const bool sum_into_values)
3086 Assert(this->fe_values.get() !=
nullptr,
3088 "Not initialized. Please call FEPointEvaluation::reinit()!"));
3089 if (!sum_into_values)
3090 for (
unsigned int i = 0; i < solution_values.
size(); ++i)
3091 solution_values[i] = 0;
3093 const std::size_t n_points = this->fe_values->get_quadrature().
size();
3098 for (
unsigned int i = 0; i < this->fe->n_dofs_per_cell(); ++i)
3100 for (
unsigned int d = 0; d < n_components; ++d)
3101 if (this->nonzero_shape_function_component[i][d] &&
3102 (this->fe->is_primitive(i) || this->fe->is_primitive()))
3103 for (
unsigned int qb = 0, q = 0; q < n_points;
3104 ++qb, q += n_lanes_user_interface)
3105 for (
unsigned int v = 0;
3106 v < n_lanes_user_interface && q + v < n_points;
3108 solution_values[i] +=
3109 this->fe_values->shape_value(i, q + v) *
3110 ETT::access(this->values[qb], v, d) *
3111 (do_JxW ? this->fe_values->JxW(q + v) : 1.);
3112 else if (this->nonzero_shape_function_component[i][d])
3113 for (
unsigned int qb = 0, q = 0; q < n_points;
3114 ++qb, q += n_lanes_user_interface)
3115 for (
unsigned int v = 0;
3116 v < n_lanes_user_interface && q + v < n_points;
3118 solution_values[i] +=
3119 this->fe_values->shape_value_component(i, q + v, d) *
3120 ETT::access(this->values[qb], v, d) *
3121 (do_JxW ? this->fe_values->JxW(q + v) : 1.);
3128 for (
unsigned int i = 0; i < this->fe->n_dofs_per_cell(); ++i)
3130 for (
unsigned int d = 0; d < n_components; ++d)
3131 if (this->nonzero_shape_function_component[i][d] &&
3132 (this->fe->is_primitive(i) || this->fe->is_primitive()))
3133 for (
unsigned int qb = 0, q = 0; q < n_points;
3134 ++qb, q += n_lanes_user_interface)
3135 for (
unsigned int v = 0;
3136 v < n_lanes_user_interface && q + v < n_points;
3138 solution_values[i] +=
3139 this->fe_values->shape_grad(i, q + v) *
3140 ETT::access(this->gradients[qb], v, d) *
3141 (do_JxW ? this->fe_values->JxW(q + v) : 1.);
3142 else if (this->nonzero_shape_function_component[i][d])
3143 for (
unsigned int qb = 0, q = 0; q < n_points;
3144 ++qb, q += n_lanes_user_interface)
3145 for (
unsigned int v = 0;
3146 v < n_lanes_user_interface && q + v < n_points;
3148 solution_values[i] +=
3149 this->fe_values->shape_grad_component(i, q + v, d) *
3150 ETT::access(this->gradients[qb], v, d) *
3151 (do_JxW ? this->fe_values->JxW(q + v) : 1.);
3158template <
int n_components_,
int dim,
int spacedim,
typename Number>
3159template <
bool do_JxW, std::
size_t str
ide_view>
3164 const bool sum_into_values)
3166 if (this->must_reinitialize_pointers)
3167 internal_reinit_single_cell_state_mapping_info();
3171 if (this->n_q_points == 0 ||
3173 (integration_flags &
3176 if (!sum_into_values)
3177 for (
unsigned int i = 0; i < solution_values.
size(); ++i)
3178 solution_values[i] = 0;
3183 !do_JxW || this->JxW_ptr !=
nullptr,
3185 "JxW pointer is not set! If you do not want to integrate() use test_and_sum()"));
3188 if (this->fast_path)
3190 if (this->use_linear_path)
3191 integrate_fast<do_JxW, true>(solution_values,
3195 integrate_fast<do_JxW, false>(solution_values,
3200 integrate_slow<do_JxW>(solution_values, integration_flags, sum_into_values);
3205template <
int n_components_,
int dim,
int spacedim,
typename Number>
3208 const unsigned int point_index)
const
3211 Assert(this->normal_ptr !=
nullptr,
3213 ExcFEPointEvaluationAccessToUninitializedMappingField(
3214 "update_normal_vectors"));
3215 return this->normal_ptr[point_index];
3220template <
int n_components_,
int dim,
int spacedim,
typename Number>
3226 const unsigned int point_index)
const
3231 if constexpr (n_components == 1)
3233 this->gradients[point_index] * normal_vector(point_index);
3235 for (
unsigned int comp = 0; comp < n_components; ++comp)
3236 normal_derivative[comp] =
3237 this->gradients[point_index][comp] * normal_vector(point_index);
3239 return normal_derivative;
3244template <
int n_components_,
int dim,
int spacedim,
typename Number>
3248 const unsigned int point_index)
3251 if constexpr (n_components == 1)
3252 this->gradients[point_index] = value * normal_vector(point_index);
3254 for (
unsigned int comp = 0; comp < n_components; ++comp)
3255 this->gradients[point_index][comp] =
3256 value[comp] * normal_vector(point_index);
3261template <
int n_components_,
int dim,
int spacedim,
typename Number>
3266 const bool is_interior,
3267 const unsigned int first_selected_component)
3271 first_selected_component,
3277template <
int n_components_,
int dim,
int spacedim,
typename Number>
3281 const unsigned int face_number)
3284 this->current_face_number = face_number;
3285 this->must_reinitialize_pointers =
false;
3287 if (this->use_linear_path)
3288 this->
template do_reinit<true, true>();
3290 this->
template do_reinit<true, false>();
3295template <
int n_components_,
int dim,
int spacedim,
typename Number>
3298 const unsigned int face_index)
3300 this->current_cell_index = face_index;
3301 this->current_face_number =
3302 this->mapping_info->get_face_number(face_index, this->is_interior);
3303 this->must_reinitialize_pointers =
false;
3305 if (this->use_linear_path)
3306 this->
template do_reinit<true, true>();
3308 this->
template do_reinit<true, false>();
3313template <
int n_components_,
int dim,
int spacedim,
typename Number>
3314template <std::
size_t str
ide_view>
3320 Assert(!this->must_reinitialize_pointers,
3321 ExcMessage(
"Object has not been reinitialized!"));
3323 if (this->n_q_points == 0)
3334 if (this->use_linear_path)
3335 do_evaluate<true>(solution_values, evaluation_flags);
3337 do_evaluate<false>(solution_values, evaluation_flags);
3342template <
int n_components_,
int dim,
int spacedim,
typename Number>
3349 solution_values.
size()),
3355template <
int n_components_,
int dim,
int spacedim,
typename Number>
3356template <
bool is_linear, std::
size_t str
ide_view>
3362 const unsigned int dofs_per_comp =
3366 if (stride_view == 1 && this->component_in_base_element == 0 &&
3367 (is_linear || this->renumber.empty()))
3368 input = solution_values.
data();
3371 for (
unsigned int comp = 0; comp < n_components; ++comp)
3373 const std::size_t offset =
3374 (this->component_in_base_element + comp) * dofs_per_comp;
3376 if (is_linear || this->renumber.empty())
3378 for (
unsigned int i = 0; i < dofs_per_comp; ++i)
3379 this->scratch_data_scalar[i + comp * dofs_per_comp] =
3380 solution_values[i + offset];
3384 const unsigned int *renumber_ptr = this->renumber.
data() + offset;
3385 for (
unsigned int i = 0; i < dofs_per_comp; ++i)
3386 this->scratch_data_scalar[i + comp * dofs_per_comp] =
3387 solution_values[renumber_ptr[i]];
3390 input = this->scratch_data_scalar.
data();
3394 this->scratch_data_scalar.begin() + dofs_per_comp * n_components;
3397 template interpolate<true, false>(n_components,
3402 this->current_face_number);
3404 do_evaluate_in_face<is_linear, 1>(output, evaluation_flags);
3409template <
int n_components_,
int dim,
int spacedim,
typename Number>
3410template <std::
size_t str
ide_view>
3415 const bool sum_into_values)
3417 Assert(!this->must_reinitialize_pointers,
3418 ExcMessage(
"Object has not been reinitialized!"));
3422 if (this->n_q_points == 0 ||
3424 (integration_flags &
3427 if (!sum_into_values)
3428 for (
unsigned int i = 0; i < solution_values.
size(); ++i)
3429 solution_values[i] = 0;
3435 if (this->use_linear_path)
3436 do_integrate<true, true>(solution_values,
3440 do_integrate<true, false>(solution_values,
3447template <
int n_components_,
int dim,
int spacedim,
typename Number>
3452 const bool sum_into_values)
3455 solution_values.
size()),
3462template <
int n_components_,
int dim,
int spacedim,
typename Number>
3463template <std::
size_t str
ide_view>
3468 const bool sum_into_values)
3470 Assert(!this->must_reinitialize_pointers,
3471 ExcMessage(
"Object has not been reinitialized!"));
3475 if (this->n_q_points == 0 ||
3477 (integration_flags &
3480 if (!sum_into_values)
3481 for (
unsigned int i = 0; i < solution_values.
size(); ++i)
3482 solution_values[i] = 0;
3488 if (this->use_linear_path)
3489 do_integrate<false, true>(solution_values,
3493 do_integrate<false, false>(solution_values,
3500template <
int n_components_,
int dim,
int spacedim,
typename Number>
3505 const bool sum_into_values)
3508 solution_values.
size()),
3515template <
int n_components_,
int dim,
int spacedim,
typename Number>
3516template <
bool do_JxW,
bool is_linear, std::
size_t str
ide_view>
3521 const bool sum_into_values)
3523 if (!sum_into_values && this->fe->n_components() > n_components)
3524 for (
unsigned int i = 0; i < solution_values.
size(); ++i)
3525 solution_values[i] = 0;
3527 do_integrate_in_face<do_JxW, is_linear, 1>(this->scratch_data_scalar.begin(),
3531 ScalarNumber *input = this->scratch_data_scalar.begin();
3533 if (stride_view == 1 && this->component_in_base_element == 0 &&
3534 (is_linear || this->renumber.empty()))
3536 if (sum_into_values)
3538 FEFaceNormalEvaluationImpl<dim, is_linear ? 1 : -1,
ScalarNumber>::
3539 template interpolate<false, true>(n_components,
3543 solution_values.
data(),
3544 this->current_face_number);
3547 FEFaceNormalEvaluationImpl<dim, is_linear ? 1 : -1,
ScalarNumber>::
3548 template interpolate<false, false>(n_components,
3552 solution_values.
data(),
3553 this->current_face_number);
3557 const unsigned int dofs_per_comp_face =
3558 is_linear ?
Utilities::pow(2, dim - 1) : this->dofs_per_component_face;
3560 const unsigned int size_input = 3 * dofs_per_comp_face * n_components;
3564 FEFaceNormalEvaluationImpl<dim, is_linear ? 1 : -1,
ScalarNumber>::
3565 template interpolate<false, false>(n_components,
3570 this->current_face_number);
3572 const unsigned int dofs_per_comp =
3575 for (
unsigned int comp = 0; comp < n_components; ++comp)
3577 const std::size_t offset =
3578 (this->component_in_base_element + comp) * dofs_per_comp;
3580 if (is_linear || this->renumber.empty())
3582 for (
unsigned int i = 0; i < dofs_per_comp; ++i)
3583 if (sum_into_values)
3584 solution_values[i + offset] +=
3585 output[i + comp * dofs_per_comp];
3587 solution_values[i + offset] =
3588 output[i + comp * dofs_per_comp];
3592 const unsigned int *renumber_ptr = this->renumber.
data() + offset;
3593 for (
unsigned int i = 0; i < dofs_per_comp; ++i)
3594 if (sum_into_values)
3595 solution_values[renumber_ptr[i]] +=
3596 output[i + comp * dofs_per_comp];
3598 solution_values[renumber_ptr[i]] =
3599 output[i + comp * dofs_per_comp];
3607template <
int n_components_,
int dim,
int spacedim,
typename Number>
3608template <
int str
ide_face_dof>
3614 if (this->use_linear_path)
3615 do_evaluate_in_face<true, stride_face_dof>(face_dof_values,
3618 do_evaluate_in_face<false, stride_face_dof>(face_dof_values,
3624template <
int n_components_,
int dim,
int spacedim,
typename Number>
3625template <
bool is_linear,
int str
ide_face_dof>
3632 if constexpr (n_components == 1)
3633 face_dof_values_ptr = face_dof_values;
3636 const unsigned int dofs_per_comp_face =
3637 is_linear ?
Utilities::pow(2, dim - 1) : this->dofs_per_component_face;
3638 for (
unsigned int comp = 0; comp < n_components; ++comp)
3639 for (
unsigned int i = 0; i < 2 * dofs_per_comp_face; ++i)
3640 ETT::read_value(face_dof_values[(i + comp * 3 * dofs_per_comp_face) *
3643 this->solution_renumbered[i]);
3645 face_dof_values_ptr = this->solution_renumbered.data();
3648 constexpr int stride_face_dof_actual =
3649 n_components == 1 ? stride_face_dof : 1;
3652 const unsigned int n_shapes = is_linear ? 2 : this->poly.size();
3654 for (
unsigned int qb = 0; qb < this->n_q_batches; ++qb)
3661 const std::array<vectorized_value_type, dim + 1> interpolated_value =
3668 stride_face_dof_actual>(face_dof_values_ptr,
3669 this->unit_point_faces_ptr[qb]) :
3676 stride_face_dof_actual>(this->shapes_faces.data() +
3679 face_dof_values_ptr);
3681 value = interpolated_value[dim - 1];
3684 if (this->current_face_number / 2 == 0)
3686 gradient[0] = interpolated_value[dim];
3688 gradient[1] = interpolated_value[0];
3690 gradient[2] = interpolated_value[1];
3692 else if (this->current_face_number / 2 == 1)
3695 gradient[1] = interpolated_value[dim];
3698 gradient[0] = interpolated_value[1];
3699 gradient[2] = interpolated_value[0];
3702 gradient[0] = interpolated_value[0];
3706 else if (this->current_face_number / 2 == 2)
3710 gradient[0] = interpolated_value[0];
3711 gradient[1] = interpolated_value[1];
3712 gradient[2] = interpolated_value[dim];
3727 stride_face_dof_actual>(face_dof_values_ptr,
3728 this->unit_point_faces_ptr[qb]) :
3734 stride_face_dof_actual>(this->shapes_faces.data() +
3737 face_dof_values_ptr);
3742 for (
unsigned int v = 0, offset = qb * stride;
3743 v < stride && (stride == 1 || offset < this->n_q_points_scalar);
3745 ETT::set_value(value, v, this->values[offset]);
3753 for (
unsigned int v = 0, offset = qb * stride;
3754 v < stride && (stride == 1 || offset < this->n_q_points_scalar);
3758 ETT::set_gradient(gradient, v, unit_gradient);
3759 this->gradients[offset] =
3763 this->inverse_jacobian_ptr[0].
transpose(), unit_gradient) :
3766 ->inverse_jacobian_ptr[this->cell_type <=
3768 GeometryType::affine ?
3780template <
int n_components_,
int dim,
int spacedim,
typename Number>
3781template <
int str
ide_face_dof>
3786 const bool sum_into_values)
3788 if (this->use_linear_path)
3789 do_integrate_in_face<true, true, stride_face_dof>(face_dof_values,
3793 do_integrate_in_face<true, false, stride_face_dof>(face_dof_values,
3800template <
int n_components_,
int dim,
int spacedim,
typename Number>
3801template <
bool do_JxW,
bool is_linear,
int str
ide_face_dof>
3807 const bool sum_into_values)
3810 if constexpr (stride == 1)
3811 if (
const unsigned int n_filled_lanes =
3812 this->n_q_points_scalar & (n_lanes_internal - 1);
3816 for (
unsigned int v = n_filled_lanes; v < n_lanes_internal; ++v)
3817 ETT::set_zero_value(this->values.back(), v);
3819 for (
unsigned int v = n_filled_lanes; v < n_lanes_internal; ++v)
3820 ETT::set_zero_gradient(this->gradients.back(), v);
3825 solution_values_vectorized_linear = {};
3828 const unsigned int n_shapes = is_linear ? 2 : this->poly.size();
3830 const bool cartesian_cell =
3832 const bool affine_cell =
3834 for (
unsigned int qb = 0; qb < this->n_q_batches; ++qb)
3840 for (
unsigned int v = 0, offset = qb * stride;
3841 v < stride && (stride == 1 || offset < this->n_q_points_scalar);
3843 ETT::get_value(value,
3845 do_JxW ? this->values[offset] * this->JxW_ptr[offset] :
3846 this->values[offset]);
3849 for (
unsigned int v = 0, offset = qb * stride;
3850 v < stride && (stride == 1 || offset < this->n_q_points_scalar);
3854 do_JxW ? this->gradients[offset] * this->JxW_ptr[offset] :
3855 this->gradients[offset];
3863 this->inverse_jacobian_ptr[affine_cell ? 0 : offset],
3869 std::array<vectorized_value_type, 2> value_face = {};
3872 value_face[0] = value;
3875 if (this->current_face_number / 2 == 0)
3877 value_face[1] = gradient[0];
3879 gradient_in_face[0] = gradient[1];
3881 gradient_in_face[1] = gradient[2];
3883 else if (this->current_face_number / 2 == 1)
3886 value_face[1] = gradient[1];
3889 gradient_in_face[0] = gradient[2];
3890 gradient_in_face[1] = gradient[0];
3893 gradient_in_face[0] = gradient[0];
3897 else if (this->current_face_number / 2 == 2)
3901 value_face[1] = gradient[2];
3902 gradient_in_face[0] = gradient[0];
3903 gradient_in_face[1] = gradient[1];
3916 2>(this->shapes_faces.data() + qb * n_shapes,
3920 is_linear ? solution_values_vectorized_linear.data() :
3921 this->solution_renumbered_vectorized.data(),
3922 this->unit_point_faces_ptr[qb],
3930 this->shapes_faces.data() + qb * n_shapes,
3933 is_linear ? solution_values_vectorized_linear.data() :
3934 this->solution_renumbered_vectorized.data(),
3935 this->unit_point_faces_ptr[qb],
3939 const unsigned int dofs_per_comp_face =
3940 is_linear ?
Utilities::pow(2, dim - 1) : this->dofs_per_component_face;
3942 for (
unsigned int comp = 0; comp < n_components; ++comp)
3943 for (
unsigned int i = 0; i < 2 * dofs_per_comp_face; ++i)
3944 if (sum_into_values)
3945 face_dof_values[(i + comp * 3 * dofs_per_comp_face) *
3947 ETT::sum_value(comp,
3949 *(solution_values_vectorized_linear.data() + i) :
3950 this->solution_renumbered_vectorized[i]);
3952 face_dof_values[(i + comp * 3 * dofs_per_comp_face) * stride_face_dof] =
3953 ETT::sum_value(comp,
3955 *(solution_values_vectorized_linear.data() + i) :
3956 this->solution_renumbered_vectorized[i]);
3961template <
int n_components_,
int dim,
int spacedim,
typename Number>
3964 const unsigned int point_index)
const
3967 Assert(this->normal_ptr !=
nullptr,
3969 ExcFEPointEvaluationAccessToUninitializedMappingField(
3970 "update_normal_vectors"));
3974 for (
unsigned int d = 0; d < dim; ++d)
3983 return this->normal_ptr[point_index];
3989template <
int n_components_,
int dim,
int spacedim,
typename Number>
4000 if constexpr (n_components == 1)
4002 this->gradients[point_index] * normal_vector(point_index);
4004 for (
unsigned int comp = 0; comp < n_components; ++comp)
4005 normal_derivative[comp] =
4006 this->gradients[point_index][comp] * normal_vector(point_index);
4008 return normal_derivative;
4013template <
int n_components_,
int dim,
int spacedim,
typename Number>
4017 const unsigned int point_index)
4020 if constexpr (n_components == 1)
4021 this->gradients[point_index] = value * normal_vector(point_index);
4023 for (
unsigned int comp = 0; comp < n_components; ++comp)
4024 this->gradients[point_index][comp] =
4025 value[comp] * normal_vector(point_index);
value_type * data() const noexcept
typename ETT::vectorized_value_type vectorized_value_type
static constexpr std::size_t n_lanes_internal
void do_integrate_in_face(ScalarNumber *face_dof_values, const EvaluationFlags::EvaluationFlags &integration_flags, const bool sum_into_values)
void integrate_in_face(ScalarNumber *face_dof_values, const EvaluationFlags::EvaluationFlags &integration_flags, const bool sum_into_values=false)
typename ETT::scalar_value_type scalar_value_type
typename internal::VectorizedArrayTrait< Number >::value_type ScalarNumber
void evaluate(const StridedArrayView< const ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &evaluation_flags)
void do_evaluate_in_face(const ScalarNumber *face_dof_values, const EvaluationFlags::EvaluationFlags &evaluation_flags)
void submit_normal_derivative(const value_type &, const unsigned int point_index)
typename internal::FEPointEvaluation::EvaluatorTypeTraits< dim, spacedim, n_components, Number > ETT
static constexpr std::size_t stride
typename ETT::interface_vectorized_unit_gradient_type interface_vectorized_unit_gradient_type
void do_evaluate(const StridedArrayView< const ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &evaluation_flags)
static constexpr unsigned int n_components
static constexpr std::size_t n_lanes_user_interface
typename ETT::real_gradient_type gradient_type
FEFacePointEvaluation(const NonMatching::MappingInfo< dim, spacedim, Number > &mapping_info, const FiniteElement< dim, spacedim > &fe, const bool is_interior=true, const unsigned int first_selected_component=0)
void evaluate_in_face(const ScalarNumber *face_dof_values, const EvaluationFlags::EvaluationFlags &evaluation_flags)
void reinit(const unsigned int cell_index, const unsigned int face_number)
void test_and_sum(const StridedArrayView< ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &integration_flags, const bool sum_into_values=false)
typename ETT::unit_gradient_type unit_gradient_type
const value_type get_normal_derivative(const unsigned int point_index) const
void do_integrate(const StridedArrayView< ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &integration_flags, const bool sum_into_values)
void integrate(const StridedArrayView< ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &integration_flags, const bool sum_into_values=false)
static constexpr unsigned int dimension
Tensor< 1, spacedim, Number > normal_vector(const unsigned int point_index) const
typename ETT::value_type value_type
typename ::internal::VectorizedArrayTrait< Number >::vectorized_value_type VectorizedArrayType
ObserverPointer< const Mapping< dim, spacedim > > mapping
const DerivativeForm< 1, dim, spacedim, Number > * jacobian_ptr
std::unique_ptr< NonMatching::MappingInfo< dim, spacedim, Number > > mapping_info_on_the_fly
std::vector< gradient_type > gradients
unsigned int dofs_per_component
typename ETT::interface_vectorized_unit_gradient_type interface_vectorized_unit_gradient_type
Number get_divergence(const unsigned int point_index) const
unsigned int dofs_per_component_face
Number JxW(const unsigned int point_index) const
const UpdateFlags update_flags
static constexpr std::size_t n_lanes_user_interface
static constexpr std::size_t stride
internal::MatrixFreeFunctions::GeometryType cell_type
std::vector< Polynomials::Polynomial< double > > poly
Point< spacedim, Number > real_point(const unsigned int point_index) const
Tensor< 1,(dim==2 ? 1 :dim), Number > get_curl(const unsigned int point_index) const
const unsigned int n_q_points_scalar
const Point< dim, VectorizedArrayType > * unit_point_ptr
FEPointEvaluationBase(FEPointEvaluationBase &&other) noexcept
AlignedVector< ScalarNumber > scratch_data_scalar
std_cxx20::ranges::iota_view< unsigned int, unsigned int > quadrature_point_indices() const
const value_type & get_value(const unsigned int point_index) const
const Point< dim - 1, VectorizedArrayType > * unit_point_faces_ptr
std::vector< scalar_value_type > solution_renumbered
const unsigned int n_q_batches
ObserverPointer< const FiniteElement< dim, spacedim > > fe
std::vector< std::array< bool, n_components > > nonzero_shape_function_component
Point< spacedim, Number > quadrature_point(const unsigned int point_index) const
unsigned int n_active_entries_per_quadrature_batch(unsigned int q)
const gradient_type & get_gradient(const unsigned int point_index) const
std::shared_ptr< FEValues< dim, spacedim > > fe_values
FEPointEvaluationBase(const Mapping< dim, spacedim > &mapping, const FiniteElement< dim, spacedim > &fe, const UpdateFlags update_flags, const unsigned int first_selected_component=0)
std::vector< unsigned int > renumber
std::vector< value_type > values
AlignedVector<::ndarray< VectorizedArrayType, 2, dim - 1 > > shapes_faces
Point< dim, Number > unit_point(const unsigned int point_index) const
const unsigned int n_q_points
void submit_divergence(const Number &value, const unsigned int point_index)
bool must_reinitialize_pointers
const Tensor< 1, spacedim, Number > * normal_ptr
DerivativeForm< 1, spacedim, dim, Number > inverse_jacobian(const unsigned int point_index) const
AlignedVector< vectorized_value_type > solution_renumbered_vectorized
static constexpr std::size_t n_lanes_internal
ObserverPointer< const NonMatching::MappingInfo< dim, spacedim, Number > > mapping_info
const DerivativeForm< 1, spacedim, dim, Number > * inverse_jacobian_ptr
AlignedVector<::ndarray< VectorizedArrayType, 2, dim > > shapes
typename ETT::value_type value_type
unsigned int current_cell_index
scalar_value_type integrate_value() const
void submit_gradient(const gradient_type &, const unsigned int point_index)
void setup(const unsigned int first_selected_component)
typename ETT::scalar_value_type scalar_value_type
static constexpr unsigned int dimension
typename ::internal::VectorizedArrayTrait< Number >::vectorized_value_type VectorizedArrayType
typename ETT::vectorized_value_type vectorized_value_type
static constexpr unsigned int n_components
typename internal::FEPointEvaluation::EvaluatorTypeTraits< dim, spacedim, n_components, Number > ETT
unsigned int current_face_number
FEPointEvaluationBase(FEPointEvaluationBase &other) noexcept
DerivativeForm< 1, dim, spacedim, Number > jacobian(const unsigned int point_index) const
typename ETT::real_gradient_type gradient_type
const Point< spacedim, Number > * real_point_ptr
FEPointEvaluationBase(const NonMatching::MappingInfo< dim, spacedim, Number > &mapping_info, const FiniteElement< dim, spacedim > &fe, const unsigned int first_selected_component=0, const bool is_interior=true)
unsigned int component_in_base_element
internal::MatrixFreeFunctions::ShapeInfo< ScalarNumber > shape_info
void submit_value(const value_type &value, const unsigned int point_index)
typename internal::VectorizedArrayTrait< Number >::value_type ScalarNumber
static constexpr std::size_t stride
void integrate_slow(const StridedArrayView< ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &integration_flags, const bool sum_into_values)
static constexpr unsigned int dimension
typename ETT::value_type value_type
void do_integrate(const StridedArrayView< ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &integration_flags, const bool sum_into_values)
void evaluate_fast(const StridedArrayView< const ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &evaluation_flags)
typename ETT::scalar_value_type scalar_value_type
typename ETT::unit_gradient_type unit_gradient_type
void evaluate(const StridedArrayView< const ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &evaluation_flags)
const value_type get_normal_derivative(const unsigned int point_index) const
void prepare_evaluate_fast(const StridedArrayView< const ScalarNumber, stride_view > &solution_values)
void test_and_sum(const StridedArrayView< ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &integration_flags, const bool sum_into_values=false)
void integrate(const StridedArrayView< ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &integration_flags, const bool sum_into_values=false)
typename internal::VectorizedArrayTrait< Number >::value_type ScalarNumber
typename ETT::vectorized_value_type vectorized_value_type
void compute_integrate_fast(const EvaluationFlags::EvaluationFlags &integration_flags, const unsigned int n_shapes, const unsigned int qb, const vectorized_value_type value, const interface_vectorized_unit_gradient_type gradient, vectorized_value_type *solution_values_vectorized_linear)
typename ::internal::VectorizedArrayTrait< Number >::vectorized_value_type VectorizedArrayType
typename ETT::real_gradient_type gradient_type
void submit_normal_derivative(const value_type &, const unsigned int point_index)
void evaluate_slow(const StridedArrayView< const ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &evaluation_flags)
static constexpr std::size_t n_lanes_internal
static constexpr unsigned int n_components
void finish_integrate_fast(const StridedArrayView< ScalarNumber, stride_view > &solution_values, vectorized_value_type *solution_values_vectorized_linear, const bool sum_into_values)
typename internal::FEPointEvaluation::EvaluatorTypeTraits< dim, spacedim, n_components, Number > ETT
void internal_reinit_single_cell_state_mapping_info()
void compute_evaluate_fast(const StridedArrayView< const ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &evaluation_flags, const unsigned int n_shapes, const unsigned int qb, vectorized_value_type &value, interface_vectorized_unit_gradient_type &gradient)
void integrate_fast(const StridedArrayView< ScalarNumber, stride_view > &solution_values, const EvaluationFlags::EvaluationFlags &integration_flags, const bool sum_into_values)
static constexpr std::size_t n_lanes_user_interface
const bool lexicographic_numbering
FEPointEvaluation(const Mapping< dim, spacedim > &mapping, const FiniteElement< dim, spacedim > &fe, const UpdateFlags update_flags, const unsigned int first_selected_component=0, const bool force_lexicographic_numbering=false)
typename ETT::interface_vectorized_unit_gradient_type interface_vectorized_unit_gradient_type
Tensor< 1, spacedim, Number > normal_vector(const unsigned int point_index) const
Abstract base class for mapping classes.
value_type * data() const noexcept
Tensor< rank, dim, Number > sum(const Tensor< rank, dim, Number > &local, const MPI_Comm mpi_communicator)
#define DEAL_II_DEPRECATED
#define DEAL_II_NAMESPACE_OPEN
constexpr bool running_in_debug_mode()
#define DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_ASSERT_UNREACHABLE()
#define DEAL_II_NOT_IMPLEMENTED()
static ::ExceptionBase & ExcNotImplemented()
#define Assert(cond, exc)
#define AssertDimension(dim1, dim2)
static ::ExceptionBase & ExcFEPointEvaluationAccessToUninitializedMappingField(std::string arg1)
#define AssertIndexRange(index, range)
static ::ExceptionBase & ExcNotInitialized()
#define DeclException1(Exception1, type1, outsequence)
static ::ExceptionBase & ExcMessage(std::string arg1)
#define AssertThrow(cond, exc)
@ update_values
Shape function values.
@ update_normal_vectors
Normal vectors.
@ update_JxW_values
Transformed quadrature weights.
@ update_jacobians
Volume element.
@ update_inverse_jacobians
Volume element.
@ update_gradients
Shape function gradients.
@ update_quadrature_points
Transformed quadrature points.
EvaluationFlags
The EvaluationFlags enum.
constexpr T pow(const T base, const int iexp)
std::vector< Polynomials::Polynomial< double > > get_polynomial_space(const FiniteElement< dim, spacedim > &fe)
bool is_fast_path_supported(const FiniteElement< dim, spacedim > &fe, const unsigned int base_element_number)
std::array< typename ProductTypeNoPoint< Number, Number2 >::type, dim+n_values > evaluate_tensor_product_value_and_gradient_shapes(const ::ndarray< Number2, 2, dim > *shapes, const int n_shapes, const Number *values, const std::vector< unsigned int > &renumber={})
void integrate_tensor_product_value_and_gradient(const ::ndarray< Number, 2, dim > *shapes, const unsigned int n_shapes, const Number2 *value, const Tensor< 1, dim, Number2 > &gradient, Number2 *values, const Point< dim, Number > &p, const bool do_add)
void compute_values_of_array_in_pairs(::ndarray< Number, 2, dim > *shapes, const std::vector< Polynomials::Polynomial< double > > &poly, const Point< dim, Number > &p0, const Point< dim, Number > &p1)
ProductTypeNoPoint< Number, Number2 >::type evaluate_tensor_product_value_shapes(const ::ndarray< Number2, 2, dim > *shapes, const int n_shapes, const Number *values, const std::vector< unsigned int > &renumber={})
void compute_values_of_array(::ndarray< Number, 2, dim > *shapes, const std::vector< Polynomials::Polynomial< double > > &poly, const Point< dim, Number > &p, const unsigned int derivative=1)
ProductTypeNoPoint< Number, Number2 >::type evaluate_tensor_product_value_linear(const Number *values, const Point< dim, Number2 > &p)
std::array< typename ProductTypeNoPoint< Number, Number2 >::type, dim+n_values > evaluate_tensor_product_value_and_gradient_linear(const Number *values, const Point< dim, Number2 > &p)
void integrate_tensor_product_value(const ::ndarray< Number, 2, dim > *shapes, const unsigned int n_shapes, const Number2 &value, Number2 *values, const Point< dim, Number > &p, const bool do_add)
constexpr unsigned int invalid_unsigned_int
boost::integer_range< IncrementableType > iota_view
typename internal::ndarray::HelperArray< T, Ns... >::type ndarray
static void set_zero_gradient(unit_gradient_type &value, const unsigned int vector_lane)
static void access(value_type &value, const unsigned int vector_lane, const unsigned int component, const ScalarNumber &shape_value)
static void set_value(const vectorized_value_type &value, const unsigned int vector_lane, scalar_value_type &result)
static Tensor< 1, dim, ScalarNumber > access(const real_gradient_type &value, const unsigned int vector_lane, const unsigned int component)
static void get_value(vectorized_value_type &value, const unsigned int, const vectorized_value_type &result)
static void set_zero_value(value_type &value, const unsigned int vector_lane)
static void set_gradient(const interface_vectorized_unit_gradient_type &value, const unsigned int vector_lane, unit_gradient_type &result)
static void read_value(const ScalarNumber vector_entry, const unsigned int component, scalar_value_type &result)
static void access(real_gradient_type &value, const unsigned int vector_lane, const unsigned int component, const Tensor< 1, dim, ScalarNumber > &shape_gradient)
static scalar_value_type sum_value(const vectorized_value_type &result)
static scalar_value_type sum_value(const scalar_value_type &result)
static ScalarNumber sum_value(const unsigned int component, const vectorized_value_type &result)
static ScalarNumber access(const value_type &value, const unsigned int vector_lane, const unsigned int component)
static void get_value(vectorized_value_type &value, const unsigned int vector_lane, const scalar_value_type &result)
typename ::internal::VectorizedArrayTrait< Number >::vectorized_value_type VectorizedArrayType
static void get_gradient(interface_vectorized_unit_gradient_type &value, const unsigned int vector_lane, const unit_gradient_type &result)
static void set_value(const vectorized_value_type &value, const unsigned int, vectorized_value_type &result)
typename internal::VectorizedArrayTrait< Number >::value_type ScalarNumber
static ScalarNumber access(const value_type &value, const unsigned int vector_lane, const unsigned int)
static void get_gradient(vectorized_unit_gradient_type &value, const unsigned int, const vectorized_unit_gradient_type &result)
static scalar_value_type sum_value(const scalar_value_type &result)
static void get_value(vectorized_value_type &value, const unsigned int, const vectorized_value_type &result)
static void set_gradient(const vectorized_unit_gradient_type &value, const unsigned int vector_lane, scalar_unit_gradient_type &result)
static void set_zero_value(value_type &value, const unsigned int vector_lane)
static Tensor< 1, spacedim, ScalarNumber > access(const real_gradient_type &value, const unsigned int vector_lane, const unsigned int)
static void set_value(const vectorized_value_type &value, const unsigned int, vectorized_value_type &result)
VectorizedArrayType vectorized_value_type
typename internal::VectorizedArrayTrait< Number >::value_type ScalarNumber
static void get_value(vectorized_value_type &value, const unsigned int vector_lane, const scalar_value_type &result)
static scalar_value_type sum_value(const vectorized_value_type &result)
static void access(real_gradient_type &value, const unsigned int vector_lane, const unsigned int, const Tensor< 1, spacedim, ScalarNumber > &shape_gradient)
static void set_gradient(const vectorized_unit_gradient_type &value, const unsigned int, vectorized_unit_gradient_type &result)
ScalarNumber scalar_value_type
static void set_value(const vectorized_value_type &value, const unsigned int vector_lane, scalar_value_type &result)
static void set_zero_gradient(real_gradient_type &value, const unsigned int vector_lane)
static void access(value_type &value, const unsigned int vector_lane, const unsigned int, const ScalarNumber &shape_value)
static void get_gradient(vectorized_unit_gradient_type &value, const unsigned int vector_lane, const scalar_unit_gradient_type &result)
static ScalarNumber sum_value(const unsigned int, const vectorized_value_type &result)
static void read_value(const ScalarNumber vector_entry, const unsigned int, scalar_value_type &result)
typename ::internal::VectorizedArrayTrait< Number >::vectorized_value_type VectorizedArrayType
static Tensor< 1, spacedim, ScalarNumber > access(const real_gradient_type &value, const unsigned int vector_lane, const unsigned int component)
static void get_gradient(interface_vectorized_unit_gradient_type &value, const unsigned int vector_lane, const DerivativeForm< 1, dim, n_components, Number > &result)
static void get_value(vectorized_value_type &value, const unsigned int, const vectorized_value_type &result)
static void get_value(vectorized_value_type &value, const unsigned int vector_lane, const scalar_value_type &result)
static void set_value(const vectorized_value_type &value, const unsigned int, vectorized_value_type &result)
static scalar_value_type sum_value(const scalar_value_type &result)
typename ::internal::VectorizedArrayTrait< Number >::vectorized_value_type VectorizedArrayType
static scalar_value_type sum_value(const vectorized_value_type &result)
static void read_value(const ScalarNumber vector_entry, const unsigned int component, scalar_value_type &result)
Tensor< 1, n_components, ScalarNumber > scalar_value_type
static void set_value(const vectorized_value_type &value, const unsigned int vector_lane, scalar_value_type &result)
static ScalarNumber access(const value_type &value, const unsigned int vector_lane, const unsigned int component)
static ScalarNumber sum_value(const unsigned int component, const vectorized_value_type &result)
Tensor< 1, n_components, Tensor< 1, dim, VectorizedArrayType > > vectorized_unit_gradient_type
static void set_zero_value(value_type &value, const unsigned int vector_lane)
static void set_gradient(const interface_vectorized_unit_gradient_type &value, const unsigned int vector_lane, unit_gradient_type &result)
static void set_zero_gradient(real_gradient_type &value, const unsigned int vector_lane)
typename internal::VectorizedArrayTrait< Number >::value_type ScalarNumber
static void get_gradient(interface_vectorized_unit_gradient_type &value, const unsigned int vector_lane, const unit_gradient_type &result)
std::conditional_t< n_components==spacedim, Tensor< 2, spacedim, Number >, Tensor< 1, n_components, Tensor< 1, spacedim, Number > > > real_gradient_type
Tensor< 1, n_components, VectorizedArrayType > vectorized_value_type
static void access(real_gradient_type &value, const unsigned int vector_lane, const unsigned int component, const Tensor< 1, spacedim, ScalarNumber > &shape_gradient)
Tensor< 1, n_components, Tensor< 1, dim, Number > > unit_gradient_type
static void access(value_type &value, const unsigned int vector_lane, const unsigned int component, const ScalarNumber &shape_value)
static constexpr std::size_t width()
static constexpr std::size_t stride()
static value_type & get(value_type &value, unsigned int c)
DEAL_II_HOST constexpr Number trace(const SymmetricTensor< 2, dim2, Number > &)