deal.II version GIT relicensing-2330-gf6dfc6c370 2025-01-06 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\}}\)
Loading...
Searching...
No Matches
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#ifdef DEBUG
503#endif
504 return cell_ids;
505 }
506
511 const std::array<unsigned int, n_lanes> &
513 {
514// implemented inline to avoid compilation problems on Windows
515#ifdef DEBUG
517#endif
518 return face_ids;
519 }
520
525 unsigned int
527 {
528// implemented inline to avoid compilation problems on Windows
529#ifdef DEBUG
531#endif
532
533 return cell;
534 }
535
540 const std::array<unsigned int, n_lanes> &
542 {
543// implemented inline to avoid compilation problems on Windows
544#ifdef DEBUG
546#endif
547
548 if (!is_face || dof_access_index ==
550 return cell_ids;
551 else
552 return face_ids;
553 }
554
562
580 template <typename T>
581 T
582 read_cell_data(const AlignedVector<T> &array) const;
583
590 template <typename T>
591 void
592 set_cell_data(AlignedVector<T> &array, const T &value) const;
593
602 template <typename T>
603 T
604 read_face_data(const AlignedVector<T> &array) const;
605
614 template <typename T>
615 void
616 set_face_data(AlignedVector<T> &array, const T &value) const;
617
633
634protected:
641 FEEvaluationData(const InitializationData &initialization_data,
642 const bool is_interior_face,
643 const unsigned int quad_no,
644 const unsigned int first_selected_component);
645
651 const std::shared_ptr<
654 const unsigned int n_fe_components,
655 const unsigned int first_selected_component);
656
664
671
679
685 const unsigned int quad_no;
686
691 const unsigned int n_fe_components;
692
697 const unsigned int first_selected_component;
698
702 const unsigned int active_fe_index;
703
708 const unsigned int active_quad_index;
709
716
720 const unsigned int n_quadrature_points;
721
727
741
746 const Tensor<1, dim *(dim + 1) / 2, Tensor<1, dim, Number>>
748
753 const Tensor<1, dim *(dim + 1) / 2, Tensor<1, dim, Number>>
755
762 const Number *J_value;
763
768
773
778
786
797 Number *values_dofs;
798
808 Number *values_quad;
809
823
836
849
860
866
873
880
887
894
901
908
915
920 unsigned int cell;
921
929
935
944 std::array<std::uint8_t, n_lanes> face_numbers;
945
954 std::array<std::uint8_t, n_lanes> face_orientations;
955
963 unsigned int subface_index;
964
972
977 std::array<unsigned int, n_lanes> cell_ids;
978
983 std::array<unsigned int, n_lanes> face_ids;
984
990 std::shared_ptr<
993
999
1000 // Make FEEvaluation and FEEvaluationBase objects friends for access to
1001 // protected member mapped_geometry.
1002 template <int, int, typename, bool, typename>
1003 friend class FEEvaluationBase;
1004
1005 template <int, int, int, int, typename, typename>
1006 friend class FEEvaluation;
1007};
1008
1009
1014template <int dim,
1015 typename Number,
1016 bool is_face,
1017 typename VectorizedArrayType = VectorizedArray<Number>>
1020
1021
1022/*----------------------- Inline functions ----------------------------------*/
1023
1024#ifndef DOXYGEN
1025
1026template <int dim, typename Number, bool is_face>
1028 const ShapeInfoType &shape_info,
1029 const bool is_interior_face)
1031 InitializationData{&shape_info, nullptr, nullptr, 0, 0, nullptr},
1033 0,
1034 0)
1035{}
1036
1037
1038template <int dim, typename Number, bool is_face>
1040 const InitializationData &initialization_data,
1041 const bool is_interior_face,
1042 const unsigned int quad_no,
1043 const unsigned int first_selected_component)
1044 : data(initialization_data.shape_info)
1045 , dof_info(initialization_data.dof_info)
1046 , mapping_data(initialization_data.mapping_data)
1047 , quad_no(quad_no)
1048 , n_fe_components(dof_info != nullptr ? dof_info->start_components.back() : 0)
1050 , active_fe_index(initialization_data.active_fe_index)
1051 , active_quad_index(initialization_data.active_quad_index)
1052 , descriptor(initialization_data.descriptor)
1053 , n_quadrature_points(descriptor == nullptr ?
1054 (is_face ? data->n_q_points_face : data->n_q_points) :
1056 , quadrature_points(nullptr)
1057 , jacobian(nullptr)
1058 , jacobian_gradients(nullptr)
1060 , J_value(nullptr)
1061 , normal_vectors(nullptr)
1062 , normal_x_jacobian(nullptr)
1064 descriptor != nullptr ? descriptor->quadrature_weights.begin() : nullptr)
1065# ifdef DEBUG
1066 , is_reinitialized(false)
1067 , dof_values_initialized(false)
1071 , values_quad_submitted(false)
1073# endif
1074 , cell(numbers::invalid_unsigned_int)
1077 is_face ?
1079 internal::MatrixFreeFunctions::DoFInfo::dof_access_face_interior :
1080 internal::MatrixFreeFunctions::DoFInfo::dof_access_face_exterior) :
1081 internal::MatrixFreeFunctions::DoFInfo::dof_access_cell)
1082 , subface_index(0)
1083 , cell_type(internal::MatrixFreeFunctions::general)
1085{}
1086
1087
1088
1089template <int dim, typename Number, bool is_face>
1091 const std::shared_ptr<
1094 const unsigned int n_fe_components,
1095 const unsigned int first_selected_component)
1096 : data(nullptr)
1097 , dof_info(nullptr)
1098 , mapping_data(nullptr)
1099 , quad_no(numbers::invalid_unsigned_int)
1102 , active_fe_index(numbers::invalid_unsigned_int)
1103 , active_quad_index(numbers::invalid_unsigned_int)
1104 , descriptor(nullptr)
1106 mapped_geometry->get_data_storage().descriptor[0].n_q_points)
1107 , quadrature_points(nullptr)
1108 , jacobian(nullptr)
1109 , jacobian_gradients(nullptr)
1111 , J_value(nullptr)
1112 , normal_vectors(nullptr)
1113 , normal_x_jacobian(nullptr)
1114 , quadrature_weights(nullptr)
1115 , cell(0)
1116 , cell_type(internal::MatrixFreeFunctions::general)
1117 , interior_face(true)
1118 , dof_access_index(internal::MatrixFreeFunctions::DoFInfo::dof_access_cell)
1120 , is_reinitialized(false)
1122{
1123 mapping_data = &mapped_geometry->get_data_storage();
1124 jacobian = mapped_geometry->get_data_storage().jacobians[0].begin();
1125 J_value = mapped_geometry->get_data_storage().JxW_values.begin();
1127 mapped_geometry->get_data_storage().jacobian_gradients[0].begin();
1129 .jacobian_gradients_non_inverse[0]
1130 .begin();
1132 mapped_geometry->get_data_storage().quadrature_points.begin();
1133}
1134
1135
1136
1137template <int dim, typename Number, bool is_face>
1140{
1147
1148 data = other.data;
1149 dof_info = other.dof_info;
1150 mapping_data = other.mapping_data;
1151 descriptor = other.descriptor;
1152 jacobian = nullptr;
1153 J_value = nullptr;
1154 normal_vectors = nullptr;
1155 normal_x_jacobian = nullptr;
1156 jacobian_gradients = nullptr;
1158 quadrature_points = nullptr;
1160
1161# ifdef DEBUG
1162 is_reinitialized = false;
1163 dof_values_initialized = false;
1167 values_quad_submitted = false;
1169# endif
1170
1174 is_face ?
1175 (is_interior_face() ?
1178 internal::MatrixFreeFunctions::DoFInfo::dof_access_cell;
1179 face_numbers[0] = 0;
1180 face_orientations[0] = 0;
1181 subface_index = 0;
1184
1185 return *this;
1186}
1187
1188
1189
1190template <int dim, typename Number, bool is_face>
1191inline void
1194 const unsigned int n_components)
1195{
1197
1198 const unsigned int tensor_dofs_per_component =
1199 Utilities::fixed_power<dim>(data->data.front().fe_degree + 1);
1200 const unsigned int dofs_per_component = data->dofs_per_component_on_cell;
1201
1202 const unsigned int size_scratch_data =
1203 std::max(tensor_dofs_per_component + 1, dofs_per_component) * n_components *
1204 3 +
1206 const unsigned int size_data_arrays =
1208 (n_components * ((dim * (dim + 1)) / 2 + 2 * dim + 2) *
1210
1211 // include 12 extra fields to insert some padding between values, gradients
1212 // and hessians, which helps to reduce the probability of cache conflicts
1213 const unsigned int allocated_size = size_scratch_data + size_data_arrays + 12;
1214# ifdef DEBUG
1216 scratch_data_array->resize(allocated_size,
1217 Number(numbers::signaling_nan<ScalarNumber>()));
1218# else
1219 scratch_data_array->resize_fast(allocated_size);
1220# endif
1221 scratch_data.reinit(scratch_data_array->begin() + size_data_arrays + 12,
1222 size_scratch_data);
1223
1224 // set the pointers to the correct position in the data array
1226 values_quad =
1229 scratch_data_array->begin() + 6 +
1232 scratch_data_array->begin() + 8 +
1235 scratch_data_array->begin() + 12 +
1238 scratch_data_array->begin() + 12 +
1240}
1241
1242
1243
1244template <int dim, typename Number, bool is_face>
1245inline void
1248{
1249 Assert(is_face == true,
1250 ExcMessage("Faces can only be set if the is_face template parameter "
1251 "is true"));
1252 face_numbers[0] =
1254 subface_index = is_interior_face() == true ?
1256 face.subface_index;
1257
1258 // First check if interior or exterior cell has non-standard orientation
1259 // (i.e. the third bit is one or not). Then set zero if this cell has
1260 // standard-orientation else copy the first three bits
1261 // (which is equivalent to modulo 8). See also the documentation of
1262 // internal::MatrixFreeFunctions::FaceToCellTopology::face_orientation.
1263 face_orientations[0] = (is_interior_face() == (face.face_orientation >= 8)) ?
1264 (face.face_orientation % 8) :
1265 0;
1266
1267 if (is_interior_face())
1268 cell_ids = face.cells_interior;
1269 else
1270 cell_ids = face.cells_exterior;
1271}
1272
1273
1274
1275template <int dim, typename Number, bool is_face>
1278 const unsigned int q_point) const
1279{
1281 Assert(normal_vectors != nullptr,
1283 "update_normal_vectors"));
1285 return normal_vectors[0];
1286 else
1287 return normal_vectors[q_point];
1288}
1289
1290
1291
1292// This function is deprecated.
1293template <int dim, typename Number, bool is_face>
1296 const unsigned int q_point) const
1297{
1298 return normal_vector(q_point);
1299}
1300
1301
1302
1303template <int dim, typename Number, bool is_face>
1304inline DEAL_II_ALWAYS_INLINE Number
1305FEEvaluationData<dim, Number, is_face>::JxW(const unsigned int q_point) const
1306{
1308 Assert(J_value != nullptr,
1310 "update_values|update_gradients"));
1312 {
1314 return J_value[0] * quadrature_weights[q_point];
1315 }
1316 else
1317 return J_value[q_point];
1318}
1319
1320
1321
1322template <int dim, typename Number, bool is_face>
1325 const unsigned int q) const
1326{
1328 Assert(this->quadrature_points != nullptr,
1330 "update_quadrature_points"));
1331
1332 // Cartesian/affine mesh: only first vertex of cell is stored, we must
1333 // compute it through the Jacobian (which is stored in non-inverted and
1334 // non-transposed form as index '1' in the jacobian field)
1335 if (is_face == false &&
1337 {
1338 Assert(this->jacobian != nullptr, ExcNotInitialized());
1340
1341 const Tensor<2, dim, Number> &jac = this->jacobian[1];
1343 for (unsigned int d = 0; d < dim; ++d)
1344 point[d] += jac[d][d] * static_cast<typename Number::value_type>(
1345 this->descriptor->quadrature.point(q)[d]);
1346 else
1347 for (unsigned int d = 0; d < dim; ++d)
1348 for (unsigned int e = 0; e < dim; ++e)
1349 point[d] += jac[d][e] * static_cast<typename Number::value_type>(
1350 this->descriptor->quadrature.point(q)[e]);
1351 return point;
1352 }
1353 else
1354 return this->quadrature_points[q];
1355}
1356
1357
1358
1359template <int dim, typename Number, bool is_face>
1362 const unsigned int q_point) const
1363{
1365 Assert(jacobian != nullptr,
1367 "update_gradients"));
1369 return jacobian[0];
1370 else
1371 return jacobian[q_point];
1372}
1373
1374
1375
1376template <int dim, typename Number, bool is_face>
1377inline const Number *
1379{
1380 return values_dofs;
1381}
1382
1383
1384
1385template <int dim, typename Number, bool is_face>
1386inline Number *
1388{
1389# ifdef DEBUG
1391# endif
1392 return values_dofs;
1393}
1394
1395
1396
1397template <int dim, typename Number, bool is_face>
1398inline const Number *
1400{
1401# ifdef DEBUG
1403# endif
1404 return values_quad;
1405}
1406
1407
1408
1409template <int dim, typename Number, bool is_face>
1410inline Number *
1412{
1413# ifdef DEBUG
1415 values_quad_submitted = true;
1416# endif
1417 return values_quad;
1418}
1419
1420
1421
1422template <int dim, typename Number, bool is_face>
1423inline const Number *
1425{
1426# ifdef DEBUG
1429# endif
1430 return gradients_quad;
1431}
1432
1433
1434
1435template <int dim, typename Number, bool is_face>
1436inline Number *
1438{
1439# ifdef DEBUG
1442# endif
1443 return gradients_quad;
1444}
1445
1446
1447
1448template <int dim, typename Number, bool is_face>
1449inline const Number *
1451{
1452# ifdef DEBUG
1454# endif
1455 return hessians_quad;
1456}
1457
1458
1459
1460template <int dim, typename Number, bool is_face>
1461inline Number *
1463{
1464# ifdef DEBUG
1466# endif
1467 return hessians_quad;
1468}
1469
1470
1471
1472template <int dim, typename Number, bool is_face>
1473inline unsigned int
1475{
1476 Assert(mapping_data != nullptr, ExcInternalError());
1477
1478 if (dof_info == nullptr)
1479 return 0;
1480 else
1481 {
1484 }
1485}
1486
1487
1488
1489template <int dim, typename Number, bool is_face>
1492{
1493# ifdef DEBUG
1495# endif
1496 return cell_type;
1497}
1498
1499
1500
1501template <int dim, typename Number, bool is_face>
1504{
1505 Assert(data != nullptr, ExcInternalError());
1506 return *data;
1507}
1508
1509
1510
1511template <int dim, typename Number, bool is_face>
1514{
1515 Assert(dof_info != nullptr,
1516 ExcMessage(
1517 "FEEvaluation was not initialized with a MatrixFree object!"));
1518 return *dof_info;
1519}
1520
1521
1522
1523template <int dim, typename Number, bool is_face>
1524inline const std::vector<unsigned int> &
1526{
1527 return data->lexicographic_numbering;
1528}
1529
1530
1531
1532template <int dim, typename Number, bool is_face>
1533inline unsigned int
1535{
1536 return quad_no;
1537}
1538
1539
1540
1541template <int dim, typename Number, bool is_face>
1542inline unsigned int
1544{
1545 if (is_face && dof_access_index ==
1547 return cell * ReferenceCell::max_n_faces<dim>() + face_numbers[0];
1548 else
1549 return cell;
1550}
1551
1552
1553
1554template <int dim, typename Number, bool is_face>
1555inline unsigned int
1557{
1558 return active_fe_index;
1559}
1560
1561
1562
1563template <int dim, typename Number, bool is_face>
1564inline unsigned int
1566{
1567 return active_quad_index;
1568}
1569
1570
1571
1572template <int dim, typename Number, bool is_face>
1573inline unsigned int
1575{
1577}
1578
1579
1580
1581template <int dim, typename Number, bool is_face>
1582inline ArrayView<Number>
1584{
1585 return scratch_data;
1586}
1587
1588
1589
1590template <int dim, typename Number, bool is_face>
1591inline std::uint8_t
1593{
1594 Assert(is_face, ExcNotInitialized());
1598 is_interior_face() == false),
1599 ExcMessage("All face numbers can only be queried for ECL at exterior "
1600 "faces. Use get_face_no() in other cases."));
1601
1602 return face_numbers[v];
1603}
1604
1605
1606
1607template <int dim, typename Number, bool is_face>
1608inline unsigned int
1610{
1611 return subface_index;
1612}
1613
1614
1615
1616template <int dim, typename Number, bool is_face>
1617inline std::uint8_t
1619 const unsigned int v) const
1620{
1621 Assert(is_face, ExcNotInitialized());
1625 is_interior_face() == false),
1626 ExcMessage("All face numbers can only be queried for ECL at exterior "
1627 "faces. Use get_face_no() in other cases."));
1628
1629 return face_orientations[v];
1630}
1631
1632
1633
1634template <int dim, typename Number, bool is_face>
1637{
1638 return dof_access_index;
1639}
1640
1641
1642
1643template <int dim, typename Number, bool is_face>
1644inline bool
1646{
1647 return interior_face;
1648}
1649
1650
1651
1652template <int dim, typename Number, bool is_face>
1655{
1656 return {0U, n_quadrature_points};
1657}
1658
1659
1660
1661namespace internal
1662{
1663 template <std::size_t N,
1664 typename VectorOfArrayType,
1665 typename ArrayType,
1666 typename FU>
1667 inline void
1668 process_cell_or_face_data(const std::array<unsigned int, N> indices,
1669 VectorOfArrayType &array,
1670 ArrayType &out,
1671 const FU &fu)
1672 {
1673 for (unsigned int i = 0; i < N; ++i)
1674 if (indices[i] != numbers::invalid_unsigned_int)
1675 {
1676 AssertIndexRange(indices[i] / N, array.size());
1677 fu(out[i], array[indices[i] / N][indices[i] % N]);
1678 }
1679 }
1680
1681 template <std::size_t N, typename VectorOfArrayType, typename ArrayType>
1682 inline void
1683 set_valid_element_to_array(const std::array<unsigned int, N> indices,
1684 const VectorOfArrayType &array,
1685 ArrayType &out)
1686 {
1687 AssertDimension(indices.size(), out.size());
1688 AssertDimension(indices.size(), array[0].size());
1689 // set all entries in array to a valid element
1690 int index = 0;
1691 for (; index < N; ++index)
1692 if (indices[index] != numbers::invalid_unsigned_int)
1693 break;
1694 for (unsigned int i = 0; i < N; ++i)
1695 out[i] = array[indices[index] / N][indices[index] % N];
1696 }
1697} // namespace internal
1698
1699
1700
1701template <int dim, typename Number, bool is_face>
1702template <typename T>
1703inline T
1705 const AlignedVector<T> &array) const
1706{
1707 T out;
1708 internal::set_valid_element_to_array(this->get_cell_ids(), array, out);
1709 internal::process_cell_or_face_data(this->get_cell_ids(),
1710 array,
1711 out,
1712 [](auto &local, const auto &global) {
1713 local = global;
1714 });
1715 return out;
1716}
1717
1718
1719
1720template <int dim, typename Number, bool is_face>
1721template <typename T>
1722inline void
1724 const T &in) const
1725{
1726 internal::process_cell_or_face_data(this->get_cell_ids(),
1727 array,
1728 in,
1729 [](const auto &local, auto &global) {
1730 global = local;
1731 });
1732}
1733
1734
1735
1736template <int dim, typename Number, bool is_face>
1737template <typename T>
1738inline T
1740 const AlignedVector<T> &array) const
1741{
1742 T out;
1743 internal::set_valid_element_to_array(this->get_cell_ids(), array, out);
1744 internal::process_cell_or_face_data(this->get_face_ids(),
1745 array,
1746 out,
1747 [](auto &local, const auto &global) {
1748 local = global;
1749 });
1750 return out;
1751}
1752
1753
1754
1755template <int dim, typename Number, bool is_face>
1756template <typename T>
1757inline void
1759 const T &in) const
1760{
1761 internal::process_cell_or_face_data(this->get_face_ids(),
1762 array,
1763 in,
1764 [](const auto &local, auto &global) {
1765 global = local;
1766 });
1767}
1768
1769
1770
1771#endif // ifndef DOXYGEN
1772
1773
1775
1776#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:521
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:111
const Point< dim > & point(const unsigned int i) const
#define DEAL_II_ALWAYS_INLINE
Definition config.h:109
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:498
#define DEAL_II_DEPRECATED_WITH_COMMENT(comment)
Definition config.h:206
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:499
#define DeclException0(Exception0)
Definition exceptions.h:466
#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)
Definition exceptions.h:511
static ::ExceptionBase & ExcMatrixFreeAccessToUninitializedMappingField(std::string arg1)
static ::ExceptionBase & ExcMessage(std::string arg1)
std::vector< index_type > data
Definition mpi.cc:735
@ general
No special properties.
Point< spacedim > point(const gp_Pnt &p, const double tolerance=1e-10)
Definition utilities.cc:191
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)
static const unsigned int invalid_unsigned_int
Definition types.h:220
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()