Loading [MathJax]/extensions/TeX/AMSsymbols.js
 deal.II version GIT relicensing-2968-g5f01c80b02 2025-03-29 13:10:00+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages Concepts
fe_evaluation_data.h
Go to the documentation of this file.
1// ------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: LGPL-2.1-or-later
4// Copyright (C) 2021 - 2024 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Part of the source code is dual licensed under Apache-2.0 WITH
9// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10// governing the source code and code contributions can be found in
11// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12//
13// ------------------------------------------------------------------------
14
15
16#ifndef dealii_matrix_free_fe_evaluation_data_h
17#define dealii_matrix_free_fe_evaluation_data_h
18
19
20#include <deal.II/base/config.h>
21
30#include <deal.II/base/tensor.h>
32
34
38
39
41
42
43
44namespace internal
45{
47
50 std::string,
51 << "You are requesting information from an FEEvaluation/FEFaceEvaluation "
52 << "object for which this kind of information has not been computed. What "
53 << "information these objects compute is determined by the update_* flags "
54 << "you pass to MatrixFree::reinit() via MatrixFree::AdditionalData. "
55 << "Here, the operation you are attempting requires the <" << arg1
56 << "> flag to be set, but it was apparently not specified "
57 << "upon initialization.");
58} // namespace internal
59
60// forward declarations
61template <int dim,
62 int fe_degree,
63 int n_q_points_1d = fe_degree + 1,
64 int n_components_ = 1,
65 typename Number = double,
66 typename VectorizedArrayType = VectorizedArray<Number>>
67class FEEvaluation;
68
69template <int dim,
70 int n_components_,
71 typename Number,
72 bool = false,
73 typename = VectorizedArray<Number>>
75
76namespace internal
77{
78 namespace MatrixFreeFunctions
79 {
80 template <int, typename>
81 class MappingDataOnTheFly;
82 }
83} // namespace internal
84
85
114template <int dim, typename Number, bool is_face>
116{
119 using MappingInfoStorageType = internal::MatrixFreeFunctions::
120 MappingInfoStorage<(is_face ? dim - 1 : dim), dim, Number>;
122
123public:
124 static constexpr unsigned int dimension = dim;
125
126 using NumberType = Number;
130
131 static constexpr unsigned int n_lanes =
133
142 const bool is_interior_face = true);
143
147 FEEvaluationData(const FEEvaluationData &other) = default;
148
154
158 virtual ~FEEvaluationData() = default;
159
165 void
167 const unsigned int n_components);
168
173 void
176
190
195 Number
196 JxW(const unsigned int q_point) const;
197
203 quadrature_point(const unsigned int q) const;
204
217 inverse_jacobian(const unsigned int q_point) const;
218
232 normal_vector(const unsigned int q_point) const;
233
239 DEAL_II_DEPRECATED_WITH_COMMENT("Use normal_vector() instead.")
240 Tensor<1, dim, Number>
241 get_normal_vector(const unsigned int q_point) const;
242
257 const Number *
259
268 Number *
270
281 const Number *
283
294 Number *
296
308 const Number *
310
322 Number *
324
337 const Number *
339
352 Number *
354
370 unsigned int
372
379 internal::MatrixFreeFunctions::GeometryType
381
385 const ShapeInfoType &
387
391 const internal::MatrixFreeFunctions::DoFInfo &
393
399 const std::vector<unsigned int> &
401
405 unsigned int
407
411 unsigned int
413
418 unsigned int
420
425 unsigned int
427
431 unsigned int
433
446 std::uint8_t
447 get_face_no(const unsigned int v = 0) const;
448
458 unsigned int
460
469 std::uint8_t
470 get_face_orientation(const unsigned int v = 0) const;
471
479 internal::MatrixFreeFunctions::DoFInfo::DoFAccessIndex
481
490 bool
492
497 const std::array<unsigned int, n_lanes> &
499 {
500 // implemented inline to avoid compilation problems on Windows
501 if constexpr (running_in_debug_mode())
502 {
504 }
505 return cell_ids;
506 }
507
512 const std::array<unsigned int, n_lanes> &
514 {
515 // implemented inline to avoid compilation problems on Windows
516 if constexpr (running_in_debug_mode())
517 {
519 }
520 return face_ids;
521 }
522
527 unsigned int
529 {
530 // implemented inline to avoid compilation problems on Windows
531 if constexpr (running_in_debug_mode())
532 {
534 }
535
536 return cell;
537 }
538
543 const std::array<unsigned int, n_lanes> &
545 {
546 // implemented inline to avoid compilation problems on Windows
547 if constexpr (running_in_debug_mode())
548 {
550 }
551
552 if (!is_face || dof_access_index ==
554 return cell_ids;
555 else
556 return face_ids;
557 }
558
566
584 template <typename T>
585 T
586 read_cell_data(const AlignedVector<T> &array) const;
587
594 template <typename T>
595 void
596 set_cell_data(AlignedVector<T> &array, const T &value) const;
597
606 template <typename T>
607 T
608 read_face_data(const AlignedVector<T> &array) const;
609
618 template <typename T>
619 void
620 set_face_data(AlignedVector<T> &array, const T &value) const;
621
637
638protected:
645 FEEvaluationData(const InitializationData &initialization_data,
646 const bool is_interior_face,
647 const unsigned int quad_no,
648 const unsigned int first_selected_component);
649
655 const std::shared_ptr<
658 const unsigned int n_fe_components,
659 const unsigned int first_selected_component);
660
668
675
683
689 const unsigned int quad_no;
690
695 const unsigned int n_fe_components;
696
701 const unsigned int first_selected_component;
702
706 const unsigned int active_fe_index;
707
712 const unsigned int active_quad_index;
713
720
724 const unsigned int n_quadrature_points;
725
731
745
750 const Tensor<1, dim *(dim + 1) / 2, Tensor<1, dim, Number>>
752
757 const Tensor<1, dim *(dim + 1) / 2, Tensor<1, dim, Number>>
759
766 const Number *J_value;
767
772
777
782
790
801 Number *values_dofs;
802
812 Number *values_quad;
813
827
840
853
864
870
877
884
891
898
905
912
919
924 unsigned int cell;
925
933
939
948 std::array<std::uint8_t, n_lanes> face_numbers;
949
958 std::array<std::uint8_t, n_lanes> face_orientations;
959
967 unsigned int subface_index;
968
976
981 std::array<unsigned int, n_lanes> cell_ids;
982
987 std::array<unsigned int, n_lanes> face_ids;
988
994 std::shared_ptr<
997
1003
1004 // Make FEEvaluation and FEEvaluationBase objects friends for access to
1005 // protected member mapped_geometry.
1006 template <int, int, typename, bool, typename>
1007 friend class FEEvaluationBase;
1008
1009 template <int, int, int, int, typename, typename>
1010 friend class FEEvaluation;
1011};
1012
1013
1018template <int dim,
1019 typename Number,
1020 bool is_face,
1021 typename VectorizedArrayType = VectorizedArray<Number>>
1024
1025
1026/*----------------------- Inline functions ----------------------------------*/
1027
1028#ifndef DOXYGEN
1029
1030template <int dim, typename Number, bool is_face>
1032 const ShapeInfoType &shape_info,
1033 const bool is_interior_face)
1035 InitializationData{&shape_info, nullptr, nullptr, 0, 0, nullptr},
1037 0,
1038 0)
1039{}
1040
1041
1042template <int dim, typename Number, bool is_face>
1044 const InitializationData &initialization_data,
1045 const bool is_interior_face,
1046 const unsigned int quad_no,
1047 const unsigned int first_selected_component)
1048 : data(initialization_data.shape_info)
1049 , dof_info(initialization_data.dof_info)
1050 , mapping_data(initialization_data.mapping_data)
1051 , quad_no(quad_no)
1052 , n_fe_components(dof_info != nullptr ? dof_info->start_components.back() : 0)
1054 , active_fe_index(initialization_data.active_fe_index)
1055 , active_quad_index(initialization_data.active_quad_index)
1056 , descriptor(initialization_data.descriptor)
1057 , n_quadrature_points(descriptor == nullptr ?
1058 (is_face ? data->n_q_points_face : data->n_q_points) :
1060 , quadrature_points(nullptr)
1061 , jacobian(nullptr)
1062 , jacobian_gradients(nullptr)
1064 , J_value(nullptr)
1065 , normal_vectors(nullptr)
1066 , normal_x_jacobian(nullptr)
1068 descriptor != nullptr ? descriptor->quadrature_weights.begin() : nullptr)
1069# ifdef DEBUG
1070 , is_reinitialized(false)
1071 , dof_values_initialized(false)
1075 , values_quad_submitted(false)
1077# endif
1081 is_face ?
1083 internal::MatrixFreeFunctions::DoFInfo::dof_access_face_interior :
1084 internal::MatrixFreeFunctions::DoFInfo::dof_access_face_exterior) :
1085 internal::MatrixFreeFunctions::DoFInfo::dof_access_cell)
1086 , subface_index(0)
1087 , cell_type(internal::MatrixFreeFunctions::general)
1089{}
1090
1091
1092
1093template <int dim, typename Number, bool is_face>
1095 const std::shared_ptr<
1098 const unsigned int n_fe_components,
1099 const unsigned int first_selected_component)
1100 : data(nullptr)
1101 , dof_info(nullptr)
1102 , mapping_data(nullptr)
1108 , descriptor(nullptr)
1110 mapped_geometry->get_data_storage().descriptor[0].n_q_points)
1111 , quadrature_points(nullptr)
1112 , jacobian(nullptr)
1113 , jacobian_gradients(nullptr)
1115 , J_value(nullptr)
1116 , normal_vectors(nullptr)
1117 , normal_x_jacobian(nullptr)
1118 , quadrature_weights(nullptr)
1119 , cell(0)
1120 , cell_type(internal::MatrixFreeFunctions::general)
1121 , interior_face(true)
1122 , dof_access_index(internal::MatrixFreeFunctions::DoFInfo::dof_access_cell)
1124 , is_reinitialized(false)
1126{
1127 mapping_data = &mapped_geometry->get_data_storage();
1128 jacobian = mapped_geometry->get_data_storage().jacobians[0].begin();
1129 J_value = mapped_geometry->get_data_storage().JxW_values.begin();
1131 mapped_geometry->get_data_storage().jacobian_gradients[0].begin();
1133 .jacobian_gradients_non_inverse[0]
1134 .begin();
1136 mapped_geometry->get_data_storage().quadrature_points.begin();
1137}
1138
1139
1140
1141template <int dim, typename Number, bool is_face>
1144{
1151
1152 data = other.data;
1153 dof_info = other.dof_info;
1154 mapping_data = other.mapping_data;
1155 descriptor = other.descriptor;
1156 jacobian = nullptr;
1157 J_value = nullptr;
1158 normal_vectors = nullptr;
1159 normal_x_jacobian = nullptr;
1160 jacobian_gradients = nullptr;
1162 quadrature_points = nullptr;
1164
1165 if constexpr (running_in_debug_mode())
1166 {
1167 is_reinitialized = false;
1168 dof_values_initialized = false;
1172 values_quad_submitted = false;
1174 }
1175
1179 is_face ?
1180 (is_interior_face() ?
1183 internal::MatrixFreeFunctions::DoFInfo::dof_access_cell;
1184 face_numbers[0] = 0;
1185 face_orientations[0] = 0;
1186 subface_index = 0;
1189
1190 return *this;
1191}
1192
1193
1194
1195template <int dim, typename Number, bool is_face>
1196inline void
1199 const unsigned int n_components)
1200{
1202
1203 const unsigned int tensor_dofs_per_component =
1204 Utilities::fixed_power<dim>(data->data.front().fe_degree + 1);
1205 const unsigned int dofs_per_component = data->dofs_per_component_on_cell;
1206
1207 const unsigned int size_scratch_data =
1208 std::max(tensor_dofs_per_component + 1, dofs_per_component) * n_components *
1209 4 +
1211 const unsigned int size_data_arrays =
1213 (n_components * ((dim * (dim + 1)) / 2 + 2 * dim + 2) *
1215
1216 // include 12 extra fields to insert some padding between values, gradients
1217 // and hessians, which helps to reduce the probability of cache conflicts
1218 const unsigned int allocated_size = size_scratch_data + size_data_arrays + 12;
1219 if constexpr (running_in_debug_mode())
1220 {
1223 allocated_size, Number(numbers::signaling_nan<ScalarNumber>()));
1224 }
1225 else
1226 {
1227 scratch_data_array->resize_fast(allocated_size);
1228 }
1229 scratch_data.reinit(scratch_data_array->begin() + size_data_arrays + 12,
1230 size_scratch_data);
1231
1232 // set the pointers to the correct position in the data array
1234 values_quad =
1237 scratch_data_array->begin() + 6 +
1240 scratch_data_array->begin() + 8 +
1243 scratch_data_array->begin() + 12 +
1246 scratch_data_array->begin() + 12 +
1248}
1249
1250
1251
1252template <int dim, typename Number, bool is_face>
1253inline void
1256{
1257 Assert(is_face == true,
1258 ExcMessage("Faces can only be set if the is_face template parameter "
1259 "is true"));
1260 face_numbers[0] =
1262 subface_index = is_interior_face() == true ?
1264 face.subface_index;
1265
1266 // First check if interior or exterior cell has non-standard orientation
1267 // (i.e. the third bit is one or not). Then set zero if this cell has
1268 // standard-orientation else copy the first three bits
1269 // (which is equivalent to modulo 8). See also the documentation of
1270 // internal::MatrixFreeFunctions::FaceToCellTopology::face_orientation.
1271 face_orientations[0] = (is_interior_face() == (face.face_orientation >= 8)) ?
1272 (face.face_orientation % 8) :
1273 0;
1274
1275 if (is_interior_face())
1276 cell_ids = face.cells_interior;
1277 else
1278 cell_ids = face.cells_exterior;
1279}
1280
1281
1282
1283template <int dim, typename Number, bool is_face>
1286 const unsigned int q_point) const
1287{
1289 Assert(normal_vectors != nullptr,
1291 "update_normal_vectors"));
1293 return normal_vectors[0];
1294 else
1295 return normal_vectors[q_point];
1296}
1297
1298
1299
1300// This function is deprecated.
1301template <int dim, typename Number, bool is_face>
1304 const unsigned int q_point) const
1305{
1306 return normal_vector(q_point);
1307}
1308
1309
1310
1311template <int dim, typename Number, bool is_face>
1312inline DEAL_II_ALWAYS_INLINE Number
1313FEEvaluationData<dim, Number, is_face>::JxW(const unsigned int q_point) const
1314{
1316 Assert(J_value != nullptr,
1318 "update_values|update_gradients"));
1320 {
1322 return J_value[0] * quadrature_weights[q_point];
1323 }
1324 else
1325 return J_value[q_point];
1326}
1327
1328
1329
1330template <int dim, typename Number, bool is_face>
1333 const unsigned int q) const
1334{
1336 Assert(this->quadrature_points != nullptr,
1338 "update_quadrature_points"));
1339
1340 // Cartesian/affine mesh: only first vertex of cell is stored, we must
1341 // compute it through the Jacobian (which is stored in non-inverted and
1342 // non-transposed form as index '1' in the jacobian field)
1343 if (is_face == false &&
1345 {
1346 Assert(this->jacobian != nullptr, ExcNotInitialized());
1348
1349 const Tensor<2, dim, Number> &jac = this->jacobian[1];
1351 for (unsigned int d = 0; d < dim; ++d)
1352 point[d] += jac[d][d] * static_cast<typename Number::value_type>(
1353 this->descriptor->quadrature.point(q)[d]);
1354 else
1355 for (unsigned int d = 0; d < dim; ++d)
1356 for (unsigned int e = 0; e < dim; ++e)
1357 point[d] += jac[d][e] * static_cast<typename Number::value_type>(
1358 this->descriptor->quadrature.point(q)[e]);
1359 return point;
1360 }
1361 else
1362 return this->quadrature_points[q];
1363}
1364
1365
1366
1367template <int dim, typename Number, bool is_face>
1370 const unsigned int q_point) const
1371{
1373 Assert(jacobian != nullptr,
1375 "update_gradients"));
1377 return jacobian[0];
1378 else
1379 return jacobian[q_point];
1380}
1381
1382
1383
1384template <int dim, typename Number, bool is_face>
1385inline const Number *
1387{
1388 return values_dofs;
1389}
1390
1391
1392
1393template <int dim, typename Number, bool is_face>
1394inline Number *
1396{
1397 if constexpr (running_in_debug_mode())
1398 {
1400 }
1401 return values_dofs;
1402}
1403
1404
1405
1406template <int dim, typename Number, bool is_face>
1407inline const Number *
1409{
1410 if constexpr (running_in_debug_mode())
1411 {
1414 }
1415 return values_quad;
1416}
1417
1418
1419
1420template <int dim, typename Number, bool is_face>
1421inline Number *
1423{
1424 if constexpr (running_in_debug_mode())
1425 {
1427 values_quad_submitted = true;
1428 }
1429 return values_quad;
1430}
1431
1432
1433
1434template <int dim, typename Number, bool is_face>
1435inline const Number *
1437{
1438 if constexpr (running_in_debug_mode())
1439 {
1442 }
1443 return gradients_quad;
1444}
1445
1446
1447
1448template <int dim, typename Number, bool is_face>
1449inline Number *
1451{
1452 if constexpr (running_in_debug_mode())
1453 {
1456 }
1457 return gradients_quad;
1458}
1459
1460
1461
1462template <int dim, typename Number, bool is_face>
1463inline const Number *
1465{
1466 if constexpr (running_in_debug_mode())
1467 {
1469 }
1470 return hessians_quad;
1471}
1472
1473
1474
1475template <int dim, typename Number, bool is_face>
1476inline Number *
1478{
1479 if constexpr (running_in_debug_mode())
1480 {
1482 }
1483 return hessians_quad;
1484}
1485
1486
1487
1488template <int dim, typename Number, bool is_face>
1489inline unsigned int
1491{
1492 Assert(mapping_data != nullptr, ExcInternalError());
1493
1494 if (dof_info == nullptr)
1495 return 0;
1496 else
1497 {
1500 }
1501}
1502
1503
1504
1505template <int dim, typename Number, bool is_face>
1508{
1509 if constexpr (running_in_debug_mode())
1510 {
1512 }
1513 return cell_type;
1514}
1515
1516
1517
1518template <int dim, typename Number, bool is_face>
1521{
1522 Assert(data != nullptr, ExcInternalError());
1523 return *data;
1524}
1525
1526
1527
1528template <int dim, typename Number, bool is_face>
1531{
1532 Assert(dof_info != nullptr,
1533 ExcMessage(
1534 "FEEvaluation was not initialized with a MatrixFree object!"));
1535 return *dof_info;
1536}
1537
1538
1539
1540template <int dim, typename Number, bool is_face>
1541inline const std::vector<unsigned int> &
1543{
1544 return data->lexicographic_numbering;
1545}
1546
1547
1548
1549template <int dim, typename Number, bool is_face>
1550inline unsigned int
1552{
1553 return quad_no;
1554}
1555
1556
1557
1558template <int dim, typename Number, bool is_face>
1559inline unsigned int
1561{
1562 if (is_face && dof_access_index ==
1564 return cell * ReferenceCells::max_n_faces<dim>() + face_numbers[0];
1565 else
1566 return cell;
1567}
1568
1569
1570
1571template <int dim, typename Number, bool is_face>
1572inline unsigned int
1574{
1575 return active_fe_index;
1576}
1577
1578
1579
1580template <int dim, typename Number, bool is_face>
1581inline unsigned int
1583{
1584 return active_quad_index;
1585}
1586
1587
1588
1589template <int dim, typename Number, bool is_face>
1590inline unsigned int
1592{
1594}
1595
1596
1597
1598template <int dim, typename Number, bool is_face>
1599inline ArrayView<Number>
1601{
1602 return scratch_data;
1603}
1604
1605
1606
1607template <int dim, typename Number, bool is_face>
1608inline std::uint8_t
1610{
1611 Assert(is_face, ExcNotInitialized());
1615 is_interior_face() == false),
1616 ExcMessage("All face numbers can only be queried for ECL at exterior "
1617 "faces. Use get_face_no() in other cases."));
1618
1619 return face_numbers[v];
1620}
1621
1622
1623
1624template <int dim, typename Number, bool is_face>
1625inline unsigned int
1627{
1628 return subface_index;
1629}
1630
1631
1632
1633template <int dim, typename Number, bool is_face>
1634inline std::uint8_t
1636 const unsigned int v) const
1637{
1638 Assert(is_face, ExcNotInitialized());
1642 is_interior_face() == false),
1643 ExcMessage("All face numbers can only be queried for ECL at exterior "
1644 "faces. Use get_face_no() in other cases."));
1645
1646 return face_orientations[v];
1647}
1648
1649
1650
1651template <int dim, typename Number, bool is_face>
1654{
1655 return dof_access_index;
1656}
1657
1658
1659
1660template <int dim, typename Number, bool is_face>
1661inline bool
1663{
1664 return interior_face;
1665}
1666
1667
1668
1669template <int dim, typename Number, bool is_face>
1672{
1675}
1676
1677
1678
1679namespace internal
1680{
1681 template <std::size_t N,
1682 typename VectorOfArrayType,
1683 typename ArrayType,
1684 typename FU>
1685 inline void
1686 process_cell_or_face_data(const std::array<unsigned int, N> indices,
1687 VectorOfArrayType &array,
1688 ArrayType &out,
1689 const FU &fu)
1690 {
1691 for (unsigned int i = 0; i < N; ++i)
1692 if (indices[i] != numbers::invalid_unsigned_int)
1693 {
1694 AssertIndexRange(indices[i] / N, array.size());
1695 fu(out[i], array[indices[i] / N][indices[i] % N]);
1696 }
1697 }
1698
1699 template <std::size_t N, typename VectorOfArrayType, typename ArrayType>
1700 inline void
1701 set_valid_element_to_array(const std::array<unsigned int, N> indices,
1702 const VectorOfArrayType &array,
1703 ArrayType &out)
1704 {
1705 AssertDimension(indices.size(), out.size());
1706 AssertDimension(indices.size(), array[0].size());
1707 // set all entries in array to a valid element
1708 int index = 0;
1709 for (; index < N; ++index)
1710 if (indices[index] != numbers::invalid_unsigned_int)
1711 break;
1712 for (unsigned int i = 0; i < N; ++i)
1713 out[i] = array[indices[index] / N][indices[index] % N];
1714 }
1715} // namespace internal
1716
1717
1718
1719template <int dim, typename Number, bool is_face>
1720template <typename T>
1721inline T
1723 const AlignedVector<T> &array) const
1724{
1725 T out;
1726 internal::set_valid_element_to_array(this->get_cell_ids(), array, out);
1727 internal::process_cell_or_face_data(this->get_cell_ids(),
1728 array,
1729 out,
1730 [](auto &local, const auto &global) {
1731 local = global;
1732 });
1733 return out;
1734}
1735
1736
1737
1738template <int dim, typename Number, bool is_face>
1739template <typename T>
1740inline void
1742 const T &in) const
1743{
1744 internal::process_cell_or_face_data(this->get_cell_ids(),
1745 array,
1746 in,
1747 [](const auto &local, auto &global) {
1748 global = local;
1749 });
1750}
1751
1752
1753
1754template <int dim, typename Number, bool is_face>
1755template <typename T>
1756inline T
1758 const AlignedVector<T> &array) const
1759{
1760 T out;
1761 internal::set_valid_element_to_array(this->get_cell_ids(), array, out);
1762 internal::process_cell_or_face_data(this->get_face_ids(),
1763 array,
1764 out,
1765 [](auto &local, const auto &global) {
1766 local = global;
1767 });
1768 return out;
1769}
1770
1771
1772
1773template <int dim, typename Number, bool is_face>
1774template <typename T>
1775inline void
1777 const T &in) const
1778{
1779 internal::process_cell_or_face_data(this->get_face_ids(),
1780 array,
1781 in,
1782 [](const auto &local, auto &global) {
1783 global = local;
1784 });
1785}
1786
1787
1788
1789#endif // ifndef DOXYGEN
1790
1791
1793
1794#endif
void resize_fast(const size_type new_size)
iterator begin()
size_type size() const
void resize(const size_type new_size)
void reinit(value_type *starting_element, const std::size_t n_elements)
Definition array_view.h:523
const unsigned int quad_no
const Number * J_value
internal::MatrixFreeFunctions::GeometryType get_cell_type() const
const Tensor< 2, dim, Number > * jacobian
const MappingInfoStorageType::QuadratureDescriptor * descriptor
const unsigned int n_quadrature_points
const MappingInfoStorageType * mapping_data
internal::MatrixFreeFunctions::DoFInfo::DoFAccessIndex dof_access_index
std::uint8_t get_face_no(const unsigned int v=0) const
ArrayView< Number > scratch_data
internal::MatrixFreeFunctions::DoFInfo::DoFAccessIndex get_dof_access_index() const
const Point< dim, Number > * quadrature_points
unsigned int subface_index
const Tensor< 1, dim *(dim+1)/2, Tensor< 1, dim, Number > > * jacobian_gradients_non_inverse
ScalarNumber shape_info_number_type
FEEvaluationData(const FEEvaluationData &other)=default
const ShapeInfoType & get_shape_info() const
void set_face_data(AlignedVector< T > &array, const T &value) const
internal::MatrixFreeFunctions::ShapeInfo< typename internal::VectorizedArrayTrait< VectorizedArrayType >::value_type > ShapeInfoType
void reinit_face(const internal::MatrixFreeFunctions::FaceToCellTopology< n_lanes > &face)
Number JxW(const unsigned int q_point) const
const std::array< unsigned int, n_lanes > & get_face_ids() const
unsigned int get_first_selected_component() const
const unsigned int n_fe_components
const ShapeInfoType * data
T read_face_data(const AlignedVector< T > &array) const
Number * gradients_from_hessians_quad
std::shared_ptr< internal::MatrixFreeFunctions::MappingDataOnTheFly< dim, Number > > mapped_geometry
unsigned int get_active_quadrature_index() const
const internal::MatrixFreeFunctions::DoFInfo & get_dof_info() const
const std::array< unsigned int, n_lanes > & get_cell_ids() const
unsigned int get_mapping_data_index_offset() const
void set_data_pointers(AlignedVector< Number > *scratch_data, const unsigned int n_components)
Tensor< 2, dim, Number > inverse_jacobian(const unsigned int q_point) const
std::array< std::uint8_t, n_lanes > face_numbers
const unsigned int active_fe_index
static constexpr unsigned int n_lanes
const Tensor< 1, dim, Number > * normal_vectors
internal::MatrixFreeFunctions::GeometryType cell_type
const Number * begin_gradients() const
const std::array< unsigned int, n_lanes > & get_cell_or_face_ids() const
Tensor< 1, dim, Number > normal_vector(const unsigned int q_point) const
std::array< unsigned int, n_lanes > cell_ids
const DoFInfo * dof_info
unsigned int get_current_cell_index() const
unsigned int get_subface_index() const
Tensor< 1, dim, Number > get_normal_vector(const unsigned int q_point) const
const unsigned int active_quad_index
unsigned int get_active_fe_index() const
Number * values_from_gradients_quad
void set_cell_data(AlignedVector< T > &array, const T &value) const
unsigned int get_quadrature_index() const
std::array< std::uint8_t, n_lanes > face_orientations
const ScalarNumber * quadrature_weights
const Tensor< 1, dim *(dim+1)/2, Tensor< 1, dim, Number > > * jacobian_gradients
const Tensor< 1, dim, Number > * normal_x_jacobian
bool is_interior_face() const
std_cxx20::ranges::iota_view< unsigned int, unsigned int > quadrature_point_indices() const
const std::vector< unsigned int > & get_internal_dof_numbering() const
FEEvaluationData & operator=(const FEEvaluationData &other)
virtual ~FEEvaluationData()=default
ArrayView< Number > get_scratch_data() const
T read_cell_data(const AlignedVector< T > &array) const
static constexpr unsigned int dimension
FEEvaluationData(const std::shared_ptr< internal::MatrixFreeFunctions::MappingDataOnTheFly< dim, Number > > &mapping_data, const unsigned int n_fe_components, const unsigned int first_selected_component)
FEEvaluationData(const ShapeInfoType &shape_info, const bool is_interior_face=true)
Point< dim, Number > quadrature_point(const unsigned int q) const
const Number * begin_values() const
typename internal::VectorizedArrayTrait< Number >::value_type ScalarNumber
std::array< unsigned int, n_lanes > face_ids
FEEvaluationData(const InitializationData &initialization_data, const bool is_interior_face, const unsigned int quad_no, const unsigned int first_selected_component)
const Number * begin_dof_values() const
std::uint8_t get_face_orientation(const unsigned int v=0) const
const Number * begin_hessians() const
unsigned int get_cell_or_face_batch_id() const
const unsigned int first_selected_component
const unsigned int dofs_per_component
const unsigned int n_q_points
static constexpr unsigned int n_components
Definition point.h:113
const Point< dim > & point(const unsigned int i) const
#define DEAL_II_ALWAYS_INLINE
Definition config.h:164
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:40
#define DEAL_II_DEPRECATED_WITH_COMMENT(comment)
Definition config.h:284
constexpr bool running_in_debug_mode()
Definition config.h:78
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:41
#define DeclException0(Exception0)
#define Assert(cond, exc)
#define AssertDimension(dim1, dim2)
#define AssertIndexRange(index, range)
static ::ExceptionBase & ExcInternalError()
static ::ExceptionBase & ExcAccessToUninitializedField()
static ::ExceptionBase & ExcNotInitialized()
#define DeclException1(Exception1, type1, outsequence)
static ::ExceptionBase & ExcMatrixFreeAccessToUninitializedMappingField(std::string arg1)
static ::ExceptionBase & ExcMessage(std::string arg1)
std::vector< index_type > data
Definition mpi.cc:746
@ general
No special properties.
constexpr char N
constexpr char T
Point< spacedim > point(const gp_Pnt &p, const double tolerance=1e-10)
Definition utilities.cc:193
SymmetricTensor< 2, dim, Number > e(const Tensor< 2, dim, Number > &F)
SymmetricTensor< 2, dim, Number > d(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
VectorType::value_type * begin(VectorType &V)
constexpr unsigned int invalid_unsigned_int
Definition types.h:232
boost::integer_range< IncrementableType > iota_view
Definition iota_view.h:45
STL namespace.
::VectorizedArray< Number, width > max(const ::VectorizedArray< Number, width > &, const ::VectorizedArray< Number, width > &)
const MappingInfoStorageType * mapping_data
const MappingInfoStorageType::QuadratureDescriptor * descriptor
std::array< unsigned int, vectorization_width > cells_interior
Definition face_info.h:60
std::array< unsigned int, vectorization_width > cells_exterior
Definition face_info.h:75
static constexpr std::size_t width()