deal.II version GIT relicensing-3132-g78fd2c863f 2025-04-24 02: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 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 Assert(!data->data.empty(), ExcInternalError());
1091}
1092
1093
1094
1095template <int dim, typename Number, bool is_face>
1097 const std::shared_ptr<
1100 const unsigned int n_fe_components,
1101 const unsigned int first_selected_component)
1102 : data(nullptr)
1103 , dof_info(nullptr)
1104 , mapping_data(nullptr)
1110 , descriptor(nullptr)
1112 mapped_geometry->get_data_storage().descriptor[0].n_q_points)
1113 , quadrature_points(nullptr)
1114 , jacobian(nullptr)
1115 , jacobian_gradients(nullptr)
1117 , J_value(nullptr)
1118 , normal_vectors(nullptr)
1119 , normal_x_jacobian(nullptr)
1120 , quadrature_weights(nullptr)
1121 , cell(0)
1122 , cell_type(internal::MatrixFreeFunctions::general)
1123 , interior_face(true)
1124 , dof_access_index(internal::MatrixFreeFunctions::DoFInfo::dof_access_cell)
1126 , is_reinitialized(false)
1128{
1129 mapping_data = &mapped_geometry->get_data_storage();
1130 jacobian = mapped_geometry->get_data_storage().jacobians[0].begin();
1131 J_value = mapped_geometry->get_data_storage().JxW_values.begin();
1133 mapped_geometry->get_data_storage().jacobian_gradients[0].begin();
1135 .jacobian_gradients_non_inverse[0]
1136 .begin();
1138 mapped_geometry->get_data_storage().quadrature_points.begin();
1139}
1140
1141
1142
1143template <int dim, typename Number, bool is_face>
1146{
1153
1154 data = other.data;
1155 dof_info = other.dof_info;
1156 mapping_data = other.mapping_data;
1157 descriptor = other.descriptor;
1158 jacobian = nullptr;
1159 J_value = nullptr;
1160 normal_vectors = nullptr;
1161 normal_x_jacobian = nullptr;
1162 jacobian_gradients = nullptr;
1164 quadrature_points = nullptr;
1166
1167 if constexpr (running_in_debug_mode())
1168 {
1169 is_reinitialized = false;
1170 dof_values_initialized = false;
1174 values_quad_submitted = false;
1176 }
1177
1181 is_face ?
1182 (is_interior_face() ?
1185 internal::MatrixFreeFunctions::DoFInfo::dof_access_cell;
1186 face_numbers[0] = 0;
1187 face_orientations[0] = 0;
1188 subface_index = 0;
1191
1192 return *this;
1193}
1194
1195
1196
1197template <int dim, typename Number, bool is_face>
1198inline void
1201 const unsigned int n_components)
1202{
1204 Assert(data != nullptr, ExcInternalError());
1205 Assert(!data->data.empty(), ExcInternalError());
1206
1207
1208 const unsigned int tensor_dofs_per_component =
1209 Utilities::fixed_power<dim>(data->data.front().fe_degree + 1);
1210 const unsigned int dofs_per_component = data->dofs_per_component_on_cell;
1211
1212 const unsigned int size_scratch_data =
1213 std::max(tensor_dofs_per_component + 1, dofs_per_component) * n_components *
1214 4 +
1216 const unsigned int size_data_arrays =
1218 (n_components * ((dim * (dim + 1)) / 2 + 2 * dim + 2) *
1220
1221 // include 12 extra fields to insert some padding between values, gradients
1222 // and hessians, which helps to reduce the probability of cache conflicts
1223 const unsigned int allocated_size = size_scratch_data + size_data_arrays + 12;
1224 if constexpr (running_in_debug_mode())
1225 {
1228 allocated_size, Number(numbers::signaling_nan<ScalarNumber>()));
1229 }
1230 else
1231 {
1232 scratch_data_array->resize_fast(allocated_size);
1233 }
1234 scratch_data.reinit(scratch_data_array->begin() + size_data_arrays + 12,
1235 size_scratch_data);
1236
1237 // set the pointers to the correct position in the data array
1239 values_quad =
1242 scratch_data_array->begin() + 6 +
1245 scratch_data_array->begin() + 8 +
1248 scratch_data_array->begin() + 12 +
1251 scratch_data_array->begin() + 12 +
1253}
1254
1255
1256
1257template <int dim, typename Number, bool is_face>
1258inline void
1261{
1262 Assert(is_face == true,
1263 ExcMessage("Faces can only be set if the is_face template parameter "
1264 "is true"));
1265 face_numbers[0] =
1267 subface_index = is_interior_face() == true ?
1269 face.subface_index;
1270
1271 // First check if interior or exterior cell has non-standard orientation
1272 // (i.e. the third bit is one or not). Then set zero if this cell has
1273 // standard-orientation else copy the first three bits
1274 // (which is equivalent to modulo 8). See also the documentation of
1275 // internal::MatrixFreeFunctions::FaceToCellTopology::face_orientation.
1276 face_orientations[0] = (is_interior_face() == (face.face_orientation >= 8)) ?
1277 (face.face_orientation % 8) :
1278 0;
1279
1280 if (is_interior_face())
1281 cell_ids = face.cells_interior;
1282 else
1283 cell_ids = face.cells_exterior;
1284}
1285
1286
1287
1288template <int dim, typename Number, bool is_face>
1291 const unsigned int q_point) const
1292{
1294 Assert(normal_vectors != nullptr,
1296 "update_normal_vectors"));
1298 return normal_vectors[0];
1299 else
1300 return normal_vectors[q_point];
1301}
1302
1303
1304
1305// This function is deprecated.
1306template <int dim, typename Number, bool is_face>
1309 const unsigned int q_point) const
1310{
1311 return normal_vector(q_point);
1312}
1313
1314
1315
1316template <int dim, typename Number, bool is_face>
1317inline DEAL_II_ALWAYS_INLINE Number
1318FEEvaluationData<dim, Number, is_face>::JxW(const unsigned int q_point) const
1319{
1321 Assert(J_value != nullptr,
1323 "update_values|update_gradients"));
1325 {
1327 return J_value[0] * quadrature_weights[q_point];
1328 }
1329 else
1330 return J_value[q_point];
1331}
1332
1333
1334
1335template <int dim, typename Number, bool is_face>
1338 const unsigned int q) const
1339{
1341 Assert(this->quadrature_points != nullptr,
1343 "update_quadrature_points"));
1344
1345 // Cartesian/affine mesh: only first vertex of cell is stored, we must
1346 // compute it through the Jacobian (which is stored in non-inverted and
1347 // non-transposed form as index '1' in the jacobian field)
1348 if (is_face == false &&
1350 {
1351 Assert(this->jacobian != nullptr, ExcNotInitialized());
1353
1354 const Tensor<2, dim, Number> &jac = this->jacobian[1];
1356 for (unsigned int d = 0; d < dim; ++d)
1357 point[d] += jac[d][d] * static_cast<typename Number::value_type>(
1358 this->descriptor->quadrature.point(q)[d]);
1359 else
1360 for (unsigned int d = 0; d < dim; ++d)
1361 for (unsigned int e = 0; e < dim; ++e)
1362 point[d] += jac[d][e] * static_cast<typename Number::value_type>(
1363 this->descriptor->quadrature.point(q)[e]);
1364 return point;
1365 }
1366 else
1367 return this->quadrature_points[q];
1368}
1369
1370
1371
1372template <int dim, typename Number, bool is_face>
1375 const unsigned int q_point) const
1376{
1378 Assert(jacobian != nullptr,
1380 "update_gradients"));
1382 return jacobian[0];
1383 else
1384 return jacobian[q_point];
1385}
1386
1387
1388
1389template <int dim, typename Number, bool is_face>
1390inline const Number *
1392{
1393 return values_dofs;
1394}
1395
1396
1397
1398template <int dim, typename Number, bool is_face>
1399inline Number *
1401{
1402 if constexpr (running_in_debug_mode())
1403 {
1405 }
1406 return values_dofs;
1407}
1408
1409
1410
1411template <int dim, typename Number, bool is_face>
1412inline const Number *
1414{
1415 if constexpr (running_in_debug_mode())
1416 {
1419 }
1420 return values_quad;
1421}
1422
1423
1424
1425template <int dim, typename Number, bool is_face>
1426inline Number *
1428{
1429 if constexpr (running_in_debug_mode())
1430 {
1432 values_quad_submitted = true;
1433 }
1434 return values_quad;
1435}
1436
1437
1438
1439template <int dim, typename Number, bool is_face>
1440inline const Number *
1442{
1443 if constexpr (running_in_debug_mode())
1444 {
1447 }
1448 return gradients_quad;
1449}
1450
1451
1452
1453template <int dim, typename Number, bool is_face>
1454inline Number *
1456{
1457 if constexpr (running_in_debug_mode())
1458 {
1461 }
1462 return gradients_quad;
1463}
1464
1465
1466
1467template <int dim, typename Number, bool is_face>
1468inline const Number *
1470{
1471 if constexpr (running_in_debug_mode())
1472 {
1474 }
1475 return hessians_quad;
1476}
1477
1478
1479
1480template <int dim, typename Number, bool is_face>
1481inline Number *
1483{
1484 if constexpr (running_in_debug_mode())
1485 {
1487 }
1488 return hessians_quad;
1489}
1490
1491
1492
1493template <int dim, typename Number, bool is_face>
1494inline unsigned int
1496{
1497 Assert(mapping_data != nullptr, ExcInternalError());
1498
1499 if (dof_info == nullptr)
1500 return 0;
1501 else
1502 {
1505 }
1506}
1507
1508
1509
1510template <int dim, typename Number, bool is_face>
1513{
1514 if constexpr (running_in_debug_mode())
1515 {
1517 }
1518 return cell_type;
1519}
1520
1521
1522
1523template <int dim, typename Number, bool is_face>
1526{
1527 Assert(data != nullptr, ExcInternalError());
1528 return *data;
1529}
1530
1531
1532
1533template <int dim, typename Number, bool is_face>
1536{
1537 Assert(dof_info != nullptr,
1538 ExcMessage(
1539 "FEEvaluation was not initialized with a MatrixFree object!"));
1540 return *dof_info;
1541}
1542
1543
1544
1545template <int dim, typename Number, bool is_face>
1546inline const std::vector<unsigned int> &
1548{
1549 return data->lexicographic_numbering;
1550}
1551
1552
1553
1554template <int dim, typename Number, bool is_face>
1555inline unsigned int
1557{
1558 return quad_no;
1559}
1560
1561
1562
1563template <int dim, typename Number, bool is_face>
1564inline unsigned int
1566{
1567 if (is_face && dof_access_index ==
1569 return cell * ReferenceCells::max_n_faces<dim>() + face_numbers[0];
1570 else
1571 return cell;
1572}
1573
1574
1575
1576template <int dim, typename Number, bool is_face>
1577inline unsigned int
1579{
1580 return active_fe_index;
1581}
1582
1583
1584
1585template <int dim, typename Number, bool is_face>
1586inline unsigned int
1588{
1589 return active_quad_index;
1590}
1591
1592
1593
1594template <int dim, typename Number, bool is_face>
1595inline unsigned int
1597{
1599}
1600
1601
1602
1603template <int dim, typename Number, bool is_face>
1604inline ArrayView<Number>
1606{
1607 return scratch_data;
1608}
1609
1610
1611
1612template <int dim, typename Number, bool is_face>
1613inline std::uint8_t
1615{
1616 Assert(is_face, ExcNotInitialized());
1620 is_interior_face() == false),
1621 ExcMessage("All face numbers can only be queried for ECL at exterior "
1622 "faces. Use get_face_no() in other cases."));
1623
1624 return face_numbers[v];
1625}
1626
1627
1628
1629template <int dim, typename Number, bool is_face>
1630inline unsigned int
1632{
1633 return subface_index;
1634}
1635
1636
1637
1638template <int dim, typename Number, bool is_face>
1639inline std::uint8_t
1641 const unsigned int v) const
1642{
1643 Assert(is_face, ExcNotInitialized());
1647 is_interior_face() == false),
1648 ExcMessage("All face numbers can only be queried for ECL at exterior "
1649 "faces. Use get_face_no() in other cases."));
1650
1651 return face_orientations[v];
1652}
1653
1654
1655
1656template <int dim, typename Number, bool is_face>
1659{
1660 return dof_access_index;
1661}
1662
1663
1664
1665template <int dim, typename Number, bool is_face>
1666inline bool
1668{
1669 return interior_face;
1670}
1671
1672
1673
1674template <int dim, typename Number, bool is_face>
1677{
1680}
1681
1682
1683
1684namespace internal
1685{
1686 template <std::size_t N,
1687 typename VectorOfArrayType,
1688 typename ArrayType,
1689 typename FU>
1690 inline void
1691 process_cell_or_face_data(const std::array<unsigned int, N> indices,
1692 VectorOfArrayType &array,
1693 ArrayType &out,
1694 const FU &fu)
1695 {
1696 for (unsigned int i = 0; i < N; ++i)
1697 if (indices[i] != numbers::invalid_unsigned_int)
1698 {
1699 AssertIndexRange(indices[i] / N, array.size());
1700 fu(out[i], array[indices[i] / N][indices[i] % N]);
1701 }
1702 }
1703
1704 template <std::size_t N, typename VectorOfArrayType, typename ArrayType>
1705 inline void
1706 set_valid_element_to_array(const std::array<unsigned int, N> indices,
1707 const VectorOfArrayType &array,
1708 ArrayType &out)
1709 {
1710 AssertDimension(indices.size(), out.size());
1711 AssertDimension(indices.size(), array[0].size());
1712 // set all entries in array to a valid element
1713 int index = 0;
1714 for (; index < N; ++index)
1715 if (indices[index] != numbers::invalid_unsigned_int)
1716 break;
1717 for (unsigned int i = 0; i < N; ++i)
1718 out[i] = array[indices[index] / N][indices[index] % N];
1719 }
1720} // namespace internal
1721
1722
1723
1724template <int dim, typename Number, bool is_face>
1725template <typename T>
1726inline T
1728 const AlignedVector<T> &array) const
1729{
1730 T out;
1731 internal::set_valid_element_to_array(this->get_cell_ids(), array, out);
1732 internal::process_cell_or_face_data(this->get_cell_ids(),
1733 array,
1734 out,
1735 [](auto &local, const auto &global) {
1736 local = global;
1737 });
1738 return out;
1739}
1740
1741
1742
1743template <int dim, typename Number, bool is_face>
1744template <typename T>
1745inline void
1747 const T &in) const
1748{
1749 internal::process_cell_or_face_data(this->get_cell_ids(),
1750 array,
1751 in,
1752 [](const auto &local, auto &global) {
1753 global = local;
1754 });
1755}
1756
1757
1758
1759template <int dim, typename Number, bool is_face>
1760template <typename T>
1761inline T
1763 const AlignedVector<T> &array) const
1764{
1765 T out;
1766 internal::set_valid_element_to_array(this->get_cell_ids(), array, out);
1767 internal::process_cell_or_face_data(this->get_face_ids(),
1768 array,
1769 out,
1770 [](auto &local, const auto &global) {
1771 local = global;
1772 });
1773 return out;
1774}
1775
1776
1777
1778template <int dim, typename Number, bool is_face>
1779template <typename T>
1780inline void
1782 const T &in) const
1783{
1784 internal::process_cell_or_face_data(this->get_face_ids(),
1785 array,
1786 in,
1787 [](const auto &local, auto &global) {
1788 global = local;
1789 });
1790}
1791
1792
1793
1794#endif // ifndef DOXYGEN
1795
1796
1798
1799#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:161
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:35
#define DEAL_II_DEPRECATED_WITH_COMMENT(comment)
Definition config.h:282
constexpr bool running_in_debug_mode()
Definition config.h:73
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:36
#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:238
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()