Reference documentation for deal.II version 9.4.1
\(\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// Copyright (C) 2019 - 2022 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#ifndef dealii_meshworker_scratch_data_h
17#define dealii_meshworker_scratch_data_h
18
19#include <deal.II/base/config.h>
20
21#include <deal.II/algorithms/general_data_storage.h>
22
23#include <deal.II/differentiation/ad.h>
24
25#include <deal.II/fe/fe_interface_values.h>
26#include <deal.II/fe/fe_values.h>
27
28#include <deal.II/hp/fe_values.h>
29#include <deal.II/hp/mapping_collection.h>
30#include <deal.II/hp/q_collection.h>
31
32#include <boost/any.hpp>
33
34#include <algorithm>
35#include <map>
36#include <vector>
37
38DEAL_II_NAMESPACE_OPEN
39
40namespace MeshWorker
41{
222 template <int dim, int spacedim = dim>
223 class ScratchData
224 {
225 public:
245 ScratchData(
246 const Mapping<dim, spacedim> & mapping,
247 const FiniteElement<dim, spacedim> &fe,
248 const Quadrature<dim> & quadrature,
249 const UpdateFlags & update_flags,
250 const Quadrature<dim - 1> &face_quadrature = Quadrature<dim - 1>(),
251 const UpdateFlags & face_update_flags = update_default);
252
269 ScratchData(
270 const Mapping<dim, spacedim> & mapping,
271 const FiniteElement<dim, spacedim> &fe,
272 const Quadrature<dim> & quadrature,
273 const UpdateFlags & update_flags,
274 const UpdateFlags & neighbor_update_flags,
275 const Quadrature<dim - 1> &face_quadrature = Quadrature<dim - 1>(),
276 const UpdateFlags & face_update_flags = update_default,
277 const UpdateFlags & neighbor_face_update_flags = update_default);
278
291 ScratchData(
292 const FiniteElement<dim, spacedim> &fe,
293 const Quadrature<dim> & quadrature,
294 const UpdateFlags & update_flags,
295 const Quadrature<dim - 1> &face_quadrature = Quadrature<dim - 1>(),
296 const UpdateFlags & face_update_flags = update_default);
297
312 ScratchData(
313 const FiniteElement<dim, spacedim> &fe,
314 const Quadrature<dim> & quadrature,
315 const UpdateFlags & update_flags,
316 const UpdateFlags & neighbor_update_flags,
317 const Quadrature<dim - 1> &face_quadrature = Quadrature<dim - 1>(),
318 const UpdateFlags & face_update_flags = update_default,
319 const UpdateFlags & neighbor_face_update_flags = update_default);
320
340 ScratchData(const hp::MappingCollection<dim, spacedim> &mapping_collection,
341 const hp::FECollection<dim, spacedim> & fe_collection,
342 const hp::QCollection<dim> & cell_quadrature_collection,
343 const UpdateFlags & cell_update_flags,
344 const hp::QCollection<dim - 1> &face_quadrature_collection =
345 hp::QCollection<dim - 1>(),
346 const UpdateFlags &face_update_flags = update_default);
347
364 ScratchData(const hp::MappingCollection<dim, spacedim> &mapping_collection,
365 const hp::FECollection<dim, spacedim> & fe_collection,
366 const hp::QCollection<dim> & cell_quadrature_collection,
367 const UpdateFlags & cell_update_flags,
368 const UpdateFlags & neighbor_cell_update_flags,
369 const hp::QCollection<dim - 1> &face_quadrature_collection =
370 hp::QCollection<dim - 1>(),
371 const UpdateFlags &face_update_flags = update_default,
372 const UpdateFlags &neighbor_face_update_flags = update_default);
373
386 ScratchData(const hp::FECollection<dim, spacedim> &fe_collection,
387 const hp::QCollection<dim> & cell_quadrature_collection,
388 const UpdateFlags & cell_update_flags,
389 const hp::QCollection<dim - 1> &face_quadrature_collection =
390 hp::QCollection<dim - 1>(),
391 const UpdateFlags &face_update_flags = update_default);
392
407 ScratchData(const hp::FECollection<dim, spacedim> &fe_collection,
408 const hp::QCollection<dim> & cell_quadrature_collection,
409 const UpdateFlags & cell_update_flags,
410 const UpdateFlags & neighbor_cell_update_flags,
411 const hp::QCollection<dim - 1> &face_quadrature_collection =
412 hp::QCollection<dim - 1>(),
413 const UpdateFlags &face_update_flags = update_default,
414 const UpdateFlags &neighbor_face_update_flags = update_default);
415
419 ScratchData(const ScratchData<dim, spacedim> &scratch);
420 // CurrentCellMethods
425
433 const FEValues<dim, spacedim> &
434 reinit(
435 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell);
436
444 const FEFaceValues<dim, spacedim> &
445 reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
446 const unsigned int face_no);
447
458 const FEFaceValuesBase<dim, spacedim> &
459 reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
460 const unsigned int face_no,
461 const unsigned int subface_no);
462
477 const FEInterfaceValues<dim, spacedim> &
478 reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
479 const unsigned int face_no,
480 const unsigned int sub_face_no,
481 const typename DoFHandler<dim, spacedim>::active_cell_iterator
482 & cell_neighbor,
483 const unsigned int face_no_neighbor,
484 const unsigned int sub_face_no_neighbor);
485
496 const FEValuesBase<dim, spacedim> &
497 get_current_fe_values() const;
498
502 const FEInterfaceValues<dim, spacedim> &
503 get_current_interface_fe_values() const;
504
508 const std::vector<Point<spacedim>> &
509 get_quadrature_points() const;
510
514 const std::vector<double> &
515 get_JxW_values() const;
516
520 const std::vector<Tensor<1, spacedim>> &
521 get_normal_vectors() const;
522
527 const std::vector<types::global_dof_index> &
528 get_local_dof_indices() const;
529
534 unsigned int
535 n_dofs_per_cell() const;
536 // CurrentCellMethods
538 // NeighborCellMethods
543
551 const FEValues<dim, spacedim> &
552 reinit_neighbor(
553 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell);
554
562 const FEFaceValues<dim, spacedim> &
563 reinit_neighbor(
564 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
565 const unsigned int face_no);
566
577 const FEFaceValuesBase<dim, spacedim> &
578 reinit_neighbor(
579 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
580 const unsigned int face_no,
581 const unsigned int subface_no);
582
594 const FEValuesBase<dim, spacedim> &
595 get_current_neighbor_fe_values() const;
596
600 const std::vector<double> &
601 get_neighbor_JxW_values() const;
602
606 const std::vector<Tensor<1, spacedim>> &
607 get_neighbor_normal_vectors();
608
613 const std::vector<types::global_dof_index> &
614 get_neighbor_dof_indices() const;
615
620 unsigned int
621 n_neighbor_dofs_per_cell() const;
622 // NeighborCellMethods
624 // hpCellMethods
629
645 const FEFaceValues<dim, spacedim> &
646 reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
647 const typename DoFHandler<dim, spacedim>::active_cell_iterator
648 & neighbor_cell,
649 const unsigned int face_no);
650
669 const FEFaceValuesBase<dim, spacedim> &
670 reinit(const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
671 const typename DoFHandler<dim, spacedim>::active_cell_iterator
672 & neighbor_cell,
673 const unsigned int face_no,
674 const unsigned int subface_no);
675
691 const FEFaceValues<dim, spacedim> &
692 reinit_neighbor(
693 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
694 const typename DoFHandler<dim, spacedim>::active_cell_iterator
695 & neighbor_cell,
696 const unsigned int face_no);
697
716 const FEFaceValuesBase<dim, spacedim> &
717 reinit_neighbor(
718 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
719 const typename DoFHandler<dim, spacedim>::active_cell_iterator
720 & neighbor_cell,
721 const unsigned int face_no,
722 const unsigned int subface_no);
723 // hpCellMethods
725
731 GeneralDataStorage &
732 get_general_data_storage();
733
739 const GeneralDataStorage &
740 get_general_data_storage() const;
741
745 const Mapping<dim, spacedim> &
746 get_mapping() const;
747
751 const FiniteElement<dim, spacedim> &
752 get_fe() const;
753
757 const Quadrature<dim> &
758 get_cell_quadrature() const;
759
763 const Quadrature<dim - 1> &
764 get_face_quadrature() const;
765
769 const hp::MappingCollection<dim, spacedim> &
770 get_mapping_collection() const;
771
775 const hp::FECollection<dim, spacedim> &
776 get_fe_collection() const;
777
781 const hp::QCollection<dim> &
782 get_cell_quadrature_collection() const;
783
787 const hp::QCollection<dim - 1> &
788 get_face_quadrature_collection() const;
789
794 bool
795 has_hp_capabilities() const;
796
800 UpdateFlags
801 get_cell_update_flags() const;
802
806 UpdateFlags
807 get_neighbor_cell_update_flags() const;
808
812 UpdateFlags
813 get_face_update_flags() const;
814
818 UpdateFlags
819 get_neighbor_face_update_flags() const;
820 // CurrentCellEvaluation
825
855 template <typename VectorType, typename Number = double>
856 void
857 extract_local_dof_values(const std::string &global_vector_name,
858 const VectorType & input_vector,
859 const Number dummy = Number(0));
860
869 template <typename Number = double>
870 const std::vector<Number> &
871 get_local_dof_values(const std::string &global_vector_name,
872 Number dummy = Number(0)) const;
873
895 template <typename Extractor, typename Number = double>
896 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
897 template solution_value_type<Number>> &
898 get_values(const std::string &global_vector_name,
899 const Extractor & variable,
900 const Number dummy = Number(0));
901
923 template <typename Extractor, typename Number = double>
924 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
925 template solution_gradient_type<Number>> &
926 get_gradients(const std::string &global_vector_name,
927 const Extractor & variable,
928 const Number dummy = Number(0));
929
952 template <typename Extractor, typename Number = double>
953 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
954 template solution_symmetric_gradient_type<Number>> &
955 get_symmetric_gradients(const std::string &global_vector_name,
956 const Extractor & variable,
957 const Number dummy = Number(0));
958
980 template <typename Extractor, typename Number = double>
981 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
982 template solution_divergence_type<Number>> &
983 get_divergences(const std::string &global_vector_name,
984 const Extractor & variable,
985 const Number dummy = Number(0));
986
1008 template <typename Extractor, typename Number = double>
1009 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1010 template solution_curl_type<Number>> &
1011 get_curls(const std::string &global_vector_name,
1012 const Extractor & variable,
1013 const Number dummy = Number(0));
1014
1036 template <typename Extractor, typename Number = double>
1037 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1038 template solution_hessian_type<Number>> &
1039 get_hessians(const std::string &global_vector_name,
1040 const Extractor & variable,
1041 const Number dummy = Number(0));
1042
1064 template <typename Extractor, typename Number = double>
1065 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1066 template solution_laplacian_type<Number>> &
1067 get_laplacians(const std::string &global_vector_name,
1068 const Extractor & variable,
1069 const Number dummy = Number(0));
1070
1092 template <typename Extractor, typename Number = double>
1093 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1094 template solution_third_derivative_type<Number>> &
1095 get_third_derivatives(const std::string &global_vector_name,
1096 const Extractor & variable,
1097 const Number dummy = Number(0));
1098 // CurrentCellEvaluation
1100 // CurrentInterfaceJumpEvaluation
1105
1128 template <typename Extractor, typename Number = double>
1129 const std::vector<
1130 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1131 template solution_value_type<Number>> &
1132 get_jumps_in_values(const std::string &global_vector_name,
1133 const Extractor & variable,
1134 const Number dummy = Number(0));
1135
1158 template <typename Extractor, typename Number = double>
1159 const std::vector<
1160 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1161 template solution_gradient_type<Number>> &
1162 get_jumps_in_gradients(const std::string &global_vector_name,
1163 const Extractor & variable,
1164 const Number dummy = Number(0));
1165
1188 template <typename Extractor, typename Number = double>
1189 const std::vector<
1190 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1191 template solution_hessian_type<Number>> &
1192 get_jumps_in_hessians(const std::string &global_vector_name,
1193 const Extractor & variable,
1194 const Number dummy = Number(0));
1195
1218 template <typename Extractor, typename Number = double>
1219 const std::vector<
1220 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1221 template solution_third_derivative_type<Number>> &
1222 get_jumps_in_third_derivatives(const std::string &global_vector_name,
1223 const Extractor & variable,
1224 const Number dummy = Number(0));
1225 // CurrentInterfaceJumpEvaluation
1227 // CurrentInterfaceAverageEvaluation
1232
1255 template <typename Extractor, typename Number = double>
1256 const std::vector<
1257 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1258 template solution_value_type<Number>> &
1259 get_averages_of_values(const std::string &global_vector_name,
1260 const Extractor & variable,
1261 const Number dummy = Number(0));
1262
1285 template <typename Extractor, typename Number = double>
1286 const std::vector<
1287 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1288 template solution_gradient_type<Number>> &
1289 get_averages_of_gradients(const std::string &global_vector_name,
1290 const Extractor & variable,
1291 const Number dummy = Number(0));
1292
1315 template <typename Extractor, typename Number = double>
1316 const std::vector<
1317 typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1318 template solution_hessian_type<Number>> &
1319 get_averages_of_hessians(const std::string &global_vector_name,
1320 const Extractor & variable,
1321 const Number dummy = Number(0));
1322 // CurrentInterfaceAverageEvaluation
1324
1325 private:
1330 template <typename Extractor, typename Number = double>
1331 std::string
1332 get_unique_name(const std::string &global_vector_name,
1333 const Extractor & variable,
1334 const std::string &object_type,
1335 const unsigned int size,
1336 const Number & exemplar_number) const;
1337
1341 template <typename Number = double>
1342 std::string
1343 get_unique_dofs_name(const std::string &global_vector_name,
1344 const unsigned int size,
1345 const Number & exemplar_number) const;
1346 // non-hp data
1351
1356 SmartPointer<const Mapping<dim, spacedim>> mapping;
1357
1362 SmartPointer<const FiniteElement<dim, spacedim>> fe;
1363
1368 Quadrature<dim> cell_quadrature;
1369
1374 Quadrature<dim - 1> face_quadrature;
1375
1379 std::unique_ptr<FEValues<dim, spacedim>> fe_values;
1380
1384 std::unique_ptr<FEFaceValues<dim, spacedim>> fe_face_values;
1385
1389 std::unique_ptr<FESubfaceValues<dim, spacedim>> fe_subface_values;
1390
1394 std::unique_ptr<FEValues<dim, spacedim>> neighbor_fe_values;
1395
1399 std::unique_ptr<FEFaceValues<dim, spacedim>> neighbor_fe_face_values;
1400
1404 std::unique_ptr<FESubfaceValues<dim, spacedim>> neighbor_fe_subface_values;
1405
1409 std::unique_ptr<FEInterfaceValues<dim, spacedim>> interface_fe_values;
1410 // non-hp data
1412 // hp data
1417
1422 SmartPointer<const hp::MappingCollection<dim, spacedim>> mapping_collection;
1423
1428 SmartPointer<const hp::FECollection<dim, spacedim>> fe_collection;
1429
1434 hp::QCollection<dim> cell_quadrature_collection;
1435
1440 hp::QCollection<dim - 1> face_quadrature_collection;
1441
1446 bool hp_capability_enabled;
1447
1451 std::unique_ptr<hp::FEValues<dim, spacedim>> hp_fe_values;
1452
1456 std::unique_ptr<hp::FEFaceValues<dim, spacedim>> hp_fe_face_values;
1457
1461 std::unique_ptr<hp::FESubfaceValues<dim, spacedim>> hp_fe_subface_values;
1462
1466 std::unique_ptr<hp::FEValues<dim, spacedim>> neighbor_hp_fe_values;
1467
1471 std::unique_ptr<hp::FEFaceValues<dim, spacedim>> neighbor_hp_fe_face_values;
1472
1476 std::unique_ptr<hp::FESubfaceValues<dim, spacedim>>
1477 neighbor_hp_fe_subface_values;
1478
1485 DeclExceptionMsg(ExcOnlyAvailableWithoutHP,
1486 "The current function doesn't make sense when used with a "
1487 "ScratchData object with hp-capabilities.");
1488
1495 DeclExceptionMsg(ExcOnlyAvailableWithHP,
1496 "The current function doesn't make sense when used with a "
1497 "ScratchData object without hp-capabilities.");
1498 // hp data
1500
1504 UpdateFlags cell_update_flags;
1505
1509 UpdateFlags neighbor_cell_update_flags;
1510
1515 UpdateFlags face_update_flags;
1516
1521 UpdateFlags neighbor_face_update_flags;
1522
1526 std::vector<types::global_dof_index> local_dof_indices;
1527
1531 std::vector<types::global_dof_index> neighbor_dof_indices;
1532
1536 GeneralDataStorage user_data_storage;
1537
1541 GeneralDataStorage internal_data_storage;
1542
1547 SmartPointer<const FEValuesBase<dim, spacedim>> current_fe_values;
1548
1553 SmartPointer<const FEValuesBase<dim, spacedim>> current_neighbor_fe_values;
1554 };
1555
1556#ifndef DOXYGEN
1557 template <int dim, int spacedim>
1558 template <typename Extractor, typename Number>
1559 std::string
1560 ScratchData<dim, spacedim>::get_unique_name(
1561 const std::string &global_vector_name,
1562 const Extractor & variable,
1563 const std::string &object_type,
1564 const unsigned int size,
1565 const Number & exemplar_number) const
1566 {
1567 return global_vector_name + "_" + variable.get_name() + "_" + object_type +
1568 "_" + Utilities::int_to_string(size) + "_" +
1569 Utilities::type_to_string(exemplar_number);
1570 }
1571
1572
1573
1574 template <int dim, int spacedim>
1575 template <typename Number>
1576 std::string
1577 ScratchData<dim, spacedim>::get_unique_dofs_name(
1578 const std::string &global_vector_name,
1579 const unsigned int size,
1580 const Number & exemplar_number) const
1581 {
1582 return global_vector_name + "_independent_local_dofs_" +
1583 Utilities::int_to_string(size) + "_" +
1584 Utilities::type_to_string(exemplar_number);
1585 }
1586
1587
1588
1589 template <int dim, int spacedim>
1590 template <typename VectorType, typename Number>
1591 void
1592 ScratchData<dim, spacedim>::extract_local_dof_values(
1593 const std::string &global_vector_name,
1594 const VectorType & input_vector,
1595 const Number dummy)
1596 {
1597 const unsigned int n_dofs = local_dof_indices.size();
1598
1599 const std::string name =
1600 get_unique_dofs_name(global_vector_name, n_dofs, dummy);
1601
1602 auto &independent_local_dofs =
1603 internal_data_storage
1604 .template get_or_add_object_with_name<std::vector<Number>>(name,
1605 n_dofs);
1606
1607 AssertDimension(independent_local_dofs.size(), n_dofs);
1608
1609 if (Differentiation::AD::is_tapeless_ad_number<Number>::value == true)
1610 for (unsigned int i = 0; i < n_dofs; ++i)
1611 Differentiation::AD::internal::Marking<Number>::independent_variable(
1612 input_vector(local_dof_indices[i]),
1613 i,
1614 n_dofs,
1615 independent_local_dofs[i]);
1616 else
1617 for (unsigned int i = 0; i < n_dofs; ++i)
1618 independent_local_dofs[i] = input_vector(local_dof_indices[i]);
1619 }
1620
1621
1622
1623 template <int dim, int spacedim>
1624 template <typename Number>
1625 const std::vector<Number> &
1626 ScratchData<dim, spacedim>::get_local_dof_values(
1627 const std::string &global_vector_name,
1628 Number dummy) const
1629 {
1630 const unsigned int n_dofs = local_dof_indices.size();
1631
1632 const std::string dofs_name =
1633 get_unique_dofs_name(global_vector_name, n_dofs, dummy);
1634
1635 Assert(
1636 internal_data_storage.stores_object_with_name(dofs_name),
1637 ExcMessage(
1638 "You did not call yet extract_local_dof_values with the right types!"));
1639
1640 return internal_data_storage
1641 .template get_object_with_name<std::vector<Number>>(dofs_name);
1642 }
1643
1644
1645
1646 template <int dim, int spacedim>
1647 template <typename Extractor, typename Number>
1648 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1649 template solution_value_type<Number>> &
1650 ScratchData<dim, spacedim>::get_values(const std::string &global_vector_name,
1651 const Extractor & variable,
1652 const Number dummy)
1653 {
1654 const std::vector<Number> &independent_local_dofs =
1655 get_local_dof_values(global_vector_name, dummy);
1656
1657 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1658
1659 const unsigned int n_q_points = fev.n_quadrature_points;
1660
1661 const std::string name = get_unique_name(
1662 global_vector_name, variable, "_values_q", n_q_points, dummy);
1663
1664 // Now build the return type
1665 using RetType =
1666 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1667 template solution_value_type<Number>>;
1668
1669 RetType &ret =
1670 internal_data_storage.template get_or_add_object_with_name<RetType>(
1671 name, n_q_points);
1672
1673 AssertDimension(ret.size(), n_q_points);
1674
1675 fev[variable].get_function_values_from_local_dof_values(
1676 independent_local_dofs, ret);
1677 return ret;
1678 }
1679
1680
1681
1682 template <int dim, int spacedim>
1683 template <typename Extractor, typename Number>
1684 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1685 template solution_gradient_type<Number>> &
1686 ScratchData<dim, spacedim>::get_gradients(
1687 const std::string &global_vector_name,
1688 const Extractor & variable,
1689 const Number dummy)
1690 {
1691 const std::vector<Number> &independent_local_dofs =
1692 get_local_dof_values(global_vector_name, dummy);
1693
1694 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1695
1696 const unsigned int n_q_points = fev.n_quadrature_points;
1697
1698 const std::string name = get_unique_name(
1699 global_vector_name, variable, "_gradients_q", n_q_points, dummy);
1700
1701 // Now build the return type
1702 using RetType =
1703 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1704 template solution_gradient_type<Number>>;
1705
1706 RetType &ret =
1707 internal_data_storage.template get_or_add_object_with_name<RetType>(
1708 name, n_q_points);
1709
1710 AssertDimension(ret.size(), n_q_points);
1711
1712 fev[variable].get_function_gradients_from_local_dof_values(
1713 independent_local_dofs, ret);
1714 return ret;
1715 }
1716
1717
1718
1719 template <int dim, int spacedim>
1720 template <typename Extractor, typename Number>
1721 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1722 template solution_hessian_type<Number>> &
1723 ScratchData<dim, spacedim>::get_hessians(
1724 const std::string &global_vector_name,
1725 const Extractor & variable,
1726 const Number dummy)
1727 {
1728 const std::vector<Number> &independent_local_dofs =
1729 get_local_dof_values(global_vector_name, dummy);
1730
1731 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1732
1733 const unsigned int n_q_points = fev.n_quadrature_points;
1734
1735 const std::string name = get_unique_name(
1736 global_vector_name, variable, "_hessians_q", n_q_points, dummy);
1737
1738 // Now build the return type
1739 using RetType =
1740 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1741 template solution_hessian_type<Number>>;
1742
1743 RetType &ret =
1744 internal_data_storage.template get_or_add_object_with_name<RetType>(
1745 name, n_q_points);
1746
1747
1748 AssertDimension(ret.size(), n_q_points);
1749
1750 fev[variable].get_function_hessians_from_local_dof_values(
1751 independent_local_dofs, ret);
1752 return ret;
1753 }
1754
1755
1756
1757 template <int dim, int spacedim>
1758 template <typename Extractor, typename Number>
1759 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1760 template solution_laplacian_type<Number>> &
1761 ScratchData<dim, spacedim>::get_laplacians(
1762 const std::string &global_vector_name,
1763 const Extractor & variable,
1764 const Number dummy)
1765 {
1766 const std::vector<Number> &independent_local_dofs =
1767 get_local_dof_values(global_vector_name, dummy);
1768
1769 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1770
1771 const unsigned int n_q_points = fev.n_quadrature_points;
1772
1773 const std::string name = get_unique_name(
1774 global_vector_name, variable, "_laplacians_q", n_q_points, dummy);
1775
1776 // Now build the return type
1777 using RetType =
1778 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1779 template solution_laplacian_type<Number>>;
1780
1781 RetType &ret =
1782 internal_data_storage.template get_or_add_object_with_name<RetType>(
1783 name, n_q_points);
1784
1785
1786 AssertDimension(ret.size(), n_q_points);
1787
1788 fev[variable].get_function_laplacians_from_local_dof_values(
1789 independent_local_dofs, ret);
1790 return ret;
1791 }
1792
1793
1794
1795 template <int dim, int spacedim>
1796 template <typename Extractor, typename Number>
1797 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1798 template solution_third_derivative_type<Number>> &
1799 ScratchData<dim, spacedim>::get_third_derivatives(
1800 const std::string &global_vector_name,
1801 const Extractor & variable,
1802 const Number dummy)
1803 {
1804 const std::vector<Number> &independent_local_dofs =
1805 get_local_dof_values(global_vector_name, dummy);
1806
1807 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1808
1809 const unsigned int n_q_points = fev.n_quadrature_points;
1810
1811 const std::string name = get_unique_name(
1812 global_vector_name, variable, "_third_derivatives_q", n_q_points, dummy);
1813
1814 // Now build the return type
1815 using RetType =
1816 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1817 template solution_third_derivative_type<Number>>;
1818
1819 RetType &ret =
1820 internal_data_storage.template get_or_add_object_with_name<RetType>(
1821 name, n_q_points);
1822
1823
1824 AssertDimension(ret.size(), n_q_points);
1825
1826 fev[variable].get_function_third_derivatives_from_local_dof_values(
1827 independent_local_dofs, ret);
1828 return ret;
1829 }
1830
1831
1832
1833 template <int dim, int spacedim>
1834 template <typename Extractor, typename Number>
1835 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1836 template solution_symmetric_gradient_type<Number>> &
1837 ScratchData<dim, spacedim>::get_symmetric_gradients(
1838 const std::string &global_vector_name,
1839 const Extractor & variable,
1840 const Number dummy)
1841 {
1842 const std::vector<Number> &independent_local_dofs =
1843 get_local_dof_values(global_vector_name, dummy);
1844
1845 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1846
1847 const unsigned int n_q_points = fev.n_quadrature_points;
1848
1849 const std::string name = get_unique_name(
1850 global_vector_name, variable, "_symmetric_gradient_q", n_q_points, dummy);
1851
1852
1853 // Now build the return type
1854 using RetType =
1855 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1856 template solution_symmetric_gradient_type<Number>>;
1857
1858 RetType &ret =
1859 internal_data_storage.template get_or_add_object_with_name<RetType>(
1860 name, n_q_points);
1861
1862
1863 AssertDimension(ret.size(), n_q_points);
1864
1865 fev[variable].get_function_symmetric_gradients_from_local_dof_values(
1866 independent_local_dofs, ret);
1867 return ret;
1868 }
1869
1870
1871 template <int dim, int spacedim>
1872 template <typename Extractor, typename Number>
1873 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1874 template solution_divergence_type<Number>> &
1875 ScratchData<dim, spacedim>::get_divergences(
1876 const std::string &global_vector_name,
1877 const Extractor & variable,
1878 const Number dummy)
1879 {
1880 const std::vector<Number> &independent_local_dofs =
1881 get_local_dof_values(global_vector_name, dummy);
1882
1883 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1884
1885 const unsigned int n_q_points = fev.n_quadrature_points;
1886
1887 const std::string name = get_unique_name(
1888 global_vector_name, variable, "_divergence_q", n_q_points, dummy);
1889
1890 // Now build the return type
1891 using RetType =
1892 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1893 template solution_divergence_type<Number>>;
1894
1895 RetType &ret =
1896 internal_data_storage.template get_or_add_object_with_name<RetType>(
1897 name, n_q_points);
1898
1899
1900 AssertDimension(ret.size(), n_q_points);
1901
1902 fev[variable].get_function_divergences_from_local_dof_values(
1903 independent_local_dofs, ret);
1904 return ret;
1905 }
1906
1907
1908
1909 template <int dim, int spacedim>
1910 template <typename Extractor, typename Number>
1911 const std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1912 template solution_curl_type<Number>> &
1913 ScratchData<dim, spacedim>::get_curls(const std::string &global_vector_name,
1914 const Extractor & variable,
1915 const Number dummy)
1916 {
1917 const std::vector<Number> &independent_local_dofs =
1918 get_local_dof_values(global_vector_name, dummy);
1919
1920 const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1921
1922 const unsigned int n_q_points = fev.n_quadrature_points;
1923
1924 const std::string name = get_unique_name(
1925 global_vector_name, variable, "_curl_q", n_q_points, dummy);
1926
1927 // Now build the return type
1928 using RetType =
1929 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1930 template solution_curl_type<Number>>;
1931
1932 RetType &ret =
1933 internal_data_storage.template get_or_add_object_with_name<RetType>(
1934 name, n_q_points);
1935
1936 AssertDimension(ret.size(), n_q_points);
1937
1938 fev[variable].get_function_curls_from_local_dof_values(
1939 independent_local_dofs, ret);
1940 return ret;
1941 }
1942
1943
1944
1945 template <int dim, int spacedim>
1946 template <typename Extractor, typename Number>
1947 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1948 template solution_value_type<Number>> &
1949 ScratchData<dim, spacedim>::get_jumps_in_values(
1950 const std::string &global_vector_name,
1951 const Extractor & variable,
1952 const Number dummy)
1953 {
1954 const std::vector<Number> &independent_local_dofs =
1955 get_local_dof_values(global_vector_name, dummy);
1956
1957 const FEInterfaceValues<dim, spacedim> &feiv =
1958 get_current_interface_fe_values();
1959
1960 AssertDimension(independent_local_dofs.size(),
1961 feiv.n_current_interface_dofs());
1962
1963 const unsigned int n_q_points = feiv.n_quadrature_points;
1964
1965 const std::string name = get_unique_name(
1966 global_vector_name, variable, "_jump_values_q", n_q_points, dummy);
1967
1968 // Now build the return type
1969 using RetType =
1970 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
1971 template solution_value_type<Number>>;
1972
1973 RetType &ret =
1974 internal_data_storage.template get_or_add_object_with_name<RetType>(
1975 name, n_q_points);
1976
1977 AssertDimension(ret.size(), n_q_points);
1978
1979 feiv[variable].get_jump_in_function_values_from_local_dof_values(
1980 independent_local_dofs, ret);
1981 return ret;
1982 }
1983
1984
1985
1986 template <int dim, int spacedim>
1987 template <typename Extractor, typename Number>
1988 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
1989 template solution_gradient_type<Number>> &
1990 ScratchData<dim, spacedim>::get_jumps_in_gradients(
1991 const std::string &global_vector_name,
1992 const Extractor & variable,
1993 const Number dummy)
1994 {
1995 const std::vector<Number> &independent_local_dofs =
1996 get_local_dof_values(global_vector_name, dummy);
1997
1998 const FEInterfaceValues<dim, spacedim> &feiv =
1999 get_current_interface_fe_values();
2000
2001 AssertDimension(independent_local_dofs.size(),
2002 feiv.n_current_interface_dofs());
2003
2004 const unsigned int n_q_points = feiv.n_quadrature_points;
2005
2006 const std::string name = get_unique_name(
2007 global_vector_name, variable, "_jump_gradients_q", n_q_points, dummy);
2008
2009 // Now build the return type
2010 using RetType =
2011 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
2012 template solution_gradient_type<Number>>;
2013
2014 RetType &ret =
2015 internal_data_storage.template get_or_add_object_with_name<RetType>(
2016 name, n_q_points);
2017
2018 AssertDimension(ret.size(), n_q_points);
2019
2020 feiv[variable].get_jump_in_function_gradients_from_local_dof_values(
2021 independent_local_dofs, ret);
2022 return ret;
2023 }
2024
2025
2026
2027 template <int dim, int spacedim>
2028 template <typename Extractor, typename Number>
2029 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
2030 template solution_hessian_type<Number>> &
2031 ScratchData<dim, spacedim>::get_jumps_in_hessians(
2032 const std::string &global_vector_name,
2033 const Extractor & variable,
2034 const Number dummy)
2035 {
2036 const std::vector<Number> &independent_local_dofs =
2037 get_local_dof_values(global_vector_name, dummy);
2038
2039 const FEInterfaceValues<dim, spacedim> &feiv =
2040 get_current_interface_fe_values();
2041
2042 AssertDimension(independent_local_dofs.size(),
2043 feiv.n_current_interface_dofs());
2044
2045 const unsigned int n_q_points = feiv.n_quadrature_points;
2046
2047 const std::string name = get_unique_name(
2048 global_vector_name, variable, "_jump_hessians_q", n_q_points, dummy);
2049
2050 // Now build the return type
2051 using RetType =
2052 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
2053 template solution_hessian_type<Number>>;
2054
2055 RetType &ret =
2056 internal_data_storage.template get_or_add_object_with_name<RetType>(
2057 name, n_q_points);
2058
2059 AssertDimension(ret.size(), n_q_points);
2060
2061 feiv[variable].get_jump_in_function_hessians_from_local_dof_values(
2062 independent_local_dofs, ret);
2063 return ret;
2064 }
2065
2066
2067
2068 template <int dim, int spacedim>
2069 template <typename Extractor, typename Number>
2070 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
2071 template solution_third_derivative_type<Number>> &
2072 ScratchData<dim, spacedim>::get_jumps_in_third_derivatives(
2073 const std::string &global_vector_name,
2074 const Extractor & variable,
2075 const Number dummy)
2076 {
2077 const std::vector<Number> &independent_local_dofs =
2078 get_local_dof_values(global_vector_name, dummy);
2079
2080 const FEInterfaceValues<dim, spacedim> &feiv =
2081 get_current_interface_fe_values();
2082
2083 AssertDimension(independent_local_dofs.size(),
2084 feiv.n_current_interface_dofs());
2085
2086 const unsigned int n_q_points = feiv.n_quadrature_points;
2087
2088 const std::string name = get_unique_name(global_vector_name,
2089 variable,
2090 "_jump_third_derivatives_q",
2091 n_q_points,
2092 dummy);
2093
2094 // Now build the return type
2095 using RetType =
2096 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
2097 template solution_third_derivative_type<Number>>;
2098
2099 RetType &ret =
2100 internal_data_storage.template get_or_add_object_with_name<RetType>(
2101 name, n_q_points);
2102
2103 AssertDimension(ret.size(), n_q_points);
2104
2105 feiv[variable].get_jump_in_function_third_derivatives_from_local_dof_values(
2106 independent_local_dofs, ret);
2107 return ret;
2108 }
2109
2110
2111
2112 template <int dim, int spacedim>
2113 template <typename Extractor, typename Number>
2114 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
2115 template solution_value_type<Number>> &
2116 ScratchData<dim, spacedim>::get_averages_of_values(
2117 const std::string &global_vector_name,
2118 const Extractor & variable,
2119 const Number dummy)
2120 {
2121 const std::vector<Number> &independent_local_dofs =
2122 get_local_dof_values(global_vector_name, dummy);
2123
2124 const FEInterfaceValues<dim, spacedim> &feiv =
2125 get_current_interface_fe_values();
2126
2127 AssertDimension(independent_local_dofs.size(),
2128 feiv.n_current_interface_dofs());
2129
2130 const unsigned int n_q_points = feiv.n_quadrature_points;
2131
2132 const std::string name = get_unique_name(
2133 global_vector_name, variable, "_average_values_q", n_q_points, dummy);
2134
2135 // Now build the return type
2136 using RetType =
2137 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
2138 template solution_value_type<Number>>;
2139
2140 RetType &ret =
2141 internal_data_storage.template get_or_add_object_with_name<RetType>(
2142 name, n_q_points);
2143
2144 AssertDimension(ret.size(), n_q_points);
2145
2146 feiv[variable].get_average_of_function_values_from_local_dof_values(
2147 independent_local_dofs, ret);
2148 return ret;
2149 }
2150
2151
2152
2153 template <int dim, int spacedim>
2154 template <typename Extractor, typename Number>
2155 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
2156 template solution_gradient_type<Number>> &
2157 ScratchData<dim, spacedim>::get_averages_of_gradients(
2158 const std::string &global_vector_name,
2159 const Extractor & variable,
2160 const Number dummy)
2161 {
2162 const std::vector<Number> &independent_local_dofs =
2163 get_local_dof_values(global_vector_name, dummy);
2164
2165 const FEInterfaceValues<dim, spacedim> &feiv =
2166 get_current_interface_fe_values();
2167
2168 AssertDimension(independent_local_dofs.size(),
2169 feiv.n_current_interface_dofs());
2170
2171 const unsigned int n_q_points = feiv.n_quadrature_points;
2172
2173 const std::string name = get_unique_name(
2174 global_vector_name, variable, "_average_gradients_q", n_q_points, dummy);
2175
2176 // Now build the return type
2177 using RetType =
2178 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
2179 template solution_gradient_type<Number>>;
2180
2181 RetType &ret =
2182 internal_data_storage.template get_or_add_object_with_name<RetType>(
2183 name, n_q_points);
2184
2185 AssertDimension(ret.size(), n_q_points);
2186
2187 feiv[variable].get_average_of_function_gradients_from_local_dof_values(
2188 independent_local_dofs, ret);
2189 return ret;
2190 }
2191
2192
2193
2194 template <int dim, int spacedim>
2195 template <typename Extractor, typename Number>
2196 const std::vector<typename FEInterfaceViews::View<dim, spacedim, Extractor>::
2197 template solution_hessian_type<Number>> &
2198 ScratchData<dim, spacedim>::get_averages_of_hessians(
2199 const std::string &global_vector_name,
2200 const Extractor & variable,
2201 const Number dummy)
2202 {
2203 const std::vector<Number> &independent_local_dofs =
2204 get_local_dof_values(global_vector_name, dummy);
2205
2206 const FEInterfaceValues<dim, spacedim> &feiv =
2207 get_current_interface_fe_values();
2208
2209 AssertDimension(independent_local_dofs.size(),
2210 feiv.n_current_interface_dofs());
2211
2212 const unsigned int n_q_points = feiv.n_quadrature_points;
2213
2214 const std::string name = get_unique_name(
2215 global_vector_name, variable, "_average_hessians_q", n_q_points, dummy);
2216
2217 // Now build the return type
2218 using RetType =
2219 std::vector<typename FEValuesViews::View<dim, spacedim, Extractor>::
2220 template solution_hessian_type<Number>>;
2221
2222 RetType &ret =
2223 internal_data_storage.template get_or_add_object_with_name<RetType>(
2224 name, n_q_points);
2225
2226 AssertDimension(ret.size(), n_q_points);
2227
2228 feiv[variable].get_average_of_function_hessians_from_local_dof_values(
2229 independent_local_dofs, ret);
2230 return ret;
2231 }
2232
2233
2234#endif
2235
2236} // namespace MeshWorker
2237
2238DEAL_II_NAMESPACE_CLOSE
2239
2240#endif
FEInterfaceValues::n_quadrature_points
const unsigned int n_quadrature_points
Definition: fe_interface_values.h:1401
FEInterfaceValues::n_current_interface_dofs
unsigned n_current_interface_dofs() const
FEValuesBase::n_quadrature_points
const unsigned int n_quadrature_points
Definition: fe_values.h:2432
Mapping
Abstract base class for mapping classes.
Definition: mapping.h:311
MeshWorker::ScratchData::user_data_storage
GeneralDataStorage user_data_storage
Definition: scratch_data.h:1536
MeshWorker::ScratchData::face_quadrature_collection
hp::QCollection< dim - 1 > face_quadrature_collection
Definition: scratch_data.h:1440
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:913
MeshWorker::ScratchData::get_mapping_collection
const hp::MappingCollection< dim, spacedim > & get_mapping_collection() const
Definition: scratch_data.cc:871
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:694
MeshWorker::ScratchData::get_general_data_storage
GeneralDataStorage & get_general_data_storage()
Definition: scratch_data.cc:811
MeshWorker::ScratchData::get_face_quadrature
const Quadrature< dim - 1 > & get_face_quadrature() const
Definition: scratch_data.cc:861
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:766
MeshWorker::ScratchData::n_dofs_per_cell
unsigned int n_dofs_per_cell() const
Definition: scratch_data.cc:784
MeshWorker::ScratchData::hp_fe_subface_values
std::unique_ptr< hp::FESubfaceValues< dim, spacedim > > hp_fe_subface_values
Definition: scratch_data.h:1461
MeshWorker::ScratchData::n_neighbor_dofs_per_cell
unsigned int n_neighbor_dofs_per_cell() const
Definition: scratch_data.cc:802
MeshWorker::ScratchData::neighbor_fe_values
std::unique_ptr< FEValues< dim, spacedim > > neighbor_fe_values
Definition: scratch_data.h:1394
MeshWorker::ScratchData::fe_face_values
std::unique_ptr< FEFaceValues< dim, spacedim > > fe_face_values
Definition: scratch_data.h:1384
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:1379
MeshWorker::ScratchData::cell_update_flags
UpdateFlags cell_update_flags
Definition: scratch_data.h:1504
MeshWorker::ScratchData::get_JxW_values
const std::vector< double > & get_JxW_values() const
Definition: scratch_data.cc:739
MeshWorker::ScratchData::get_mapping
const Mapping< dim, spacedim > & get_mapping() const
Definition: scratch_data.cc:829
MeshWorker::ScratchData::interface_fe_values
std::unique_ptr< FEInterfaceValues< dim, spacedim > > interface_fe_values
Definition: scratch_data.h:1409
MeshWorker::ScratchData::get_neighbor_JxW_values
const std::vector< double > & get_neighbor_JxW_values() const
Definition: scratch_data.cc:748
MeshWorker::ScratchData::cell_quadrature
Quadrature< dim > cell_quadrature
Definition: scratch_data.h:1368
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::get_fe
const FiniteElement< dim, spacedim > & get_fe() const
Definition: scratch_data.cc:840
MeshWorker::ScratchData::fe_collection
SmartPointer< const hp::FECollection< dim, spacedim > > fe_collection
Definition: scratch_data.h:1428
MeshWorker::ScratchData::neighbor_fe_face_values
std::unique_ptr< FEFaceValues< dim, spacedim > > neighbor_fe_face_values
Definition: scratch_data.h:1399
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:893
MeshWorker::ScratchData::neighbor_dof_indices
std::vector< types::global_dof_index > neighbor_dof_indices
Definition: scratch_data.h:1531
MeshWorker::ScratchData::fe
SmartPointer< const FiniteElement< dim, spacedim > > fe
Definition: scratch_data.h:1362
MeshWorker::ScratchData::face_update_flags
UpdateFlags face_update_flags
Definition: scratch_data.h:1515
MeshWorker::ScratchData::get_neighbor_dof_indices
const std::vector< types::global_dof_index > & get_neighbor_dof_indices() const
Definition: scratch_data.cc:793
MeshWorker::ScratchData::get_face_update_flags
UpdateFlags get_face_update_flags() const
Definition: scratch_data.cc:940
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:1451
MeshWorker::ScratchData::mapping_collection
SmartPointer< const hp::MappingCollection< dim, spacedim > > mapping_collection
Definition: scratch_data.h:1422
MeshWorker::ScratchData::neighbor_cell_update_flags
UpdateFlags neighbor_cell_update_flags
Definition: scratch_data.h:1509
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:931
MeshWorker::ScratchData::get_fe_collection
const hp::FECollection< dim, spacedim > & get_fe_collection() const
Definition: scratch_data.cc:882
MeshWorker::ScratchData::get_normal_vectors
const std::vector< Tensor< 1, spacedim > > & get_normal_vectors() const
Definition: scratch_data.cc:757
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:479
MeshWorker::ScratchData::neighbor_hp_fe_face_values
std::unique_ptr< hp::FEFaceValues< dim, spacedim > > neighbor_hp_fe_face_values
Definition: scratch_data.h:1471
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:1526
MeshWorker::ScratchData::mapping
SmartPointer< const Mapping< dim, spacedim > > mapping
Definition: scratch_data.h:1356
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::current_fe_values
SmartPointer< const FEValuesBase< dim, spacedim > > current_fe_values
Definition: scratch_data.h:1547
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:730
MeshWorker::ScratchData::neighbor_hp_fe_values
std::unique_ptr< hp::FEValues< dim, spacedim > > neighbor_hp_fe_values
Definition: scratch_data.h:1466
MeshWorker::ScratchData::get_current_neighbor_fe_values
const FEValuesBase< dim, spacedim > & get_current_neighbor_fe_values() const
Definition: scratch_data.cc:718
MeshWorker::ScratchData::get_local_dof_indices
const std::vector< types::global_dof_index > & get_local_dof_indices() const
Definition: scratch_data.cc:775
MeshWorker::ScratchData::current_neighbor_fe_values
SmartPointer< const FEValuesBase< dim, spacedim > > current_neighbor_fe_values
Definition: scratch_data.h:1553
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:1374
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:706
MeshWorker::ScratchData::cell_quadrature_collection
hp::QCollection< dim > cell_quadrature_collection
Definition: scratch_data.h:1434
MeshWorker::ScratchData::get_cell_update_flags
UpdateFlags get_cell_update_flags() const
Definition: scratch_data.cc:922
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:1521
MeshWorker::ScratchData::get_cell_quadrature
const Quadrature< dim > & get_cell_quadrature() const
Definition: scratch_data.cc:851
MeshWorker::ScratchData::get_face_quadrature_collection
const hp::QCollection< dim - 1 > & get_face_quadrature_collection() const
Definition: scratch_data.cc:903
MeshWorker::ScratchData::neighbor_fe_subface_values
std::unique_ptr< FESubfaceValues< dim, spacedim > > neighbor_fe_subface_values
Definition: scratch_data.h:1404
MeshWorker::ScratchData::reinit
const FEValues< dim, spacedim > & reinit(const typename DoFHandler< dim, spacedim >::active_cell_iterator &cell)
Definition: scratch_data.cc:226
MeshWorker::ScratchData::neighbor_hp_fe_subface_values
std::unique_ptr< hp::FESubfaceValues< dim, spacedim > > neighbor_hp_fe_subface_values
Definition: scratch_data.h:1477
MeshWorker::ScratchData::fe_subface_values
std::unique_ptr< FESubfaceValues< dim, spacedim > > fe_subface_values
Definition: scratch_data.h:1389
MeshWorker::ScratchData::internal_data_storage
GeneralDataStorage internal_data_storage
Definition: scratch_data.h:1541
MeshWorker::ScratchData::get_neighbor_face_update_flags
UpdateFlags get_neighbor_face_update_flags() const
Definition: scratch_data.cc:949
MeshWorker::ScratchData::hp_fe_face_values
std::unique_ptr< hp::FEFaceValues< dim, spacedim > > hp_fe_face_values
Definition: scratch_data.h:1456
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:442
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:443
fe_values.h
fe_interface_values.h
UpdateFlags
UpdateFlags
Definition: fe_update_flags.h:67
update_default
@ update_default
No update.
Definition: fe_update_flags.h:69
general_data_storage.h
Assert
#define Assert(cond, exc)
Definition: exceptions.h:1473
AssertDimension
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1667
MeshWorker::ScratchData::ExcOnlyAvailableWithoutHP
static ::ExceptionBase & ExcOnlyAvailableWithoutHP()
DeclExceptionMsg
#define DeclExceptionMsg(Exception, defaulttext)
Definition: exceptions.h:487
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:438
fe_values.h
mapping_collection.h
FEInterfaceViews::View
typename ::internal::FEInterfaceViews::ViewType< dim, spacedim, Extractor >::type View
Definition: fe_interface_values.h:1365
Utilities::type_to_string
std::string type_to_string(const T &t)
Definition: utilities.h:1144
Utilities::int_to_string
std::string int_to_string(const unsigned int value, const unsigned int digits=numbers::invalid_unsigned_int)
Definition: utilities.cc:473
q_collection.h
Differentiation::AD::is_tapeless_ad_number
Definition: ad_number_traits.h:250
Generated by doxygen 1.9.5