Reference documentation for deal.II version Git 8382684c1d 2019-11-18 13:30:09 -0500
\(\newcommand{\dealcoloneq}{\mathrel{\vcenter{:}}=}\)
Classes | Public Member Functions | Private Attributes | List of all members
hp::FECollection< dim, spacedim > Class Template Reference

#include <deal.II/hp/fe_collection.h>

Inheritance diagram for hp::FECollection< dim, spacedim >:
[legend]

Classes

struct  DefaultHierarchy
 

Public Member Functions

 FECollection ()
 
 FECollection (const FiniteElement< dim, spacedim > &fe)
 
template<class... FETypes>
 FECollection (const FETypes &... fes)
 
 FECollection (const std::vector< const FiniteElement< dim, spacedim > *> &fes)
 
 FECollection (const FECollection< dim, spacedim > &)=default
 
 FECollection (FECollection< dim, spacedim > &&) noexcept(std::is_nothrow_move_constructible< std::vector< std::shared_ptr< const FiniteElement< dim, spacedim >>>>::value &&std::is_nothrow_move_constructible< std::function< unsigned int(const typename hp::FECollection< dim, spacedim > &, const unsigned int)>>::value)=default
 
FECollection< dim, spacedim > & operator= (FECollection< dim, spacedim > &&)=default
 
bool operator== (const FECollection< dim, spacedim > &fe_collection) const
 
bool operator!= (const FECollection< dim, spacedim > &fe_collection) const
 
void push_back (const FiniteElement< dim, spacedim > &new_fe)
 
const FiniteElement< dim, spacedim > & operator[] (const unsigned int index) const
 
unsigned int size () const
 
unsigned int n_components () const
 
unsigned int n_blocks () const
 
unsigned int max_dofs_per_vertex () const
 
unsigned int max_dofs_per_line () const
 
unsigned int max_dofs_per_quad () const
 
unsigned int max_dofs_per_hex () const
 
unsigned int max_dofs_per_face () const
 
unsigned int max_dofs_per_cell () const
 
std::size_t memory_consumption () const
 
bool hp_constraints_are_implemented () const
 
unsigned int find_least_face_dominating_fe (const std::set< unsigned int > &fes) const
 
std::set< unsigned int > find_common_fes (const std::set< unsigned int > &fes, const unsigned int codim=0) const
 
std::set< unsigned int > find_enclosing_fes (const std::set< unsigned int > &fes, const unsigned int codim=0) const
 
unsigned int find_dominating_fe (const std::set< unsigned int > &fes, const unsigned int codim=0) const
 
unsigned int find_dominated_fe (const std::set< unsigned int > &fes, const unsigned int codim=0) const
 
unsigned int find_dominating_fe_extended (const std::set< unsigned int > &fes, const unsigned int codim=0) const
 
unsigned int find_dominated_fe_extended (const std::set< unsigned int > &fes, const unsigned int codim=0) const
 
void set_hierarchy (const std::function< unsigned int(const typename hp::FECollection< dim, spacedim > &, const unsigned int)> &next, const std::function< unsigned int(const typename hp::FECollection< dim, spacedim > &, const unsigned int)> &prev)
 
void set_default_hierarchy ()
 
unsigned int next_in_hierarchy (const unsigned int fe_index) const
 
unsigned int previous_in_hierarchy (const unsigned int fe_index) const
 
ComponentMask component_mask (const FEValuesExtractors::Scalar &scalar) const
 
ComponentMask component_mask (const FEValuesExtractors::Vector &vector) const
 
ComponentMask component_mask (const FEValuesExtractors::SymmetricTensor< 2 > &sym_tensor) const
 
ComponentMask component_mask (const BlockMask &block_mask) const
 
BlockMask block_mask (const FEValuesExtractors::Scalar &scalar) const
 
BlockMask block_mask (const FEValuesExtractors::Vector &vector) const
 
BlockMask block_mask (const FEValuesExtractors::SymmetricTensor< 2 > &sym_tensor) const
 
BlockMask block_mask (const ComponentMask &component_mask) const
 
- Public Member Functions inherited from Subscriptor
 Subscriptor ()
 
 Subscriptor (const Subscriptor &)
 
 Subscriptor (Subscriptor &&) noexcept
 
virtual ~Subscriptor ()
 
Subscriptoroperator= (const Subscriptor &)
 
Subscriptoroperator= (Subscriptor &&) noexcept
 
void subscribe (std::atomic< bool > *const validity, const std::string &identifier="") const
 
void unsubscribe (std::atomic< bool > *const validity, const std::string &identifier="") const
 
unsigned int n_subscriptions () const
 
template<typename StreamType >
void list_subscribers (StreamType &stream) const
 
void list_subscribers () const
 
template<class Archive >
void serialize (Archive &ar, const unsigned int version)
 

Static Public Member Functions

Exceptions
static ::ExceptionBaseExcNoFiniteElements ()
 
static ::ExceptionBaseExcNoDominatedFiniteElementAmongstChildren ()
 
- Static Public Member Functions inherited from Subscriptor
static ::ExceptionBaseExcInUse (int arg1, std::string arg2, std::string arg3)
 
static ::ExceptionBaseExcNoSubscriber (std::string arg1, std::string arg2)
 

Private Attributes

std::vector< std::shared_ptr< const FiniteElement< dim, spacedim > > > finite_elements
 
std::function< unsigned int(const typename hp::FECollection< dim, spacedim > &, const unsigned int)> hierarchy_next
 
std::function< unsigned int(const typename hp::FECollection< dim, spacedim > &, const unsigned int)> hierarchy_prev
 

Detailed Description

template<int dim, int spacedim = dim>
class hp::FECollection< dim, spacedim >

This class acts as a collection of finite element objects used in the hp::DoFHandler. It is thus to a hp::DoFHandler what a FiniteElement is to a DoFHandler.

It implements the concepts stated in the hp Collections module described in the doxygen documentation.

In addition to offering access to the elements of the collection, this class provides access to the maximal number of degrees of freedom per vertex, line, etc, to allow allocation of as much memory as is necessary in the worst case when using the finite elements associated with the cells of a triangulation.

This class has not yet been implemented for the use in the codimension one case (spacedim != dim ).

Author
Wolfgang Bangerth, 2003

Definition at line 54 of file fe_collection.h.

Constructor & Destructor Documentation

◆ FECollection() [1/6]

template<int dim, int spacedim>
hp::FECollection< dim, spacedim >::FECollection ( )

Default constructor. Leads to an empty collection that can later be filled using push_back(). Establishes a hierarchy of finite elements corresponding to their index in the collection.

Definition at line 249 of file fe_collection.cc.

◆ FECollection() [2/6]

template<int dim, int spacedim>
hp::FECollection< dim, spacedim >::FECollection ( const FiniteElement< dim, spacedim > &  fe)
explicit

Conversion constructor. This constructor creates a FECollection from a single finite element. More finite element objects can be added with push_back(), if desired, though it would probably be clearer to add all mappings the same way.

Definition at line 257 of file fe_collection.cc.

◆ FECollection() [3/6]

template<int dim, int spacedim>
template<class... FETypes>
hp::FECollection< dim, spacedim >::FECollection ( const FETypes &...  fes)
explicit

Constructor. This constructor creates a FECollection from one or more finite element objects passed to the constructor. For this call to be valid, all arguments need to be of types derived from class FiniteElement<dim,spacedim>.

Definition at line 827 of file fe_collection.h.

◆ FECollection() [4/6]

template<int dim, int spacedim>
hp::FECollection< dim, spacedim >::FECollection ( const std::vector< const FiniteElement< dim, spacedim > *> &  fes)

Constructor. Same as above but for any number of elements. Pointers to the elements are passed in a vector to this constructor. As above, the finite element objects pointed to by the argument are not actually used other than to create copies internally. Consequently, you can delete these pointers immediately again after calling this constructor.

Definition at line 267 of file fe_collection.cc.

◆ FECollection() [5/6]

template<int dim, int spacedim = dim>
hp::FECollection< dim, spacedim >::FECollection ( const FECollection< dim, spacedim > &  )
default

Copy constructor.

◆ FECollection() [6/6]

template<int dim, int spacedim = dim>
hp::FECollection< dim, spacedim >::FECollection ( FECollection< dim, spacedim > &&  ) const &
defaultnoexcept

Move constructor.

Note
The implementation of standard datatypes may change with different libraries, so their move members may or may not be flagged non-throwing. We need to explicitly set the noexcept specifier according to its member variables to still get the performance benefits (and to satisfy clang-tidy).

Member Function Documentation

◆ operator=()

template<int dim, int spacedim = dim>
FECollection<dim, spacedim>& hp::FECollection< dim, spacedim >::operator= ( FECollection< dim, spacedim > &&  )
default

Move assignment operator.

◆ operator==()

template<int dim, int spacedim>
bool hp::FECollection< dim, spacedim >::operator== ( const FECollection< dim, spacedim > &  fe_collection) const
inline

Equality comparison operator. All stored FiniteElement objects are compared in order.

Definition at line 874 of file fe_collection.h.

◆ operator!=()

template<int dim, int spacedim>
bool hp::FECollection< dim, spacedim >::operator!= ( const FECollection< dim, spacedim > &  fe_collection) const
inline

Non-equality comparison operator. All stored FiniteElement objects are compared in order.

Definition at line 892 of file fe_collection.h.

◆ push_back()

template<int dim, int spacedim>
void hp::FECollection< dim, spacedim >::push_back ( const FiniteElement< dim, spacedim > &  new_fe)

Add a finite element. This function generates a copy of the given element, i.e. you can do things like push_back(FE_Q<dim>(1));. The internal copy is later destroyed by this object upon destruction of the entire collection.

When a new element is added, it needs to have the same number of vector components as all other elements already in the collection.

Definition at line 282 of file fe_collection.cc.

◆ operator[]()

template<int dim, int spacedim>
const FiniteElement< dim, spacedim > & hp::FECollection< dim, spacedim >::operator[] ( const unsigned int  index) const
inline

Get a reference to the given element in this collection.

Precondition
index must be between zero and the number of elements of the collection.

Definition at line 901 of file fe_collection.h.

◆ size()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::size ( ) const
inline

Return the number of finite element objects stored in this collection.

Definition at line 846 of file fe_collection.h.

◆ n_components()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::n_components ( ) const
inline

Return the number of vector components of the finite elements in this collection. This number must be the same for all elements in the collection.

This function calls FiniteElement::n_components. See the glossary for more information.

Definition at line 854 of file fe_collection.h.

◆ n_blocks()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::n_blocks ( ) const

Return the number of vector blocks of the finite elements in this collection. While this class ensures that all elements stored in it have the same number of vector components, there is no such guarantees for the number of blocks each element is made up of (an element may have fewer blocks than vector components; see the glossary for more information). For example, you may have an FECollection object that stores one copy of an FESystem with dim FE_Q objects and one copy of an FE_RaviartThomas element. Both have dim vector components but while the former has dim blocks the latter has only one. Consequently, this function will throw an assertion if the number of blocks is not the same for all elements. If they are the same, this function returns the result of FiniteElement::n_blocks().

Definition at line 531 of file fe_collection.cc.

◆ max_dofs_per_vertex()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::max_dofs_per_vertex ( ) const

Return the maximal number of degrees of freedom per vertex over all elements of this collection.

Definition at line 912 of file fe_collection.h.

◆ max_dofs_per_line()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::max_dofs_per_line ( ) const

Return the maximal number of degrees of freedom per line over all elements of this collection.

Definition at line 928 of file fe_collection.h.

◆ max_dofs_per_quad()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::max_dofs_per_quad ( ) const

Return the maximal number of degrees of freedom per quad over all elements of this collection.

Definition at line 944 of file fe_collection.h.

◆ max_dofs_per_hex()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::max_dofs_per_hex ( ) const

Return the maximal number of degrees of freedom per hex over all elements of this collection.

Definition at line 960 of file fe_collection.h.

◆ max_dofs_per_face()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::max_dofs_per_face ( ) const

Return the maximal number of degrees of freedom per face over all elements of this collection.

Definition at line 976 of file fe_collection.h.

◆ max_dofs_per_cell()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::max_dofs_per_cell ( ) const

Return the maximal number of degrees of freedom per cell over all elements of this collection.

Definition at line 992 of file fe_collection.h.

◆ memory_consumption()

template<int dim, int spacedim>
std::size_t hp::FECollection< dim, spacedim >::memory_consumption ( ) const

Return an estimate for the memory allocated for this object.

Definition at line 548 of file fe_collection.cc.

◆ hp_constraints_are_implemented()

template<int dim, int spacedim>
bool hp::FECollection< dim, spacedim >::hp_constraints_are_implemented ( ) const

Return whether all elements in this collection implement the hanging node constraints in the new way, which has to be used to make elements "hp compatible". If this is not the case, the function returns false, which implies, that at least one element in the FECollection does not support the new face interface constraints. On the other hand, if this method does return true, this does not imply that the hp method will work!

This behaviour is related to the fact, that FiniteElement classes, which provide the new style hanging node constraints might still not provide them for all possible cases. If FE_Q and FE_RaviartThomas elements are included in the FECollection and both properly implement the get_face_interpolation_matrix method, this method will return true. But the get_face_interpolation_matrix might still fail to find an interpolation matrix between these two elements.

Definition at line 1007 of file fe_collection.h.

◆ find_least_face_dominating_fe()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::find_least_face_dominating_fe ( const std::set< unsigned int > &  fes) const

Try to find a least dominant finite element inside this FECollection which dominates all of those finite elements in the current collection indexed by the numbers provided through fes . In other words, we first form the set of elements in this collection that dominate all of the ones that are indexed by the argument fes, and then within that set of dominating elements, we find the least dominant one.

For example, if an FECollection consists of {FE_Q(1),FE_Q(2),FE_Q(3),FE_Q(4)} elements and the argument fes equals {2,3}, then the set of dominating elements consists of {0,1,2}, of which 2 (i.e., the FE_Q(3)) is the least dominant one, and then that's what the function returns.

On the other hand, if the FECollection consists of {FE_Q(1)xFE_Q(1),FE_Q(2)xFE_Q(2),FE_Q(2)xFE_Q(3),FE_Q(3)xFE_Q(2)} elements and the argument is again fes equal to {2,3}, then the set of dominating elements consists of {0,1} because now neither of the last two elements dominates the other, of which 1 (i.e., the FE_Q(2)xFE_Q(2)) is the least dominant one – so that's what the function returns in this case.

For the purpose of this function by domination we consider either FiniteElementDomination::Domination::this_element_dominates or FiniteElementDomination::Domination::either_element_can_dominate; therefore the element can dominate itself. Thus, if an FECollection contains {FE_Q(1),FE_Q(2),FE_Q(3),FE_Q(4)} and fes only has a single element {3}, then the function returns 3.

If the function is not able to find a finite element that satisfies the description above, the function returns numbers::invalid_unsigned_int. An example would go like this: If the FECollection consists of {FE_Nothing x FE_Nothing, FE_Q(1)xFE_Q(2), FE_Q(2)xFE_Q(1)} with fes as {1}, the function will not find a most dominating element as the default behavior of FE_Nothing is to return FiniteElementDomination::no_requirements when comparing for face domination with any other element. In other words, the set of dominating elements is empty, and we can not find a least dominant one among it. The return value is therefore numbers::invalid_unsigned_int.

Deprecated:
This function has been succeeded by hp::FECollection::find_dominating_fe_extended(fes, 1). To recreate its exact behavior, use code such as fe_collection.find_dominated_fe( fe_collection.find_common_fes(fes, 1), 1).

Definition at line 27 of file fe_collection.cc.

◆ find_common_fes()

template<int dim, int spacedim>
std::set< unsigned int > hp::FECollection< dim, spacedim >::find_common_fes ( const std::set< unsigned int > &  fes,
const unsigned int  codim = 0 
) const

Return the indices of finite elements in this FECollection that dominate all elements associated with the provided set of indices fes.

You may find information about the domination behavior of finite elements in their respecitve class documentation or in the implementation of their inherited member function FiniteElement::compare_for_domination(). Consider that a finite element may or may not dominate itself (e.g. FE_Nothing elements).

For example, if a FECollection consists of {FE_Q(1),FE_Q(2),FE_Q(3),FE_Q(4)} elements and we are looking for the finite elements that dominate the middle elements of this collection (i.e., fes is {1,2}), then the answer is {FE_Q(1),FE_Q(2) and therefore this function will return their indices in the FECollection, namely {0,1}.

The codim parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison. See FiniteElement::compare_for_domination() for more information.

Definition at line 38 of file fe_collection.cc.

◆ find_enclosing_fes()

template<int dim, int spacedim>
std::set< unsigned int > hp::FECollection< dim, spacedim >::find_enclosing_fes ( const std::set< unsigned int > &  fes,
const unsigned int  codim = 0 
) const

Return the indices of finite elements in this FECollection that are dominated by all elements associated with the provided set of indices fes.

You may find information about the domination behavior of finite elements in their respecitve class documentation or in the implementation of their inherited member function FiniteElement::compare_for_domination(). Consider that a finite element may or may not dominate itself (e.g. FE_Nothing elements).

For example, if a FECollection consists of {FE_Q(1),FE_Q(2),FE_Q(3),FE_Q(4)} elements and we are looking for the finite elements that are dominated by the middle elements of this collection (i.e., fes is {1,2}), then the answer is {FE_Q(3),FE_Q(4) and therefore this function will return their indices in the FECollection, namely {2,3}.

The codim parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison. See FiniteElement::compare_for_domination() for more information.

Definition at line 78 of file fe_collection.cc.

◆ find_dominating_fe()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::find_dominating_fe ( const std::set< unsigned int > &  fes,
const unsigned int  codim = 0 
) const

Return the index of a finite element from the provided set of indices fes that dominates all other elements of this very set.

You may find information about the domination behavior of finite elements in their respecitve class documentation or in the implementation of their inherited member function FiniteElement::compare_for_domination(). Consider that a finite element may or may not dominate itself (e.g. FE_Nothing elements).

If this set consists of exactly one element, we consider it to be the dominating one and return its corresponding index. Further, if the function is not able to find a finite element at all, it returns numbers::invalid_unsigned_int.

For example, if a FECollection consists of {FE_Q(1),FE_Q(2),FE_Q(3),FE_Q(4)} elements and we are looking for the dominating finite element among the middle elements of this collection (i.e., fes is {1,2}), then the answer is FE_Q(2) and therefore this function will return its index in the FECollection, namely 1.

It is of course possible that there is more than one element that dominates all selected elements. For example, if the collection consists of {FE_Q(1),FE_Q(1),FE_Q(2),FE_Q(2)} and fes covers all indices, then one could return zero or one. In that case, the function returns either 0 or 1 since there is no tie-breaker between the two.

The codim parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison. See FiniteElement::compare_for_domination() for more information.

Definition at line 118 of file fe_collection.cc.

◆ find_dominated_fe()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::find_dominated_fe ( const std::set< unsigned int > &  fes,
const unsigned int  codim = 0 
) const

Return the index of a finite element from the provided set of indices fes that is dominated by all other elements of this very set.

You may find information about the domination behavior of finite elements in their respecitve class documentation or in the implementation of their inherited member function FiniteElement::compare_for_domination(). Consider that a finite element may or may not dominate itself (e.g. FE_Nothing elements).

If this set consists of exactly one element, we consider it to be the dominated one and return its corresponding index. Further, if the function is not able to find a finite element at all, it returns numbers::invalid_unsigned_int.

For example, if a FECollection consists of {FE_Q(1),FE_Q(2),FE_Q(3),FE_Q(4)} elements and we are looking for the dominated finite element among the middle elements of this collection (i.e., fes is {1,2}), then the answer is FE_Q(3) and therefore this function will return its index in the FECollection, namely 2.

It is of course possible that there is more than one element that is dominated by all selected elements. For example, if the collection consists of {FE_Q(1),FE_Q(1),FE_Q(2),FE_Q(2)} and fes covers all indices, then one could return two or three. In that case, the function returns either 2 or 3 since there is no tie-breaker between the two.

The codim parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison. See FiniteElement::compare_for_domination() for more information.

Definition at line 164 of file fe_collection.cc.

◆ find_dominating_fe_extended()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::find_dominating_fe_extended ( const std::set< unsigned int > &  fes,
const unsigned int  codim = 0 
) const

Return the index of a finite element from the provided set of indices fes that dominates all other elements of this very set. If we do not succeed, we extend our search on the whole collection by picking the least dominating one, which is the element that describes the largest finite element space of which all of the finite elements of the provided set fes are part of.

You may find information about the domination behavior of finite elements in their respecitve class documentation or in the implementation of their inherited member function FiniteElement::compare_for_domination(). Consider that a finite element may or may not dominate itself (e.g. FE_Nothing elements).

If this set consists of exactly one element, we consider it to be the dominated one and return its corresponding index. Further, if the function is not able to find a finite element at all, it returns numbers::invalid_unsigned_int.

The codim parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison. See FiniteElement::compare_for_domination() for more information.

Definition at line 210 of file fe_collection.cc.

◆ find_dominated_fe_extended()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::find_dominated_fe_extended ( const std::set< unsigned int > &  fes,
const unsigned int  codim = 0 
) const

Return the index of a finite element from the provided set of indices fes that is dominated by all other elements of this very set. If we do not succeed, we extend our search on the whole collection by picking the most dominated one, which is the element that describes the smallest finite element space which includes all finite elements of the provided set fes.

You may find information about the domination behavior of finite elements in their respecitve class documentation or in the implementation of their inherited member function FiniteElement::compare_for_domination(). Consider that a finite element may or may not dominate itself (e.g. FE_Nothing elements).

If this set consists of exactly one element, we consider it to be the dominating one and return its corresponding index. Further, if the function is not able to find a finite element at all, it returns numbers::invalid_unsigned_int.

The codim parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison. See FiniteElement::compare_for_domination() for more information.

Definition at line 230 of file fe_collection.cc.

◆ set_hierarchy()

template<int dim, int spacedim>
void hp::FECollection< dim, spacedim >::set_hierarchy ( const std::function< unsigned int(const typename hp::FECollection< dim, spacedim > &, const unsigned int)> &  next,
const std::function< unsigned int(const typename hp::FECollection< dim, spacedim > &, const unsigned int)> &  prev 
)

Set functions determining the hierarchy of finite elements, i.e. a function next that returns the index of the finite element following the given one, and a function prev returning the preceding one.

Both functions expect an hp::FECollection to be passed along with a finite element index, on whose basis the new index will be found and returned.

Note
Both passed and returned indices have to be valid within the index range of this collection, i.e. within [0, size()).

Definition at line 302 of file fe_collection.cc.

◆ set_default_hierarchy()

template<int dim, int spacedim>
void hp::FECollection< dim, spacedim >::set_default_hierarchy ( )

Set the default hierarchy corresponding to the index of each finite element in the collection.

This default hierarchy is established with functions DefaultHierarchy::next_index() and DefaultHierarchy::previous_index().

Definition at line 319 of file fe_collection.cc.

◆ next_in_hierarchy()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::next_in_hierarchy ( const unsigned int  fe_index) const

Function returning the index of the finite element following the given fe_index in hierarchy.

By default, the index succeeding fe_index will be returned. If fe_index already corresponds to the last index, the last index will be returned. A custom hierarchy can be supplied via the member function set_hierachy().

Definition at line 330 of file fe_collection.cc.

◆ previous_in_hierarchy()

template<int dim, int spacedim>
unsigned int hp::FECollection< dim, spacedim >::previous_in_hierarchy ( const unsigned int  fe_index) const

Function returning the index of the finite element preceding the given fe_index in hierarchy.

By default, the index preceding fe_index will be returned. If fe_index already corresponds to the first index, the first index will be returned. A custom hierarchy can be supplied via the member function set_hierachy().

Definition at line 345 of file fe_collection.cc.

◆ component_mask() [1/4]

template<int dim, int spacedim>
ComponentMask hp::FECollection< dim, spacedim >::component_mask ( const FEValuesExtractors::Scalar scalar) const

Return a component mask with as many elements as this object has vector components and of which exactly the one component is true that corresponds to the given argument.

Note
This function is the equivalent of FiniteElement::component_mask() with the same arguments. It verifies that it gets the same result from every one of the elements that are stored in this FECollection. If this is not the case, it throws an exception.
Parameters
scalarAn object that represents a single scalar vector component of this finite element.
Returns
A component mask that is false in all components except for the one that corresponds to the argument.

Definition at line 360 of file fe_collection.cc.

◆ component_mask() [2/4]

template<int dim, int spacedim>
ComponentMask hp::FECollection< dim, spacedim >::component_mask ( const FEValuesExtractors::Vector vector) const

Return a component mask with as many elements as this object has vector components and of which exactly the dim components are true that correspond to the given argument.

Note
This function is the equivalent of FiniteElement::component_mask() with the same arguments. It verifies that it gets the same result from every one of the elements that are stored in this FECollection. If this is not the case, it throws an exception.
Parameters
vectorAn object that represents dim vector components of this finite element.
Returns
A component mask that is false in all components except for the ones that corresponds to the argument.

Definition at line 380 of file fe_collection.cc.

◆ component_mask() [3/4]

template<int dim, int spacedim>
ComponentMask hp::FECollection< dim, spacedim >::component_mask ( const FEValuesExtractors::SymmetricTensor< 2 > &  sym_tensor) const

Return a component mask with as many elements as this object has vector components and of which exactly the dim*(dim+1)/2 components are true that correspond to the given argument.

Note
This function is the equivalent of FiniteElement::component_mask() with the same arguments. It verifies that it gets the same result from every one of the elements that are stored in this FECollection. If this is not the case, it throws an exception.
Parameters
sym_tensorAn object that represents dim*(dim+1)/2 components of this finite element that are jointly to be interpreted as forming a symmetric tensor.
Returns
A component mask that is false in all components except for the ones that corresponds to the argument.

Definition at line 400 of file fe_collection.cc.

◆ component_mask() [4/4]

template<int dim, int spacedim>
ComponentMask hp::FECollection< dim, spacedim >::component_mask ( const BlockMask block_mask) const

Given a block mask (see this glossary entry ), produce a component mask (see this glossary entry ) that represents the components that correspond to the blocks selected in the input argument. This is essentially a conversion operator from BlockMask to ComponentMask.

Note
This function is the equivalent of FiniteElement::component_mask() with the same arguments. It verifies that it gets the same result from every one of the elements that are stored in this FECollection. If this is not the case, it throws an exception.
Parameters
block_maskThe mask that selects individual blocks of the finite element
Returns
A mask that selects those components corresponding to the selected blocks of the input argument.

Definition at line 420 of file fe_collection.cc.

◆ block_mask() [1/4]

template<int dim, int spacedim>
BlockMask hp::FECollection< dim, spacedim >::block_mask ( const FEValuesExtractors::Scalar scalar) const

Return a block mask with as many elements as this object has blocks and of which exactly the one component is true that corresponds to the given argument. See the glossary for more information.

Note
This function will only succeed if the scalar referenced by the argument encompasses a complete block. In other words, if, for example, you pass an extractor for the single \(x\) velocity and this object represents an FE_RaviartThomas object, then the single scalar object you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
This function is the equivalent of FiniteElement::component_mask() with the same arguments. It verifies that it gets the same result from every one of the elements that are stored in this FECollection. If this is not the case, it throws an exception.
Parameters
scalarAn object that represents a single scalar vector component of this finite element.
Returns
A component mask that is false in all components except for the one that corresponds to the argument.

Definition at line 441 of file fe_collection.cc.

◆ block_mask() [2/4]

template<int dim, int spacedim>
BlockMask hp::FECollection< dim, spacedim >::block_mask ( const FEValuesExtractors::Vector vector) const

Return a component mask with as many elements as this object has vector components and of which exactly the dim components are true that correspond to the given argument. See the glossary for more information.

Note
This function is the equivalent of FiniteElement::component_mask() with the same arguments. It verifies that it gets the same result from every one of the elements that are stored in this FECollection. If this is not the case, it throws an exception.
The same caveat applies as to the version of the function above: The extractor object passed as argument must be so that it corresponds to full blocks and does not split blocks of this element.
Parameters
vectorAn object that represents dim vector components of this finite element.
Returns
A component mask that is false in all components except for the ones that corresponds to the argument.

Definition at line 463 of file fe_collection.cc.

◆ block_mask() [3/4]

template<int dim, int spacedim>
BlockMask hp::FECollection< dim, spacedim >::block_mask ( const FEValuesExtractors::SymmetricTensor< 2 > &  sym_tensor) const

Return a component mask with as many elements as this object has vector components and of which exactly the dim*(dim+1)/2 components are true that correspond to the given argument. See the glossary for more information.

Note
The same caveat applies as to the version of the function above: The extractor object passed as argument must be so that it corresponds to full blocks and does not split blocks of this element.
This function is the equivalent of FiniteElement::component_mask() with the same arguments. It verifies that it gets the same result from every one of the elements that are stored in this FECollection. If this is not the case, it throws an exception.
Parameters
sym_tensorAn object that represents dim*(dim+1)/2 components of this finite element that are jointly to be interpreted as forming a symmetric tensor.
Returns
A component mask that is false in all components except for the ones that corresponds to the argument.

Definition at line 485 of file fe_collection.cc.

◆ block_mask() [4/4]

template<int dim, int spacedim>
BlockMask hp::FECollection< dim, spacedim >::block_mask ( const ComponentMask component_mask) const

Given a component mask (see this glossary entry ), produce a block mask (see this glossary entry ) that represents the blocks that correspond to the components selected in the input argument. This is essentially a conversion operator from ComponentMask to BlockMask.

Note
This function will only succeed if the components referenced by the argument encompasses complete blocks. In other words, if, for example, you pass an component mask for the single \(x\) velocity and this object represents an FE_RaviartThomas object, then the single component you selected is part of a larger block and consequently there is no block mask that would represent it. The function will then produce an exception.
This function is the equivalent of FiniteElement::component_mask() with the same arguments. It verifies that it gets the same result from every one of the elements that are stored in this FECollection. If this is not the case, it throws an exception.
Parameters
component_maskThe mask that selects individual components of the finite element
Returns
A mask that selects those blocks corresponding to the selected blocks of the input argument.

Definition at line 508 of file fe_collection.cc.

Member Data Documentation

◆ finite_elements

template<int dim, int spacedim = dim>
std::vector<std::shared_ptr<const FiniteElement<dim, spacedim> > > hp::FECollection< dim, spacedim >::finite_elements
private

Array of pointers to the finite elements stored by this collection.

Definition at line 802 of file fe_collection.h.

◆ hierarchy_next

template<int dim, int spacedim = dim>
std::function<unsigned int(const typename hp::FECollection<dim, spacedim> &, const unsigned int)> hp::FECollection< dim, spacedim >::hierarchy_next
private

Function returning the index of the finite element following the given one in hierarchy.

Definition at line 810 of file fe_collection.h.

◆ hierarchy_prev

template<int dim, int spacedim = dim>
std::function<unsigned int(const typename hp::FECollection<dim, spacedim> &, const unsigned int)> hp::FECollection< dim, spacedim >::hierarchy_prev
private

Function returning the index of the finite element preceding the given one in hierarchy.

Definition at line 818 of file fe_collection.h.


The documentation for this class was generated from the following files: