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
fe_tools.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) 2000 - 2026 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_fe_tools_h
14#define dealii_fe_tools_h
15
16
17
18#include <deal.II/base/config.h>
19
20#include <deal.II/base/enable_observer_pointer.h>
21#include <deal.II/base/exceptions.h>
22#include <deal.II/base/geometry_info.h>
23#include <deal.II/base/symmetric_tensor.h>
24#include <deal.II/base/tensor.h>
25
26#include <deal.II/distributed/tria.h>
27
28#include <deal.II/fe/component_mask.h>
29
30#include <deal.II/lac/la_parallel_vector.h>
31
32#include <memory>
33#include <string>
34#include <vector>
35
36
37DEAL_II_NAMESPACE_OPEN
38
39// Forward declarations
40#ifndef DOXYGEN
41template <typename number>
42class FullMatrix;
43template <int dim>
44class Quadrature;
45template <int dim, int spacedim>
46class FiniteElement;
47template <int dim, int spacedim>
48DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
49class DoFHandler;
50template <int dim>
51class FiniteElementData;
52template <typename number>
53class AffineConstraints;
54#endif
55
56
75namespace FETools
76{
85 template <int dim, int spacedim = dim>
86 class FEFactoryBase : public EnableObserverPointer
87 {
88 public:
92 virtual std::unique_ptr<FiniteElement<dim, spacedim>>
93 get(const unsigned int degree) const = 0;
94
100 virtual std::unique_ptr<FiniteElement<dim, spacedim>>
101 get(const Quadrature<1> &quad) const = 0;
102
106 virtual ~FEFactoryBase() override = default;
107 };
108
118 template <class FE>
119 class FEFactory : public FEFactoryBase<FE::dimension, FE::space_dimension>
120 {
121 public:
125 virtual std::unique_ptr<FiniteElement<FE::dimension, FE::space_dimension>>
126 get(const unsigned int degree) const override;
127
132 virtual std::unique_ptr<FiniteElement<FE::dimension, FE::space_dimension>>
133 get(const Quadrature<1> &quad) const override;
134 };
135
151 template <int dim, int spacedim>
152 void
153 compute_component_wise(const FiniteElement<dim, spacedim> &fe,
154 std::vector<unsigned int> &renumbering,
155 std::vector<std::vector<unsigned int>> &start_indices);
156
172 template <int dim, int spacedim>
173 void
174 compute_block_renumbering(const FiniteElement<dim, spacedim> &fe,
175 std::vector<types::global_dof_index> &renumbering,
176 std::vector<types::global_dof_index> &block_data,
177 bool return_start_indices = true);
178
192 template <int dim, typename number, int spacedim>
193 void
194 get_interpolation_matrix(const FiniteElement<dim, spacedim> &fe1,
195 const FiniteElement<dim, spacedim> &fe2,
196 FullMatrix<number> &interpolation_matrix);
197
209 template <int dim, typename number, int spacedim>
210 void
211 get_back_interpolation_matrix(const FiniteElement<dim, spacedim> &fe1,
212 const FiniteElement<dim, spacedim> &fe2,
213 FullMatrix<number> &interpolation_matrix);
214
226 template <int dim, typename number, int spacedim>
227 void
228 get_interpolation_difference_matrix(const FiniteElement<dim, spacedim> &fe1,
229 const FiniteElement<dim, spacedim> &fe2,
230 FullMatrix<number> &difference_matrix);
231
235 template <int dim, typename number, int spacedim>
236 void
237 get_projection_matrix(const FiniteElement<dim, spacedim> &fe1,
238 const FiniteElement<dim, spacedim> &fe2,
239 FullMatrix<number> &matrix);
240
309 template <int dim, int spacedim>
310 FullMatrix<double>
311 compute_node_matrix(const FiniteElement<dim, spacedim> &fe);
312
351 template <int dim, typename number, int spacedim>
352 void
353 compute_embedding_matrices(
354 const FiniteElement<dim, spacedim> &fe,
355 std::vector<std::vector<FullMatrix<number>>> &matrices,
356 const bool isotropic_only = false,
357 const double threshold = 1.e-12);
358
380 template <int dim, typename number, int spacedim>
381 void
382 compute_face_embedding_matrices(const FiniteElement<dim, spacedim> &fe,
383 const ArrayView<FullMatrix<number>> &matrices,
384 const unsigned int face_coarse,
385 const unsigned int face_fine,
386 const double threshold = 1.e-12);
387
419 template <int dim, typename number, int spacedim>
420 void
421 compute_projection_matrices(
422 const FiniteElement<dim, spacedim> &fe,
423 std::vector<std::vector<FullMatrix<number>>> &matrices,
424 const bool isotropic_only = false);
425
511 template <int dim, int spacedim>
512 void
513 compute_projection_from_quadrature_points_matrix(
514 const FiniteElement<dim, spacedim> &fe,
515 const Quadrature<dim> &lhs_quadrature,
516 const Quadrature<dim> &rhs_quadrature,
517 FullMatrix<double> &X);
518
526 template <int dim, int spacedim>
527 void
528 compute_interpolation_to_quadrature_points_matrix(
529 const FiniteElement<dim, spacedim> &fe,
530 const Quadrature<dim> &quadrature,
531 FullMatrix<double> &I_q);
532
546 template <int dim>
547 void
548 compute_projection_from_quadrature_points(
549 const FullMatrix<double> &projection_matrix,
550 const std::vector<Tensor<1, dim>> &vector_of_tensors_at_qp,
551 std::vector<Tensor<1, dim>> &vector_of_tensors_at_nodes);
552
553
554
558 template <int dim>
559 void
560 compute_projection_from_quadrature_points(
561 const FullMatrix<double> &projection_matrix,
562 const std::vector<SymmetricTensor<2, dim>> &vector_of_tensors_at_qp,
563 std::vector<SymmetricTensor<2, dim>> &vector_of_tensors_at_nodes);
564
565
566
576 template <int dim, int spacedim>
577 void
578 compute_projection_from_face_quadrature_points_matrix(
579 const FiniteElement<dim, spacedim> &fe,
580 const Quadrature<dim - 1> &lhs_quadrature,
581 const Quadrature<dim - 1> &rhs_quadrature,
582 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
583 const unsigned int face,
584 FullMatrix<double> &X);
585
618 template <int dim, int spacedim = dim>
619 Quadrature<dim>
620 compute_nodal_quadrature(const FiniteElement<dim, spacedim> &fe);
621
637 template <int dim, int spacedim, typename number>
638 void
639 convert_generalized_support_point_values_to_dof_values(
640 const FiniteElement<dim, spacedim> &finite_element,
641 const std::vector<Vector<number>> &support_point_values,
642 std::vector<number> &dof_values);
643
644
645
683 template <int dim, int spacedim, class InVector, class OutVector>
684 void
685 interpolate(const DoFHandler<dim, spacedim> &dof1,
686 const InVector &u1,
687 const DoFHandler<dim, spacedim> &dof2,
688 OutVector &u2);
689
709 template <int dim, int spacedim, class InVector, class OutVector>
710 void
711 interpolate(
712 const DoFHandler<dim, spacedim> &dof1,
713 const InVector &u1,
714 const DoFHandler<dim, spacedim> &dof2,
715 const AffineConstraints<typename OutVector::value_type> &constraints,
716 OutVector &u2);
717
731 template <int dim, class InVector, class OutVector, int spacedim>
732 void
733 back_interpolate(const DoFHandler<dim, spacedim> &dof1,
734 const InVector &u1,
735 const FiniteElement<dim, spacedim> &fe2,
736 OutVector &u1_interpolated);
737
750 template <int dim, class InVector, class OutVector, int spacedim>
751 void
752 back_interpolate(
753 const DoFHandler<dim, spacedim> &dof1,
754 const AffineConstraints<typename OutVector::value_type> &constraints1,
755 const InVector &u1,
756 const DoFHandler<dim, spacedim> &dof2,
757 const AffineConstraints<typename OutVector::value_type> &constraints2,
758 OutVector &u1_interpolated);
759
769 template <int dim, class InVector, class OutVector, int spacedim>
770 void
771 interpolation_difference(const DoFHandler<dim, spacedim> &dof1,
772 const InVector &z1,
773 const FiniteElement<dim, spacedim> &fe2,
774 OutVector &z1_difference);
775
788 template <int dim, class InVector, class OutVector, int spacedim>
789 void
790 interpolation_difference(
791 const DoFHandler<dim, spacedim> &dof1,
792 const AffineConstraints<typename OutVector::value_type> &constraints1,
793 const InVector &z1,
794 const DoFHandler<dim, spacedim> &dof2,
795 const AffineConstraints<typename OutVector::value_type> &constraints2,
796 OutVector &z1_difference);
797
798
799
808 template <int dim, class InVector, class OutVector, int spacedim>
809 void
810 project_dg(const DoFHandler<dim, spacedim> &dof1,
811 const InVector &u1,
812 const DoFHandler<dim, spacedim> &dof2,
813 OutVector &u2);
814
871 template <int dim, class InVector, class OutVector, int spacedim>
872 void
873 extrapolate(const DoFHandler<dim, spacedim> &dof1,
874 const InVector &z1,
875 const DoFHandler<dim, spacedim> &dof2,
876 OutVector &z2);
877
890 template <int dim, class InVector, class OutVector, int spacedim>
891 void
892 extrapolate(
893 const DoFHandler<dim, spacedim> &dof1,
894 const InVector &z1,
895 const DoFHandler<dim, spacedim> &dof2,
896 const AffineConstraints<typename OutVector::value_type> &constraints,
897 OutVector &z2);
898
914 template <int dim>
915 std::vector<unsigned int>
916 hierarchic_to_lexicographic_numbering(unsigned int degree);
917
924 template <int dim>
925 std::vector<unsigned int>
926 lexicographic_to_hierarchic_numbering(unsigned int degree);
927
949 template <int dim>
950 std::pair<std::vector<unsigned int>, std::vector<unsigned int>>
951 cell_to_face_patch_numbering(const unsigned int &degree,
952 const unsigned int &direction,
953 const bool &cell_hierarchical_numbering,
954 const bool &is_continuous);
955
956
962 template <int dim>
963 DEAL_II_DEPRECATED_WITH_COMMENT(
964 "Use FETools::cell_to_face_patch_numbering() instead.")
965 std::pair<
966 std::vector<unsigned int>,
967 std::vector<unsigned int>> cell_to_face_patch(const unsigned int &degree,
968 const unsigned int &direction,
969 const bool &
970 cell_hierarchical_numbering,
971 const bool &is_continuous);
972
984 template <int dim, int spacedim>
985 unsigned int
986 face_to_cell_index(const FiniteElement<dim, spacedim> &fe,
987 const unsigned int face_dof_index,
988 const unsigned int face_no,
989 const types::geometric_orientation combined_orientation);
990
1066 namespace Compositing
1067 {
1084 template <int dim, int spacedim>
1085 FiniteElementData<dim>
1086 multiply_dof_numbers(
1087 const std::vector<const FiniteElement<dim, spacedim> *> &fes,
1088 const std::vector<unsigned int> &multiplicities,
1089 const bool do_tensor_product = true);
1090
1096 template <int dim, int spacedim>
1097 FiniteElementData<dim>
1098 multiply_dof_numbers(
1099 const std::initializer_list<
1100 std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1101 &fe_systems);
1102
1109 template <int dim, int spacedim>
1110 DEAL_II_DEPRECATED FiniteElementData<dim>
1111 multiply_dof_numbers(const FiniteElement<dim, spacedim> *fe1,
1112 const unsigned int N1,
1113 const FiniteElement<dim, spacedim> *fe2 = nullptr,
1114 const unsigned int N2 = 0,
1115 const FiniteElement<dim, spacedim> *fe3 = nullptr,
1116 const unsigned int N3 = 0,
1117 const FiniteElement<dim, spacedim> *fe4 = nullptr,
1118 const unsigned int N4 = 0,
1119 const FiniteElement<dim, spacedim> *fe5 = nullptr,
1120 const unsigned int N5 = 0);
1121
1134 template <int dim, int spacedim>
1135 std::vector<bool>
1136 compute_restriction_is_additive_flags(
1137 const std::vector<const FiniteElement<dim, spacedim> *> &fes,
1138 const std::vector<unsigned int> &multiplicities);
1139
1145 template <int dim, int spacedim>
1146 std::vector<bool>
1147 compute_restriction_is_additive_flags(
1148 const std::initializer_list<
1149 std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1150 &fe_systems);
1151
1169 template <int dim, int spacedim>
1170 DEAL_II_DEPRECATED std::vector<bool>
1171 compute_restriction_is_additive_flags(
1172 const FiniteElement<dim, spacedim> *fe1,
1173 const unsigned int N1,
1174 const FiniteElement<dim, spacedim> *fe2 = nullptr,
1175 const unsigned int N2 = 0,
1176 const FiniteElement<dim, spacedim> *fe3 = nullptr,
1177 const unsigned int N3 = 0,
1178 const FiniteElement<dim, spacedim> *fe4 = nullptr,
1179 const unsigned int N4 = 0,
1180 const FiniteElement<dim, spacedim> *fe5 = nullptr,
1181 const unsigned int N5 = 0);
1182
1183
1200 template <int dim, int spacedim>
1201 std::vector<ComponentMask>
1202 compute_nonzero_components(
1203 const std::vector<const FiniteElement<dim, spacedim> *> &fes,
1204 const std::vector<unsigned int> &multiplicities,
1205 const bool do_tensor_product = true);
1206
1212 template <int dim, int spacedim>
1213 std::vector<ComponentMask>
1214 compute_nonzero_components(
1215 const std::initializer_list<
1216 std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1217 &fe_systems);
1218
1240 template <int dim, int spacedim>
1241 DEAL_II_DEPRECATED std::vector<ComponentMask>
1242 compute_nonzero_components(
1243 const FiniteElement<dim, spacedim> *fe1,
1244 const unsigned int N1,
1245 const FiniteElement<dim, spacedim> *fe2 = nullptr,
1246 const unsigned int N2 = 0,
1247 const FiniteElement<dim, spacedim> *fe3 = nullptr,
1248 const unsigned int N3 = 0,
1249 const FiniteElement<dim, spacedim> *fe4 = nullptr,
1250 const unsigned int N4 = 0,
1251 const FiniteElement<dim, spacedim> *fe5 = nullptr,
1252 const unsigned int N5 = 0,
1253 const bool do_tensor_product = true);
1254
1271 template <int dim, int spacedim>
1272 void
1273 build_cell_tables(
1274 std::vector<std::pair<std::pair<unsigned int, unsigned int>,
1275 unsigned int>> &system_to_base_table,
1276 std::vector<std::pair<unsigned int, unsigned int>>
1277 &system_to_component_table,
1278 std::vector<std::pair<std::pair<unsigned int, unsigned int>,
1279 unsigned int>> &component_to_base_table,
1280 const FiniteElement<dim, spacedim> &finite_element,
1281 const bool do_tensor_product = true);
1282
1298 template <int dim, int spacedim>
1299 void
1300 build_face_tables(
1301 std::vector<std::pair<std::pair<unsigned int, unsigned int>,
1302 unsigned int>> &face_system_to_base_table,
1303 std::vector<std::pair<unsigned int, unsigned int>>
1304 &face_system_to_component_table,
1305 const FiniteElement<dim, spacedim> &finite_element,
1306 const bool do_tensor_product = true,
1307 const unsigned int face_no = 0 /*TODO*/);
1308
1309 } // namespace Compositing
1310
1311
1345 template <int dim, int spacedim = dim>
1346 std::unique_ptr<FiniteElement<dim, spacedim>>
1347 get_fe_by_name(const std::string &name);
1348
1391 template <int dim, int spacedim>
1392 void
1393 add_fe_name(const std::string &name,
1394 const FEFactoryBase<dim, spacedim> *factory);
1395
1405 DeclException1(ExcInvalidFEName,
1406 std::string,
1407 << "Can't re-generate a finite element from the string '"
1408 << arg1 << "'.");
1409
1421 DeclException2(ExcInvalidFEDimension,
1422 char,
1423 int,
1424 << "The dimension " << arg1
1425 << " in the finite element string must match "
1426 << "the space dimension " << arg2 << '.');
1427
1433 DeclException0(ExcInvalidFE);
1434
1441 DeclException0(ExcFENotPrimitive);
1447 DeclException0(ExcTriangulationMismatch);
1448
1455 DeclExceptionMsg(ExcHangingNodesNotAllowed,
1456 "You are using continuous elements on a grid with "
1457 "hanging nodes but without providing hanging node "
1458 "constraints. Use the respective function with "
1459 "additional AffineConstraints argument(s), instead.");
1465 DeclException0(ExcGridNotRefinedAtLeastOnce);
1471 DeclException4(ExcMatrixDimensionMismatch,
1472 int,
1473 int,
1474 int,
1475 int,
1476 << "This is a " << arg1 << 'x' << arg2 << " matrix, "
1477 << "but should be a " << arg3 << 'x' << arg4 << " matrix.");
1478
1484 DeclException1(ExcLeastSquaresError,
1485 double,
1486 << "Least squares fit leaves a gap of " << arg1);
1487
1493 DeclException2(ExcNotGreaterThan,
1494 int,
1495 int,
1496 << arg1 << " must be greater than " << arg2);
1497} // namespace FETools
1498
1499
1500#ifndef DOXYGEN
1501
1502namespace FETools
1503{
1504 template <class FE>
1505 std::unique_ptr<FiniteElement<FE::dimension, FE::space_dimension>>
1506 FEFactory<FE>::get(const unsigned int degree) const
1507 {
1508 return std::make_unique<FE>(degree);
1509 }
1510
1511 namespace Compositing
1512 {
1513 template <int dim, int spacedim>
1514 std::vector<bool>
1515 compute_restriction_is_additive_flags(
1516 const std::initializer_list<
1517 std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1518 &fe_systems)
1519 {
1520 std::vector<const FiniteElement<dim, spacedim> *> fes;
1521 std::vector<unsigned int> multiplicities;
1522
1523 const auto extract =
1524 [&fes, &multiplicities](
1525 const std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>,
1526 unsigned int> &fe_system) {
1527 fes.push_back(fe_system.first.get());
1528 multiplicities.push_back(fe_system.second);
1529 };
1530
1531 for (const auto &p : fe_systems)
1532 extract(p);
1533
1534 return compute_restriction_is_additive_flags(fes, multiplicities);
1535 }
1536
1537
1538
1539 template <int dim, int spacedim>
1540 FiniteElementData<dim>
1541 multiply_dof_numbers(
1542 const std::initializer_list<
1543 std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1544 &fe_systems)
1545 {
1546 std::vector<const FiniteElement<dim, spacedim> *> fes;
1547 std::vector<unsigned int> multiplicities;
1548
1549 const auto extract =
1550 [&fes, &multiplicities](
1551 const std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>,
1552 unsigned int> &fe_system) {
1553 fes.push_back(fe_system.first.get());
1554 multiplicities.push_back(fe_system.second);
1555 };
1556
1557 for (const auto &p : fe_systems)
1558 extract(p);
1559
1560 return multiply_dof_numbers(fes, multiplicities, true);
1561 }
1562
1563
1564
1565 template <int dim, int spacedim>
1566 std::vector<ComponentMask>
1567 compute_nonzero_components(
1568 const std::initializer_list<
1569 std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1570 &fe_systems)
1571 {
1572 std::vector<const FiniteElement<dim, spacedim> *> fes;
1573 std::vector<unsigned int> multiplicities;
1574
1575 const auto extract =
1576 [&fes, &multiplicities](
1577 const std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>,
1578 unsigned int> &fe_system) {
1579 fes.push_back(fe_system.first.get());
1580 multiplicities.push_back(fe_system.second);
1581 };
1582
1583 for (const auto &p : fe_systems)
1584 extract(p);
1585
1586 return compute_nonzero_components(fes, multiplicities, true);
1587 }
1588 } // namespace Compositing
1589} // namespace FETools
1590
1591#endif
1592
1595DEAL_II_NAMESPACE_CLOSE
1596
1597#endif /* dealii_fe_tools_h */
FETools::FEFactoryBase::~FEFactoryBase
virtual ~FEFactoryBase() override=default
FETools::FEFactoryBase::get
virtual std::unique_ptr< FiniteElement< dim, spacedim > > get(const Quadrature< 1 > &quad) const =0
FETools::FEFactoryBase::get
virtual std::unique_ptr< FiniteElement< dim, spacedim > > get(const unsigned int degree) const =0
FETools::FEFactory::get
virtual std::unique_ptr< FiniteElement< FE::dimension, FE::space_dimension > > get(const Quadrature< 1 > &quad) const override
FETools::FEFactory::get
virtual std::unique_ptr< FiniteElement< FE::dimension, FE::space_dimension > > get(const unsigned int degree) const override
component_mask.h
concepts::is_valid_dim_spacedim
Definition template_constraints.h:712
DEAL_II_DEPRECATED
#define DEAL_II_DEPRECATED
Definition config.h:294
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:38
DEAL_II_DEPRECATED_WITH_COMMENT
#define DEAL_II_DEPRECATED_WITH_COMMENT(comment)
Definition config.h:295
DEAL_II_CXX20_REQUIRES
#define DEAL_II_CXX20_REQUIRES(condition)
Definition config.h:249
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:39
enable_observer_pointer.h
geometry_info.h
DeclException0
#define DeclException0(Exception0)
Definition exception_macros.h:323
FETools::ExcTriangulationMismatch
static ::ExceptionBase & ExcTriangulationMismatch()
FETools::ExcInvalidFEName
static ::ExceptionBase & ExcInvalidFEName(std::string arg1)
DeclException4
#define DeclException4(Exception4, type1, type2, type3, type4, outsequence)
Definition exception_macros.h:437
FETools::ExcInvalidFEDimension
static ::ExceptionBase & ExcInvalidFEDimension(char arg1, int arg2)
FETools::ExcLeastSquaresError
static ::ExceptionBase & ExcLeastSquaresError(double arg1)
DeclException2
#define DeclException2(Exception2, type1, type2, outsequence)
Definition exception_macros.h:391
FETools::ExcFENotPrimitive
static ::ExceptionBase & ExcFENotPrimitive()
FETools::ExcHangingNodesNotAllowed
static ::ExceptionBase & ExcHangingNodesNotAllowed()
DeclExceptionMsg
#define DeclExceptionMsg(Exception, defaulttext)
Definition exception_macros.h:346
FETools::ExcInvalidFE
static ::ExceptionBase & ExcInvalidFE()
FETools::ExcGridNotRefinedAtLeastOnce
static ::ExceptionBase & ExcGridNotRefinedAtLeastOnce()
FETools::ExcMatrixDimensionMismatch
static ::ExceptionBase & ExcMatrixDimensionMismatch(int arg1, int arg2, int arg3, int arg4)
DeclException1
#define DeclException1(Exception1, type1, outsequence)
Definition exception_macros.h:368
FETools::ExcNotGreaterThan
static ::ExceptionBase & ExcNotGreaterThan(int arg1, int arg2)
DoFHandler::active_cell_iterator
typename ActiveSelector::active_cell_iterator active_cell_iterator
Definition dof_handler.h:447
la_parallel_vector.h
FETools::Compositing::build_face_tables
void build_face_tables(std::vector< std::pair< std::pair< unsigned int, unsigned int >, unsigned int > > &face_system_to_base_table, std::vector< std::pair< unsigned int, unsigned int > > &face_system_to_component_table, const FiniteElement< dim, spacedim > &finite_element, const bool do_tensor_product=true, const unsigned int face_no=0)
FETools::Compositing::compute_nonzero_components
std::vector< ComponentMask > compute_nonzero_components(const std::vector< const FiniteElement< dim, spacedim > * > &fes, const std::vector< unsigned int > &multiplicities, const bool do_tensor_product=true)
FETools::Compositing::compute_restriction_is_additive_flags
std::vector< bool > compute_restriction_is_additive_flags(const std::vector< const FiniteElement< dim, spacedim > * > &fes, const std::vector< unsigned int > &multiplicities)
FETools::Compositing::build_cell_tables
void build_cell_tables(std::vector< std::pair< std::pair< unsigned int, unsigned int >, unsigned int > > &system_to_base_table, std::vector< std::pair< unsigned int, unsigned int > > &system_to_component_table, std::vector< std::pair< std::pair< unsigned int, unsigned int >, unsigned int > > &component_to_base_table, const FiniteElement< dim, spacedim > &finite_element, const bool do_tensor_product=true)
FETools::Compositing::multiply_dof_numbers
FiniteElementData< dim > multiply_dof_numbers(const std::vector< const FiniteElement< dim, spacedim > * > &fes, const std::vector< unsigned int > &multiplicities, const bool do_tensor_product=true)
FETools::interpolation_difference
void interpolation_difference(const DoFHandler< dim, spacedim > &dof1, const InVector &z1, const FiniteElement< dim, spacedim > &fe2, OutVector &z1_difference)
FETools::compute_projection_from_quadrature_points
void compute_projection_from_quadrature_points(const FullMatrix< double > &projection_matrix, const std::vector< Tensor< 1, dim > > &vector_of_tensors_at_qp, std::vector< Tensor< 1, dim > > &vector_of_tensors_at_nodes)
FETools::project_dg
void project_dg(const DoFHandler< dim, spacedim > &dof1, const InVector &u1, const DoFHandler< dim, spacedim > &dof2, OutVector &u2)
FETools::get_back_interpolation_matrix
void get_back_interpolation_matrix(const FiniteElement< dim, spacedim > &fe1, const FiniteElement< dim, spacedim > &fe2, FullMatrix< number > &interpolation_matrix)
FETools::get_projection_matrix
void get_projection_matrix(const FiniteElement< dim, spacedim > &fe1, const FiniteElement< dim, spacedim > &fe2, FullMatrix< number > &matrix)
FETools::compute_component_wise
void compute_component_wise(const FiniteElement< dim, spacedim > &fe, std::vector< unsigned int > &renumbering, std::vector< std::vector< unsigned int > > &start_indices)
FETools::cell_to_face_patch_numbering
std::pair< std::vector< unsigned int >, std::vector< unsigned int > > cell_to_face_patch_numbering(const unsigned int &degree, const unsigned int &direction, const bool &cell_hierarchical_numbering, const bool &is_continuous)
FETools::add_fe_name
void add_fe_name(const std::string &name, const FEFactoryBase< dim, spacedim > *factory)
FETools::hierarchic_to_lexicographic_numbering
std::vector< unsigned int > hierarchic_to_lexicographic_numbering(unsigned int degree)
FETools::face_to_cell_index
unsigned int face_to_cell_index(const FiniteElement< dim, spacedim > &fe, const unsigned int face_dof_index, const unsigned int face_no, const types::geometric_orientation combined_orientation)
FETools::convert_generalized_support_point_values_to_dof_values
void convert_generalized_support_point_values_to_dof_values(const FiniteElement< dim, spacedim > &finite_element, const std::vector< Vector< number > > &support_point_values, std::vector< number > &dof_values)
FETools::compute_interpolation_to_quadrature_points_matrix
void compute_interpolation_to_quadrature_points_matrix(const FiniteElement< dim, spacedim > &fe, const Quadrature< dim > &quadrature, FullMatrix< double > &I_q)
FETools::compute_nodal_quadrature
Quadrature< dim > compute_nodal_quadrature(const FiniteElement< dim, spacedim > &fe)
Compute the nodal quadrature rule associated with an element.
FETools::get_fe_by_name
std::unique_ptr< FiniteElement< dim, spacedim > > get_fe_by_name(const std::string &name)
FETools::compute_projection_from_quadrature_points_matrix
void compute_projection_from_quadrature_points_matrix(const FiniteElement< dim, spacedim > &fe, const Quadrature< dim > &lhs_quadrature, const Quadrature< dim > &rhs_quadrature, FullMatrix< double > &X)
FETools::get_interpolation_matrix
void get_interpolation_matrix(const FiniteElement< dim, spacedim > &fe1, const FiniteElement< dim, spacedim > &fe2, FullMatrix< number > &interpolation_matrix)
FETools::extrapolate
void extrapolate(const DoFHandler< dim, spacedim > &dof1, const InVector &z1, const DoFHandler< dim, spacedim > &dof2, OutVector &z2)
FETools::compute_embedding_matrices
void compute_embedding_matrices(const FiniteElement< dim, spacedim > &fe, std::vector< std::vector< FullMatrix< number > > > &matrices, const bool isotropic_only=false, const double threshold=1.e-12)
FETools::compute_face_embedding_matrices
void compute_face_embedding_matrices(const FiniteElement< dim, spacedim > &fe, const ArrayView< FullMatrix< number > > &matrices, const unsigned int face_coarse, const unsigned int face_fine, const double threshold=1.e-12)
FETools::interpolate
void interpolate(const DoFHandler< dim, spacedim > &dof1, const InVector &u1, const DoFHandler< dim, spacedim > &dof2, OutVector &u2)
FETools::compute_block_renumbering
void compute_block_renumbering(const FiniteElement< dim, spacedim > &fe, std::vector< types::global_dof_index > &renumbering, std::vector< types::global_dof_index > &block_data, bool return_start_indices=true)
FETools::lexicographic_to_hierarchic_numbering
std::vector< unsigned int > lexicographic_to_hierarchic_numbering(unsigned int degree)
FETools::compute_projection_from_face_quadrature_points_matrix
void compute_projection_from_face_quadrature_points_matrix(const FiniteElement< dim, spacedim > &fe, const Quadrature< dim - 1 > &lhs_quadrature, const Quadrature< dim - 1 > &rhs_quadrature, const typename DoFHandler< dim, spacedim >::active_cell_iterator &cell, const unsigned int face, FullMatrix< double > &X)
FETools::compute_node_matrix
FullMatrix< double > compute_node_matrix(const FiniteElement< dim, spacedim > &fe)
FETools::get_interpolation_difference_matrix
void get_interpolation_difference_matrix(const FiniteElement< dim, spacedim > &fe1, const FiniteElement< dim, spacedim > &fe2, FullMatrix< number > &difference_matrix)
FETools::back_interpolate
void back_interpolate(const DoFHandler< dim, spacedim > &dof1, const InVector &u1, const FiniteElement< dim, spacedim > &fe2, OutVector &u1_interpolated)
FETools::compute_projection_matrices
void compute_projection_matrices(const FiniteElement< dim, spacedim > &fe, std::vector< std::vector< FullMatrix< number > > > &matrices, const bool isotropic_only=false)
FETools::cell_to_face_patch
std::pair< std::vector< unsigned int >, std::vector< unsigned int > > cell_to_face_patch(const unsigned int &degree, const unsigned int &direction, const bool &cell_hierarchical_numbering, const bool &is_continuous)
TensorAccessors::extract
constexpr ReturnType< rank, T >::value_type & extract(T &t, const ArrayType &indices)
Definition tensor_accessors.h:219
std
STL namespace.
types
Definition types.h:30
symmetric_tensor.h
Generated by doxygen 1.9.8