![]() |
Reference documentation for deal.II version 9.1.1
|
#include <deal.II/non_matching/immersed_surface_quadrature.h>
Public Member Functions | |
ImmersedSurfaceQuadrature ()=default | |
ImmersedSurfaceQuadrature (const std::vector< Point< dim >> &points, const std::vector< double > &weights, const std::vector< Tensor< 1, dim >> &normals) | |
void | push_back (const Point< dim > &point, const double weight, const Tensor< 1, dim > &normal) |
const Tensor< 1, dim > & | normal_vector (const unsigned int i) const |
const std::vector< Tensor< 1, dim > > & | get_normal_vectors () const |
![]() | |
Quadrature (const unsigned int n_quadrature_points=0) | |
Quadrature (const SubQuadrature &, const Quadrature< 1 > &) | |
Quadrature (const Quadrature< dim !=1 ? 1 :0 > &quadrature_1d) | |
Quadrature (const Quadrature< dim > &q) | |
Quadrature (Quadrature< dim > &&) noexcept=default | |
Quadrature (const std::vector< Point< dim >> &points, const std::vector< double > &weights) | |
Quadrature (const std::vector< Point< dim >> &points) | |
Quadrature (const Point< dim > &point) | |
virtual | ~Quadrature () override=default |
Quadrature & | operator= (const Quadrature< dim > &) |
Quadrature & | operator= (Quadrature< dim > &&)=default |
bool | operator== (const Quadrature< dim > &p) const |
void | initialize (const std::vector< Point< dim >> &points, const std::vector< double > &weights) |
unsigned int | size () const |
const Point< dim > & | point (const unsigned int i) const |
const std::vector< Point< dim > > & | get_points () const |
double | weight (const unsigned int i) const |
const std::vector< double > & | get_weights () const |
std::size_t | memory_consumption () const |
template<class Archive > | |
void | serialize (Archive &ar, const unsigned int version) |
bool | is_tensor_product () const |
const std::array< Quadrature< 1 >, dim > & | get_tensor_basis () const |
![]() | |
Subscriptor () | |
Subscriptor (const Subscriptor &) | |
Subscriptor (Subscriptor &&) noexcept | |
virtual | ~Subscriptor () |
Subscriptor & | operator= (const Subscriptor &) |
Subscriptor & | operator= (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) |
Protected Attributes | |
std::vector< Tensor< 1, dim > > | normals |
![]() | |
std::vector< Point< dim > > | quadrature_points |
std::vector< double > | weights |
bool | is_tensor_product_flag |
std::unique_ptr< std::array< Quadrature< 1 >, dim > > | tensor_basis |
Additional Inherited Members | |
![]() | |
using | SubQuadrature = Quadrature< dim - 1 > |
![]() | |
static ::ExceptionBase & | ExcInUse (int arg1, std::string arg2, std::string arg3) |
static ::ExceptionBase & | ExcNoSubscriber (std::string arg1, std::string arg2) |
This class defines a quadrature formula for integration over an oriented surface, \(\hat{S}\), immersed in the unit cell. By immersed it is meant that the surface may intersect the unit cell in an arbitrary way. The quadrature formula is described by a set of quadrature points, \(\hat{x}_q\), weights, \(w_q\), and normalized surface normals, \(\hat{n}_q\).
We typically want to compute surface integrals in real space. A surface \(S\) intersecting a cell \(K\) in real space, can be mapped onto a surface \(\hat{S}\) intersecting the unit cell \(\hat{K}\). Thus a surface integral over \(S\cap K\) in real space can be transformed to a surface integral over \(\hat{S} \cap \hat{K}\) according to
\[ \int_{S\cap K} f(x) dS = \int_{S\cap K} f(x) |d\bar{S}| = \int_{\hat{S}\cap\hat{K}} f(F_{K}(\hat{x})) \det(J) |\left( J^{-1} \right )^T d\hat{S}|, \]
where \(F_K\) is the mapping from reference to real space and \(J\) is its Jacobian. This transformation is possible since the continuous surface elements are vectors: \(d\bar{S}, d\hat{S} \in \mathbb{R}^{dim}\) which are parallel to the normals of \(S\) and \(\hat{S}\). So in order to compute the integral in real space one needs information about the normal to do the transformation.
Thus, in addition to storing points and weights, this quadrature stores also the normalized normal for each quadrature point. This can be viewed as storing a discrete surface element,
\[ \Delta \hat{S}_q \dealcoloneq w_q \hat{n}_q \approx d\hat{S}(\hat{x}_q), \]
for each quadrature point. The surface integral in real space would then be approximated as
\[ \int_{S\cap K} f(x) dS \approx \sum_{q} f \left(F_{K}(\hat{x}_{q}) \right) \det(J_q) |\left( J_q^{-1} \right)^T \hat{n}_q| w_q. \]
Definition at line 76 of file immersed_surface_quadrature.h.
|
default |
Default constructor to initialize the quadrature with no quadrature points.
NonMatching::ImmersedSurfaceQuadrature< dim >::ImmersedSurfaceQuadrature | ( | const std::vector< Point< dim >> & | points, |
const std::vector< double > & | weights, | ||
const std::vector< Tensor< 1, dim >> & | normals | ||
) |
Construct a quadrature formula from vectors of points, weights and surface normals. The points, weights and normals should be with respect to reference space, and the normals should be normalized.
Definition at line 22 of file immersed_surface_quadrature.cc.
void NonMatching::ImmersedSurfaceQuadrature< dim >::push_back | ( | const Point< dim > & | point, |
const double | weight, | ||
const Tensor< 1, dim > & | normal | ||
) |
Extend the given formula by an additional quadrature point. The point, weight and normal should be with respect to reference space, and the normal should be normalized.
This function exists since immersed quadrature rules can be rather complicated to construct. Often the construction is done by partitioning the cell into regions and constructing points on each region separately. This can make it cumbersome to create the quadrature from the constructor since all quadrature points have to be known at time of creation of the object.
Definition at line 43 of file immersed_surface_quadrature.cc.
const Tensor< 1, dim > & NonMatching::ImmersedSurfaceQuadrature< dim >::normal_vector | ( | const unsigned int | i | ) | const |
Return a reference to the i
th surface normal.
Definition at line 58 of file immersed_surface_quadrature.cc.
const std::vector< Tensor< 1, dim > > & NonMatching::ImmersedSurfaceQuadrature< dim >::get_normal_vectors | ( | ) | const |
Return a reference to the whole vector of normals.
Definition at line 68 of file immersed_surface_quadrature.cc.
|
protected |
Vector of surface normals at each quadrature point.
Definition at line 130 of file immersed_surface_quadrature.h.