Namespaces | Modules | Functions

Integrators

Collaboration diagram for Integrators:

Namespaces

namespace  LocalIntegrators::Divergence
 

Local integrators related to the divergence operator and its trace.


namespace  LocalIntegrators::Elasticity
 

Local integrators related to elasticity problems.


namespace  LocalIntegrators::L2
 

Local integrators related to L2-inner products.


namespace  LocalIntegrators::Laplace
 

Local integrators related to the Laplacian and its DG formulations.


namespace  LocalIntegrators
 

Library of integrals over cells and faces.


namespace  LocalIntegrators::Maxwell
 

Local integrators related to curl operators and their traces.


namespace  LocalIntegrators::Patches
 

Integrators writing patches with values in quadrature points.


namespace  MeshWorker

Modules

 The MeshWorker interface

Functions

template<int dim>
void LocalIntegrators::L2::mass_matrix (FullMatrix< double > &M, const FEValuesBase< dim > &fe, const double factor=1.)
template<int dim>
void LocalIntegrators::L2::L2 (Vector< double > &result, const FEValuesBase< dim > &fe, const VectorSlice< const std::vector< std::vector< double > > > &input, const double factor=1.)
template<int dim>
void LocalIntegrators::L2::jump_matrix (FullMatrix< double > &M11, FullMatrix< double > &M12, FullMatrix< double > &M21, FullMatrix< double > &M22, const FEValuesBase< dim > &fe1, const FEValuesBase< dim > &fe2, const double factor1=1., const double factor2=1.)
template<int dim>
void LocalIntegrators::Laplace::cell_matrix (FullMatrix< double > &M, const FEValuesBase< dim > &fe, const double factor=1.)
template<int dim>
void LocalIntegrators::Laplace::nitsche_matrix (FullMatrix< double > &M, const FEValuesBase< dim > &fe, double penalty, double factor=1.)
template<int dim>
void LocalIntegrators::Laplace::nitsche_residual (Vector< double > &result, const FEValuesBase< dim > &fe, const VectorSlice< const std::vector< std::vector< double > > > &input, const VectorSlice< const std::vector< std::vector< Tensor< 1, dim > > > > &Dinput, const VectorSlice< const std::vector< std::vector< double > > > &data, double penalty, double factor=1.)
template<int dim>
void LocalIntegrators::Laplace::ip_matrix (FullMatrix< double > &M11, FullMatrix< double > &M12, FullMatrix< double > &M21, FullMatrix< double > &M22, const FEValuesBase< dim > &fe1, const FEValuesBase< dim > &fe2, double penalty, double factor1=1., double factor2=-1.)

Detailed Description

A collection of namespaces and functions which simplify the coding of forms and bilinear forms on finite element spaces. Functions for two different purposes are gathered here: the abstract integration on finite element meshes in MeshWorker and actual implementations of the integration of cell and face terms for concrete problems in LocalIntegrators.

Note:
Documentation on coding conventions, relations between classes, and details of the implementation is found in the documentation of namespaces in this module.

Integration on finite element meshes

When we integrate a function or a functional on a finite element space, the structure of the integration loop is always the same. We have between 3 and 5 nested loops, from outside to inside:

  1. Loop over all cells
  2. Optionally, loop over all faces to compute fluxes
  3. Loop over all quadrature points of the cell/face
  4. Optionally, loop over all test functions to compute forms
  5. Optionally, loop over all trial functions to compute bilinear forms

These loops naturally fall into two classes, namely the computation of cell and face contributions (loops 3 to 5), and the outer loops over the mesh objects, often referred to as assembling.

Support for the outer loop in deal.II can be found in the namespace MeshWorker (see the documentation there). In order to support the cell and face contributions (referred to as local contributions from now on), deal.II offers FEValuesBase and its derived classes. While the outer loop is generic (with exception of the data types), the computation of local contributions is problem dependent. Therefore, no generic algorithm is possible here. Nevertheless, we can define a generic interface for functions for this purpose and provide a library of local integrators for use in applications. These are collected in the namespace LocalIntegrators


Function Documentation

template<int dim>
void LocalIntegrators::L2::mass_matrix ( FullMatrix< double > &  M,
const FEValuesBase< dim > &  fe,
const double  factor = 1. 
)

The mass matrix for scalar or vector values finite elements.

\[ \int_Z uv\,dx \quad \text{or} \quad \int_Z \mathbf u\cdot \mathbf v\,dx \]

Likewise, this term can be used on faces, where it computes the integrals

\[ \int_F uv\,ds \quad \text{or} \quad \int_F \mathbf u\cdot \mathbf v\,ds \]

Author:
Guido Kanschat
Date:
2008, 2009, 2010

Definition at line 53 of file l2.h.

References FEValuesBase< dim, spacedim >::dofs_per_cell, FEValuesBase< dim, spacedim >::get_fe(), FEValuesBase< dim, spacedim >::JxW(), FEValuesBase< dim, spacedim >::n_quadrature_points, and FEValuesBase< dim, spacedim >::shape_value_component().

template<int dim>
void LocalIntegrators::L2::L2 ( Vector< double > &  result,
const FEValuesBase< dim > &  fe,
const VectorSlice< const std::vector< std::vector< double > > > &  input,
const double  factor = 1. 
)
template<int dim>
void LocalIntegrators::L2::jump_matrix ( FullMatrix< double > &  M11,
FullMatrix< double > &  M12,
FullMatrix< double > &  M21,
FullMatrix< double > &  M22,
const FEValuesBase< dim > &  fe1,
const FEValuesBase< dim > &  fe2,
const double  factor1 = 1.,
const double  factor2 = 1. 
)

The jump matrix between two cells for scalar or vector values finite elements. Note that the factor $\gamma$ can be used to implement weighted jumps.

\[ \int_F [\gamma u][\gamma v]\,ds \quad \text{or} \int_F [\gamma \mathbf u]\cdot [\gamma \mathbf v]\,ds \]

Using appropriate weights, this term can be used to penalize violation of conformity in H1.

Author:
Guido Kanschat
Date:
2008, 2009, 2010

Definition at line 149 of file l2.h.

References Assert, AssertDimension, FEValuesBase< dim, spacedim >::dofs_per_cell, StandardExceptions::ExcNotImplemented(), FEValuesBase< dim, spacedim >::get_fe(), FEValuesBase< dim, spacedim >::JxW(), FullMatrix< number >::m(), FullMatrix< number >::n(), FEValuesBase< dim, spacedim >::n_quadrature_points, and FEValuesBase< dim, spacedim >::shape_value_component().

template<int dim>
void LocalIntegrators::Laplace::cell_matrix ( FullMatrix< double > &  M,
const FEValuesBase< dim > &  fe,
const double  factor = 1. 
)

Laplacian in weak form, namely on the cell Z the matrix

\[ \int_Z \nu \nabla u \cdot \nabla v \, dx. \]

The FiniteElement in fe may be scalar or vector valued. In the latter case, the Laplacian is applied to each component separately.

Author:
Guido Kanschat
Date:
2008, 2009, 2010

Definition at line 52 of file laplace.h.

References FEValuesBase< dim, spacedim >::dofs_per_cell, FEValuesBase< dim, spacedim >::get_fe(), FEValuesBase< dim, spacedim >::JxW(), FEValuesBase< dim, spacedim >::n_quadrature_points, and FEValuesBase< dim, spacedim >::shape_grad_component().

template<int dim>
void LocalIntegrators::Laplace::nitsche_matrix ( FullMatrix< double > &  M,
const FEValuesBase< dim > &  fe,
double  penalty,
double  factor = 1. 
)
template<int dim>
void LocalIntegrators::Laplace::nitsche_residual ( Vector< double > &  result,
const FEValuesBase< dim > &  fe,
const VectorSlice< const std::vector< std::vector< double > > > &  input,
const VectorSlice< const std::vector< std::vector< Tensor< 1, dim > > > > &  Dinput,
const VectorSlice< const std::vector< std::vector< double > > > &  data,
double  penalty,
double  factor = 1. 
)

Weak boundary condition for the Laplace operator by Nitsche, vector valued version, namely on the face F the vector

\[ \int_F \Bigl(\gamma (u-g) v - \partial_n u v - (u-g) \partial_n v\Bigr)\;ds. \]

Here, u is the finite element function whose values and gradient are given in the arguments input and Dinput, respectively. g is the inhomogeneous boundary value in the argument data. $\gamma$ is the usual penalty parameter.

Author:
Guido Kanschat
Date:
2008, 2009, 2010

Definition at line 131 of file laplace.h.

References AssertVectorVectorDimension, FEValuesBase< dim, spacedim >::dofs_per_cell, FEValuesBase< dim, spacedim >::get_fe(), FEValuesBase< dim, spacedim >::JxW(), FEValuesBase< dim, spacedim >::n_quadrature_points, FEValuesBase< dim, spacedim >::normal_vector(), FEValuesBase< dim, spacedim >::shape_grad_component(), and FEValuesBase< dim, spacedim >::shape_value_component().

template<int dim>
void LocalIntegrators::Laplace::ip_matrix ( FullMatrix< double > &  M11,
FullMatrix< double > &  M12,
FullMatrix< double > &  M21,
FullMatrix< double > &  M22,
const FEValuesBase< dim > &  fe1,
const FEValuesBase< dim > &  fe2,
double  penalty,
double  factor1 = 1.,
double  factor2 = -1. 
)

Flux for the interior penalty method for the Laplacian, namely on the face F the matrices associated with the bilinear form

\[ \int_F \Bigl( \gamma [u][v] - \{\nabla u\}[v\mathbf n] - [u\mathbf n]\{\nabla v\} \Bigr) \; ds. \]

The penalty parameter should always be the mean value of the penalties needed for stability on each side. In the case of constant coefficients, it can be computed using compute_penalty().

If factor2 is missing or negative, the factor is assumed the same on both sides. If factors differ, note that the penalty parameter has to be computed accordingly.

Author:
Guido Kanschat
Date:
2008, 2009, 2010

Definition at line 231 of file laplace.h.

References AssertDimension, FEValuesBase< dim, spacedim >::dofs_per_cell, FEValuesBase< dim, spacedim >::get_fe(), FEValuesBase< dim, spacedim >::JxW(), FullMatrix< number >::m(), FullMatrix< number >::n(), FEValuesBase< dim, spacedim >::n_quadrature_points, FEValuesBase< dim, spacedim >::normal_vector(), FEValuesBase< dim, spacedim >::shape_grad_component(), and FEValuesBase< dim, spacedim >::shape_value_component().

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

deal.II documentation generated on Tue May 22 2012 12:06:59 by doxygen 1.7.3