Public Member Functions | |
FE_Q_Hierarchical (const unsigned int p) | |
virtual std::string | get_name () const |
virtual bool | has_support_on_face (const unsigned int shape_index, const unsigned int face_index) const |
virtual unsigned int | memory_consumption () const |
std::vector< unsigned int > | get_embedding_dofs (const unsigned int sub_degree) const |
template<> | |
void | initialize_unit_face_support_points () |
template<> | |
bool | has_support_on_face (const unsigned int, const unsigned int) const |
template<> | |
std::vector< unsigned int > | face_fe_q_hierarchical_to_hierarchic_numbering (const unsigned int) |
Protected Member Functions | |
virtual FiniteElement< dim > * | clone () const |
Private Member Functions | |
void | build_dofs_cell (std::vector< FullMatrix< double > > &dofs_cell, std::vector< FullMatrix< double > > &dofs_subcell) const |
void | initialize_constraints (const std::vector< FullMatrix< double > > &dofs_subcell) |
void | initialize_embedding_and_restriction (const std::vector< FullMatrix< double > > &dofs_cell, const std::vector< FullMatrix< double > > &dofs_subcell) |
void | initialize_unit_support_points () |
void | initialize_unit_face_support_points () |
Static Private Member Functions | |
static std::vector< unsigned int > | get_dpo_vector (const unsigned int degree) |
static std::vector< unsigned int > | hierarchic_to_fe_q_hierarchical_numbering (const FiniteElementData< dim > &fe) |
static std::vector< unsigned int > | face_fe_q_hierarchical_to_hierarchic_numbering (const unsigned int degree) |
Private Attributes | |
const std::vector< unsigned int > | face_renumber |
Friends | |
class | FE_Q_Hierarchical |
Implementation of Hierarchical finite elements Qp
that yield the finite element space of continuous, piecewise polynomials of degree p
. This class is realized using tensor product polynomials based on a hierarchical basis Hierarchical
of the interval [0,1]
which is suitable for building an hp
tensor product finite element, if we assume that each element has a single degree.
There are not many differences between FE_Q_Hierarchical
and FE_Q
, except that we add a function embedding_dofs
that takes a given integer q
, between 1
and p
, and returns the numbering of basis functions of the element of order q
in basis of order p
. This function is useful if one wants to make calculations using the hierarchical nature of these shape functions.
The unit support points now are reduced to 0
, 1
, and 0.5
in one dimension, and tensor products in higher dimensions. Thus, various interpolation functions will only work correctly for the linear case. Future work will involve writing projection--interpolation operators that can interpolate onto the higher order bubble functions.
The various constraint, prolongation, and restriction matrices are now available in all dimensions for all degrees p
, currently up to order 19.
The constructor of this class takes the degree p
of this finite element.
This class is not implemented for the codimension one case (spacedim != dim
).
The constructor creates a TensorProductPolynomials object that includes the tensor product of Hierarchical
polynomials of degree p
. This TensorProductPolynomials
object provides all values and derivatives of the shape functions.
The original ordering of the shape functions represented by the TensorProductPolynomials is a tensor product numbering. However, the shape functions on a cell are renumbered beginning with the shape functions whose support points are at the vertices, then on the line, on the quads, and finally (for 3d) on the hexes. To be explicit, these numberings are listed in the following:
1D case:
* 0-------1 *
2D case:
* 2-------3 * | | * | | * | | * 0-------1 *
3D case:
* 6-------7 6-------7 * /| | / /| * / | | / / | * / | | / / | * 4 | | 4-------5 | * | 2-------3 | | 3 * | / / | | / * | / / | | / * |/ / | |/ * 0-------1 0-------1 *
The respective coordinate values of the support points of the degrees of freedom are as follows:
[0, 0, 0]
; [1, 0, 0]
; [0, 1, 0]
; [1, 1, 0]
; [0, 0, 1]
; [1, 0, 1]
; [0, 1, 1]
; [1, 1, 1]
; 1D case:
* 0---2---1 *
2D case:
* 2---7---3 * | | * 4 8 5 * | | * 0---6---1 *
3D case:
* 6--15---7 6--15---7 * /| | / /| * 12 | 19 12 1319 * / 18 | / / | * 4 | | 4---14--5 | * | 2---11--3 | | 3 * | / / | 17 / * 16 8 9 16 | 9 * |/ / | |/ * 0---10--1 0---8---1 * * *-------* *-------* * /| | / /| * / | 23 | / 25 / | * / | | / / | * * | | *-------* | * |20 *-------* | |21 * * | / / | 22 | / * | / 24 / | | / * |/ / | |/ * *-------* *-------* *
The center vertex has number 26.
The respective coordinate values of the support points of the degrees of freedom are as follows:
[0, 0, 0]
; [1, 0, 0]
; [0, 1, 0]
; [1, 1, 0]
; [0, 0, 1]
; [1, 0, 1]
; [0, 1, 1]
; [1, 1, 1]
; [0, 1/2, 0]
; [1, 1/2, 0]
; [1/2, 0, 0]
; [1/2, 1, 0]
; [0, 1/2, 1]
; [1, 1/2, 1]
; [1/2, 0, 1]
; [1/2, 1, 1]
; [0, 0, 1/2]
; [1, 0, 1/2]
; [0, 1, 1/2]
; [1, 1, 1/2]
; [0, 1/2, 1/2]
; [1, 1/2, 1/2]
; [1/2, 0, 1/2]
; [1/2, 1, 1/2]
; [1/2, 1/2, 0]
; [1/2, 1/2, 1]
; [1/2, 1/2, 1/2]
; 1D case:
* 0--2--3--1 *
* 2--10-11-3 * | | * 5 14 15 7 * | | * 4 12 13 6 * | | * 0--8--9--1 *
1D case:
* 0--2--3--4--1 *
* 2--13-14-15-3 * | | * 6 22 23 24 9 * | | * 5 19 20 21 8 * | | * 4 16 17 18 7 * | | * 0--10-11-12-1 *
FE_Q_Hierarchical< dim >::FE_Q_Hierarchical | ( | const unsigned int | p | ) |
Constructor for tensor product polynomials of degree p
.
virtual std::string FE_Q_Hierarchical< dim >::get_name | ( | ) | const [virtual] |
Return a string that uniquely identifies a finite element. This class returns FE_Q_Hierarchical<dim>(degree)
, with dim
and degree
replaced by appropriate values.
Implements FiniteElement< dim, dim >.
virtual bool FE_Q_Hierarchical< dim >::has_support_on_face | ( | const unsigned int | shape_index, | |
const unsigned int | face_index | |||
) | const [virtual] |
Check for non-zero values on a face.
This function returns true
, if the shape function shape_index
has non-zero values on the face face_index
.
Implementation of the interface in FiniteElement
Reimplemented from FiniteElement< dim, dim >.
virtual unsigned int FE_Q_Hierarchical< dim >::memory_consumption | ( | ) | const [virtual] |
Determine an estimate for the memory consumption (in bytes) of this object.
This function is made virtual, since finite element objects are usually accessed through pointers to their base class, rather than the class itself.
Reimplemented from FiniteElement< dim, dim >.
std::vector<unsigned int> FE_Q_Hierarchical< dim >::get_embedding_dofs | ( | const unsigned int | sub_degree | ) | const |
For a finite element of degree sub_degree
< degree
, we return a vector which maps the numbering on an FE of degree sub_degree
into the numbering on this element.
virtual FiniteElement<dim>* FE_Q_Hierarchical< dim >::clone | ( | ) | const [protected, virtual] |
clone
function instead of a copy constructor.
This function is needed by the constructors of FESystem
.
Implements FiniteElement< dim, dim >.
static std::vector<unsigned int> FE_Q_Hierarchical< dim >::get_dpo_vector | ( | const unsigned int | degree | ) | [static, private] |
Only for internal use. Its full name is get_dofs_per_object_vector
function and it creates the dofs_per_object
vector that is needed within the constructor to be passed to the constructor of FiniteElementData
.
static std::vector<unsigned int> FE_Q_Hierarchical< dim >::hierarchic_to_fe_q_hierarchical_numbering | ( | const FiniteElementData< dim > & | fe | ) | [static, private] |
The numbering of the degrees of freedom in continous 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.
The dofs associated with 1d hierarchical polynomials are ordered with the vertices first ( and
) and then the line dofs (the higher degree polynomials). The 2d and 3d hierarchical polynomials originate from the 1d hierarchical polynomials by tensor product. In the following, the resulting numbering of dofs will be denoted by `fe_q_hierarchical numbering`.
This function constructs a table which fe_q_hierarchical index each degree of freedom in the hierarchic numbering would have.
This function is anologous to the FETools::hierarchical_to_lexicographic_numbering() function. However, in contrast to the fe_q_hierarchical numbering defined above, the lexicographic numbering originates from the tensor products of consecutive numbered dofs (like for LagrangeEquidistant).
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.
static std::vector<unsigned int> FE_Q_Hierarchical< dim >::face_fe_q_hierarchical_to_hierarchic_numbering | ( | const unsigned int | degree | ) | [static, private] |
This is an analogon to the previous function, but working on faces.
void FE_Q_Hierarchical< dim >::build_dofs_cell | ( | std::vector< FullMatrix< double > > & | dofs_cell, | |
std::vector< FullMatrix< double > > & | dofs_subcell | |||
) | const [private] |
Initialize two auxiliary fields that will be used in setting up the various matrices in the constructor.
void FE_Q_Hierarchical< dim >::initialize_constraints | ( | const std::vector< FullMatrix< double > > & | dofs_subcell | ) | [private] |
Initialize the hanging node constraints matrices. Called from the constructor.
void FE_Q_Hierarchical< dim >::initialize_embedding_and_restriction | ( | const std::vector< FullMatrix< double > > & | dofs_cell, | |
const std::vector< FullMatrix< double > > & | dofs_subcell | |||
) | [private] |
Initialize the embedding matrices. Called from the constructor.
void FE_Q_Hierarchical< dim >::initialize_unit_support_points | ( | ) | [private] |
Initialize the unit_support_points
field of the FiniteElement class. Called from the constructor.
void FE_Q_Hierarchical< dim >::initialize_unit_face_support_points | ( | ) | [private] |
Initialize the unit_face_support_points
field of the FiniteElement class. Called from the constructor.
void FE_Q_Hierarchical< 1 >::initialize_unit_face_support_points | ( | ) | [inline] |
bool FE_Q_Hierarchical< 1 >::has_support_on_face | ( | const unsigned int | shape_index, | |
const unsigned int | face_index | |||
) | const [inline, virtual] |
Check for non-zero values on a face in order to optimize out matrix elements.
This function returns true
, if the shape function shape_index
has non-zero values on the face face_index
.
A default implementation is provided in this basis class which always returns true
. This is the safe way to go.
Reimplemented from FiniteElement< dim, dim >.
std::vector< unsigned int > FE_Q_Hierarchical< 1 >::face_fe_q_hierarchical_to_hierarchic_numbering | ( | const unsigned | int | ) | [inline] |
friend class FE_Q_Hierarchical [friend] |
Allow access from other dimensions. We need this since we want to call the functions get_dpo_vector
and lexicographic_to_hierarchic_numbering
for the faces of the finite element of dimension dim+1.
const std::vector<unsigned int> FE_Q_Hierarchical< dim >::face_renumber [private] |
Mapping from lexicographic to shape function numbering on first face.