Reference documentation for deal.II version 8.4.1

Classes  
class  FEFactory 
class  FEFactoryBase 
Functions  
template<int dim, int spacedim>  
void  compute_component_wise (const FiniteElement< dim, spacedim > &fe, std::vector< unsigned int > &renumbering, std::vector< std::vector< unsigned int > > &start_indices) 
template<int dim, int spacedim>  
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) 
template<int dim>  
void  hierarchic_to_lexicographic_numbering (unsigned int degree, std::vector< unsigned int > &h2l) 
template<int dim>  
std::vector< unsigned int >  hierarchic_to_lexicographic_numbering (const FiniteElementData< dim > &fe_data) 
template<int dim>  
void  lexicographic_to_hierarchic_numbering (const FiniteElementData< dim > &fe_data, std::vector< unsigned int > &l2h) 
template<int dim>  
std::vector< unsigned int >  lexicographic_to_hierarchic_numbering (const FiniteElementData< dim > &fe_data) 
template<int dim, int spacedim>  
FiniteElement< dim, spacedim > *  get_fe_by_name (const std::string &name) 
template<int dim>  
FiniteElement< dim, dim > *  get_fe_from_name (const std::string &name) 
template<int dim, int spacedim>  
void  add_fe_name (const std::string &name, const FEFactoryBase< dim, spacedim > *factory) 
DeclException1 (ExcInvalidFEName, std::string,<< "Can't regenerate a finite element from the string '"<< arg1<< "'.")  
DeclException2 (ExcInvalidFEDimension, char, int,<< "The dimension "<< arg1<< " in the finite element string must match "<< "the space dimension "<< arg2<< ".")  
DeclException0 (ExcInvalidFE)  
DeclException0 (ExcFENotPrimitive)  
DeclException0 (ExcTriangulationMismatch)  
DeclException1 (ExcHangingNodesNotAllowed, int,<< "You are using continuous elements on a grid with "<< "hanging nodes but without providing hanging node "<< "constraints. Use the respective function with "<< "additional ConstraintMatrix argument(s), instead."<< (arg1?"":""))  
DeclException0 (ExcGridNotRefinedAtLeastOnce)  
DeclException4 (ExcMatrixDimensionMismatch, int, int, int, int,<< "This is a "<< arg1<< "x"<< arg2<< " matrix, "<< "but should be a "<< arg3<< "x"<< arg4<< " matrix.")  
DeclException1 (ExcLeastSquaresError, double,<< "Least squares fit leaves a gap of "<< arg1)  
DeclException2 (ExcNotGreaterThan, int, int,<< arg1<< " must be greater than "<< arg2)  
template<int dim>  
FiniteElement< dim > *  get_fe_from_name (const std::string ¶meter_name) 
Generation of local matrices  
template<int dim, typename number , int spacedim>  
void  get_interpolation_matrix (const FiniteElement< dim, spacedim > &fe1, const FiniteElement< dim, spacedim > &fe2, FullMatrix< number > &interpolation_matrix) 
template<int dim, typename number , int spacedim>  
void  get_back_interpolation_matrix (const FiniteElement< dim, spacedim > &fe1, const FiniteElement< dim, spacedim > &fe2, FullMatrix< number > &interpolation_matrix) 
template<int dim, typename number , int spacedim>  
void  get_interpolation_difference_matrix (const FiniteElement< dim, spacedim > &fe1, const FiniteElement< dim, spacedim > &fe2, FullMatrix< number > &difference_matrix) 
template<int dim, typename number , int spacedim>  
void  get_projection_matrix (const FiniteElement< dim, spacedim > &fe1, const FiniteElement< dim, spacedim > &fe2, FullMatrix< number > &matrix) 
template<int dim, int spacedim>  
void  compute_node_matrix (FullMatrix< double > &M, const FiniteElement< dim, spacedim > &fe) 
template<int dim, typename number , int spacedim>  
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.e12) 
template<int dim, typename number , int spacedim>  
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.e12) 
template<int dim, typename number , int spacedim>  
void  compute_projection_matrices (const FiniteElement< dim, spacedim > &fe, std::vector< std::vector< FullMatrix< number > > > &matrices, const bool isotropic_only=false) 
template<int dim, int spacedim>  
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) 
template<int dim, int spacedim>  
void  compute_interpolation_to_quadrature_points_matrix (const FiniteElement< dim, spacedim > &fe, const Quadrature< dim > &quadrature, FullMatrix< double > &I_q) 
template<int dim>  
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) 
template<int dim>  
void  compute_projection_from_quadrature_points (const FullMatrix< double > &projection_matrix, const std::vector< SymmetricTensor< 2, dim > > &vector_of_tensors_at_qp, std::vector< SymmetricTensor< 2, dim > > &vector_of_tensors_at_nodes) 
template<int dim, int spacedim>  
void  compute_projection_from_face_quadrature_points_matrix (const FiniteElement< dim, spacedim > &fe, const Quadrature< dim1 > &lhs_quadrature, const Quadrature< dim1 > &rhs_quadrature, const typename DoFHandler< dim, spacedim >::active_cell_iterator &cell, const unsigned int face, FullMatrix< double > &X) 
Functions which should be in DoFTools  
template<int dim, int spacedim, template< int, int > class DoFHandlerType1, template< int, int > class DoFHandlerType2, class InVector , class OutVector >  
void  interpolate (const DoFHandlerType1< dim, spacedim > &dof1, const InVector &u1, const DoFHandlerType2< dim, spacedim > &dof2, OutVector &u2) 
template<int dim, int spacedim, template< int, int > class DoFHandlerType1, template< int, int > class DoFHandlerType2, class InVector , class OutVector >  
void  interpolate (const DoFHandlerType1< dim, spacedim > &dof1, const InVector &u1, const DoFHandlerType2< dim, spacedim > &dof2, const ConstraintMatrix &constraints, OutVector &u2) 
template<int dim, class InVector , class OutVector , int spacedim>  
void  back_interpolate (const DoFHandler< dim, spacedim > &dof1, const InVector &u1, const FiniteElement< dim, spacedim > &fe2, OutVector &u1_interpolated) 
template<int dim, template< int > class DoFHandlerType, class InVector , class OutVector , int spacedim>  
void  back_interpolate (const DoFHandlerType< dim > &dof1, const InVector &u1, const FiniteElement< dim, spacedim > &fe2, OutVector &u1_interpolated) 
template<int dim, class InVector , class OutVector , int spacedim>  
void  back_interpolate (const DoFHandler< dim, spacedim > &dof1, const ConstraintMatrix &constraints1, const InVector &u1, const DoFHandler< dim, spacedim > &dof2, const ConstraintMatrix &constraints2, OutVector &u1_interpolated) 
template<int dim, class InVector , class OutVector , int spacedim>  
void  interpolation_difference (const DoFHandler< dim, spacedim > &dof1, const InVector &z1, const FiniteElement< dim, spacedim > &fe2, OutVector &z1_difference) 
template<int dim, class InVector , class OutVector , int spacedim>  
void  interpolation_difference (const DoFHandler< dim, spacedim > &dof1, const ConstraintMatrix &constraints1, const InVector &z1, const DoFHandler< dim, spacedim > &dof2, const ConstraintMatrix &constraints2, OutVector &z1_difference) 
template<int dim, class InVector , class OutVector , int spacedim>  
void  project_dg (const DoFHandler< dim, spacedim > &dof1, const InVector &u1, const DoFHandler< dim, spacedim > &dof2, OutVector &u2) 
template<int dim, class InVector , class OutVector , int spacedim>  
void  extrapolate (const DoFHandler< dim, spacedim > &dof1, const InVector &z1, const DoFHandler< dim, spacedim > &dof2, OutVector &z2) 
template<int dim, class InVector , class OutVector , int spacedim>  
void  extrapolate (const DoFHandler< dim, spacedim > &dof1, const InVector &z1, const DoFHandler< dim, spacedim > &dof2, const ConstraintMatrix &constraints, OutVector &z2) 
This namespace offers interpolations and extrapolations of discrete functions of one FiniteElement
fe1
to another FiniteElement
fe2
.
It also provides the local interpolation matrices that interpolate on each cell. Furthermore it provides the difference matrix \(idI_h\) that is needed for evaluating \((idI_h)z\) for e.g. the dual solution \(z\).
For more information about the spacedim
template parameter check the documentation of FiniteElement or the one of Triangulation.
void FETools::compute_component_wise  (  const FiniteElement< dim, spacedim > &  fe, 
std::vector< unsigned int > &  renumbering,  
std::vector< std::vector< unsigned int > > &  start_indices  
) 
Compute the vector required to renumber the dofs of a cell by component. Furthermore, compute the vector storing the start indices of each component in the local block vector.
The second vector is organized such that there is a vector for each base element containing the start index for each component served by this base element.
While the first vector is checked to have the correct size, the second one is reinitialized for convenience.
Definition at line 343 of file fe_tools.cc.
void FETools::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 

) 
Compute the vector required to renumber the dofs of a cell by block. Furthermore, compute the vector storing either the start indices or the size of each local block vector.
If the bool
parameter is true, block_data
is filled with the start indices of each local block. If it is false, then the block sizes are returned.
The vector renumbering
will be indexed by the standard numbering of local degrees of freedom, namely first first vertex, then second vertex, after vertices lines, quads, and hexes. For each index, the entry indicates the index which this degree of freedom receives in a numbering scheme, where the first block is numbered completely before the second.
Definition at line 385 of file fe_tools.cc.
void FETools::get_interpolation_matrix  (  const FiniteElement< dim, spacedim > &  fe1, 
const FiniteElement< dim, spacedim > &  fe2,  
FullMatrix< number > &  interpolation_matrix  
) 
Gives the interpolation matrix that interpolates a fe1
function to a fe2function
on each cell. The interpolation_matrix needs to be of size (fe2.dofs_per_cell, fe1.dofs_per_cell)
.
Note, that if the finite element space fe1
is a subset of the finite element space fe2
then the interpolation_matrix
is an embedding matrix.
Definition at line 433 of file fe_tools.cc.
void FETools::get_back_interpolation_matrix  (  const FiniteElement< dim, spacedim > &  fe1, 
const FiniteElement< dim, spacedim > &  fe2,  
FullMatrix< number > &  interpolation_matrix  
) 
Gives the interpolation matrix that interpolates a fe1
function to a fe2function
, and interpolates this to a second fe1function
on each cell. The interpolation_matrix needs to be of size (fe1.dofs_per_cell, fe1.dofs_per_cell)
.
Note, that this function only makes sense if the finite element space due to fe1
is not a subset of the finite element space due to fe2
, as if it were a subset then the interpolation_matrix
would be only the unit matrix.
Definition at line 497 of file fe_tools.cc.
void FETools::get_interpolation_difference_matrix  (  const FiniteElement< dim, spacedim > &  fe1, 
const FiniteElement< dim, spacedim > &  fe2,  
FullMatrix< number > &  difference_matrix  
) 
Gives the unit matrix minus the back interpolation matrix. The difference_matrix
needs to be of size (fe1.dofs_per_cell, fe1.dofs_per_cell)
.
This function gives the matrix that transforms a fe1
function \(z\) to \(zI_hz\) where \(I_h\) denotes the interpolation operator from the fe1
space to the fe2
space. This matrix hence is useful to evaluate error representations where \(z\) denotes the dual solution.
Definition at line 523 of file fe_tools.cc.
void FETools::get_projection_matrix  (  const FiniteElement< dim, spacedim > &  fe1, 
const FiniteElement< dim, spacedim > &  fe2,  
FullMatrix< number > &  matrix  
) 
Compute the local \(L^2\)projection matrix from fe1 to fe2.
Definition at line 549 of file fe_tools.cc.
void FETools::compute_node_matrix  (  FullMatrix< double > &  M, 
const FiniteElement< dim, spacedim > &  fe  
) 
Compute the matrix of nodal values of a finite element applied to all its shape functions.
This function is supposed to help building finite elements from polynomial spaces and should be called inside the constructor of an element. Applied to a completely initialized finite element, the result should be the unit matrix by definition of the node values.
Using this matrix allows the construction of the basis of shape functions in two steps.
Define the space of shape functions using an arbitrary basis w_{j} and compute the matrix M of node functionals N_{i} applied to these basis functions.
Compute the basis v_{j} of the finite element shape function space by applying M^{1} to the basis w_{j}.
Definition at line 633 of file fe_tools.cc.
void FETools::compute_embedding_matrices  (  const FiniteElement< dim, spacedim > &  fe, 
std::vector< std::vector< FullMatrix< number > > > &  matrices,  
const bool  isotropic_only = false , 

const double  threshold = 1.e12 

) 
For all possible (isotropic and anisotropic) refinement cases compute the embedding matrices from a coarse cell to the child cells. Each column of the resulting matrices contains the representation of a coarse grid basis function by the fine grid basis; the matrices are split such that there is one matrix for every child.
This function computes the coarse grid function in a sufficiently large number of quadrature points and fits the fine grid functions using least squares approximation. Therefore, the use of this function is restricted to the case that the finite element spaces are actually nested.
Note, that matrices[refinement_case1][child]
includes the embedding (or prolongation) matrix of child child
for the RefinementCase refinement_case
. Here, we use refinement_case1
instead of refinement_case
as for RefinementCase::no_refinement(=0) there are no prolongation matrices available.
Typically this function is called by the various implementations of FiniteElement classes in order to fill the respective FiniteElement::prolongation matrices.
fe  The finite element class for which we compute the embedding matrices. 
matrices  A reference to RefinementCase<dim>::isotropic_refinement vectors of FullMatrix objects. Each vector corresponds to one RefinementCase refinement_case and is of the vector size GeometryInfo<dim>::n_children(refinement_case). This is the format used in FiniteElement, where we want to use this function mostly. 
isotropic_only  Set to true if you only want to compute matrices for isotropic refinement. 
threshold  is the gap allowed in the least squares algorithm computing the embedding. 
Definition at line 891 of file fe_tools.cc.
void FETools::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.e12 

) 
Compute the embedding matrices on faces needed for constraint matrices.
fe  The finite element for which to compute these matrices. 
matrices  An array of GeometryInfo<dim>::subfaces_per_face = 2^{dim1} FullMatrix objects,holding the embedding matrix for each subface. 
face_coarse  The number of the face on the coarse side of the face for which this is computed. 
face_fine  The number of the face on the refined side of the face for which this is computed. 
threshold  is the gap allowed in the least squares algorithm computing the embedding. 
Definition at line 914 of file fe_tools.cc.
void FETools::compute_projection_matrices  (  const FiniteElement< dim, spacedim > &  fe, 
std::vector< std::vector< FullMatrix< number > > > &  matrices,  
const bool  isotropic_only = false 

) 
For all possible (isotropic and anisotropic) refinement cases compute the L^{2}projection matrices from the children to a coarse cell.
Note, that matrices[refinement_case1][child]
includes the projection (or restriction) matrix of child child
for the RefinementCase refinement_case
. Here, we use refinement_case1
instead of refinement_case
as for RefinementCase::no_refinement(=0) there are no projection matrices available.
Typically this function is called by the various implementations of FiniteElement classes in order to fill the respective FiniteElement::restriction matrices.
RefinementCase<dim>::isotropic_refinement
vectors of FullMatrix objects. Each vector corresponds to one RefinementCase refinement_case
and is of the vector size GeometryInfo<dim>::n_children(refinement_case)
. This is the format used in FiniteElement, where we want to use this function mostly.true
if you only want to compute matrices for isotropic refinement. Definition at line 1117 of file fe_tools.cc.
void FETools::compute_projection_from_quadrature_points_matrix  (  const FiniteElement< dim, spacedim > &  fe, 
const Quadrature< dim > &  lhs_quadrature,  
const Quadrature< dim > &  rhs_quadrature,  
FullMatrix< double > &  X  
) 
Projects scalar data defined in quadrature points to a finite element space on a single cell.
What this function does is the following: assume that there is scalar data u_{q}, 0 <= q < Q:=quadrature.size()
defined at the quadrature points of a cell, with the points defined by the given rhs_quadrature
object. We may then want to ask for that finite element function (on a single cell) v_{h}
in the finite dimensional space defined by the given FE object that is the projection of u
in the following sense:
Usually, the projection v_{h}
is that function that satisfies (v_{h},w)=(u,w)
for all discrete test functions w
. In the present case, we can't evaluate the right hand side, since u
is only defined in the quadrature points given by rhs_quadrature
, so we replace it by a quadrature approximation. Likewise, the left hand side is approximated using the lhs_quadrature
object; if this quadrature object is chosen appropriately, then the integration of the left hand side can be done exactly, without any approximation. The use of different quadrature objects is necessary if the quadrature object for the right hand side has too few quadrature points – for example, if data q
is only defined at the cell center, then the corresponding onepoint quadrature formula is obviously insufficient to approximate the scalar product on the left hand side by a definite form.
After these quadrature approximations, we end up with a nodal representation V_{h}
of v_{h}
that satisfies the following system of linear equations: M V_{h} = Q U
, where M_{ij}=(phi_i,phi_j)
is the mass matrix approximated by lhs_quadrature
, and Q
is the matrix Q_{iq}=phi_{i}(x_{q}) w_{q}
where w_{q}
are quadrature weights; U
is the vector of quadrature point data u_{q}
.
In order to then get the nodal representation V_{h}
of the projection of U
, one computes V_{h} = X U, X=M^{1} Q
. The purpose of this function is to compute the matrix X
and return it through the last argument of this function.
Note that this function presently only supports scalar data. An extension of the mass matrix is of course trivial, but one has to define the order of data in the vector U
if it contains vector valued data in all quadrature points.
A use for this function is described in the introduction to the step18 example program.
The opposite of this function, interpolation of a finite element function onto quadrature points is essentially what the FEValues::get_function_values
functions do; to make things a little simpler, the FETools::compute_interpolation_to_quadrature_points_matrix
provides the matrix form of this.
Note that this function works on a single cell, rather than an entire triangulation. In effect, it therefore doesn't matter if you use a continuous or discontinuous version of the finite element.
It is worth noting that there are a few confusing cases of this function. The first one is that it really only makes sense to project onto a finite element that has at most as many degrees of freedom per cell as there are quadrature points; the projection of N quadrature point data into a space with M>N unknowns is welldefined, but often yields funny and non intuitive results. Secondly, one would think that if the quadrature point data is defined in the support points of the finite element, i.e. the quadrature points of ths_quadrature
equal fe.get_unit_support_points()
, then the projection should be the identity, i.e. each degree of freedom of the finite element equals the value of the given data in the support point of the corresponding shape function. However, this is not generally the case: while the matrix Q
in that case is the identity matrix, the mass matrix M
is not equal to the identity matrix, except for the special case that the quadrature formula lhs_quadrature
also has its quadrature points in the support points of the finite element.
Finally, this function only defines a cell wise projection, while one frequently wants to apply it to all cells in a triangulation. However, if it is applied to one cell after the other, the results from later cells may overwrite nodal values computed already from previous cells if degrees of freedom live on the interfaces between cells. The function is therefore most useful for discontinuous elements.
Definition at line 1647 of file fe_tools.cc.
void FETools::compute_interpolation_to_quadrature_points_matrix  (  const FiniteElement< dim, spacedim > &  fe, 
const Quadrature< dim > &  quadrature,  
FullMatrix< double > &  I_q  
) 
Given a (scalar) local finite element function, compute the matrix that maps the vector of nodal values onto the vector of values of this function at quadrature points as given by the second argument. In a sense, this function does the opposite of the FETools::compute_projection_from_quadrature_points_matrix function.
Definition at line 1687 of file fe_tools.cc.
void FETools::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  
) 
Computes the projection of tensorial (firstorder tensor) data stored at the quadrature points vector_of_tensors_at_qp
to data vector_of_tensors_at_nodes
at the support points of the cell. The data in vector_of_tensors_at_qp
is ordered sequentially following the quadrature point numbering. The size of vector_of_tensors_at_qp
must correspond to the number of columns of projection_matrix
. The size of vector_of_tensors_at_nodes
must correspond to the number of rows of vector_of_tensors_at_nodes
. The projection matrix projection_matrix
describes the projection of scalar data from the quadrature points and can be obtained from the FETools::compute_projection_from_quadrature_points_matrix function.
Definition at line 1705 of file fe_tools.cc.
void FETools::compute_projection_from_quadrature_points  (  const FullMatrix< double > &  projection_matrix, 
const std::vector< SymmetricTensor< 2, dim > > &  vector_of_tensors_at_qp,  
std::vector< SymmetricTensor< 2, dim > > &  vector_of_tensors_at_nodes  
) 
same as last function but for a SymmetricTensor
.
Definition at line 1766 of file fe_tools.cc.
void FETools::compute_projection_from_face_quadrature_points_matrix  (  const FiniteElement< dim, spacedim > &  fe, 
const Quadrature< dim1 > &  lhs_quadrature,  
const Quadrature< dim1 > &  rhs_quadrature,  
const typename DoFHandler< dim, spacedim >::active_cell_iterator &  cell,  
const unsigned int  face,  
FullMatrix< double > &  X  
) 
This method implements the FETools::compute_projection_from_quadrature_points_matrix method for faces of a mesh. The matrix that it returns, X, is face specific and its size is fe.dofs_per_cell by rhs_quadrature.size(). The dimension, dim must be larger than 1 for this class, since Quadrature<dim1> objects are required. See the documentation on the Quadrature class for more information.
Definition at line 1836 of file fe_tools.cc.
void FETools::interpolate  (  const DoFHandlerType1< dim, spacedim > &  dof1, 
const InVector &  u1,  
const DoFHandlerType2< dim, spacedim > &  dof2,  
OutVector &  u2  
) 
Gives the interpolation of a the dof1function
u1
to a dof2function
u2
. dof1
and dof2
need to be DoFHandlers based on the same triangulation.
If the elements fe1
and fe2
are either both continuous or both discontinuous then this interpolation is the usual point interpolation. The same is true if fe1
is a continuous and fe2
is a discontinuous finite element. For the case that fe1
is a discontinuous and fe2
is a continuous finite element there is no point interpolation defined at the discontinuities. Therefore the mean value is taken at the DoF values on the discontinuities.
Note that for continuous elements on grids with hanging nodes (i.e. locally refined grids) this function does not give the expected output. Indeed, the resulting output vector does not necessarily respect continuity requirements at hanging nodes: if, for example, you are interpolating a Q2 field to a Q1 field, then at hanging nodes the output field will have the function value of the input field, which however is not usually the mean value of the two adjacent nodes. It is thus not part of the Q1 function space on the whole triangulation, although it is of course Q1 on each cell.
For this case (continuous elements on grids with hanging nodes), please use the interpolate()
function with an additional ConstraintMatrix argument, see below, or make the field conforming yourself by calling the distribute
function of your hanging node constraints object.
Definition at line 58 of file fe_tools_interpolate.cc.
void FETools::interpolate  (  const DoFHandlerType1< dim, spacedim > &  dof1, 
const InVector &  u1,  
const DoFHandlerType2< dim, spacedim > &  dof2,  
const ConstraintMatrix &  constraints,  
OutVector &  u2  
) 
Gives the interpolation of a the dof1function
u1
to a dof2function
u2
. dof1
and dof2
need to be DoFHandlers (or hp::DoFHandlers) based on the same triangulation. constraints
is a hanging node constraints object corresponding to dof2
. This object is particular important when interpolating onto continuous elements on grids with hanging nodes (locally refined grids).
If the elements fe1
and fe2
are either both continuous or both discontinuous then this interpolation is the usual point interpolation. The same is true if fe1
is a continuous and fe2
is a discontinuous finite element. For the case that fe1
is a discontinuous and fe2
is a continuous finite element there is no point interpolation defined at the discontinuities. Therefore the mean value is taken at the DoF values at the discontinuities.
Definition at line 75 of file fe_tools_interpolate.cc.
void FETools::back_interpolate  (  const DoFHandler< dim, spacedim > &  dof1, 
const InVector &  u1,  
const FiniteElement< dim, spacedim > &  fe2,  
OutVector &  u1_interpolated  
) 
Gives the interpolation of the fe1function
u1
to a fe2function
, and interpolates this to a second fe1function
named u1_interpolated
.
Note, that this function does not work on continuous elements at hanging nodes. For that case use the back_interpolate
function, below, that takes an additional ConstraintMatrix
object.
Furthermore note, that for the specific case when the finite element space corresponding to fe1
is a subset of the finite element space corresponding to fe2
, this function is simply an identity mapping.
Definition at line 240 of file fe_tools_interpolate.cc.
void FETools::back_interpolate  (  const DoFHandlerType< dim > &  dof1, 
const InVector &  u1,  
const FiniteElement< dim, spacedim > &  fe2,  
OutVector &  u1_interpolated  
) 
Same as last function, except that the dof handler objects might be of type hp::DoFHandler
.
Definition at line 321 of file fe_tools_interpolate.cc.
void FETools::back_interpolate  (  const DoFHandler< dim, spacedim > &  dof1, 
const ConstraintMatrix &  constraints1,  
const InVector &  u1,  
const DoFHandler< dim, spacedim > &  dof2,  
const ConstraintMatrix &  constraints2,  
OutVector &  u1_interpolated  
) 
Gives the interpolation of the dof1function
u1
to a dof2function
, and interpolates this to a second dof1function
named u1_interpolated
. constraints1
and constraints2
are the hanging node constraints corresponding to dof1
and dof2
, respectively. These objects are particular important when continuous elements on grids with hanging nodes (locally refined grids) are involved.
Furthermore note, that for the specific case when the finite element space corresponding to dof1
is a subset of the finite element space corresponding to dof2
, this function is simply an identity mapping.
Definition at line 521 of file fe_tools_interpolate.cc.
void FETools::interpolation_difference  (  const DoFHandler< dim, spacedim > &  dof1, 
const InVector &  z1,  
const FiniteElement< dim, spacedim > &  fe2,  
OutVector &  z1_difference  
) 
Gives \((IdI_h)z_1\) for a given dof1function
\(z_1\), where \(I_h\) is the interpolation from fe1
to fe2
. The result \((IdI_h)z_1\) is written into z1_difference
.
Note, that this function does not work for continuous elements at hanging nodes. For that case use the interpolation_difference
function, below, that takes an additional ConstraintMatrix
object.
Definition at line 552 of file fe_tools_interpolate.cc.
void FETools::interpolation_difference  (  const DoFHandler< dim, spacedim > &  dof1, 
const ConstraintMatrix &  constraints1,  
const InVector &  z1,  
const DoFHandler< dim, spacedim > &  dof2,  
const ConstraintMatrix &  constraints2,  
OutVector &  z1_difference  
) 
Gives \((IdI_h)z_1\) for a given dof1function
\(z_1\), where \(I_h\) is the interpolation from fe1
to fe2
. The result \((IdI_h)z_1\) is written into z1_difference
. constraints1
and constraints2
are the hanging node constraints corresponding to dof1
and dof2
, respectively. These objects are particular important when continuous elements on grids with hanging nodes (locally refined grids) are involved.
For parallel computations with PETSc, supply z1
with ghost elements and z1_difference
without ghost elements.
Definition at line 676 of file fe_tools_interpolate.cc.
void FETools::project_dg  (  const DoFHandler< dim, spacedim > &  dof1, 
const InVector &  u1,  
const DoFHandler< dim, spacedim > &  dof2,  
OutVector &  u2  
) 
\(L^2\) projection for discontinuous elements. Operates the same direction as interpolate.
The global projection can be computed by local matrices if the finite element spaces are discontinuous. With continuous elements, this is impossible, since a global mass matrix must be inverted.
Definition at line 699 of file fe_tools_interpolate.cc.
void FETools::extrapolate  (  const DoFHandler< dim, spacedim > &  dof1, 
const InVector &  z1,  
const DoFHandler< dim, spacedim > &  dof2,  
OutVector &  z2  
) 
Gives the patchwise extrapolation of a dof1
function z1
to a dof2
function z2
. dof1
and dof2
need to be DoFHandler objects based on the same triangulation. This function is used, for example, for extrapolating patchwise a piecewise linear solution to a piecewise quadratic solution.
The function's name is historical and probably not particularly well chosen. The function performs the following operations, one after the other:
dof1
to the corresponding cell of dof2
using the interpolation matrix of the finite element spaces used on these cells and provided by the finite element objects involved. This step is done using the FETools::interpolate() function.  It then performs a loop over all nonactive cells of dof2
. If such a nonactive cell has at least one active child, then we call the children of this cell a "patch". We then interpolate from the children of this patch to the patch, using the finite element space associated with dof2
and immediately interpolate back to the children. In essence, this information throws away all information in the solution vector that lives on a scale smaller than the patch cell.  Since we traverse nonactive cells from the coarsest to the finest levels, we may find patches that correspond to child cells of previously treated patches if the mesh had been refined adaptively (this cannot happen if the mesh has been refined globally because there the children of a patch are all active). We also perform the operation described above on these patches, but it is easy to see that on patches that are children of previously treated patches, the operation is now the identity operation (since it interpolates from the children of the current patch a function that had previously been interpolated to these children from an even coarser patch). Consequently, this does not alter the solution vector any more.The name of the function originates from the fact that it can be used to construct a representation of a function of higher polynomial degree on a once coarser mesh. For example, if you imagine that you start with a \(Q_1\) function on globally refined mesh, and that dof2
is associated with a \(Q_2\) element, then this function computes the equivalent of the operator \(I_{2h}^{(2)}\) interpolating the original piecewise linear function onto a quadratic function on a once coarser mesh with mesh size \(2h\) (but representing this function on the original mesh with size \(h\)). If the exact solution is sufficiently smooth, then \(u^\ast=I_{2h}^{(2)}u_h\) is typically a better approximation to the exact solution \(u\) of the PDE than \(u_h\) is. In other words, this function provides a postprocessing step that improves the solution in a similar way one often obtains by extrapolating a sequence of solutions, explaining the origin of the function's name.
extrapolate
function with an additional ConstraintMatrix argument, see below.Definition at line 742 of file fe_tools_interpolate.cc.
void FETools::extrapolate  (  const DoFHandler< dim, spacedim > &  dof1, 
const InVector &  z1,  
const DoFHandler< dim, spacedim > &  dof2,  
const ConstraintMatrix &  constraints,  
OutVector &  z2  
) 
Gives the patchwise extrapolation of a dof1
function z1
to a dof2
function z2
. dof1
and dof2
need to be DoFHandler objects based on the same triangulation. constraints
is a hanging node constraints object corresponding to dof2
. This object is necessary when interpolating onto continuous elements on grids with hanging nodes (locally refined grids).
Otherwise, the function does the same as the other extrapolate
function above (for which the documentation provides an extensive description of its operation).
Definition at line 755 of file fe_tools_interpolate.cc.
void FETools::hierarchic_to_lexicographic_numbering  (  unsigned int  degree, 
std::vector< unsigned int > &  h2l  
) 
The numbering of the degrees of freedom in continuous finite elements is hierarchic, i.e. in such a way that we first number the vertex dofs, in the order of the vertices as defined by the triangulation, then the line dofs in the order and respecting the direction of the lines, then the dofs on quads, etc. However, we could have, as well, numbered them in a lexicographic way, i.e. with indices first running in xdirection, then in ydirection and finally in zdirection. Discontinuous elements of class FE_DGQ() are numbered in this way, for example.
This function constructs a table which lexicographic index each degree of freedom in the hierarchic numbering would have. It operates on the continuous finite element given as first argument, and outputs the lexicographic indices in the second.
Note that since this function uses specifics of the continuous finite elements, it can only operate on FiniteElementData<dim> objects inherent in FE_Q(). However, this function does not take a FE_Q object as it is also invoked by the FE_Q() constructor.
It is assumed that the size of the output argument already matches the correct size, which is equal to the number of degrees of freedom in the finite element.
Definition at line 1896 of file fe_tools.cc.
std::vector< unsigned int > FETools::hierarchic_to_lexicographic_numbering  (  const FiniteElementData< dim > &  fe_data  ) 
Like the previous function but instead of returning its result through the last argument return it as a value.
Definition at line 2076 of file fe_tools.cc.
void FETools::lexicographic_to_hierarchic_numbering  (  const FiniteElementData< dim > &  fe_data, 
std::vector< unsigned int > &  l2h  
) 
This is the reverse function to the above one, generating the map from the lexicographic to the hierarchical numbering. All the remarks made about the above function are also valid here.
Definition at line 2086 of file fe_tools.cc.
std::vector< unsigned int > FETools::lexicographic_to_hierarchic_numbering  (  const FiniteElementData< dim > &  fe_data  ) 
Like the previous function but instead of returning its result through the last argument return it as a value.
Definition at line 2096 of file fe_tools.cc.
FiniteElement< dim, spacedim > * FETools::get_fe_by_name  (  const std::string &  name  ) 
Parse the name of a finite element and generate a finite element object accordingly. The parser ignores space characters between words (things matching the regular expression [AZaz09_]).
The name must be in the form which is returned by the FiniteElement::get_name function, where dimension template parameters <2> etc. can be omitted. Alternatively, the explicit number can be replaced by dim
or d
. If a number is given, it must match the template parameter of this function.
The names of FESystem elements follow the pattern FESystem[FE_Base1^p1FE_Base2^p2]
The powers p1
etc. may either be numbers or can be replaced by dim
or d
.
If no finite element can be reconstructed from this string, an exception of type FETools::ExcInvalidFEName
is thrown.
The function returns a pointer to a newly create finite element. It is in the caller's responsibility to destroy the object pointed to at an appropriate later time.
Since the value of the template argument can't be deduced from the (string) argument given to this function, you have to explicitly specify it when you call this function.
This function knows about all the standard elements defined in the library. However, it doesn't by default know about elements that you may have defined in your program. To make your own elements known to this function, use the add_fe_name() function. This function does not work if one wants to get a codimension 1 finite element.
Definition at line 1549 of file fe_tools.cc.
FiniteElement<dim,dim>* FETools::get_fe_from_name  (  const std::string &  name  ) 
Definition at line 1638 of file fe_tools.cc.
void FETools::add_fe_name  (  const std::string &  name, 
const FEFactoryBase< dim, spacedim > *  factory  
) 
Extend the list of finite elements that can be generated by get_fe_from_name() by the one given as name
. If get_fe_from_name() is later called with this name, it will use the object given as second argument to create a finite element object.
The format of the name
parameter should include the name of a finite element. However, it is safe to use either the class name alone or to use the result of FiniteElement::get_name (which includes the space dimension as well as the polynomial degree), since everything after the first non name character will be ignored.
The FEFactory object should be an object newly created with new
. FETools will take ownership of this object and delete it once it is not used anymore.
In most cases, if you want objects of type MyFE
be created whenever the name my_fe
is given to get_fe_from_name, you will want the second argument to this function be of type FEFactory<MyFE>, but you can of course create your custom finite element factory class.
This function takes over ownership of the object given as second argument, i.e. you should never attempt to destroy it later on. The object will be deleted at the end of the program's lifetime.
If the name of the element is already in use, an exception is thrown. Thus, functionality of get_fe_from_name() can only be added, not changed.
Note also that this table exists once for each space dimension. If you have a program that works with finite elements in different space dimensions (for example, step4 does something like this), then you should call this function for each space dimension for which you want your finite element added to the map.
Definition at line 1277 of file fe_tools.cc.
FiniteElement<dim>* FETools::get_fe_from_name  (  const std::string &  name  ) 
Definition at line 1638 of file fe_tools.cc.