DuffyTrick

The DuffyTrick module provides quadrature routines for (nearly) singular integrals. More...

Functions
Eigen::Vector3i	Bembel::DuffyTrick::compareElements (const ElementTreeNode &e1, const ElementTreeNode &e2, double *dist)
	Compares two elements for similarities and determines, how the elements have to be rotated to move the similarity to the first vertices_ or edge.
template<typename Derived , class T , class CubatureVector >
void	Bembel::DuffyTrick::evaluateBilinearForm (const LinearOperatorBase< Derived > &linOp, const T &super_space, const ElementTreeNode &e1, const ElementTreeNode &e2, const CubatureVector &GS, const ElementSurfacePoints &ffield_qnodes1, const ElementSurfacePoints &ffield_qnodes2, Eigen::Matrix< typename LinearOperatorTraits< Derived >::Scalar, Eigen::Dynamic, Eigen::Dynamic > *intval)
	This function wraps the quadrature routines for the DuffyTrick and returns all integrals for the given pair of elements.
template<class T >
std::vector< ElementSurfacePoints >	Bembel::DuffyTrick::computeFfieldQnodes (const T &super_space, const Cubature &Q)
	evaluates a given quadrature on all surface panels storage format is qNodes.col(k) = [xi, w, Chi(xi); dsChi(xi); dtChi(xi)]
template<typename Derived , class T >
void	Bembel::DuffyTrick::integrate0 (const LinearOperatorBase< Derived > &LinOp, const T &super_space, const ElementTreeNode &e1, int rot1, const ElementTreeNode &e2, int rot2, const ElementSurfacePoints &ffield_qnodes1, const ElementSurfacePoints &ffield_qnodes2, const Cubature &Q, Eigen::Matrix< typename LinearOperatorTraits< Derived >::Scalar, Eigen::Dynamic, Eigen::Dynamic > *intval)
	far-field quadrature routine, which is based on precomputed values in order to quickly evaluate the integrand in the case that the far-field quadrature degree can be used
template<typename Derived , class T >
void	Bembel::DuffyTrick::integrate1 (const LinearOperatorBase< Derived > &LinOp, const T &super_space, const ElementTreeNode &e1, int rot1, const ElementTreeNode &e2, int rot2, const ElementSurfacePoints &ffield_qnodes1, const ElementSurfacePoints &ffield_qnodes2, const Cubature &Q, Eigen::Matrix< typename LinearOperatorTraits< Derived >::Scalar, Eigen::Dynamic, Eigen::Dynamic > *intval)
	no-problem quadrature routine, elements are sufficiently far away from each other, but not far-field yet (this is just an isotropic tensor product quadrature!). More...
template<typename Derived , class T >
void	Bembel::DuffyTrick::integrate2 (const LinearOperatorBase< Derived > &LinOp, const T &super_space, const ElementTreeNode &e1, int rot1, const ElementTreeNode &e2, int rot2, const ElementSurfacePoints &ffield_qnodes1, const ElementSurfacePoints &ffield_qnodes2, const Cubature &Q, Eigen::Matrix< typename LinearOperatorTraits< Derived >::Scalar, Eigen::Dynamic, Eigen::Dynamic > *intval)
	quadrature routine for identical elements More...
template<typename Derived , class T >
void	Bembel::DuffyTrick::integrate3 (const LinearOperatorBase< Derived > &LinOp, const T &super_space, const ElementTreeNode &e1, int rot1, const ElementTreeNode &e2, int rot2, const ElementSurfacePoints &ffield_qnodes1, const ElementSurfacePoints &ffield_qnodes2, const Cubature &Q, Eigen::Matrix< typename LinearOperatorTraits< Derived >::Scalar, Eigen::Dynamic, Eigen::Dynamic > *intval)
	quadrature routine for the common edge case More...
template<typename Derived , class T >
void	Bembel::DuffyTrick::integrate4 (const LinearOperatorBase< Derived > &LinOp, const T &super_space, const ElementTreeNode &e1, int rot1, const ElementTreeNode &e2, int rot2, const ElementSurfacePoints &ffield_qnodes1, const ElementSurfacePoints &ffield_qnodes2, const Cubature &Q, Eigen::Matrix< typename LinearOperatorTraits< Derived >::Scalar, Eigen::Dynamic, Eigen::Dynamic > *intval)
	quadrature routine for common vertex case. More...
Eigen::Vector2d	Bembel::DuffyTrick::tau (double x, double y, int thecase)
	computes rotations for the DuffyTrick. More...

Detailed Description

The DuffyTrick module provides quadrature routines for (nearly) singular integrals.

Therein, the implementation is essentially an adaptation of the so-called Sauter-Schwab quadrature rules

Function Documentation

integrate1()

template<typename Derived , class T >

void Bembel::DuffyTrick::integrate1	(	const LinearOperatorBase< Derived > &	LinOp,
		const T &	super_space,
		const ElementTreeNode &	e1,
		int	rot1,
		const ElementTreeNode &	e2,
		int	rot2,
		const ElementSurfacePoints &	ffield_qnodes1,
		const ElementSurfacePoints &	ffield_qnodes2,
		const Cubature &	Q,
		Eigen::Matrix< typename LinearOperatorTraits< Derived >::Scalar, Eigen::Dynamic, Eigen::Dynamic > *	intval
	)

no-problem quadrature routine, elements are sufficiently far away from each other, but not far-field yet (this is just an isotropic tensor product quadrature!).

Todo:

be sure that map2element computes the weight h*Q.w(i) such that the integrand may then be scaled by qp1.weight * qp2.weight

Definition at line 26 of file integrate1.hpp.

integrate2()

template<typename Derived , class T >

void Bembel::DuffyTrick::integrate2	(	const LinearOperatorBase< Derived > &	LinOp,
		const T &	super_space,
		const ElementTreeNode &	e1,
		int	rot1,
		const ElementTreeNode &	e2,
		int	rot2,
		const ElementSurfacePoints &	ffield_qnodes1,
		const ElementSurfacePoints &	ffield_qnodes2,
		const Cubature &	Q,
		Eigen::Matrix< typename LinearOperatorTraits< Derived >::Scalar, Eigen::Dynamic, Eigen::Dynamic > *	intval
	)

quadrature routine for identical elements

Todo:

be sure that map2element computes the weight h*Q.w(i) such that the integrand may then be scaled by qp1.weight * qp2.weight here we just set one weight to the actual weight, while the other one will be set to 1. This is to remain conforming to the structure of integrate0/1.

Information that map2element has to provide: xi; w; Chi(xi); dChidx(xi); dChidy(xi);

Definition at line 28 of file integrate2.hpp.

integrate3()

template<typename Derived , class T >

void Bembel::DuffyTrick::integrate3	(	const LinearOperatorBase< Derived > &	LinOp,
		const T &	super_space,
		const ElementTreeNode &	e1,
		int	rot1,
		const ElementTreeNode &	e2,
		int	rot2,
		const ElementSurfacePoints &	ffield_qnodes1,
		const ElementSurfacePoints &	ffield_qnodes2,
		const Cubature &	Q,
		Eigen::Matrix< typename LinearOperatorTraits< Derived >::Scalar, Eigen::Dynamic, Eigen::Dynamic > *	intval
	)

quadrature routine for the common edge case

Todo:

be sure that map2element computes the weight h*Q.w(i) such that the integrand may then be scaled by qp1.weight * qp2.weight here we just set one weight to the actual weight, while the other one will be set to 1. This is to remain conforming to the structure of integrate0/1.

Information that map2surface has to provide: xi; w; Chi(xi); dChidx(xi); dChidy(xi);

Definition at line 28 of file integrate3.hpp.

integrate4()

template<typename Derived , class T >

void Bembel::DuffyTrick::integrate4	(	const LinearOperatorBase< Derived > &	LinOp,
		const T &	super_space,
		const ElementTreeNode &	e1,
		int	rot1,
		const ElementTreeNode &	e2,
		int	rot2,
		const ElementSurfacePoints &	ffield_qnodes1,
		const ElementSurfacePoints &	ffield_qnodes2,
		const Cubature &	Q,
		Eigen::Matrix< typename LinearOperatorTraits< Derived >::Scalar, Eigen::Dynamic, Eigen::Dynamic > *	intval
	)

quadrature routine for common vertex case.

Todo:

be sure that map2element computes the weight h*Q.w(i) such that the integrand may then be scaled by qp1.weight * qp2.weight here we just set one weight to the actual weight, while the other one will be set to 1. This is to remain conforming to the structure of integrate0/1.

Information that map2element has to provide: xi; w; Chi(xi); dChidx(xi); dChidy(xi);

Definition at line 28 of file integrate4.hpp.

tau()

Eigen::Vector2d Bembel::DuffyTrick::tau	(	double	x,
		double	y,
		int	thecase
	)

computes rotations for the DuffyTrick.

Parameters

x	x coordinate
y	y coordinate
thecase	Edge case denoting how the element needs to be turned.

Returns

Point in rotated element.

Definition at line 26 of file tau.hpp.