Reference documentation for deal.II version 9.2.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\}}\)
fe_tools.h
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2000 - 2020 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/std_cxx14/memory.h>
26 #include <deal.II/base/subscriptor.h>
27 #include <deal.II/base/symmetric_tensor.h>
28 #include <deal.II/base/tensor.h>
29 
30 #include <deal.II/distributed/tria.h>
31 
32 #include <deal.II/fe/component_mask.h>
33 
34 #include <deal.II/lac/la_parallel_vector.h>
35 
36 #include <string>
37 #include <vector>
38 
39 
40 DEAL_II_NAMESPACE_OPEN
41 
42 // Forward declarations
43 #ifndef DOXYGEN
44 template <typename number>
45 class FullMatrix;
46 template <int dim>
47 class Quadrature;
48 template <int dim, int spacedim>
49 class FiniteElement;
50 template <int dim, int spacedim>
51 class DoFHandler;
52 template <int dim>
53 class FiniteElementData;
54 template <typename number>
55 class AffineConstraints;
56 #endif
57 
58 
61 
62 
78 namespace FETools
79 {
90  template <int dim, int spacedim = dim>
91  class FEFactoryBase : public Subscriptor
92  {
93  public:
97  virtual std::unique_ptr<FiniteElement<dim, spacedim>>
98  get(const unsigned int degree) const = 0;
99 
105  virtual std::unique_ptr<FiniteElement<dim, spacedim>>
106  get(const Quadrature<1> &quad) const = 0;
107 
111  virtual ~FEFactoryBase() override = default;
112  };
113 
125  template <class FE>
126  class FEFactory : public FEFactoryBase<FE::dimension, FE::space_dimension>
127  {
128  public:
132  virtual std::unique_ptr<FiniteElement<FE::dimension, FE::space_dimension>>
133  get(const unsigned int degree) const override;
134 
139  virtual std::unique_ptr<FiniteElement<FE::dimension, FE::space_dimension>>
140  get(const Quadrature<1> &quad) const override;
141  };
142 
158  template <int dim, int spacedim>
159  void
160  compute_component_wise(const FiniteElement<dim, spacedim> & fe,
161  std::vector<unsigned int> & renumbering,
162  std::vector<std::vector<unsigned int>> &start_indices);
163 
179  template <int dim, int spacedim>
180  void
181  compute_block_renumbering(const FiniteElement<dim, spacedim> & fe,
182  std::vector<types::global_dof_index> &renumbering,
183  std::vector<types::global_dof_index> &block_data,
184  bool return_start_indices = true);
185 
199  template <int dim, typename number, int spacedim>
200  void
201  get_interpolation_matrix(const FiniteElement<dim, spacedim> &fe1,
202  const FiniteElement<dim, spacedim> &fe2,
203  FullMatrix<number> &interpolation_matrix);
204 
216  template <int dim, typename number, int spacedim>
217  void
218  get_back_interpolation_matrix(const FiniteElement<dim, spacedim> &fe1,
219  const FiniteElement<dim, spacedim> &fe2,
220  FullMatrix<number> &interpolation_matrix);
221 
233  template <int dim, typename number, int spacedim>
234  void
235  get_interpolation_difference_matrix(const FiniteElement<dim, spacedim> &fe1,
236  const FiniteElement<dim, spacedim> &fe2,
237  FullMatrix<number> &difference_matrix);
238 
242  template <int dim, typename number, int spacedim>
243  void
244  get_projection_matrix(const FiniteElement<dim, spacedim> &fe1,
245  const FiniteElement<dim, spacedim> &fe2,
246  FullMatrix<number> & matrix);
247 
316  template <int dim, int spacedim>
317  FullMatrix<double>
318  compute_node_matrix(const FiniteElement<dim, spacedim> &fe);
319 
358  template <int dim, typename number, int spacedim>
359  void
360  compute_embedding_matrices(
361  const FiniteElement<dim, spacedim> & fe,
362  std::vector<std::vector<FullMatrix<number>>> &matrices,
363  const bool isotropic_only = false,
364  const double threshold = 1.e-12);
365 
387  template <int dim, typename number, int spacedim>
388  void
389  compute_face_embedding_matrices(
390  const FiniteElement<dim, spacedim> &fe,
391  FullMatrix<number> (&matrices)[GeometryInfo<dim>::max_children_per_face],
392  const unsigned int face_coarse,
393  const unsigned int face_fine,
394  const double threshold = 1.e-12);
395 
427  template <int dim, typename number, int spacedim>
428  void
429  compute_projection_matrices(
430  const FiniteElement<dim, spacedim> & fe,
431  std::vector<std::vector<FullMatrix<number>>> &matrices,
432  const bool isotropic_only = false);
433 
519  template <int dim, int spacedim>
520  void
521  compute_projection_from_quadrature_points_matrix(
522  const FiniteElement<dim, spacedim> &fe,
523  const Quadrature<dim> & lhs_quadrature,
524  const Quadrature<dim> & rhs_quadrature,
525  FullMatrix<double> & X);
526 
534  template <int dim, int spacedim>
535  void
536  compute_interpolation_to_quadrature_points_matrix(
537  const FiniteElement<dim, spacedim> &fe,
538  const Quadrature<dim> & quadrature,
539  FullMatrix<double> & I_q);
540 
554  template <int dim>
555  void
556  compute_projection_from_quadrature_points(
557  const FullMatrix<double> & projection_matrix,
558  const std::vector<Tensor<1, dim>> &vector_of_tensors_at_qp,
559  std::vector<Tensor<1, dim>> & vector_of_tensors_at_nodes);
560 
561 
562 
566  template <int dim>
567  void
568  compute_projection_from_quadrature_points(
569  const FullMatrix<double> & projection_matrix,
570  const std::vector<SymmetricTensor<2, dim>> &vector_of_tensors_at_qp,
571  std::vector<SymmetricTensor<2, dim>> & vector_of_tensors_at_nodes);
572 
573 
574 
584  template <int dim, int spacedim>
585  void
586  compute_projection_from_face_quadrature_points_matrix(
587  const FiniteElement<dim, spacedim> &fe,
588  const Quadrature<dim - 1> & lhs_quadrature,
589  const Quadrature<dim - 1> & rhs_quadrature,
590  const typename DoFHandler<dim, spacedim>::active_cell_iterator &cell,
591  const unsigned int face,
592  FullMatrix<double> & X);
593 
594 
595 
611  template <int dim, int spacedim, typename number>
612  void
613  convert_generalized_support_point_values_to_dof_values(
614  const FiniteElement<dim, spacedim> &finite_element,
615  const std::vector<Vector<number>> & support_point_values,
616  std::vector<number> & dof_values);
617 
618 
619 
621 
654  template <int dim,
655  int spacedim,
656  template <int, int> class DoFHandlerType1,
657  template <int, int> class DoFHandlerType2,
658  class InVector,
659  class OutVector>
660  void
661  interpolate(const DoFHandlerType1<dim, spacedim> &dof1,
662  const InVector & u1,
663  const DoFHandlerType2<dim, spacedim> &dof2,
664  OutVector & u2);
665 
682  template <int dim,
683  int spacedim,
684  template <int, int> class DoFHandlerType1,
685  template <int, int> class DoFHandlerType2,
686  class InVector,
687  class OutVector>
688  void
689  interpolate(
690  const DoFHandlerType1<dim, spacedim> & dof1,
691  const InVector & u1,
692  const DoFHandlerType2<dim, spacedim> & dof2,
693  const AffineConstraints<typename OutVector::value_type> &constraints,
694  OutVector & u2);
695 
711  template <int dim,
712  template <int, int> class DoFHandlerType,
713  class InVector,
714  class OutVector,
715  int spacedim>
716  void
717  back_interpolate(const DoFHandlerType<dim, spacedim> &dof1,
718  const InVector & u1,
719  const FiniteElement<dim, spacedim> & fe2,
720  OutVector & u1_interpolated);
721 
734  template <int dim, class InVector, class OutVector, int spacedim>
735  void
736  back_interpolate(
737  const DoFHandler<dim, spacedim> & dof1,
738  const AffineConstraints<typename OutVector::value_type> &constraints1,
739  const InVector & u1,
740  const DoFHandler<dim, spacedim> & dof2,
741  const AffineConstraints<typename OutVector::value_type> &constraints2,
742  OutVector & u1_interpolated);
743 
753  template <int dim, class InVector, class OutVector, int spacedim>
754  void
755  interpolation_difference(const DoFHandler<dim, spacedim> & dof1,
756  const InVector & z1,
757  const FiniteElement<dim, spacedim> &fe2,
758  OutVector & z1_difference);
759 
772  template <int dim, class InVector, class OutVector, int spacedim>
773  void
774  interpolation_difference(
775  const DoFHandler<dim, spacedim> & dof1,
776  const AffineConstraints<typename OutVector::value_type> &constraints1,
777  const InVector & z1,
778  const DoFHandler<dim, spacedim> & dof2,
779  const AffineConstraints<typename OutVector::value_type> &constraints2,
780  OutVector & z1_difference);
781 
782 
783 
792  template <int dim, class InVector, class OutVector, int spacedim>
793  void
794  project_dg(const DoFHandler<dim, spacedim> &dof1,
795  const InVector & u1,
796  const DoFHandler<dim, spacedim> &dof2,
797  OutVector & u2);
798 
859  template <int dim, class InVector, class OutVector, int spacedim>
860  void
861  extrapolate(const DoFHandler<dim, spacedim> &dof1,
862  const InVector & z1,
863  const DoFHandler<dim, spacedim> &dof2,
864  OutVector & z2);
865 
878  template <int dim, class InVector, class OutVector, int spacedim>
879  void
880  extrapolate(
881  const DoFHandler<dim, spacedim> & dof1,
882  const InVector & z1,
883  const DoFHandler<dim, spacedim> & dof2,
884  const AffineConstraints<typename OutVector::value_type> &constraints,
885  OutVector & z2);
886 
888 
902  template <int dim>
903  std::vector<unsigned int>
904  hierarchic_to_lexicographic_numbering(unsigned int degree);
905 
913  template <int dim>
914  DEAL_II_DEPRECATED void
915  hierarchic_to_lexicographic_numbering(unsigned int degree,
916  std::vector<unsigned int> &h2l);
917 
925  template <int dim>
926  DEAL_II_DEPRECATED void
927  hierarchic_to_lexicographic_numbering(const FiniteElementData<dim> &fe_data,
928  std::vector<unsigned int> & h2l);
929 
934  template <int dim>
935  DEAL_II_DEPRECATED std::vector<unsigned int>
936  hierarchic_to_lexicographic_numbering(const FiniteElementData<dim> &fe_data);
937 
944  template <int dim>
945  std::vector<unsigned int>
946  lexicographic_to_hierarchic_numbering(unsigned int degree);
947 
952  template <int dim>
953  DEAL_II_DEPRECATED void
954  lexicographic_to_hierarchic_numbering(const FiniteElementData<dim> &fe_data,
955  std::vector<unsigned int> & l2h);
956 
961  template <int dim>
962  DEAL_II_DEPRECATED std::vector<unsigned int>
963  lexicographic_to_hierarchic_numbering(const FiniteElementData<dim> &fe_data);
964 
965 
1039  namespace Compositing
1040  {
1057  template <int dim, int spacedim>
1058  FiniteElementData<dim>
1059  multiply_dof_numbers(
1060  const std::vector<const FiniteElement<dim, spacedim> *> &fes,
1061  const std::vector<unsigned int> & multiplicities,
1062  const bool do_tensor_product = true);
1063 
1069  template <int dim, int spacedim>
1070  FiniteElementData<dim>
1071  multiply_dof_numbers(
1072  const std::initializer_list<
1073  std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1074  &fe_systems);
1075 
1079  template <int dim, int spacedim>
1080  FiniteElementData<dim>
1081  multiply_dof_numbers(const FiniteElement<dim, spacedim> *fe1,
1082  const unsigned int N1,
1083  const FiniteElement<dim, spacedim> *fe2 = nullptr,
1084  const unsigned int N2 = 0,
1085  const FiniteElement<dim, spacedim> *fe3 = nullptr,
1086  const unsigned int N3 = 0,
1087  const FiniteElement<dim, spacedim> *fe4 = nullptr,
1088  const unsigned int N4 = 0,
1089  const FiniteElement<dim, spacedim> *fe5 = nullptr,
1090  const unsigned int N5 = 0);
1091 
1104  template <int dim, int spacedim>
1105  std::vector<bool>
1106  compute_restriction_is_additive_flags(
1107  const std::vector<const FiniteElement<dim, spacedim> *> &fes,
1108  const std::vector<unsigned int> & multiplicities);
1109 
1115  template <int dim, int spacedim>
1116  std::vector<bool>
1117  compute_restriction_is_additive_flags(
1118  const std::initializer_list<
1119  std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1120  &fe_systems);
1121 
1136  template <int dim, int spacedim>
1137  std::vector<bool>
1138  compute_restriction_is_additive_flags(
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 
1150 
1167  template <int dim, int spacedim>
1168  std::vector<ComponentMask>
1169  compute_nonzero_components(
1170  const std::vector<const FiniteElement<dim, spacedim> *> &fes,
1171  const std::vector<unsigned int> & multiplicities,
1172  const bool do_tensor_product = true);
1173 
1179  template <int dim, int spacedim>
1180  std::vector<ComponentMask>
1181  compute_nonzero_components(
1182  const std::initializer_list<
1183  std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1184  &fe_systems);
1185 
1204  template <int dim, int spacedim>
1205  std::vector<ComponentMask>
1206  compute_nonzero_components(
1207  const FiniteElement<dim, spacedim> *fe1,
1208  const unsigned int N1,
1209  const FiniteElement<dim, spacedim> *fe2 = nullptr,
1210  const unsigned int N2 = 0,
1211  const FiniteElement<dim, spacedim> *fe3 = nullptr,
1212  const unsigned int N3 = 0,
1213  const FiniteElement<dim, spacedim> *fe4 = nullptr,
1214  const unsigned int N4 = 0,
1215  const FiniteElement<dim, spacedim> *fe5 = nullptr,
1216  const unsigned int N5 = 0,
1217  const bool do_tensor_product = true);
1218 
1235  template <int dim, int spacedim>
1236  void
1237  build_cell_tables(
1238  std::vector<std::pair<std::pair<unsigned int, unsigned int>,
1239  unsigned int>> &system_to_base_table,
1240  std::vector<std::pair<unsigned int, unsigned int>>
1241  & system_to_component_table,
1242  std::vector<std::pair<std::pair<unsigned int, unsigned int>,
1243  unsigned int>> &component_to_base_table,
1244  const FiniteElement<dim, spacedim> & finite_element,
1245  const bool do_tensor_product = true);
1246 
1262  template <int dim, int spacedim>
1263  void
1264  build_face_tables(
1265  std::vector<std::pair<std::pair<unsigned int, unsigned int>,
1266  unsigned int>> &face_system_to_base_table,
1267  std::vector<std::pair<unsigned int, unsigned int>>
1268  & face_system_to_component_table,
1269  const FiniteElement<dim, spacedim> &finite_element,
1270  const bool do_tensor_product = true);
1271 
1272  } // namespace Compositing
1273 
1274 
1308  template <int dim, int spacedim = dim>
1309  std::unique_ptr<FiniteElement<dim, spacedim>>
1310  get_fe_by_name(const std::string &name);
1311 
1312 
1316  template <int dim>
1317  DEAL_II_DEPRECATED FiniteElement<dim, dim> *
1318  get_fe_from_name(const std::string &name);
1319 
1320 
1363  template <int dim, int spacedim>
1364  void
1365  add_fe_name(const std::string & name,
1366  const FEFactoryBase<dim, spacedim> *factory);
1367 
1377  DeclException1(ExcInvalidFEName,
1378  std::string,
1379  << "Can't re-generate a finite element from the string '"
1380  << arg1 << "'.");
1381 
1393  DeclException2(ExcInvalidFEDimension,
1394  char,
1395  int,
1396  << "The dimension " << arg1
1397  << " in the finite element string must match "
1398  << "the space dimension " << arg2 << ".");
1399 
1405  DeclException0(ExcInvalidFE);
1406 
1413  DeclException0(ExcFENotPrimitive);
1419  DeclException0(ExcTriangulationMismatch);
1420 
1427  DeclExceptionMsg(ExcHangingNodesNotAllowed,
1428  "You are using continuous elements on a grid with "
1429  "hanging nodes but without providing hanging node "
1430  "constraints. Use the respective function with "
1431  "additional AffineConstraints argument(s), instead.");
1437  DeclException0(ExcGridNotRefinedAtLeastOnce);
1443  DeclException4(ExcMatrixDimensionMismatch,
1444  int,
1445  int,
1446  int,
1447  int,
1448  << "This is a " << arg1 << "x" << arg2 << " matrix, "
1449  << "but should be a " << arg3 << "x" << arg4 << " matrix.");
1450 
1456  DeclException1(ExcLeastSquaresError,
1457  double,
1458  << "Least squares fit leaves a gap of " << arg1);
1459 
1465  DeclException2(ExcNotGreaterThan,
1466  int,
1467  int,
1468  << arg1 << " must be greater than " << arg2);
1469 } // namespace FETools
1470 
1471 
1472 #ifndef DOXYGEN
1473 
1474 namespace FETools
1475 {
1476  template <class FE>
1477  std::unique_ptr<FiniteElement<FE::dimension, FE::space_dimension>>
1478  FEFactory<FE>::get(const unsigned int degree) const
1479  {
1480  return std_cxx14::make_unique<FE>(degree);
1481  }
1482 
1483  namespace Compositing
1484  {
1485  template <int dim, int spacedim>
1486  std::vector<bool>
1487  compute_restriction_is_additive_flags(
1488  const std::initializer_list<
1489  std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1490  &fe_systems)
1491  {
1492  std::vector<const FiniteElement<dim, spacedim> *> fes;
1493  std::vector<unsigned int> multiplicities;
1494 
1495  const auto extract =
1496  [&fes, &multiplicities](
1497  const std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>,
1498  unsigned int> &fe_system) {
1499  fes.push_back(fe_system.first.get());
1500  multiplicities.push_back(fe_system.second);
1501  };
1502 
1503  for (const auto &p : fe_systems)
1504  extract(p);
1505 
1506  return compute_restriction_is_additive_flags(fes, multiplicities);
1507  }
1508 
1509 
1510 
1511  template <int dim, int spacedim>
1512  FiniteElementData<dim>
1513  multiply_dof_numbers(
1514  const std::initializer_list<
1515  std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1516  &fe_systems)
1517  {
1518  std::vector<const FiniteElement<dim, spacedim> *> fes;
1519  std::vector<unsigned int> multiplicities;
1520 
1521  const auto extract =
1522  [&fes, &multiplicities](
1523  const std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>,
1524  unsigned int> &fe_system) {
1525  fes.push_back(fe_system.first.get());
1526  multiplicities.push_back(fe_system.second);
1527  };
1528 
1529  for (const auto &p : fe_systems)
1530  extract(p);
1531 
1532  return multiply_dof_numbers(fes, multiplicities, true);
1533  }
1534 
1535 
1536 
1537  template <int dim, int spacedim>
1538  std::vector<ComponentMask>
1539  compute_nonzero_components(
1540  const std::initializer_list<
1541  std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>, unsigned int>>
1542  &fe_systems)
1543  {
1544  std::vector<const FiniteElement<dim, spacedim> *> fes;
1545  std::vector<unsigned int> multiplicities;
1546 
1547  const auto extract =
1548  [&fes, &multiplicities](
1549  const std::pair<std::unique_ptr<FiniteElement<dim, spacedim>>,
1550  unsigned int> &fe_system) {
1551  fes.push_back(fe_system.first.get());
1552  multiplicities.push_back(fe_system.second);
1553  };
1554 
1555  for (const auto &p : fe_systems)
1556  extract(p);
1557 
1558  return compute_nonzero_components(fes, multiplicities, true);
1559  }
1560  } // namespace Compositing
1561 } // namespace FETools
1562 
1563 #endif
1564 
1567 DEAL_II_NAMESPACE_CLOSE
1568 
1569 #endif /* dealii_fe_tools_H */
FETools::hierarchic_to_lexicographic_numbering
std::vector< unsigned int > hierarchic_to_lexicographic_numbering(unsigned int degree)
DeclExceptionMsg
#define DeclExceptionMsg(Exception, defaulttext)
Definition: exceptions.h:496
FETools::interpolation_difference
void interpolation_difference(const DoFHandler< dim, spacedim > &dof1, const InVector &z1, const FiniteElement< dim, spacedim > &fe2, OutVector &z1_difference)
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::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::project_dg
void project_dg(const DoFHandler< dim, spacedim > &dof1, const InVector &u1, const DoFHandler< dim, spacedim > &dof2, OutVector &u2)
DoFHandler::active_cell_iterator
typename ActiveSelector::active_cell_iterator active_cell_iterator
Definition: dof_handler.h:329
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)
SymmetricTensor< 2, dim >
FETools::ExcInvalidFEName
static ::ExceptionBase & ExcInvalidFEName(std::string arg1)
FETools::get_fe_by_name
std::unique_ptr< FiniteElement< dim, spacedim > > get_fe_by_name(const std::string &name)
FETools::FEFactory
Definition: fe_tools.h:126
FETools::back_interpolate
void back_interpolate(const DoFHandlerType< dim, spacedim > &dof1, const InVector &u1, const FiniteElement< dim, spacedim > &fe2, OutVector &u1_interpolated)
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::extrapolate
void extrapolate(const DoFHandler< dim, spacedim > &dof1, const InVector &z1, const DoFHandler< dim, spacedim > &dof2, OutVector &z2)
FiniteElementData
Definition: fe_base.h:147
FETools::ExcLeastSquaresError
static ::ExceptionBase & ExcLeastSquaresError(double arg1)
GeometryInfo
Definition: geometry_info.h:1224
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)
Physics::Elasticity::Kinematics::e
SymmetricTensor< 2, dim, Number > e(const Tensor< 2, dim, Number > &F)
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_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_projection_matrices
void compute_projection_matrices(const FiniteElement< dim, spacedim > &fe, std::vector< std::vector< FullMatrix< number >>> &matrices, const bool isotropic_only=false)
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::FEFactoryBase::get
virtual std::unique_ptr< FiniteElement< dim, spacedim > > get(const unsigned int degree) const =0
FETools::get_interpolation_matrix
void get_interpolation_matrix(const FiniteElement< dim, spacedim > &fe1, const FiniteElement< dim, spacedim > &fe2, FullMatrix< number > &interpolation_matrix)
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::ExcNotGreaterThan
static ::ExceptionBase & ExcNotGreaterThan(int arg1, int arg2)
DoFHandler
Definition: dof_handler.h:205
la_parallel_vector.h
Subscriptor
Definition: subscriptor.h:62
FETools::get_back_interpolation_matrix
void get_back_interpolation_matrix(const FiniteElement< dim, spacedim > &fe1, const FiniteElement< dim, spacedim > &fe2, FullMatrix< number > &interpolation_matrix)
TensorAccessors::extract
constexpr ReturnType< rank, T >::value_type & extract(T &t, const ArrayType &indices)
Definition: tensor_accessors.h:226
FETools::get_projection_matrix
void get_projection_matrix(const FiniteElement< dim, spacedim > &fe1, const FiniteElement< dim, spacedim > &fe2, FullMatrix< number > &matrix)
tensor.h
FETools::compute_node_matrix
FullMatrix< double > compute_node_matrix(const FiniteElement< dim, spacedim > &fe)
FETools::ExcHangingNodesNotAllowed
static ::ExceptionBase & ExcHangingNodesNotAllowed()
FETools::ExcTriangulationMismatch
static ::ExceptionBase & ExcTriangulationMismatch()
geometry_info.h
subscriptor.h
Tensor< 1, dim >
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)
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:358
LAPACKSupport::matrix
@ matrix
Contents is actually a matrix.
Definition: lapack_support.h:60
FETools::add_fe_name
void add_fe_name(const std::string &name, const FEFactoryBase< dim, spacedim > *factory)
DEAL_II_DEPRECATED
#define DEAL_II_DEPRECATED
Definition: config.h:98
DeclException1
#define DeclException1(Exception1, type1, outsequence)
Definition: exceptions.h:518
component_mask.h
FETools::ExcInvalidFEDimension
static ::ExceptionBase & ExcInvalidFEDimension(char arg1, int arg2)
FiniteElement
Definition: fe.h:648
FETools::ExcMatrixDimensionMismatch
static ::ExceptionBase & ExcMatrixDimensionMismatch(int arg1, int arg2, int arg3, int arg4)
exceptions.h
FETools::ExcFENotPrimitive
static ::ExceptionBase & ExcFENotPrimitive()
DeclException4
#define DeclException4(Exception4, type1, type2, type3, type4, outsequence)
Definition: exceptions.h:587
tria.h
AffineConstraints
Definition: affine_constraints.h:180
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)
symmetric_tensor.h
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)
DeclException0
#define DeclException0(Exception0)
Definition: exceptions.h:473
FETools::get_fe_from_name
FiniteElement< dim, dim > * get_fe_from_name(const std::string &name)
FETools::ExcInvalidFE
static ::ExceptionBase & ExcInvalidFE()
FETools::FEFactory::get
virtual std::unique_ptr< FiniteElement< FE::dimension, FE::space_dimension > > get(const unsigned int degree) const override
FETools
Definition: fe_tools.h:78
config.h
FullMatrix
Definition: full_matrix.h:71
FETools::interpolate
void interpolate(const DoFHandlerType1< dim, spacedim > &dof1, const InVector &u1, const DoFHandlerType2< dim, spacedim > &dof2, OutVector &u2)
memory.h
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)
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:359
FETools::FEFactoryBase::~FEFactoryBase
virtual ~FEFactoryBase() override=default
Quadrature
Definition: quadrature.h:85
Vector< number >
FETools::get_interpolation_difference_matrix
void get_interpolation_difference_matrix(const FiniteElement< dim, spacedim > &fe1, const FiniteElement< dim, spacedim > &fe2, FullMatrix< number > &difference_matrix)
DeclException2
#define DeclException2(Exception2, type1, type2, outsequence)
Definition: exceptions.h:541
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::ExcGridNotRefinedAtLeastOnce
static ::ExceptionBase & ExcGridNotRefinedAtLeastOnce()
FETools::FEFactoryBase
Definition: fe_tools.h:91
FETools::lexicographic_to_hierarchic_numbering
std::vector< unsigned int > lexicographic_to_hierarchic_numbering(unsigned int degree)
Generated by   doxygen 1.8.17