Reference documentation for deal.II version Git 95a79d5 20180620 15:34:22 +0200

Enumerations  
enum  Domination { this_element_dominates, other_element_dominates, neither_element_dominates, either_element_can_dominate, no_requirements } 
Functions  
Domination  operator& (const Domination d1, const Domination d2) 
A namespace solely for the purpose of defining the Domination enum as well as associated operators.
An enum that describes the outcome of comparing two elements for mutual domination. If one element dominates another, then the restriction of the space described by the dominated element to a face of the cell is strictly larger than that of the dominating element. For example, in 2d Q(2) elements dominate Q(4) elements, because the traces of Q(4) elements are quartic polynomials which is a space strictly larger than the quadratic polynomials (the restriction of the Q(2) element). In general, Q(k) dominates Q(k') if \(k\le k'\).
This enum is used in the FiniteElement::compare_for_face_domination() function that is used in the context of hp finite element methods when determining what to do at faces where two different finite elements meet (see the hp paper for a more detailed description of the following). In that case, the degrees of freedom of one side need to be constrained to those on the other side. The determination which side is which is based on the outcome of a comparison for mutual domination: the dominated side is constrained to the dominating one.
A similar situation happens in 3d, where we have to consider different elements meeting at only an edge, not an entire face. Such comparisons are then implemented in the FiniteElement::compare_for_line_domination() function.
Note that there are situations where neither side dominates. The hp paper lists two case, with the simpler one being that a \(Q_2\times Q_1\) vector valued element (i.e. a FESystem(FE_Q(2),1,FE_Q(1),1)
) meets a \(Q_1\times Q_2\) element: here, for each of the two vectorcomponents, we can define a domination relationship, but it is different for the two components.
It is clear that the concept of domination doesn't matter for discontinuous elements. However, discontinuous elements may be part of vectorvalued elements and may therefore be compared against each other for domination. They should return either_element_can_dominate
in that case. Likewise, when comparing two identical finite elements, they should return this code; the reason is that we can not decide which element will dominate at the time we look at the first component of, for example, two \(Q_2\times Q_1\) and \(Q_2\times Q_2\) elements, and have to keep our options open until we get to the second base element.
Finally, the code no_requirements exists for cases where elements impose no continuity requirements. The case is primarily meant for FE_Nothing which is an element that has no degrees of freedom in a subdomain. It could also be used by discontinuous elements, for example.
More details on domination can be found in the hp paper.

inline 
A generalization of the binary and
operator to a comparison relationship. The way this works is pretty much as when you would want to define a comparison relationship for vectors: either all elements of the first vector are smaller, equal, or larger than those of the second vector, or some are and some are not.
This operator is pretty much the same: if both arguments are this_element_dominates
or other_element_dominates
, then the returned value is that value. On the other hand, if one of the values is either_element_can_dominate
, then the returned value is that of the other argument. If either argument is neither_element_dominates
, or if the two arguments are this_element_dominates
and other_element_dominates
, then the returned value is neither_element_dominates
.