Reference documentation for deal.II version 9.5.0
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Loading...
Searching...
No Matches
fe_tools.h
Go to the documentation of this file.
1// ---------------------------------------------------------------------
2//
3// Copyright (C) 2000 - 2023 by the deal.II authors
4//
5// This file is part of the deal.II library.
6//
7// The deal.II library is free software; you can use it, redistribute
8// it, and/or modify it under the terms of the GNU Lesser General
9// Public License as published by the Free Software Foundation; either
10// version 2.1 of the License, or (at your option) any later version.
11// The full text of the license can be found in the file LICENSE.md at
12// the top level directory of deal.II.
13//
14// ---------------------------------------------------------------------
15
16#ifndef dealii_fe_tools_H
17#define dealii_fe_tools_H
18
19
20
21#include <deal.II/base/config.h>
22
23#include <deal.II/base/exceptions.h>
24#include <deal.II/base/geometry_info.h>
25#include <deal.II/base/subscriptor.h>
26#include <deal.II/base/symmetric_tensor.h>
27#include <deal.II/base/tensor.h>
28
29#include <deal.II/distributed/tria.h>
30
31#include <deal.II/fe/component_mask.h>
32
33#include <deal.II/lac/la_parallel_vector.h>
34
35#include <memory>
36#include <string>
37#include <vector>
38
39
40DEAL_II_NAMESPACE_OPEN
41
42// Forward declarations
43#ifndef DOXYGEN
44template <typename number>
45class FullMatrix;
46template <int dim>
47class Quadrature;
48template <int dim, int spacedim>
49class FiniteElement;
50template <int dim, int spacedim>
51DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
52class DoFHandler;
53template <int dim>
54class FiniteElementData;
55template <typename number>
56class AffineConstraints;
57#endif
58
59
78namespace FETools
79{
88 template <int dim, int spacedim = dim>
89 class FEFactoryBase : public Subscriptor
90 {
91 public:
95 virtual std::unique_ptr<FiniteElement<dim, spacedim>>
96 get(const unsigned int degree) const = 0;
97
103 virtual std::unique_ptr<FiniteElement<dim, spacedim>>
104 get(const Quadrature<1> &quad) const = 0;
105
109 virtual ~FEFactoryBase() override = default;
110 };
111
121 template <class FE>
122 class FEFactory : public FEFactoryBase<FE::dimension, FE::space_dimension>
123 {
124 public:
128 virtual std::unique_ptr<FiniteElement<FE::dimension, FE::space_dimension>>
129 get(const unsigned int degree) const override;
130
135 virtual std::unique_ptr<FiniteElement<FE::dimension, FE::space_dimension>>
136 get(const Quadrature<1> &quad) const override;
137 };
138
154 template <int dim, int spacedim>
155 void
156 compute_component_wise(const FiniteElement<dim, spacedim> & fe,
157 std::vector<unsigned int> & renumbering,
158 std::vector<std::vector<unsigned int>> &start_indices);
159
175 template <int dim, int spacedim>
176 void
177 compute_block_renumbering(const FiniteElement<dim, spacedim> & fe,
178 std::vector<types::global_dof_index> &renumbering,
179 std::vector<types::global_dof_index> &block_data,
180 bool return_start_indices = true);
181
195 template <int dim, typename number, int spacedim>
196 void
197 get_interpolation_matrix(const FiniteElement<dim, spacedim> &fe1,
198 const FiniteElement<dim, spacedim> &fe2,
199 FullMatrix<number> &interpolation_matrix);
200
212 template <int dim, typename number, int spacedim>
213 void
214 get_back_interpolation_matrix(const FiniteElement<dim, spacedim> &fe1,
215 const FiniteElement<dim, spacedim> &fe2,
216 FullMatrix<number> &interpolation_matrix);
217
229 template <int dim, typename number, int spacedim>
230 void
231 get_interpolation_difference_matrix(const FiniteElement<dim, spacedim> &fe1,
232 const FiniteElement<dim, spacedim> &fe2,
233 FullMatrix<number> &difference_matrix);
234
238 template <int dim, typename number, int spacedim>
239 void
240 get_projection_matrix(const FiniteElement<dim, spacedim> &fe1,
241 const FiniteElement<dim, spacedim> &fe2,
242 FullMatrix<number> & matrix);
243
312 template <int dim, int spacedim>
313 FullMatrix<double>
314 compute_node_matrix(const FiniteElement<dim, spacedim> &fe);
315
354 template <int dim, typename number, int spacedim>
355 void
356 compute_embedding_matrices(
357 const FiniteElement<dim, spacedim> & fe,
358 std::vector<std::vector<FullMatrix<number>>> &matrices,
359 const bool isotropic_only = false,
360 const double threshold = 1.e-12);
361
383 template <int dim, typename number, int spacedim>
384 void
385 compute_face_embedding_matrices(
386 const FiniteElement<dim, spacedim> &fe,
387 FullMatrix<number> (&matrices)[GeometryInfo<dim>::max_children_per_face],
388 const unsigned int face_coarse,
389 const unsigned int face_fine,
390 const double threshold = 1.e-12);
391
423 template <int dim, typename number, int spacedim>
424 void
425 compute_projection_matrices(
426 const FiniteElement<dim, spacedim> & fe,
427 std::vector<std::vector<FullMatrix<number>>> &matrices,
428 const bool isotropic_only = false);
429
515 template <int dim, int spacedim>
516 void
517 compute_projection_from_quadrature_points_matrix(
518 const FiniteElement<dim, spacedim> &fe,
519 const Quadrature<dim> & lhs_quadrature,
520 const Quadrature<dim> & rhs_quadrature,
521 FullMatrix<double> & X);
522
530 template <int dim, int spacedim>
531 void
532 compute_interpolation_to_quadrature_points_matrix(
533 const FiniteElement<dim, spacedim> &fe,
534 const Quadrature<dim> & quadrature,
535 FullMatrix<double> & I_q);
536
550 template <int dim>
551 void
552 compute_projection_from_quadrature_points(
553 const FullMatrix<double> & projection_matrix,
554 const std::vector<Tensor<1, dim>> &vector_of_tensors_at_qp,
555 std::vector<Tensor<1, dim>> & vector_of_tensors_at_nodes);
556
557
558
562 template <int dim>
563 void
564 compute_projection_from_quadrature_points(
565 const FullMatrix<double> & projection_matrix,
566 const std::vector<SymmetricTensor<2, dim>> &vector_of_tensors_at_qp,
567 std::vector<SymmetricTensor<2, dim>> & vector_of_tensors_at_nodes);
568
569
570
580 template <int dim, int spacedim>
581 void
582 compute_projection_from_face_quadrature_points_matrix(
583 const FiniteElement<dim, spacedim> &fe,
584 const Quadrature<dim - 1> & lhs_quadrature,
585 const Quadrature<dim - 1> & rhs_quadrature,
586 const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
587 const unsigned int face,
588 FullMatrix<double> & X);
589
590
591
607 template <int dim, int spacedim, typename number>
608 void
609 convert_generalized_support_point_values_to_dof_values(
610 const FiniteElement<dim, spacedim> &finite_element,
611 const std::vector<Vector<number>> & support_point_values,
612 std::vector<number> & dof_values);
613
614
615
650 template <int dim, int spacedim, class InVector, class OutVector>
651 void
652 interpolate(const DoFHandler<dim, spacedim> &dof1,
653 const InVector & u1,
654 const DoFHandler<dim, spacedim> &dof2,
655 OutVector & u2);
656
673 template <int dim, int spacedim, class InVector, class OutVector>
674 void
675 interpolate(
676 const DoFHandler<dim, spacedim> & dof1,
677 const InVector & u1,
678 const DoFHandler<dim, spacedim> & dof2,
679 const AffineConstraints<typename OutVector::value_type> &constraints,
680 OutVector & u2);
681
695 template <int dim, class InVector, class OutVector, int spacedim>
696 void
697 back_interpolate(const DoFHandler<dim, spacedim> & dof1,
698 const InVector & u1,
699 const FiniteElement<dim, spacedim> &fe2,
700 OutVector & u1_interpolated);
701
714 template <int dim, class InVector, class OutVector, int spacedim>
715 void
716 back_interpolate(
717 const DoFHandler<dim, spacedim> & dof1,
718 const AffineConstraints<typename OutVector::value_type> &constraints1,
719 const InVector & u1,
720 const DoFHandler<dim, spacedim> & dof2,
721 const AffineConstraints<typename OutVector::value_type> &constraints2,
722 OutVector & u1_interpolated);
723
733 template <int dim, class InVector, class OutVector, int spacedim>
734 void
735 interpolation_difference(const DoFHandler<dim, spacedim> & dof1,
736 const InVector & z1,
737 const FiniteElement<dim, spacedim> &fe2,
738 OutVector & z1_difference);
739
752 template <int dim, class InVector, class OutVector, int spacedim>
753 void
754 interpolation_difference(
755 const DoFHandler<dim, spacedim> & dof1,
756 const AffineConstraints<typename OutVector::value_type> &constraints1,
757 const InVector & z1,
758 const DoFHandler<dim, spacedim> & dof2,
759 const AffineConstraints<typename OutVector::value_type> &constraints2,
760 OutVector & z1_difference);
761
762
763
772 template <int dim, class InVector, class OutVector, int spacedim>
773 void
774 project_dg(const DoFHandler<dim, spacedim> &dof1,
775 const InVector & u1,
776 const DoFHandler<dim, spacedim> &dof2,
777 OutVector & u2);
778
839 template <int dim, class InVector, class OutVector, int spacedim>
840 void
841 extrapolate(const DoFHandler<dim, spacedim> &dof1,
842 const InVector & z1,
843 const DoFHandler<dim, spacedim> &dof2,
844 OutVector & z2);
845
858 template <int dim, class InVector, class OutVector, int spacedim>
859 void
860 extrapolate(
861 const DoFHandler<dim, spacedim> & dof1,
862 const InVector & z1,
863 const DoFHandler<dim, spacedim> & dof2,
864 const AffineConstraints<typename OutVector::value_type> &constraints,
865 OutVector & z2);
866
882 template <int dim>
883 std::vector<unsigned int>
884 hierarchic_to_lexicographic_numbering(unsigned int degree);
885
892 template <int dim>
893 std::vector<unsigned int>
894 lexicographic_to_hierarchic_numbering(unsigned int degree);
895
971 namespace Compositing
972 {
989 template <int dim, int spacedim>
990 FiniteElementData<dim>
991 multiply_dof_numbers(
992 const std::vector<const FiniteElement<dim, spacedim> *> &fes,
993 const std::vector<unsigned int> & multiplicities,
994 const bool do_tensor_product = true);
995
1001 template <int dim, int spacedim>
1002 FiniteElementData<dim>
1003 multiply_dof_numbers(
1004 const std::initializer_list<
1005 std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1006 &fe_systems);
1007
1011 template <int dim, int spacedim>
1012 FiniteElementData<dim>
1013 multiply_dof_numbers(const FiniteElement<dim, spacedim> *fe1,
1014 const unsigned int N1,
1015 const FiniteElement<dim, spacedim> *fe2 = nullptr,
1016 const unsigned int N2 = 0,
1017 const FiniteElement<dim, spacedim> *fe3 = nullptr,
1018 const unsigned int N3 = 0,
1019 const FiniteElement<dim, spacedim> *fe4 = nullptr,
1020 const unsigned int N4 = 0,
1021 const FiniteElement<dim, spacedim> *fe5 = nullptr,
1022 const unsigned int N5 = 0);
1023
1036 template <int dim, int spacedim>
1037 std::vector<bool>
1038 compute_restriction_is_additive_flags(
1039 const std::vector<const FiniteElement<dim, spacedim> *> &fes,
1040 const std::vector<unsigned int> & multiplicities);
1041
1047 template <int dim, int spacedim>
1048 std::vector<bool>
1049 compute_restriction_is_additive_flags(
1050 const std::initializer_list<
1051 std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1052 &fe_systems);
1053
1068 template <int dim, int spacedim>
1069 std::vector<bool>
1070 compute_restriction_is_additive_flags(
1071 const FiniteElement<dim, spacedim> *fe1,
1072 const unsigned int N1,
1073 const FiniteElement<dim, spacedim> *fe2 = nullptr,
1074 const unsigned int N2 = 0,
1075 const FiniteElement<dim, spacedim> *fe3 = nullptr,
1076 const unsigned int N3 = 0,
1077 const FiniteElement<dim, spacedim> *fe4 = nullptr,
1078 const unsigned int N4 = 0,
1079 const FiniteElement<dim, spacedim> *fe5 = nullptr,
1080 const unsigned int N5 = 0);
1081
1082
1099 template <int dim, int spacedim>
1100 std::vector<ComponentMask>
1101 compute_nonzero_components(
1102 const std::vector<const FiniteElement<dim, spacedim> *> &fes,
1103 const std::vector<unsigned int> & multiplicities,
1104 const bool do_tensor_product = true);
1105
1111 template <int dim, int spacedim>
1112 std::vector<ComponentMask>
1113 compute_nonzero_components(
1114 const std::initializer_list<
1115 std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1116 &fe_systems);
1117
1136 template <int dim, int spacedim>
1137 std::vector<ComponentMask>
1138 compute_nonzero_components(
1139 const FiniteElement<dim, spacedim> *fe1,
1140 const unsigned int N1,
1141 const FiniteElement<dim, spacedim> *fe2 = nullptr,
1142 const unsigned int N2 = 0,
1143 const FiniteElement<dim, spacedim> *fe3 = nullptr,
1144 const unsigned int N3 = 0,
1145 const FiniteElement<dim, spacedim> *fe4 = nullptr,
1146 const unsigned int N4 = 0,
1147 const FiniteElement<dim, spacedim> *fe5 = nullptr,
1148 const unsigned int N5 = 0,
1149 const bool do_tensor_product = true);
1150
1167 template <int dim, int spacedim>
1168 void
1169 build_cell_tables(
1170 std::vector<std::pair<std::pair<unsigned int, unsigned int>,
1171 unsigned int>> &system_to_base_table,
1172 std::vector<std::pair<unsigned int, unsigned int>>
1173 & system_to_component_table,
1174 std::vector<std::pair<std::pair<unsigned int, unsigned int>,
1175 unsigned int>> &component_to_base_table,
1176 const FiniteElement<dim, spacedim> & finite_element,
1177 const bool do_tensor_product = true);
1178
1194 template <int dim, int spacedim>
1195 void
1196 build_face_tables(
1197 std::vector<std::pair<std::pair<unsigned int, unsigned int>,
1198 unsigned int>> &face_system_to_base_table,
1199 std::vector<std::pair<unsigned int, unsigned int>>
1200 & face_system_to_component_table,
1201 const FiniteElement<dim, spacedim> &finite_element,
1202 const bool do_tensor_product = true,
1203 const unsigned int face_no = 0 /*TODO*/);
1204
1205 } // namespace Compositing
1206
1207
1241 template <int dim, int spacedim = dim>
1242 std::unique_ptr<FiniteElement<dim, spacedim>>
1243 get_fe_by_name(const std::string &name);
1244
1287 template <int dim, int spacedim>
1288 void
1289 add_fe_name(const std::string & name,
1290 const FEFactoryBase<dim, spacedim> *factory);
1291
1301 DeclException1(ExcInvalidFEName,
1302 std::string,
1303 << "Can't re-generate a finite element from the string '"
1304 << arg1 << "'.");
1305
1317 DeclException2(ExcInvalidFEDimension,
1318 char,
1319 int,
1320 << "The dimension " << arg1
1321 << " in the finite element string must match "
1322 << "the space dimension " << arg2 << '.');
1323
1329 DeclException0(ExcInvalidFE);
1330
1337 DeclException0(ExcFENotPrimitive);
1343 DeclException0(ExcTriangulationMismatch);
1344
1351 DeclExceptionMsg(ExcHangingNodesNotAllowed,
1352 "You are using continuous elements on a grid with "
1353 "hanging nodes but without providing hanging node "
1354 "constraints. Use the respective function with "
1355 "additional AffineConstraints argument(s), instead.");
1361 DeclException0(ExcGridNotRefinedAtLeastOnce);
1367 DeclException4(ExcMatrixDimensionMismatch,
1368 int,
1369 int,
1370 int,
1371 int,
1372 << "This is a " << arg1 << 'x' << arg2 << " matrix, "
1373 << "but should be a " << arg3 << 'x' << arg4 << " matrix.");
1374
1380 DeclException1(ExcLeastSquaresError,
1381 double,
1382 << "Least squares fit leaves a gap of " << arg1);
1383
1389 DeclException2(ExcNotGreaterThan,
1390 int,
1391 int,
1392 << arg1 << " must be greater than " << arg2);
1393} // namespace FETools
1394
1395
1396#ifndef DOXYGEN
1397
1398namespace FETools
1399{
1400 template <class FE>
1401 std::unique_ptr<FiniteElement<FE::dimension, FE::space_dimension>>
1402 FEFactory<FE>::get(const unsigned int degree) const
1403 {
1404 return std::make_unique<FE>(degree);
1405 }
1406
1407 namespace Compositing
1408 {
1409 template <int dim, int spacedim>
1410 std::vector<bool>
1411 compute_restriction_is_additive_flags(
1412 const std::initializer_list<
1413 std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1414 &fe_systems)
1415 {
1416 std::vector<const FiniteElement<dim, spacedim> *> fes;
1417 std::vector<unsigned int> multiplicities;
1418
1419 const auto extract =
1420 [&fes, &multiplicities](
1421 const std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>,
1422 unsigned int> &fe_system) {
1423 fes.push_back(fe_system.first.get());
1424 multiplicities.push_back(fe_system.second);
1425 };
1426
1427 for (const auto &p : fe_systems)
1428 extract(p);
1429
1430 return compute_restriction_is_additive_flags(fes, multiplicities);
1431 }
1432
1433
1434
1435 template <int dim, int spacedim>
1436 FiniteElementData<dim>
1437 multiply_dof_numbers(
1438 const std::initializer_list<
1439 std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1440 &fe_systems)
1441 {
1442 std::vector<const FiniteElement<dim, spacedim> *> fes;
1443 std::vector<unsigned int> multiplicities;
1444
1445 const auto extract =
1446 [&fes, &multiplicities](
1447 const std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>,
1448 unsigned int> &fe_system) {
1449 fes.push_back(fe_system.first.get());
1450 multiplicities.push_back(fe_system.second);
1451 };
1452
1453 for (const auto &p : fe_systems)
1454 extract(p);
1455
1456 return multiply_dof_numbers(fes, multiplicities, true);
1457 }
1458
1459
1460
1461 template <int dim, int spacedim>
1462 std::vector<ComponentMask>
1463 compute_nonzero_components(
1464 const std::initializer_list<
1465 std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1466 &fe_systems)
1467 {
1468 std::vector<const FiniteElement<dim, spacedim> *> fes;
1469 std::vector<unsigned int> multiplicities;
1470
1471 const auto extract =
1472 [&fes, &multiplicities](
1473 const std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>,
1474 unsigned int> &fe_system) {
1475 fes.push_back(fe_system.first.get());
1476 multiplicities.push_back(fe_system.second);
1477 };
1478
1479 for (const auto &p : fe_systems)
1480 extract(p);
1481
1482 return compute_nonzero_components(fes, multiplicities, true);
1483 }
1484 } // namespace Compositing
1485} // namespace FETools
1486
1487#endif
1488
1491DEAL_II_NAMESPACE_CLOSE
1492
1493#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:720
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:472
DEAL_II_CXX20_REQUIRES
#define DEAL_II_CXX20_REQUIRES(condition)
Definition config.h:160
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:473
geometry_info.h
DeclException0
#define DeclException0(Exception0)
Definition exceptions.h:465
FETools::ExcTriangulationMismatch
static ::ExceptionBase & ExcTriangulationMismatch()
FETools::ExcInvalidFEName
static ::ExceptionBase & ExcInvalidFEName(std::string arg1)
DeclException4
#define DeclException4(Exception4, type1, type2, type3, type4, outsequence)
Definition exceptions.h:579
FETools::ExcInvalidFEDimension
static ::ExceptionBase & ExcInvalidFEDimension(char arg1, int arg2)
FETools::ExcLeastSquaresError
static ::ExceptionBase & ExcLeastSquaresError(double arg1)
DeclException2
#define DeclException2(Exception2, type1, type2, outsequence)
Definition exceptions.h:533
FETools::ExcFENotPrimitive
static ::ExceptionBase & ExcFENotPrimitive()
FETools::ExcHangingNodesNotAllowed
static ::ExceptionBase & ExcHangingNodesNotAllowed()
DeclExceptionMsg
#define DeclExceptionMsg(Exception, defaulttext)
Definition exceptions.h:488
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 exceptions.h:510
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:441
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::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::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::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, FullMatrix< number >(&matrices)[GeometryInfo< dim >::max_children_per_face], 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)
TensorAccessors::extract
constexpr ReturnType< rank, T >::value_type & extract(T &t, const ArrayType &indices)
Definition tensor_accessors.h:219
symmetric_tensor.h
Generated by doxygen 1.9.7