deal.II version GIT relicensing-6834-g5b78e6bcdf 2026-10-01 11:20:01+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
scratch_data.h
Go to the documentation of this file.
1// -----------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
4// Copyright (C) 2019 - 2024 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Detailed license information governing the source code and contributions
9// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
10//
11// -----------------------------------------------------------------------------
12
13#ifndef dealii_meshworker_scratch_data_h
14#define dealii_meshworker_scratch_data_h
15
16#include <deal.II/base/config.h>
17
18#include <deal.II/algorithms/general_data_storage.h>
19
20#include <deal.II/differentiation/ad.h>
21
22#include <deal.II/fe/fe_interface_values.h>
23#include <deal.II/fe/fe_values.h>
24
25#include <deal.II/hp/fe_values.h>
26#include <deal.II/hp/mapping_collection.h>
27#include <deal.II/hp/q_collection.h>
28
29#include <boost/any.hpp>
30
31#include <algorithm>
32#include <vector>
33
34DEAL_II_NAMESPACE_OPEN
35
36namespace MeshWorker
37{
206 template <int dim, int spacedim = dim>
207 class ScratchData
208 {
209 public:
229 ScratchData(
230 const Mapping<dim, spacedim> &mapping,
231 const FiniteElement<dim, spacedim> &fe,
232 const Quadrature<dim> &quadrature,
233 const UpdateFlags &update_flags,
234 const Quadrature<dim - 1> &face_quadrature = Quadrature<dim - 1>(),
235 const UpdateFlags &face_update_flags = update_default);
236
253 ScratchData(
254 const Mapping<dim, spacedim> &mapping,
255 const FiniteElement<dim, spacedim> &fe,
256 const Quadrature<dim> &quadrature,
257 const UpdateFlags &update_flags,
258 const UpdateFlags &neighbor_update_flags,
259 const Quadrature<dim - 1> &face_quadrature = Quadrature<dim - 1>(),
260 const UpdateFlags &face_update_flags = update_default,
261 const UpdateFlags &neighbor_face_update_flags = update_default);
262
275 ScratchData(
276 const FiniteElement<dim, spacedim> &fe,
277 const Quadrature<dim> &quadrature,
278 const UpdateFlags &update_flags,
279 const Quadrature<dim - 1> &face_quadrature = Quadrature<dim - 1>(),
280 const UpdateFlags &face_update_flags = update_default);
281
296 ScratchData(
297 const FiniteElement<dim, spacedim> &fe,
298 const Quadrature<dim> &quadrature,
299 const UpdateFlags &update_flags,
300 const UpdateFlags &neighbor_update_flags,
301 const Quadrature<dim - 1> &face_quadrature = Quadrature<dim - 1>(),
302 const UpdateFlags &face_update_flags = update_default,
303 const UpdateFlags &neighbor_face_update_flags = update_default);
304
324 ScratchData(const hp::MappingCollection<dim, spacedim> &mapping_collection,
325 const hp::FECollection<dim, spacedim> &fe_collection,
326 const hp::QCollection<dim> &cell_quadrature_collection,
327 const UpdateFlags &cell_update_flags,
328 const hp::QCollection<dim - 1> &face_quadrature_collection =
329 hp::QCollection<dim - 1>(),
330 const UpdateFlags &face_update_flags = update_default);
331
348 ScratchData(const hp::MappingCollection<dim, spacedim> &mapping_collection,
349 const hp::FECollection<dim, spacedim> &fe_collection,
350 const hp::QCollection<dim> &cell_quadrature_collection,
351 const UpdateFlags &cell_update_flags,
352 const UpdateFlags &neighbor_cell_update_flags,
353 const hp::QCollection<dim - 1> &face_quadrature_collection =
354 hp::QCollection<dim - 1>(),
355 const UpdateFlags &face_update_flags = update_default,
356 const UpdateFlags &neighbor_face_update_flags = update_default);
357
370 ScratchData(const hp::FECollection<dim, spacedim> &fe_collection,
371 const hp::QCollection<dim> &cell_quadrature_collection,
372 const UpdateFlags &cell_update_flags,
373 const hp::QCollection<dim - 1> &face_quadrature_collection =
374 hp::QCollection<dim - 1>(),
375 const UpdateFlags &face_update_flags = update_default);
376
391 ScratchData(const hp::FECollection<dim, spacedim> &fe_collection,
392 const hp::QCollection<dim> &cell_quadrature_collection,
393 const UpdateFlags &cell_update_flags,
394 const UpdateFlags &neighbor_cell_update_flags,
395 const hp::QCollection<dim - 1> &face_quadrature_collection =
396 hp::QCollection<dim - 1>(),
397 const UpdateFlags &face_update_flags = update_default,
398 const UpdateFlags &neighbor_face_update_flags = update_default);
399
403 ScratchData(const ScratchData<dim, spacedim> &scratch);
404
417 const FEValues<dim, spacedim> &
418 reinit(
419 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell);
420
428 const FEFaceValues<dim, spacedim> &
429 reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
430 const unsigned int face_no);
431
442 const FEFaceValuesBase<dim, spacedim> &
443 reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
444 const unsigned int face_no,
445 const unsigned int subface_no);
446
461 const FEInterfaceValues<dim, spacedim> &
462 reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
463 const unsigned int face_no,
464 const typename DoFHandler<dim, spacedim>::active_cell_iterator
465 &cell_neighbor,
466 const unsigned int face_no_neighbor);
467
482 const FEInterfaceValues<dim, spacedim> &
483 reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
484 const unsigned int face_no,
485 const unsigned int sub_face_no,
486 const typename DoFHandler<dim, spacedim>::active_cell_iterator
487 &cell_neighbor,
488 const unsigned int face_no_neighbor,
489 const unsigned int sub_face_no_neighbor);
490
501 const FEValuesBase<dim, spacedim> &
502 get_current_fe_values() const;
503
507 const FEInterfaceValues<dim, spacedim> &
508 get_current_interface_fe_values() const;
509
513 const std::vector<Point<spacedim>> &
514 get_quadrature_points() const;
515
519 const std::vector<double> &
520 get_JxW_values() const;
521
525 const std::vector<Tensor<1, spacedim>> &
526 get_normal_vectors() const;
527
532 const std::vector<types::global_dof_index> &
533 get_local_dof_indices() const;
534
539 unsigned int
540 n_dofs_per_cell() const;
541
// CurrentCellMethods
543
556 const FEValues<dim, spacedim> &
557 reinit_neighbor(
558 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell);
559
567 const FEFaceValues<dim, spacedim> &
568 reinit_neighbor(
569 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
570 const unsigned int face_no);
571
582 const FEFaceValuesBase<dim, spacedim> &
583 reinit_neighbor(
584 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
585 const unsigned int face_no,
586 const unsigned int subface_no);
587
599 const FEValuesBase<dim, spacedim> &
600 get_current_neighbor_fe_values() const;
601
605 const std::vector<double> &
606 get_neighbor_JxW_values() const;
607
611 const std::vector<Tensor<1, spacedim>> &
612 get_neighbor_normal_vectors();
613
618 const std::vector<types::global_dof_index> &
619 get_neighbor_dof_indices() const;
620
625 unsigned int
626 n_neighbor_dofs_per_cell() const;
627
// NeighborCellMethods
629
// hpCellMethods
634
650 const FEFaceValues<dim, spacedim> &
651 reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
652 const typename DoFHandler<dim, spacedim>::active_cell_iterator
653 &neighbor_cell,
654 const unsigned int face_no);
655
674 const FEFaceValuesBase<dim, spacedim> &
675 reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
676 const typename DoFHandler<dim, spacedim>::active_cell_iterator
677 &neighbor_cell,
678 const unsigned int face_no,
679 const unsigned int subface_no);
680
696 const FEFaceValues<dim, spacedim> &
697 reinit_neighbor(
698 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
699 const typename DoFHandler<dim, spacedim>::active_cell_iterator
700 &neighbor_cell,
701 const unsigned int face_no);
702
721 const FEFaceValuesBase<dim, spacedim> &
722 reinit_neighbor(
723 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
724 const typename DoFHandler<dim, spacedim>::active_cell_iterator
725 &neighbor_cell,
726 const unsigned int face_no,
727 const unsigned int subface_no);
728
// hpCellMethods
730
736 GeneralDataStorage &
737 get_general_data_storage();
738
744 const GeneralDataStorage &
745 get_general_data_storage() const;
746
750 const Mapping<dim, spacedim> &
751 get_mapping() const;
752
756 const FiniteElement<dim, spacedim> &
757 get_fe() const;
758
762 const Quadrature<dim> &
763 get_cell_quadrature() const;
764
768 const Quadrature<dim - 1> &
769 get_face_quadrature() const;
770
774 const hp::MappingCollection<dim, spacedim> &
775 get_mapping_collection() const;
776
780 const hp::FECollection<dim, spacedim> &
781 get_fe_collection() const;
782
786 const hp::QCollection<dim> &
787 get_cell_quadrature_collection() const;
788
792 const hp::QCollection<dim - 1> &
793 get_face_quadrature_collection() const;
794
799 bool
800 has_hp_capabilities() const;
801
805 UpdateFlags
806 get_cell_update_flags() const;
807
811 UpdateFlags
812 get_neighbor_cell_update_flags() const;
813
817 UpdateFlags
818 get_face_update_flags() const;
819
823 UpdateFlags
824 get_neighbor_face_update_flags() const;
825
// CurrentCellEvaluation
830
860 template <typename VectorType, typename Number = double>
861 void
862 extract_local_dof_values(const std::string &global_vector_name,
863 const VectorType &input_vector,
864 const Number dummy = Number(0));
865
874 template <typename Number = double>
875 const std::vector<Number> &
876 get_local_dof_values(const std::string &global_vector_name,
877 Number dummy = Number(0)) const;
878
900 template <typename Extractor, typename Number = double>
901 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
902 template solution_value_type<Number>> &
903 get_values(const std::string &global_vector_name,
904 const Extractor &variable,
905 const Number dummy = Number(0));
906
928 template <typename Extractor, typename Number = double>
929 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
930 template solution_gradient_type<Number>> &
931 get_gradients(const std::string &global_vector_name,
932 const Extractor &variable,
933 const Number dummy = Number(0));
934
957 template <typename Extractor, typename Number = double>
958 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
959 template solution_symmetric_gradient_type<Number>> &
960 get_symmetric_gradients(const std::string &global_vector_name,
961 const Extractor &variable,
962 const Number dummy = Number(0));
963
985 template <typename Extractor, typename Number = double>
986 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
987 template solution_divergence_type<Number>> &
988 get_divergences(const std::string &global_vector_name,
989 const Extractor &variable,
990 const Number dummy = Number(0));
991
1013 template <typename Extractor, typename Number = double>
1014 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1015 template solution_curl_type<Number>> &
1016 get_curls(const std::string &global_vector_name,
1017 const Extractor &variable,
1018 const Number dummy = Number(0));
1019
1041 template <typename Extractor, typename Number = double>
1042 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1043 template solution_hessian_type<Number>> &
1044 get_hessians(const std::string &global_vector_name,
1045 const Extractor &variable,
1046 const Number dummy = Number(0));
1047
1069 template <typename Extractor, typename Number = double>
1070 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1071 template solution_laplacian_type<Number>> &
1072 get_laplacians(const std::string &global_vector_name,
1073 const Extractor &variable,
1074 const Number dummy = Number(0));
1075
1097 template <typename Extractor, typename Number = double>
1098 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1099 template solution_third_derivative_type<Number>> &
1100 get_third_derivatives(const std::string &global_vector_name,
1101 const Extractor &variable,
1102 const Number dummy = Number(0));
1103
// CurrentCellEvaluation
1105
// CurrentInterfaceJumpEvaluation
1110
1133 template <typename Extractor, typename Number = double>
1134 const std::vector<
1135 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1136 template solution_value_type<Number>> &
1137 get_jumps_in_values(const std::string &global_vector_name,
1138 const Extractor &variable,
1139 const Number dummy = Number(0));
1140
1163 template <typename Extractor, typename Number = double>
1164 const std::vector<
1165 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1166 template solution_gradient_type<Number>> &
1167 get_jumps_in_gradients(const std::string &global_vector_name,
1168 const Extractor &variable,
1169 const Number dummy = Number(0));
1170
1193 template <typename Extractor, typename Number = double>
1194 const std::vector<
1195 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1196 template solution_hessian_type<Number>> &
1197 get_jumps_in_hessians(const std::string &global_vector_name,
1198 const Extractor &variable,
1199 const Number dummy = Number(0));
1200
1223 template <typename Extractor, typename Number = double>
1224 const std::vector<
1225 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1226 template solution_third_derivative_type<Number>> &
1227 get_jumps_in_third_derivatives(const std::string &global_vector_name,
1228 const Extractor &variable,
1229 const Number dummy = Number(0));
1230
// CurrentInterfaceJumpEvaluation
1232
// CurrentInterfaceAverageEvaluation
1237
1260 template <typename Extractor, typename Number = double>
1261 const std::vector<
1262 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1263 template solution_value_type<Number>> &
1264 get_averages_of_values(const std::string &global_vector_name,
1265 const Extractor &variable,
1266 const Number dummy = Number(0));
1267
1290 template <typename Extractor, typename Number = double>
1291 const std::vector<
1292 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1293 template solution_gradient_type<Number>> &
1294 get_averages_of_gradients(const std::string &global_vector_name,
1295 const Extractor &variable,
1296 const Number dummy = Number(0));
1297
1320 template <typename Extractor, typename Number = double>
1321 const std::vector<
1322 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1323 template solution_hessian_type<Number>> &
1324 get_averages_of_hessians(const std::string &global_vector_name,
1325 const Extractor &variable,
1326 const Number dummy = Number(0));
1327
// CurrentInterfaceAverageEvaluation
1329
1330 private:
1335 template <typename Extractor, typename Number = double>
1336 std::string
1337 get_unique_name(const std::string &global_vector_name,
1338 const Extractor &variable,
1339 const std::string &object_type,
1340 const unsigned int size,
1341 const Number &exemplar_number) const;
1342
1346 template <typename Number = double>
1347 std::string
1348 get_unique_dofs_name(const std::string &global_vector_name,
1349 const unsigned int size,
1350 const Number &exemplar_number) const;
1351
// non-hp data
1356
1361 ObserverPointer<const Mapping<dim, spacedim>> mapping;
1362
1367 ObserverPointer<const FiniteElement<dim, spacedim>> fe;
1368
1373 Quadrature<dim> cell_quadrature;
1374
1379 Quadrature<dim - 1> face_quadrature;
1380
1384 std::unique_ptr<FEValues<dim, spacedim>> fe_values;
1385
1389 std::unique_ptr<FEFaceValues<dim, spacedim>> fe_face_values;
1390
1394 std::unique_ptr<FESubfaceValues<dim, spacedim>> fe_subface_values;
1395
1399 std::unique_ptr<FEValues<dim, spacedim>> neighbor_fe_values;
1400
1404 std::unique_ptr<FEFaceValues<dim, spacedim>> neighbor_fe_face_values;
1405
1409 std::unique_ptr<FESubfaceValues<dim, spacedim>> neighbor_fe_subface_values;
1410
1414 // The FEInterfaceValues class supports initialization with hp objects
1415 // as well.
1416 std::unique_ptr<FEInterfaceValues<dim, spacedim>> interface_fe_values;
1417
// non-hp data
1419
// hp data
1424
1429 ObserverPointer<const hp::MappingCollection<dim, spacedim>>
1430 mapping_collection;
1431
1436 ObserverPointer<const hp::FECollection<dim, spacedim>> fe_collection;
1437
1442 hp::QCollection<dim> cell_quadrature_collection;
1443
1448 hp::QCollection<dim - 1> face_quadrature_collection;
1449
1454 bool hp_capability_enabled;
1455
1459 std::unique_ptr<hp::FEValues<dim, spacedim>> hp_fe_values;
1460
1464 std::unique_ptr<hp::FEFaceValues<dim, spacedim>> hp_fe_face_values;
1465
1469 std::unique_ptr<hp::FESubfaceValues<dim, spacedim>> hp_fe_subface_values;
1470
1474 std::unique_ptr<hp::FEValues<dim, spacedim>> neighbor_hp_fe_values;
1475
1479 std::unique_ptr<hp::FEFaceValues<dim, spacedim>> neighbor_hp_fe_face_values;
1480
1484 std::unique_ptr<hp::FESubfaceValues<dim, spacedim>>
1485 neighbor_hp_fe_subface_values;
1486
1493 DeclExceptionMsg(ExcOnlyAvailableWithoutHP,
1494 "The current function doesn't make sense when used with a "
1495 "ScratchData object with hp-capabilities.");
1496
1503 DeclExceptionMsg(ExcOnlyAvailableWithHP,
1504 "The current function doesn't make sense when used with a "
1505 "ScratchData object without hp-capabilities.");
1506
// hp data
1508
1512 UpdateFlags cell_update_flags;
1513
1517 UpdateFlags neighbor_cell_update_flags;
1518
1523 UpdateFlags face_update_flags;
1524
1529 UpdateFlags neighbor_face_update_flags;
1530
1534 std::vector<types::global_dof_index> local_dof_indices;
1535
1539 std::vector<types::global_dof_index> neighbor_dof_indices;
1540
1544 GeneralDataStorage user_data_storage;
1545
1549 GeneralDataStorage internal_data_storage;
1550
1555 ObserverPointer<const FEValuesBase<dim, spacedim>> current_fe_values;
1556
1561 ObserverPointer<const FEValuesBase<dim, spacedim>>
1562 current_neighbor_fe_values;
1563 };
1564
1565#ifndef DOXYGEN
1566 template <int dim, int spacedim>
1567 template <typename Extractor, typename Number>
1568 std::string
1569 ScratchData<dim, spacedim>::get_unique_name(
1570 const std::string &global_vector_name,
1571 const Extractor &variable,
1572 const std::string &object_type,
1573 const unsigned int size,
1574 const Number &exemplar_number) const
1575 {
1576 return global_vector_name + "_" + variable.get_name() + "_" + object_type +
1577 "_" + Utilities::int_to_string(size) + "_" +
1578 Utilities::type_to_string(exemplar_number);
1579 }
1580
1581
1582
1583 template <int dim, int spacedim>
1584 template <typename Number>
1585 std::string
1586 ScratchData<dim, spacedim>::get_unique_dofs_name(
1587 const std::string &global_vector_name,
1588 const unsigned int size,
1589 const Number &exemplar_number) const
1590 {
1591 return global_vector_name + "_independent_local_dofs_" +
1592 Utilities::int_to_string(size) + "_" +
1593 Utilities::type_to_string(exemplar_number);
1594 }
1595
1596
1597
1598 template <int dim, int spacedim>
1599 template <typename VectorType, typename Number>
1600 void
1601 ScratchData<dim, spacedim>::extract_local_dof_values(
1602 const std::string &global_vector_name,
1603 const VectorType &input_vector,
1604 const Number dummy)
1605 {
1606 const unsigned int n_dofs = local_dof_indices.size();
1607
1608 const std::string name =
1609 get_unique_dofs_name(global_vector_name, n_dofs, dummy);
1610
1611 auto &independent_local_dofs =
1612 internal_data_storage
1613 .template get_or_add_object_with_name<std::vector<Number>>(name,
1614 n_dofs);
1615
1616 AssertDimension(independent_local_dofs.size(), n_dofs);
1617
1618 if (Differentiation::AD::is_tapeless_ad_number<Number>::value == true)
1619 for (unsigned int i = 0; i < n_dofs; ++i)
1620 Differentiation::AD::internal::Marking<Number>::independent_variable(
1621 input_vector(local_dof_indices[i]),
1622 i,
1623 n_dofs,
1624 independent_local_dofs[i]);
1625 else
1626 for (unsigned int i = 0; i < n_dofs; ++i)
1627 independent_local_dofs[i] = input_vector(local_dof_indices[i]);
1628 }
1629
1630
1631
1632 template <int dim, int spacedim>
1633 template <typename Number>
1634 const std::vector<Number> &
1635 ScratchData<dim, spacedim>::get_local_dof_values(
1636 const std::string &global_vector_name,
1637 Number dummy) const
1638 {
1639 const unsigned int n_dofs = local_dof_indices.size();
1640
1641 const std::string dofs_name =
1642 get_unique_dofs_name(global_vector_name, n_dofs, dummy);
1643
1644 Assert(
1645 internal_data_storage.stores_object_with_name(dofs_name),
1646 ExcMessage(
1647 "You did not call yet extract_local_dof_values with the right types!"));
1648
1649 return internal_data_storage
1650 .template get_object_with_name<std::vector<Number>>(dofs_name);
1651 }
1652
1653
1654
1655 template <int dim, int spacedim>
1656 template <typename Extractor, typename Number>
1657 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1658 template solution_value_type<Number>> &
1659 ScratchData<dim, spacedim>::get_values(const std::string &global_vector_name,
1660 const Extractor &variable,
1661 const Number dummy)
1662 {
1663 const std::vector<Number> &independent_local_dofs =
1664 get_local_dof_values(global_vector_name, dummy);
1665
1666 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1667
1668 const unsigned int n_q_points = fev.n_quadrature_points;
1669
1670 const std::string name = get_unique_name(
1671 global_vector_name, variable, "_values_q", n_q_points, dummy);
1672
1673 // Now build the return type
1674 using RetType =
1675 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1676 template solution_value_type<Number>>;
1677
1678 RetType &ret =
1679 internal_data_storage.template get_or_add_object_with_name<RetType>(
1680 name, n_q_points);
1681
1682 AssertDimension(ret.size(), n_q_points);
1683
1684 fev[variable].get_function_values_from_local_dof_values(
1685 independent_local_dofs, ret);
1686 return ret;
1687 }
1688
1689
1690
1691 template <int dim, int spacedim>
1692 template <typename Extractor, typename Number>
1693 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1694 template solution_gradient_type<Number>> &
1695 ScratchData<dim, spacedim>::get_gradients(
1696 const std::string &global_vector_name,
1697 const Extractor &variable,
1698 const Number dummy)
1699 {
1700 const std::vector<Number> &independent_local_dofs =
1701 get_local_dof_values(global_vector_name, dummy);
1702
1703 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1704
1705 const unsigned int n_q_points = fev.n_quadrature_points;
1706
1707 const std::string name = get_unique_name(
1708 global_vector_name, variable, "_gradients_q", n_q_points, dummy);
1709
1710 // Now build the return type
1711 using RetType =
1712 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1713 template solution_gradient_type<Number>>;
1714
1715 RetType &ret =
1716 internal_data_storage.template get_or_add_object_with_name<RetType>(
1717 name, n_q_points);
1718
1719 AssertDimension(ret.size(), n_q_points);
1720
1721 fev[variable].get_function_gradients_from_local_dof_values(
1722 independent_local_dofs, ret);
1723 return ret;
1724 }
1725
1726
1727
1728 template <int dim, int spacedim>
1729 template <typename Extractor, typename Number>
1730 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1731 template solution_hessian_type<Number>> &
1732 ScratchData<dim, spacedim>::get_hessians(
1733 const std::string &global_vector_name,
1734 const Extractor &variable,
1735 const Number dummy)
1736 {
1737 const std::vector<Number> &independent_local_dofs =
1738 get_local_dof_values(global_vector_name, dummy);
1739
1740 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1741
1742 const unsigned int n_q_points = fev.n_quadrature_points;
1743
1744 const std::string name = get_unique_name(
1745 global_vector_name, variable, "_hessians_q", n_q_points, dummy);
1746
1747 // Now build the return type
1748 using RetType =
1749 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1750 template solution_hessian_type<Number>>;
1751
1752 RetType &ret =
1753 internal_data_storage.template get_or_add_object_with_name<RetType>(
1754 name, n_q_points);
1755
1756
1757 AssertDimension(ret.size(), n_q_points);
1758
1759 fev[variable].get_function_hessians_from_local_dof_values(
1760 independent_local_dofs, ret);
1761 return ret;
1762 }
1763
1764
1765
1766 template <int dim, int spacedim>
1767 template <typename Extractor, typename Number>
1768 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1769 template solution_laplacian_type<Number>> &
1770 ScratchData<dim, spacedim>::get_laplacians(
1771 const std::string &global_vector_name,
1772 const Extractor &variable,
1773 const Number dummy)
1774 {
1775 const std::vector<Number> &independent_local_dofs =
1776 get_local_dof_values(global_vector_name, dummy);
1777
1778 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1779
1780 const unsigned int n_q_points = fev.n_quadrature_points;
1781
1782 const std::string name = get_unique_name(
1783 global_vector_name, variable, "_laplacians_q", n_q_points, dummy);
1784
1785 // Now build the return type
1786 using RetType =
1787 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1788 template solution_laplacian_type<Number>>;
1789
1790 RetType &ret =
1791 internal_data_storage.template get_or_add_object_with_name<RetType>(
1792 name, n_q_points);
1793
1794
1795 AssertDimension(ret.size(), n_q_points);
1796
1797 fev[variable].get_function_laplacians_from_local_dof_values(
1798 independent_local_dofs, ret);
1799 return ret;
1800 }
1801
1802
1803
1804 template <int dim, int spacedim>
1805 template <typename Extractor, typename Number>
1806 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1807 template solution_third_derivative_type<Number>> &
1808 ScratchData<dim, spacedim>::get_third_derivatives(
1809 const std::string &global_vector_name,
1810 const Extractor &variable,
1811 const Number dummy)
1812 {
1813 const std::vector<Number> &independent_local_dofs =
1814 get_local_dof_values(global_vector_name, dummy);
1815
1816 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1817
1818 const unsigned int n_q_points = fev.n_quadrature_points;
1819
1820 const std::string name = get_unique_name(
1821 global_vector_name, variable, "_third_derivatives_q", n_q_points, dummy);
1822
1823 // Now build the return type
1824 using RetType =
1825 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1826 template solution_third_derivative_type<Number>>;
1827
1828 RetType &ret =
1829 internal_data_storage.template get_or_add_object_with_name<RetType>(
1830 name, n_q_points);
1831
1832
1833 AssertDimension(ret.size(), n_q_points);
1834
1835 fev[variable].get_function_third_derivatives_from_local_dof_values(
1836 independent_local_dofs, ret);
1837 return ret;
1838 }
1839
1840
1841
1842 template <int dim, int spacedim>
1843 template <typename Extractor, typename Number>
1844 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1845 template solution_symmetric_gradient_type<Number>> &
1846 ScratchData<dim, spacedim>::get_symmetric_gradients(
1847 const std::string &global_vector_name,
1848 const Extractor &variable,
1849 const Number dummy)
1850 {
1851 const std::vector<Number> &independent_local_dofs =
1852 get_local_dof_values(global_vector_name, dummy);
1853
1854 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1855
1856 const unsigned int n_q_points = fev.n_quadrature_points;
1857
1858 const std::string name = get_unique_name(
1859 global_vector_name, variable, "_symmetric_gradient_q", n_q_points, dummy);
1860
1861
1862 // Now build the return type
1863 using RetType =
1864 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1865 template solution_symmetric_gradient_type<Number>>;
1866
1867 RetType &ret =
1868 internal_data_storage.template get_or_add_object_with_name<RetType>(
1869 name, n_q_points);
1870
1871
1872 AssertDimension(ret.size(), n_q_points);
1873
1874 fev[variable].get_function_symmetric_gradients_from_local_dof_values(
1875 independent_local_dofs, ret);
1876 return ret;
1877 }
1878
1879
1880 template <int dim, int spacedim>
1881 template <typename Extractor, typename Number>
1882 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1883 template solution_divergence_type<Number>> &
1884 ScratchData<dim, spacedim>::get_divergences(
1885 const std::string &global_vector_name,
1886 const Extractor &variable,
1887 const Number dummy)
1888 {
1889 const std::vector<Number> &independent_local_dofs =
1890 get_local_dof_values(global_vector_name, dummy);
1891
1892 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1893
1894 const unsigned int n_q_points = fev.n_quadrature_points;
1895
1896 const std::string name = get_unique_name(
1897 global_vector_name, variable, "_divergence_q", n_q_points, dummy);
1898
1899 // Now build the return type
1900 using RetType =
1901 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1902 template solution_divergence_type<Number>>;
1903
1904 RetType &ret =
1905 internal_data_storage.template get_or_add_object_with_name<RetType>(
1906 name, n_q_points);
1907
1908
1909 AssertDimension(ret.size(), n_q_points);
1910
1911 fev[variable].get_function_divergences_from_local_dof_values(
1912 independent_local_dofs, ret);
1913 return ret;
1914 }
1915
1916
1917
1918 template <int dim, int spacedim>
1919 template <typename Extractor, typename Number>
1920 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1921 template solution_curl_type<Number>> &
1922 ScratchData<dim, spacedim>::get_curls(const std::string &global_vector_name,
1923 const Extractor &variable,
1924 const Number dummy)
1925 {
1926 const std::vector<Number> &independent_local_dofs =
1927 get_local_dof_values(global_vector_name, dummy);
1928
1929 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1930
1931 const unsigned int n_q_points = fev.n_quadrature_points;
1932
1933 const std::string name = get_unique_name(
1934 global_vector_name, variable, "_curl_q", n_q_points, dummy);
1935
1936 // Now build the return type
1937 using RetType =
1938 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1939 template solution_curl_type<Number>>;
1940
1941 RetType &ret =
1942 internal_data_storage.template get_or_add_object_with_name<RetType>(
1943 name, n_q_points);
1944
1945 AssertDimension(ret.size(), n_q_points);
1946
1947 fev[variable].get_function_curls_from_local_dof_values(
1948 independent_local_dofs, ret);
1949 return ret;
1950 }
1951
1952
1953
1954 template <int dim, int spacedim>
1955 template <typename Extractor, typename Number>
1956 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1957 template solution_value_type<Number>> &
1958 ScratchData<dim, spacedim>::get_jumps_in_values(
1959 const std::string &global_vector_name,
1960 const Extractor &variable,
1961 const Number dummy)
1962 {
1963 const std::vector<Number> &independent_local_dofs =
1964 get_local_dof_values(global_vector_name, dummy);
1965
1966 const FEInterfaceValues<dim, spacedim> &feiv =
1967 get_current_interface_fe_values();
1968
1969 AssertDimension(independent_local_dofs.size(),
1970 feiv.n_current_interface_dofs());
1971
1972 const unsigned int n_q_points = feiv.n_quadrature_points;
1973
1974 const std::string name = get_unique_name(
1975 global_vector_name, variable, "_jump_values_q", n_q_points, dummy);
1976
1977 // Now build the return type
1978 using RetType =
1979 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1980 template solution_value_type<Number>>;
1981
1982 RetType &ret =
1983 internal_data_storage.template get_or_add_object_with_name<RetType>(
1984 name, n_q_points);
1985
1986 AssertDimension(ret.size(), n_q_points);
1987
1988 feiv[variable].get_jump_in_function_values_from_local_dof_values(
1989 independent_local_dofs, ret);
1990 return ret;
1991 }
1992
1993
1994
1995 template <int dim, int spacedim>
1996 template <typename Extractor, typename Number>
1997 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1998 template solution_gradient_type<Number>> &
1999 ScratchData<dim, spacedim>::get_jumps_in_gradients(
2000 const std::string &global_vector_name,
2001 const Extractor &variable,
2002 const Number dummy)
2003 {
2004 const std::vector<Number> &independent_local_dofs =
2005 get_local_dof_values(global_vector_name, dummy);
2006
2007 const FEInterfaceValues<dim, spacedim> &feiv =
2008 get_current_interface_fe_values();
2009
2010 AssertDimension(independent_local_dofs.size(),
2011 feiv.n_current_interface_dofs());
2012
2013 const unsigned int n_q_points = feiv.n_quadrature_points;
2014
2015 const std::string name = get_unique_name(
2016 global_vector_name, variable, "_jump_gradients_q", n_q_points, dummy);
2017
2018 // Now build the return type
2019 using RetType =
2020 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
2021 template solution_gradient_type<Number>>;
2022
2023 RetType &ret =
2024 internal_data_storage.template get_or_add_object_with_name<RetType>(
2025 name, n_q_points);
2026
2027 AssertDimension(ret.size(), n_q_points);
2028
2029 feiv[variable].get_jump_in_function_gradients_from_local_dof_values(
2030 independent_local_dofs, ret);
2031 return ret;
2032 }
2033
2034
2035
2036 template <int dim, int spacedim>
2037 template <typename Extractor, typename Number>
2038 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
2039 template solution_hessian_type<Number>> &
2040 ScratchData<dim, spacedim>::get_jumps_in_hessians(
2041 const std::string &global_vector_name,
2042 const Extractor &variable,
2043 const Number dummy)
2044 {
2045 const std::vector<Number> &independent_local_dofs =
2046 get_local_dof_values(global_vector_name, dummy);
2047
2048 const FEInterfaceValues<dim, spacedim> &feiv =
2049 get_current_interface_fe_values();
2050
2051 AssertDimension(independent_local_dofs.size(),
2052 feiv.n_current_interface_dofs());
2053
2054 const unsigned int n_q_points = feiv.n_quadrature_points;
2055
2056 const std::string name = get_unique_name(
2057 global_vector_name, variable, "_jump_hessians_q", n_q_points, dummy);
2058
2059 // Now build the return type
2060 using RetType =
2061 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
2062 template solution_hessian_type<Number>>;
2063
2064 RetType &ret =
2065 internal_data_storage.template get_or_add_object_with_name<RetType>(
2066 name, n_q_points);
2067
2068 AssertDimension(ret.size(), n_q_points);
2069
2070 feiv[variable].get_jump_in_function_hessians_from_local_dof_values(
2071 independent_local_dofs, ret);
2072 return ret;
2073 }
2074
2075
2076
2077 template <int dim, int spacedim>
2078 template <typename Extractor, typename Number>
2079 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
2080 template solution_third_derivative_type<Number>> &
2081 ScratchData<dim, spacedim>::get_jumps_in_third_derivatives(
2082 const std::string &global_vector_name,
2083 const Extractor &variable,
2084 const Number dummy)
2085 {
2086 const std::vector<Number> &independent_local_dofs =
2087 get_local_dof_values(global_vector_name, dummy);
2088
2089 const FEInterfaceValues<dim, spacedim> &feiv =
2090 get_current_interface_fe_values();
2091
2092 AssertDimension(independent_local_dofs.size(),
2093 feiv.n_current_interface_dofs());
2094
2095 const unsigned int n_q_points = feiv.n_quadrature_points;
2096
2097 const std::string name = get_unique_name(global_vector_name,
2098 variable,
2099 "_jump_third_derivatives_q",
2100 n_q_points,
2101 dummy);
2102
2103 // Now build the return type
2104 using RetType =
2105 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
2106 template solution_third_derivative_type<Number>>;
2107
2108 RetType &ret =
2109 internal_data_storage.template get_or_add_object_with_name<RetType>(
2110 name, n_q_points);
2111
2112 AssertDimension(ret.size(), n_q_points);
2113
2114 feiv[variable].get_jump_in_function_third_derivatives_from_local_dof_values(
2115 independent_local_dofs, ret);
2116 return ret;
2117 }
2118
2119
2120
2121 template <int dim, int spacedim>
2122 template <typename Extractor, typename Number>
2123 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
2124 template solution_value_type<Number>> &
2125 ScratchData<dim, spacedim>::get_averages_of_values(
2126 const std::string &global_vector_name,
2127 const Extractor &variable,
2128 const Number dummy)
2129 {
2130 const std::vector<Number> &independent_local_dofs =
2131 get_local_dof_values(global_vector_name, dummy);
2132
2133 const FEInterfaceValues<dim, spacedim> &feiv =
2134 get_current_interface_fe_values();
2135
2136 AssertDimension(independent_local_dofs.size(),
2137 feiv.n_current_interface_dofs());
2138
2139 const unsigned int n_q_points = feiv.n_quadrature_points;
2140
2141 const std::string name = get_unique_name(
2142 global_vector_name, variable, "_average_values_q", n_q_points, dummy);
2143
2144 // Now build the return type
2145 using RetType =
2146 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
2147 template solution_value_type<Number>>;
2148
2149 RetType &ret =
2150 internal_data_storage.template get_or_add_object_with_name<RetType>(
2151 name, n_q_points);
2152
2153 AssertDimension(ret.size(), n_q_points);
2154
2155 feiv[variable].get_average_of_function_values_from_local_dof_values(
2156 independent_local_dofs, ret);
2157 return ret;
2158 }
2159
2160
2161
2162 template <int dim, int spacedim>
2163 template <typename Extractor, typename Number>
2164 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
2165 template solution_gradient_type<Number>> &
2166 ScratchData<dim, spacedim>::get_averages_of_gradients(
2167 const std::string &global_vector_name,
2168 const Extractor &variable,
2169 const Number dummy)
2170 {
2171 const std::vector<Number> &independent_local_dofs =
2172 get_local_dof_values(global_vector_name, dummy);
2173
2174 const FEInterfaceValues<dim, spacedim> &feiv =
2175 get_current_interface_fe_values();
2176
2177 AssertDimension(independent_local_dofs.size(),
2178 feiv.n_current_interface_dofs());
2179
2180 const unsigned int n_q_points = feiv.n_quadrature_points;
2181
2182 const std::string name = get_unique_name(
2183 global_vector_name, variable, "_average_gradients_q", n_q_points, dummy);
2184
2185 // Now build the return type
2186 using RetType =
2187 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
2188 template solution_gradient_type<Number>>;
2189
2190 RetType &ret =
2191 internal_data_storage.template get_or_add_object_with_name<RetType>(
2192 name, n_q_points);
2193
2194 AssertDimension(ret.size(), n_q_points);
2195
2196 feiv[variable].get_average_of_function_gradients_from_local_dof_values(
2197 independent_local_dofs, ret);
2198 return ret;
2199 }
2200
2201
2202
2203 template <int dim, int spacedim>
2204 template <typename Extractor, typename Number>
2205 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
2206 template solution_hessian_type<Number>> &
2207 ScratchData<dim, spacedim>::get_averages_of_hessians(
2208 const std::string &global_vector_name,
2209 const Extractor &variable,
2210 const Number dummy)
2211 {
2212 const std::vector<Number> &independent_local_dofs =
2213 get_local_dof_values(global_vector_name, dummy);
2214
2215 const FEInterfaceValues<dim, spacedim> &feiv =
2216 get_current_interface_fe_values();
2217
2218 AssertDimension(independent_local_dofs.size(),
2219 feiv.n_current_interface_dofs());
2220
2221 const unsigned int n_q_points = feiv.n_quadrature_points;
2222
2223 const std::string name = get_unique_name(
2224 global_vector_name, variable, "_average_hessians_q", n_q_points, dummy);
2225
2226 // Now build the return type
2227 using RetType =
2228 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
2229 template solution_hessian_type<Number>>;
2230
2231 RetType &ret =
2232 internal_data_storage.template get_or_add_object_with_name<RetType>(
2233 name, n_q_points);
2234
2235 AssertDimension(ret.size(), n_q_points);
2236
2237 feiv[variable].get_average_of_function_hessians_from_local_dof_values(
2238 independent_local_dofs, ret);
2239 return ret;
2240 }
2241
2242
2243#endif
2244
2245} // namespace MeshWorker
2246
2247DEAL_II_NAMESPACE_CLOSE
2248
2249#endif
FEInterfaceValues::n_quadrature_points
const unsigned int n_quadrature_points
Definition fe_interface_values.h:1357
FEInterfaceValues::n_current_interface_dofs
unsigned n_current_interface_dofs() const
FEValuesBase::n_quadrature_points
const unsigned int n_quadrature_points
Definition fe_values_base.h:174
Mapping
Abstract base class for mapping classes.
Definition mapping.h:318
MeshWorker::ScratchData::user_data_storage
GeneralDataStorage user_data_storage
Definition scratch_data.h:1544
MeshWorker::ScratchData::face_quadrature_collection
hp::QCollection< dim - 1 > face_quadrature_collection
Definition scratch_data.h:1448
MeshWorker::ScratchData::get_jumps_in_gradients
const std::vector< typename FEInterfaceViews::View< dim, spacedim, Extractor >::template solution_gradient_type< Number > > & get_jumps_in_gradients(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::has_hp_capabilities
bool has_hp_capabilities() const
Definition scratch_data.cc:981
MeshWorker::ScratchData::get_mapping_collection
const hp::MappingCollection< dim, spacedim > & get_mapping_collection() const
Definition scratch_data.cc:939
MeshWorker::ScratchData::get_values
const std::vector< typename FEValuesViews::View< dim, spacedim, Extractor >::template solution_value_type< Number > > & get_values(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::get_current_fe_values
const FEValuesBase< dim, spacedim > & get_current_fe_values() const
Definition scratch_data.cc:762
MeshWorker::ScratchData::get_general_data_storage
GeneralDataStorage & get_general_data_storage()
Definition scratch_data.cc:879
MeshWorker::ScratchData::get_face_quadrature
const Quadrature< dim - 1 > & get_face_quadrature() const
Definition scratch_data.cc:929
MeshWorker::ScratchData::get_unique_name
std::string get_unique_name(const std::string &global_vector_name, const Extractor &variable, const std::string &object_type, const unsigned int size, const Number &exemplar_number) const
MeshWorker::ScratchData::get_jumps_in_values
const std::vector< typename FEInterfaceViews::View< dim, spacedim, Extractor >::template solution_value_type< Number > > & get_jumps_in_values(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::get_divergences
const std::vector< typename FEValuesViews::View< dim, spacedim, Extractor >::template solution_divergence_type< Number > > & get_divergences(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::get_neighbor_normal_vectors
const std::vector< Tensor< 1, spacedim > > & get_neighbor_normal_vectors()
Definition scratch_data.cc:834
MeshWorker::ScratchData::n_dofs_per_cell
unsigned int n_dofs_per_cell() const
Definition scratch_data.cc:852
MeshWorker::ScratchData::hp_fe_subface_values
std::unique_ptr< hp::FESubfaceValues< dim, spacedim > > hp_fe_subface_values
Definition scratch_data.h:1469
MeshWorker::ScratchData::n_neighbor_dofs_per_cell
unsigned int n_neighbor_dofs_per_cell() const
Definition scratch_data.cc:870
MeshWorker::ScratchData::neighbor_fe_values
std::unique_ptr< FEValues< dim, spacedim > > neighbor_fe_values
Definition scratch_data.h:1399
MeshWorker::ScratchData::fe_face_values
std::unique_ptr< FEFaceValues< dim, spacedim > > fe_face_values
Definition scratch_data.h:1389
MeshWorker::ScratchData::get_unique_dofs_name
std::string get_unique_dofs_name(const std::string &global_vector_name, const unsigned int size, const Number &exemplar_number) const
MeshWorker::ScratchData::extract_local_dof_values
void extract_local_dof_values(const std::string &global_vector_name, const VectorType &input_vector, const Number dummy=Number(0))
MeshWorker::ScratchData::fe_values
std::unique_ptr< FEValues< dim, spacedim > > fe_values
Definition scratch_data.h:1384
MeshWorker::ScratchData::get_JxW_values
const std::vector< double > & get_JxW_values() const
Definition scratch_data.cc:807
MeshWorker::ScratchData::get_mapping
const Mapping< dim, spacedim > & get_mapping() const
Definition scratch_data.cc:897
MeshWorker::ScratchData::mapping
ObserverPointer< const Mapping< dim, spacedim > > mapping
Definition scratch_data.h:1361
MeshWorker::ScratchData::interface_fe_values
std::unique_ptr< FEInterfaceValues< dim, spacedim > > interface_fe_values
Definition scratch_data.h:1416
MeshWorker::ScratchData::get_neighbor_JxW_values
const std::vector< double > & get_neighbor_JxW_values() const
Definition scratch_data.cc:816
MeshWorker::ScratchData::cell_quadrature
Quadrature< dim > cell_quadrature
Definition scratch_data.h:1373
MeshWorker::ScratchData::get_averages_of_values
const std::vector< typename FEInterfaceViews::View< dim, spacedim, Extractor >::template solution_value_type< Number > > & get_averages_of_values(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::fe_collection
ObserverPointer< const hp::FECollection< dim, spacedim > > fe_collection
Definition scratch_data.h:1436
MeshWorker::ScratchData::get_fe
const FiniteElement< dim, spacedim > & get_fe() const
Definition scratch_data.cc:908
MeshWorker::ScratchData::neighbor_fe_face_values
std::unique_ptr< FEFaceValues< dim, spacedim > > neighbor_fe_face_values
Definition scratch_data.h:1404
MeshWorker::ScratchData::get_averages_of_gradients
const std::vector< typename FEInterfaceViews::View< dim, spacedim, Extractor >::template solution_gradient_type< Number > > & get_averages_of_gradients(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::get_cell_quadrature_collection
const hp::QCollection< dim > & get_cell_quadrature_collection() const
Definition scratch_data.cc:961
MeshWorker::ScratchData::neighbor_dof_indices
std::vector< types::global_dof_index > neighbor_dof_indices
Definition scratch_data.h:1539
MeshWorker::ScratchData::get_neighbor_dof_indices
const std::vector< types::global_dof_index > & get_neighbor_dof_indices() const
Definition scratch_data.cc:861
MeshWorker::ScratchData::get_face_update_flags
UpdateFlags get_face_update_flags() const
Definition scratch_data.cc:1008
MeshWorker::ScratchData::get_jumps_in_hessians
const std::vector< typename FEInterfaceViews::View< dim, spacedim, Extractor >::template solution_hessian_type< Number > > & get_jumps_in_hessians(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::get_laplacians
const std::vector< typename FEValuesViews::View< dim, spacedim, Extractor >::template solution_laplacian_type< Number > > & get_laplacians(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::hp_fe_values
std::unique_ptr< hp::FEValues< dim, spacedim > > hp_fe_values
Definition scratch_data.h:1459
MeshWorker::ScratchData::current_fe_values
ObserverPointer< const FEValuesBase< dim, spacedim > > current_fe_values
Definition scratch_data.h:1555
MeshWorker::ScratchData::neighbor_cell_update_flags
UpdateFlags neighbor_cell_update_flags
Definition scratch_data.h:1517
MeshWorker::ScratchData::get_third_derivatives
const std::vector< typename FEValuesViews::View< dim, spacedim, Extractor >::template solution_third_derivative_type< Number > > & get_third_derivatives(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::get_neighbor_cell_update_flags
UpdateFlags get_neighbor_cell_update_flags() const
Definition scratch_data.cc:999
MeshWorker::ScratchData::get_fe_collection
const hp::FECollection< dim, spacedim > & get_fe_collection() const
Definition scratch_data.cc:950
MeshWorker::ScratchData::get_normal_vectors
const std::vector< Tensor< 1, spacedim > > & get_normal_vectors() const
Definition scratch_data.cc:825
MeshWorker::ScratchData::get_curls
const std::vector< typename FEValuesViews::View< dim, spacedim, Extractor >::template solution_curl_type< Number > > & get_curls(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::reinit_neighbor
const FEValues< dim, spacedim > & reinit_neighbor(const typename DoFHandler< dim, spacedim >::active_cell_iterator &cell)
Definition scratch_data.cc:535
MeshWorker::ScratchData::neighbor_hp_fe_face_values
std::unique_ptr< hp::FEFaceValues< dim, spacedim > > neighbor_hp_fe_face_values
Definition scratch_data.h:1479
MeshWorker::ScratchData::fe
ObserverPointer< const FiniteElement< dim, spacedim > > fe
Definition scratch_data.h:1367
MeshWorker::ScratchData::get_hessians
const std::vector< typename FEValuesViews::View< dim, spacedim, Extractor >::template solution_hessian_type< Number > > & get_hessians(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::local_dof_indices
std::vector< types::global_dof_index > local_dof_indices
Definition scratch_data.h:1534
MeshWorker::ScratchData::get_jumps_in_third_derivatives
const std::vector< typename FEInterfaceViews::View< dim, spacedim, Extractor >::template solution_third_derivative_type< Number > > & get_jumps_in_third_derivatives(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::get_local_dof_values
const std::vector< Number > & get_local_dof_values(const std::string &global_vector_name, Number dummy=Number(0)) const
MeshWorker::ScratchData::get_quadrature_points
const std::vector< Point< spacedim > > & get_quadrature_points() const
Definition scratch_data.cc:798
MeshWorker::ScratchData::neighbor_hp_fe_values
std::unique_ptr< hp::FEValues< dim, spacedim > > neighbor_hp_fe_values
Definition scratch_data.h:1474
MeshWorker::ScratchData::current_neighbor_fe_values
ObserverPointer< const FEValuesBase< dim, spacedim > > current_neighbor_fe_values
Definition scratch_data.h:1562
MeshWorker::ScratchData::get_current_neighbor_fe_values
const FEValuesBase< dim, spacedim > & get_current_neighbor_fe_values() const
Definition scratch_data.cc:786
MeshWorker::ScratchData::get_local_dof_indices
const std::vector< types::global_dof_index > & get_local_dof_indices() const
Definition scratch_data.cc:843
MeshWorker::ScratchData::get_symmetric_gradients
const std::vector< typename FEValuesViews::View< dim, spacedim, Extractor >::template solution_symmetric_gradient_type< Number > > & get_symmetric_gradients(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::face_quadrature
Quadrature< dim - 1 > face_quadrature
Definition scratch_data.h:1379
MeshWorker::ScratchData::get_averages_of_hessians
const std::vector< typename FEInterfaceViews::View< dim, spacedim, Extractor >::template solution_hessian_type< Number > > & get_averages_of_hessians(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::get_current_interface_fe_values
const FEInterfaceValues< dim, spacedim > & get_current_interface_fe_values() const
Definition scratch_data.cc:774
MeshWorker::ScratchData::cell_quadrature_collection
hp::QCollection< dim > cell_quadrature_collection
Definition scratch_data.h:1442
MeshWorker::ScratchData::get_cell_update_flags
UpdateFlags get_cell_update_flags() const
Definition scratch_data.cc:990
MeshWorker::ScratchData::get_gradients
const std::vector< typename FEValuesViews::View< dim, spacedim, Extractor >::template solution_gradient_type< Number > > & get_gradients(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
MeshWorker::ScratchData::neighbor_face_update_flags
UpdateFlags neighbor_face_update_flags
Definition scratch_data.h:1529
MeshWorker::ScratchData::get_cell_quadrature
const Quadrature< dim > & get_cell_quadrature() const
Definition scratch_data.cc:919
MeshWorker::ScratchData::get_face_quadrature_collection
const hp::QCollection< dim - 1 > & get_face_quadrature_collection() const
Definition scratch_data.cc:971
MeshWorker::ScratchData::neighbor_fe_subface_values
std::unique_ptr< FESubfaceValues< dim, spacedim > > neighbor_fe_subface_values
Definition scratch_data.h:1409
MeshWorker::ScratchData::mapping_collection
ObserverPointer< const hp::MappingCollection< dim, spacedim > > mapping_collection
Definition scratch_data.h:1430
MeshWorker::ScratchData::reinit
const FEValues< dim, spacedim > & reinit(const typename DoFHandler< dim, spacedim >::active_cell_iterator &cell)
Definition scratch_data.cc:223
MeshWorker::ScratchData::neighbor_hp_fe_subface_values
std::unique_ptr< hp::FESubfaceValues< dim, spacedim > > neighbor_hp_fe_subface_values
Definition scratch_data.h:1485
MeshWorker::ScratchData::fe_subface_values
std::unique_ptr< FESubfaceValues< dim, spacedim > > fe_subface_values
Definition scratch_data.h:1394
MeshWorker::ScratchData::internal_data_storage
GeneralDataStorage internal_data_storage
Definition scratch_data.h:1549
MeshWorker::ScratchData::get_neighbor_face_update_flags
UpdateFlags get_neighbor_face_update_flags() const
Definition scratch_data.cc:1017
MeshWorker::ScratchData::hp_fe_face_values
std::unique_ptr< hp::FEFaceValues< dim, spacedim > > hp_fe_face_values
Definition scratch_data.h:1464
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:38
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:39
fe_values.h
fe_interface_values.h
general_data_storage.h
Assert
#define Assert(cond, exc)
Definition exception_macros.h:543
AssertDimension
#define AssertDimension(dim1, dim2)
Definition exception_macros.h:829
MeshWorker::ScratchData::ExcOnlyAvailableWithoutHP
static ::ExceptionBase & ExcOnlyAvailableWithoutHP()
DeclExceptionMsg
#define DeclExceptionMsg(Exception, defaulttext)
Definition exception_macros.h:346
StandardExceptions::ExcMessage
static ::ExceptionBase & ExcMessage(std::string arg1)
MeshWorker::ScratchData::ExcOnlyAvailableWithHP
static ::ExceptionBase & ExcOnlyAvailableWithHP()
DoFHandler::active_cell_iterator
typename ActiveSelector::active_cell_iterator active_cell_iterator
Definition dof_handler.h:447
UpdateFlags
UpdateFlags
Definition fe_update_flags.h:62
update_default
@ update_default
No update.
Definition fe_update_flags.h:64
fe_values.h
mapping_collection.h
size
std::size_t size
Definition mpi.cc:733
FEInterfaceViews::View
typename ::internal::FEInterfaceViews::ViewType< dim, spacedim, Extractor >::type View
Definition fe_interface_values.h:1283
Utilities::type_to_string
std::string type_to_string(const T &t)
Definition utilities.h:994
Utilities::int_to_string
std::string int_to_string(const unsigned int value, const unsigned int digits=numbers::invalid_unsigned_int)
Definition utilities.cc:464
q_collection.h
Differentiation::AD::is_tapeless_ad_number
Definition ad_number_traits.h:247
Generated by doxygen 1.9.8