Reference documentation for deal.II version Git 6b6ce30 20181020 08:13:43 0400

#include <deal.II/hp/fe_collection.h>
Public Member Functions  
FECollection ()=default  
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=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_in_collection (const std::set< unsigned int > &fes) const 
unsigned int  find_least_face_dominating_fe (const std::set< unsigned int > &fes) const 
unsigned int  find_face_dominating_fe_in_subset (const std::set< unsigned int > &fes) 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 () 
Subscriptor &  operator= (const Subscriptor &) 
Subscriptor &  operator= (Subscriptor &&) noexcept 
void  subscribe (const char *identifier=nullptr) const 
void  unsubscribe (const char *identifier=nullptr) 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  
static::ExceptionBase &  ExcNoFiniteElements () 
Static Public Member Functions inherited from Subscriptor  
static::ExceptionBase &  ExcInUse (int arg1, std::string arg2, std::string arg3) 
static::ExceptionBase &  ExcNoSubscriber (std::string arg1, std::string arg2) 
Private Attributes  
std::vector< std::shared_ptr< const FiniteElement< dim, spacedim > > >  finite_elements 
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
).
Definition at line 52 of file dof_tools.h.

default 
Default constructor. Leads to an empty collection that can later be filled using push_back().

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 154 of file fe_collection.cc.

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 544 of file fe_collection.h.
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 163 of file fe_collection.cc.

default 
Copy constructor.

defaultnoexcept 
Move constructor.

default 
Move assignment operator.

inline 
Equality comparison operator. All stored FiniteElement objects are compared in order.
Definition at line 590 of file fe_collection.h.

inline 
Nonequality comparison operator. All stored FiniteElement objects are compared in order.
Definition at line 608 of file fe_collection.h.
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 177 of file fe_collection.cc.

inline 
Get a reference to the given element in this collection.
index
must be between zero and the number of elements of the collection. Definition at line 617 of file fe_collection.h.

inline 
Return the number of finite element objects stored in this collection.
Definition at line 562 of file fe_collection.h.

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 570 of file fe_collection.h.
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 368 of file fe_collection.cc.
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 628 of file fe_collection.h.
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 644 of file fe_collection.h.
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 660 of file fe_collection.h.
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 676 of file fe_collection.h.
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 692 of file fe_collection.h.
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 708 of file fe_collection.h.
std::size_t hp::FECollection< dim, spacedim >::memory_consumption  (  )  const 
Return an estimate for the memory allocated for this object.
Definition at line 385 of file fe_collection.cc.
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 723 of file fe_collection.h.
unsigned int hp::FECollection< dim, spacedim >::find_least_face_dominating_fe_in_collection  (  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.
Definition at line 27 of file fe_collection.cc.
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.
Definition at line 99 of file fe_collection.cc.
unsigned int hp::FECollection< dim, spacedim >::find_face_dominating_fe_in_subset  (  const std::set< unsigned int > &  fes  )  const 
Try to find a most face dominating finite element inside the subset of fe_indices fes
as part of this FECollection. For example, if an FECollection consists of {FE_Q(1),FE_Q(2),FE_Q(3),FE_Q(4)}
elements and we are looking for the most face dominating finite element among the last two elements of this collection (i.e., fes
is {2,3}
), then the answer is FE_Q(3) and therefore this function will return its index in the FECollection, namely 2
.
This function differs from find_least_face_dominating_fe() in such a way that it looks for the most dominating finite element within the given subset fes
, instead of finding a finite element in the whole FECollection that dominates all elements of the subset fes
.
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, the function returns numbers::invalid_unsigned_int.
Definition at line 109 of file fe_collection.cc.
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.
scalar  An object that represents a single scalar vector component of this finite element. 
Definition at line 197 of file fe_collection.cc.
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.
vector  An object that represents dim vector components of this finite element. 
Definition at line 217 of file fe_collection.cc.
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.
sym_tensor  An object that represents dim*(dim+1)/2 components of this finite element that are jointly to be interpreted as forming a symmetric tensor. 
Definition at line 237 of file fe_collection.cc.
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.
block_mask  The mask that selects individual blocks of the finite element 
Definition at line 257 of file fe_collection.cc.
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.
scalar  An object that represents a single scalar vector component of this finite element. 
Definition at line 278 of file fe_collection.cc.
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.
vector  An object that represents dim vector components of this finite element. 
Definition at line 300 of file fe_collection.cc.
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.
sym_tensor  An object that represents dim*(dim+1)/2 components of this finite element that are jointly to be interpreted as forming a symmetric tensor. 
Definition at line 322 of file fe_collection.cc.
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.
component_mask  The mask that selects individual components of the finite element 
Definition at line 345 of file fe_collection.cc.

private 
Array of pointers to the finite elements stored by this collection.
Definition at line 535 of file fe_collection.h.