Reference documentation for deal.II version GIT relicensing1054gedd46abbd6 20240712 01:20:01+00:00

#include <deal.II/base/config.h>
#include <deal.II/algorithms/general_data_storage.h>
#include <deal.II/base/std_cxx20/iota_view.h>
#include <deal.II/base/subscriptor.h>
#include <deal.II/base/thread_local_storage.h>
#include <deal.II/base/utilities.h>
#include <deal.II/fe/fe_values_views.h>
Go to the source code of this file.
Classes  
struct  FEValuesViews::RenumberingData 
class  FEValuesViews::RenumberedView< ViewType > 
class  FECouplingValues< dim1, dim2, spacedim > 
Namespaces  
namespace  FEValuesViews 
Enumerations  
enum class  QuadratureCouplingType { tensor_product , unrolled , matching , reorder , overlapping } 
enum class  DoFCouplingType { independent , contiguous } 

strong 
Quadrature coupling options when assembling quadrature formulas for double integrals.
When computing the approximation of double integrals of the form
\[ \int_{T_1} \int{T_2} K(x_1, x_2) f(x_1) g(x_2) dT_1 dT_2, \]
where \(T_1\) and \(T_2\) are two arbitrary sets (cells, faces, edges, or any combination thereof), and \(K\) is a (possibly singular) coupling kernel, one needs to combine quadrature formulas from two different FEValuesBase objects.
This enum class provides a way to specify how the quadrature points and weights should be combined. In general, the two FEValuesBase objects provide different quadrature rules, and these can be interpreted in different ways, depending on the kernel function that is being integrated, and on how the two quadrature rules were constructed.
This enum is used in the constructor of FECouplingValues to specify how to interpret and manipulate the quadrature points and weights of the two FEValuesBase objects.
Enumerator  

tensor_product  The FEValuesBase objects provide different quadrature rules, and the resulting quadrature points and weights should be constructed as the tensor product of the two quadrature rules. This is generally used for nonlocal and nonsingular kernels, where the quadrature points of the two FEValuesBase objects are independent of each other. 
unrolled  Both FEValuesBase objects provide the same number of (generally different) quadrature points, that should be used as is to implement the double integration. This is equivalent to rewriting double integrals as a single sum over unrolled indices, and it is useful, for example, when performing integration of singular kernels, which require special quadrature rules both on the inside and on the outside integral. An exception is thrown if the two FEValuesBase objects do not provide the same number of quadrature points, but otherwise the two sets of points and weights can be arbitrary. 
matching  The FEValuesBase objects provide the same quadrature rule over the same set, with the same orientation. This is similar to the unrolled case, in the sense that the quadrature formulas are used as is, but both objects are assumed to return the same quadrature points and weights. This is useful when integrating over faces of neighboring cells, and when the reordering of the quadrature points is known to match a priori. An exception is thrown if the quadrature points and weightsÂ of the two FEValuesBase objects do not match onetoone. 
reorder  The FEValuesBase objects provide the same quadrature rule over the same set, but with possibly different orientations. The quadrature points are reordered internally, so that the resulting quadrature points and weights are the same as in the matching case. An exception is thrown if the quadrature points and weightsÂ of the two FEValuesBase cannot be reordered to match onetoone. 
overlapping  The FEValuesBase objects provide partially overlapping quadrature rules over two intersecting sets, with possibly different orientations. The quadrature points are reordered and matched internally, so that the resulting quadrature points and weights are only the ones that match between the two objects. If no overlapping points and weights can be found, an empty set is used to integrate, and the resulting integral is zero. No exception is thrown in this case. 
Definition at line 434 of file fe_coupling_values.h.

strong 
DoF coupling options when assembling double integrals.
When computing the approximation of double integrals of the form
\[ \int_{T_1} \int{T_2} K(x_1, x_2) v_i(x_1) w_j(x_2) dT_1 dT_2, \]
where \(T_1\) and \(T_2\) are two arbitrary sets (cells, faces, edges, or any combination thereof), and \(K\) is a (possibly singular) coupling kernel, one may want to combine degrees from two different FEValuesBase objects (i.e., basis functions \(v_i\) and \(w_j\) in the examples above).
This enum class provides a way to specify how the degrees of freedom should be combined. There are two cases of interest:
In the first case, one usually treats the two sets of degrees of freedom as independent of each other, and the resulting matrix is generally rectangular.
In the second case, one may choose to treat the two sets of degrees of freedom either as independent or to group them together. A similar approach is used in the FEInterfaceValues class, where the degrees of freedom of the two FEValuesBase objects are grouped together, in a contiguous way, so that the resulting basis functions are interpreted in the following way:
\[ \phi_{1,i}(x) = \begin{cases} v_i(x) & \text{ if } i \in [0,n_l) \\ 0 & \text{ if } i \in [n_1, n_1+n_2] \end{cases},\quad \phi_{1,i}(x) = \begin{cases} 0(x) & \text{ if } i \in [0,n_1) \\ w_{in_1}(x) & \text{ if } i \in [n_1, n_1+n_2] \end{cases}, \]
where \(\phi_{1,i}\) is the first basis function with index \(i\) and \(n_{1,2}\) are the number of local dofs on the first and second FEValuesBase objects.
This enum is used in the constructor of FECouplingValues to specify how to interpret and manipulate the local dof indices of the two FEValuesBase objects.
Enumerator  

independent  The FEValuesBase objects may have different dof indices, possibly indexing different DoFHandler objects, and we are interested in assembling a generally rectangular matrix, where there is no relationship between the two index spaces. 
contiguous  The FEValuesBase objects may have different dof indices, but they both index the same DoFHandler objects, and we are interested in assembling them all together in a single matrix. In this coupling type, the DoF indices are grouped together, one after the other, first the first dof indices, and then the second dof indices. This is useful when one wants to assemble four matrices at the same time, corresponding to the four possible combinations of the two FEValuesBase objects, (i.e., first coupled with first, first coupled with second, second coupled with first, and second coupled with second) and then sum them together to obtain the final system. This is similar to what is done in the FEInterfaceValues class. 
Definition at line 534 of file fe_coupling_values.h.