Reference documentation for deal.II version 9.5.0
\(\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// Copyright (C) 2020 - 2023 by the deal.II authors
4//
5// This file is part of the deal.II library.
6//
7// The deal.II library is free software; you can use it, redistribute
8// it, and/or modify it under the terms of the GNU Lesser General
9// Public License as published by the Free Software Foundation; either
10// version 2.1 of the License, or (at your option) any later version.
11// The full text of the license can be found in the file LICENSE.md at
12// the top level directory of deal.II.
13//
14// ---------------------------------------------------------------------
15
16
17#ifndef dealii_matrix_free_fe_evaluation_data_h
18#define dealii_matrix_free_fe_evaluation_data_h
19
20
21#include <deal.II/base/config.h>
22
31#include <deal.II/base/tensor.h>
33
37
38
40
41
42
43namespace internal
44{
46
49 std::string,
50 << "You are requesting information from an FEEvaluation/FEFaceEvaluation "
51 << "object for which this kind of information has not been computed. What "
52 << "information these objects compute is determined by the update_* flags you "
53 << "pass to MatrixFree::reinit() via MatrixFree::AdditionalData. Here, "
54 << "the operation you are attempting requires the <" << arg1
55 << "> flag to be set, but it was apparently not specified "
56 << "upon initialization.");
57} // namespace internal
58
59// forward declarations
60template <int dim,
61 int fe_degree,
62 int n_q_points_1d = fe_degree + 1,
63 int n_components_ = 1,
64 typename Number = double,
65 typename VectorizedArrayType = VectorizedArray<Number>>
66class FEEvaluation;
67
68template <int dim,
69 int n_components_,
70 typename Number,
71 bool = false,
72 typename = VectorizedArray<Number>>
74
75namespace internal
76{
77 namespace MatrixFreeFunctions
78 {
79 template <int, typename>
80 class MappingDataOnTheFly;
81 }
82} // namespace internal
83
84
113template <int dim, typename Number, bool is_face>
115{
117 using MappingInfoStorageType = internal::MatrixFreeFunctions::
118 MappingInfoStorage<(is_face ? dim - 1 : dim), dim, Number>;
120
121public:
122 static constexpr unsigned int dimension = dim;
123
124 using NumberType = Number;
128
129 static constexpr unsigned int n_lanes =
131
140 const bool is_interior_face = true);
141
145 FEEvaluationData(const FEEvaluationData &other) = default;
146
152
156 virtual ~FEEvaluationData() = default;
157
163 void
165 const unsigned int n_components);
166
171 void
174
188
193 Number
194 JxW(const unsigned int q_point) const;
195
201 quadrature_point(const unsigned int q) const;
202
215 inverse_jacobian(const unsigned int q_point) const;
216
230 normal_vector(const unsigned int q_point) const;
231
238 get_normal_vector(const unsigned int q_point) const;
239
254 const Number *
256
265 Number *
267
278 const Number *
280
291 Number *
293
305 const Number *
307
319 Number *
321
334 const Number *
336
349 Number *
351
367 unsigned int
369
378
382 const ShapeInfoType &
384
390
396 const std::vector<unsigned int> &
398
402 unsigned int
404
408 unsigned int
410
415 unsigned int
417
422 unsigned int
424
428 unsigned int
430
443 std::uint8_t
444 get_face_no(const unsigned int v = 0) const;
445
455 unsigned int
457
466 std::uint8_t
467 get_face_orientation(const unsigned int v = 0) const;
468
478
487 bool
489
494 const std::array<unsigned int, n_lanes> &
496 {
497// implemented inline to avoid compilation problems on Windows
498#ifdef DEBUG
500#endif
501 return cell_ids;
502 }
503
508 const std::array<unsigned int, n_lanes> &
510 {
511// implemented inline to avoid compilation problems on Windows
512#ifdef DEBUG
514#endif
515 return face_ids;
516 }
517
522 unsigned int
524 {
525// implemented inline to avoid compilation problems on Windows
526#ifdef DEBUG
528#endif
529
530 return cell;
531 }
532
537 const std::array<unsigned int, n_lanes> &
539 {
540// implemented inline to avoid compilation problems on Windows
541#ifdef DEBUG
543#endif
544
545 if (!is_face || dof_access_index ==
547 return cell_ids;
548 else
549 return face_ids;
550 }
551
559
577 template <typename T>
578 T
579 read_cell_data(const AlignedVector<T> &array) const;
580
587 template <typename T>
588 void
589 set_cell_data(AlignedVector<T> &array, const T &value) const;
590
599 template <typename T>
600 T
601 read_face_data(const AlignedVector<T> &array) const;
602
611 template <typename T>
612 void
613 set_face_data(AlignedVector<T> &array, const T &value) const;
614
622 {
626 unsigned int active_fe_index;
627 unsigned int active_quad_index;
629 };
630
631protected:
638 FEEvaluationData(const InitializationData &initialization_data,
639 const bool is_interior_face,
640 const unsigned int quad_no,
641 const unsigned int first_selected_component);
642
648 const std::shared_ptr<
650 & mapping_data,
651 const unsigned int n_fe_components,
652 const unsigned int first_selected_component);
653
661
668
676
682 const unsigned int quad_no;
683
688 const unsigned int n_fe_components;
689
694 const unsigned int first_selected_component;
695
699 const unsigned int active_fe_index;
700
705 const unsigned int active_quad_index;
706
713
717 const unsigned int n_quadrature_points;
718
724
738
743 const Tensor<1, dim *(dim + 1) / 2, Tensor<1, dim, Number>>
745
750 const Tensor<1, dim *(dim + 1) / 2, Tensor<1, dim, Number>>
752
759 const Number *J_value;
760
765
770
775
783
794 Number *values_dofs;
795
805 Number *values_quad;
806
820
833
846
857
863
870
877
884
891
898
905
912
917 unsigned int cell;
918
926
932
941 std::array<std::uint8_t, n_lanes> face_numbers;
942
951 std::array<std::uint8_t, n_lanes> face_orientations;
952
960 unsigned int subface_index;
961
969
974 std::array<unsigned int, n_lanes> cell_ids;
975
980 std::array<unsigned int, n_lanes> face_ids;
981
987 std::shared_ptr<
990
996
997 // Make FEEvaluation and FEEvaluationBase objects friends for access to
998 // protected member mapped_geometry.
999 template <int, int, typename, bool, typename>
1000 friend class FEEvaluationBase;
1001
1002 template <int, int, int, int, typename, typename>
1003 friend class FEEvaluation;
1004};
1005
1006
1011template <int dim,
1012 typename Number,
1013 bool is_face,
1014 typename VectorizedArrayType = VectorizedArray<Number>>
1017
1018
1019/*----------------------- Inline functions ----------------------------------*/
1020
1021#ifndef DOXYGEN
1022
1023template <int dim, typename Number, bool is_face>
1025 const ShapeInfoType &shape_info,
1026 const bool is_interior_face)
1028 InitializationData{&shape_info, nullptr, nullptr, 0, 0, nullptr},
1030 0,
1031 0)
1032{}
1033
1034
1035template <int dim, typename Number, bool is_face>
1037 const InitializationData &initialization_data,
1038 const bool is_interior_face,
1039 const unsigned int quad_no,
1040 const unsigned int first_selected_component)
1041 : data(initialization_data.shape_info)
1042 , dof_info(initialization_data.dof_info)
1043 , mapping_data(initialization_data.mapping_data)
1044 , quad_no(quad_no)
1045 , n_fe_components(dof_info != nullptr ? dof_info->start_components.back() : 0)
1047 , active_fe_index(initialization_data.active_fe_index)
1048 , active_quad_index(initialization_data.active_quad_index)
1049 , descriptor(initialization_data.descriptor)
1050 , n_quadrature_points(descriptor == nullptr ?
1051 (is_face ? data->n_q_points_face : data->n_q_points) :
1053 , quadrature_points(nullptr)
1054 , jacobian(nullptr)
1055 , jacobian_gradients(nullptr)
1057 , J_value(nullptr)
1058 , normal_vectors(nullptr)
1059 , normal_x_jacobian(nullptr)
1061 descriptor != nullptr ? descriptor->quadrature_weights.begin() : nullptr)
1062# ifdef DEBUG
1063 , is_reinitialized(false)
1064 , dof_values_initialized(false)
1068 , values_quad_submitted(false)
1070# endif
1071 , cell(numbers::invalid_unsigned_int)
1074 is_face ?
1076 internal::MatrixFreeFunctions::DoFInfo::dof_access_face_interior :
1077 internal::MatrixFreeFunctions::DoFInfo::dof_access_face_exterior) :
1078 internal::MatrixFreeFunctions::DoFInfo::dof_access_cell)
1079 , subface_index(0)
1080 , cell_type(internal::MatrixFreeFunctions::general)
1082{}
1083
1084
1085
1086template <int dim, typename Number, bool is_face>
1088 const std::shared_ptr<
1091 const unsigned int n_fe_components,
1092 const unsigned int first_selected_component)
1093 : data(nullptr)
1094 , dof_info(nullptr)
1095 , mapping_data(nullptr)
1096 , quad_no(numbers::invalid_unsigned_int)
1099 , active_fe_index(numbers::invalid_unsigned_int)
1100 , active_quad_index(numbers::invalid_unsigned_int)
1101 , descriptor(nullptr)
1103 mapped_geometry->get_data_storage().descriptor[0].n_q_points)
1104 , quadrature_points(nullptr)
1105 , jacobian(nullptr)
1106 , jacobian_gradients(nullptr)
1108 , J_value(nullptr)
1109 , normal_vectors(nullptr)
1110 , normal_x_jacobian(nullptr)
1111 , quadrature_weights(nullptr)
1112 , cell(0)
1113 , cell_type(internal::MatrixFreeFunctions::general)
1114 , interior_face(true)
1115 , dof_access_index(internal::MatrixFreeFunctions::DoFInfo::dof_access_cell)
1117 , is_reinitialized(false)
1119{
1120 mapping_data = &mapped_geometry->get_data_storage();
1121 jacobian = mapped_geometry->get_data_storage().jacobians[0].begin();
1122 J_value = mapped_geometry->get_data_storage().JxW_values.begin();
1124 mapped_geometry->get_data_storage().jacobian_gradients[0].begin();
1126 .jacobian_gradients_non_inverse[0]
1127 .begin();
1129 mapped_geometry->get_data_storage().quadrature_points.begin();
1130}
1131
1132
1133
1134template <int dim, typename Number, bool is_face>
1137{
1144
1145 data = other.data;
1146 dof_info = other.dof_info;
1147 mapping_data = other.mapping_data;
1148 descriptor = other.descriptor;
1149 jacobian = nullptr;
1150 J_value = nullptr;
1151 normal_vectors = nullptr;
1152 normal_x_jacobian = nullptr;
1153 jacobian_gradients = nullptr;
1155 quadrature_points = nullptr;
1157
1158# ifdef DEBUG
1159 is_reinitialized = false;
1160 dof_values_initialized = false;
1164 values_quad_submitted = false;
1166# endif
1167
1171 is_face ?
1172 (is_interior_face() ?
1175 internal::MatrixFreeFunctions::DoFInfo::dof_access_cell;
1176 face_numbers[0] = 0;
1177 face_orientations[0] = 0;
1178 subface_index = 0;
1181
1182 return *this;
1183}
1184
1185
1186
1187template <int dim, typename Number, bool is_face>
1188inline void
1191 const unsigned int n_components)
1192{
1194
1195 const unsigned int tensor_dofs_per_component =
1196 Utilities::fixed_power<dim>(data->data.front().fe_degree + 1);
1198
1199 const unsigned int size_scratch_data =
1200 std::max(tensor_dofs_per_component + 1, dofs_per_component) * n_components *
1201 3 +
1203 const unsigned int size_data_arrays =
1205 (n_components * ((dim * (dim + 1)) / 2 + 2 * dim + 2) *
1207
1208 const unsigned int allocated_size = size_scratch_data + size_data_arrays;
1209# ifdef DEBUG
1211 scratch_data_array->resize(allocated_size,
1212 Number(numbers::signaling_nan<ScalarNumber>()));
1213# else
1214 scratch_data_array->resize_fast(allocated_size);
1215# endif
1216 scratch_data.reinit(scratch_data_array->begin() + size_data_arrays,
1217 size_scratch_data);
1218
1219 // set the pointers to the correct position in the data array
1234}
1235
1236
1237
1238template <int dim, typename Number, bool is_face>
1239inline void
1242{
1243 Assert(is_face == true,
1244 ExcMessage("Faces can only be set if the is_face template parameter "
1245 "is true"));
1246 face_numbers[0] =
1248 subface_index = is_interior_face() == true ?
1250 face.subface_index;
1251
1252 // First check if interior or exterior cell has non-standard orientation
1253 // (i.e. the third bit is one or not). Then set zero if this cell has
1254 // standard-orientation else copy the first three bits
1255 // (which is equivalent to modulo 8). See also the documentation of
1256 // internal::MatrixFreeFunctions::FaceToCellTopology::face_orientation.
1257 face_orientations[0] = (is_interior_face() == (face.face_orientation >= 8)) ?
1258 (face.face_orientation % 8) :
1259 0;
1260
1261 if (is_interior_face())
1262 cell_ids = face.cells_interior;
1263 else
1264 cell_ids = face.cells_exterior;
1265}
1266
1267
1268
1269template <int dim, typename Number, bool is_face>
1272 const unsigned int q_point) const
1273{
1275 Assert(normal_vectors != nullptr,
1277 "update_normal_vectors"));
1279 return normal_vectors[0];
1280 else
1281 return normal_vectors[q_point];
1282}
1283
1284
1285
1286// This function is deprecated.
1287template <int dim, typename Number, bool is_face>
1290 const unsigned int q_point) const
1291{
1292 return normal_vector(q_point);
1293}
1294
1295
1296
1297template <int dim, typename Number, bool is_face>
1298inline DEAL_II_ALWAYS_INLINE Number
1299FEEvaluationData<dim, Number, is_face>::JxW(const unsigned int q_point) const
1300{
1302 Assert(J_value != nullptr,
1304 "update_values|update_gradients"));
1306 {
1308 return J_value[0] * quadrature_weights[q_point];
1309 }
1310 else
1311 return J_value[q_point];
1312}
1313
1314
1315
1316template <int dim, typename Number, bool is_face>
1319 const unsigned int q) const
1320{
1322 Assert(this->quadrature_points != nullptr,
1324 "update_quadrature_points"));
1325
1326 // Cartesian/affine mesh: only first vertex of cell is stored, we must
1327 // compute it through the Jacobian (which is stored in non-inverted and
1328 // non-transposed form as index '1' in the jacobian field)
1329 if (is_face == false &&
1331 {
1332 Assert(this->jacobian != nullptr, ExcNotInitialized());
1334
1335 const Tensor<2, dim, Number> &jac = this->jacobian[1];
1337 for (unsigned int d = 0; d < dim; ++d)
1338 point[d] += jac[d][d] * static_cast<typename Number::value_type>(
1339 this->descriptor->quadrature.point(q)[d]);
1340 else
1341 for (unsigned int d = 0; d < dim; ++d)
1342 for (unsigned int e = 0; e < dim; ++e)
1343 point[d] += jac[d][e] * static_cast<typename Number::value_type>(
1344 this->descriptor->quadrature.point(q)[e]);
1345 return point;
1346 }
1347 else
1348 return this->quadrature_points[q];
1349}
1350
1351
1352
1353template <int dim, typename Number, bool is_face>
1356 const unsigned int q_point) const
1357{
1359 Assert(jacobian != nullptr,
1361 "update_gradients"));
1363 return jacobian[0];
1364 else
1365 return jacobian[q_point];
1366}
1367
1368
1369
1370template <int dim, typename Number, bool is_face>
1371inline const Number *
1373{
1374 return values_dofs;
1375}
1376
1377
1378
1379template <int dim, typename Number, bool is_face>
1380inline Number *
1382{
1383# ifdef DEBUG
1385# endif
1386 return values_dofs;
1387}
1388
1389
1390
1391template <int dim, typename Number, bool is_face>
1392inline const Number *
1394{
1395# ifdef DEBUG
1397# endif
1398 return values_quad;
1399}
1400
1401
1402
1403template <int dim, typename Number, bool is_face>
1404inline Number *
1406{
1407# ifdef DEBUG
1409 values_quad_submitted = true;
1410# endif
1411 return values_quad;
1412}
1413
1414
1415
1416template <int dim, typename Number, bool is_face>
1417inline const Number *
1419{
1420# ifdef DEBUG
1423# endif
1424 return gradients_quad;
1425}
1426
1427
1428
1429template <int dim, typename Number, bool is_face>
1430inline Number *
1432{
1433# ifdef DEBUG
1436# endif
1437 return gradients_quad;
1438}
1439
1440
1441
1442template <int dim, typename Number, bool is_face>
1443inline const Number *
1445{
1446# ifdef DEBUG
1448# endif
1449 return hessians_quad;
1450}
1451
1452
1453
1454template <int dim, typename Number, bool is_face>
1455inline Number *
1457{
1458# ifdef DEBUG
1460# endif
1461 return hessians_quad;
1462}
1463
1464
1465
1466template <int dim, typename Number, bool is_face>
1467inline unsigned int
1469{
1470 Assert(mapping_data != nullptr, ExcInternalError());
1471
1472 if (dof_info == nullptr)
1473 return 0;
1474 else
1475 {
1478 }
1479}
1480
1481
1482
1483template <int dim, typename Number, bool is_face>
1486{
1487# ifdef DEBUG
1489# endif
1490 return cell_type;
1491}
1492
1493
1494
1495template <int dim, typename Number, bool is_face>
1498{
1499 Assert(data != nullptr, ExcInternalError());
1500 return *data;
1501}
1502
1503
1504
1505template <int dim, typename Number, bool is_face>
1508{
1509 Assert(dof_info != nullptr,
1510 ExcMessage(
1511 "FEEvaluation was not initialized with a MatrixFree object!"));
1512 return *dof_info;
1513}
1514
1515
1516
1517template <int dim, typename Number, bool is_face>
1518inline const std::vector<unsigned int> &
1520{
1522}
1523
1524
1525
1526template <int dim, typename Number, bool is_face>
1527inline unsigned int
1529{
1530 return quad_no;
1531}
1532
1533
1534
1535template <int dim, typename Number, bool is_face>
1536inline unsigned int
1538{
1539 if (is_face && dof_access_index ==
1542 else
1543 return cell;
1544}
1545
1546
1547
1548template <int dim, typename Number, bool is_face>
1549inline unsigned int
1551{
1552 return active_fe_index;
1553}
1554
1555
1556
1557template <int dim, typename Number, bool is_face>
1558inline unsigned int
1560{
1561 return active_quad_index;
1562}
1563
1564
1565
1566template <int dim, typename Number, bool is_face>
1567inline unsigned int
1569{
1571}
1572
1573
1574
1575template <int dim, typename Number, bool is_face>
1576inline ArrayView<Number>
1578{
1579 return scratch_data;
1580}
1581
1582
1583
1584template <int dim, typename Number, bool is_face>
1585inline std::uint8_t
1587{
1588 Assert(is_face, ExcNotInitialized());
1592 is_interior_face() == false),
1593 ExcMessage("All face numbers can only be queried for ECL at exterior "
1594 "faces. Use get_face_no() in other cases."));
1595
1596 return face_numbers[v];
1597}
1598
1599
1600
1601template <int dim, typename Number, bool is_face>
1602inline unsigned int
1604{
1605 return subface_index;
1606}
1607
1608
1609
1610template <int dim, typename Number, bool is_face>
1611inline std::uint8_t
1613 const unsigned int v) const
1614{
1615 Assert(is_face, ExcNotInitialized());
1619 is_interior_face() == false),
1620 ExcMessage("All face numbers can only be queried for ECL at exterior "
1621 "faces. Use get_face_no() in other cases."));
1622
1623 return face_orientations[v];
1624}
1625
1626
1627
1628template <int dim, typename Number, bool is_face>
1631{
1632 return dof_access_index;
1633}
1634
1635
1636
1637template <int dim, typename Number, bool is_face>
1638inline bool
1640{
1641 return interior_face;
1642}
1643
1644
1645
1646template <int dim, typename Number, bool is_face>
1649{
1650 return {0U, n_quadrature_points};
1651}
1652
1653
1654
1655namespace internal
1656{
1657 template <std::size_t N,
1658 typename VectorOfArrayType,
1659 typename ArrayType,
1660 typename FU>
1661 inline void
1662 process_cell_or_face_data(const std::array<unsigned int, N> indices,
1663 VectorOfArrayType & array,
1664 ArrayType & out,
1665 const FU & fu)
1666 {
1667 for (unsigned int i = 0; i < N; ++i)
1668 if (indices[i] != numbers::invalid_unsigned_int)
1669 {
1670 AssertIndexRange(indices[i] / N, array.size());
1671 fu(out[i], array[indices[i] / N][indices[i] % N]);
1672 }
1673 }
1674
1675 template <std::size_t N, typename VectorOfArrayType, typename ArrayType>
1676 inline void
1677 set_valid_element_to_array(const std::array<unsigned int, N> indices,
1678 const VectorOfArrayType & array,
1679 ArrayType & out)
1680 {
1681 AssertDimension(indices.size(), out.size());
1682 AssertDimension(indices.size(), array[0].size());
1683 // set all entries in array to a valid element
1684 int index = 0;
1685 for (; index < N; ++index)
1686 if (indices[index] != numbers::invalid_unsigned_int)
1687 break;
1688 for (unsigned int i = 0; i < N; ++i)
1689 out[i] = array[indices[index] / N][indices[index] % N];
1690 }
1691} // namespace internal
1692
1693
1694
1695template <int dim, typename Number, bool is_face>
1696template <typename T>
1697inline T
1699 const AlignedVector<T> &array) const
1700{
1701 T out;
1702 internal::set_valid_element_to_array(this->get_cell_ids(), array, out);
1703 internal::process_cell_or_face_data(this->get_cell_ids(),
1704 array,
1705 out,
1706 [](auto &local, const auto &global) {
1707 local = global;
1708 });
1709 return out;
1710}
1711
1712
1713
1714template <int dim, typename Number, bool is_face>
1715template <typename T>
1716inline void
1718 const T &in) const
1719{
1720 internal::process_cell_or_face_data(this->get_cell_ids(),
1721 array,
1722 in,
1723 [](const auto &local, auto &global) {
1724 global = local;
1725 });
1726}
1727
1728
1729
1730template <int dim, typename Number, bool is_face>
1731template <typename T>
1732inline T
1734 const AlignedVector<T> &array) const
1735{
1736 T out;
1737 internal::set_valid_element_to_array(this->get_cell_ids(), array, out);
1738 internal::process_cell_or_face_data(this->get_face_ids(),
1739 array,
1740 out,
1741 [](auto &local, const auto &global) {
1742 local = global;
1743 });
1744 return out;
1745}
1746
1747
1748
1749template <int dim, typename Number, bool is_face>
1750template <typename T>
1751inline void
1753 const T &in) const
1754{
1755 internal::process_cell_or_face_data(this->get_face_ids(),
1756 array,
1757 in,
1758 [](const auto &local, auto &global) {
1759 global = local;
1760 });
1761}
1762
1763
1764
1765#endif // ifndef DOXYGEN
1766
1767
1769
1770#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:413
AlignedVector< VectorizedArrayType > * scratch_data_array
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
Number * begin_gradients()
Number * begin_hessians()
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
Number * begin_values()
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
FEEvaluationData(const FEEvaluationData &other)=default
const ShapeInfoType & get_shape_info() const
void set_face_data(AlignedVector< T > &array, const T &value) const
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
Number * begin_dof_values()
static constexpr unsigned int dimension
internal::MatrixFreeFunctions::ShapeInfo< VectorizedArrayType > ShapeInfoType
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:112
const Point< dim > & point(const unsigned int i) const
#define DEAL_II_ALWAYS_INLINE
Definition config.h:106
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:472
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:473
#define DeclException0(Exception0)
Definition exceptions.h:465
#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:510
static ::ExceptionBase & ExcMatrixFreeAccessToUninitializedMappingField(std::string arg1)
static ::ExceptionBase & ExcMessage(std::string arg1)
@ general
No special properties.
Point< spacedim > point(const gp_Pnt &p, const double tolerance=1e-10)
Definition utilities.cc:189
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:213
boost::integer_range< IncrementableType > iota_view
Definition iota_view.h:46
::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:61
std::array< unsigned int, vectorization_width > cells_exterior
Definition face_info.h:76
std::vector< UnivariateShapeData< Number > > data
Definition shape_info.h:441
std::vector< unsigned int > lexicographic_numbering
Definition shape_info.h:435
static constexpr std::size_t width()