Reference documentation for deal.II version Git 08727cc441 2020-07-02 15:45:42 -0400
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Public Member Functions | Static Public Member Functions | List of all members
Polynomials::HermiteLikeInterpolation Class Reference

#include <deal.II/base/polynomial.h>

Inheritance diagram for Polynomials::HermiteLikeInterpolation:

Public Member Functions

 HermiteLikeInterpolation (const unsigned int degree, const unsigned int index)
- Public Member Functions inherited from Polynomials::Polynomial< double >
 Polynomial (const std::vector< double > &coefficients)
 Polynomial (const unsigned int n)
 Polynomial (const std::vector< Point< 1 >> &lagrange_support_points, const unsigned int evaluation_point)
 Polynomial ()
double value (const double x) const
void value (const double x, std::vector< double > &values) const
void value (const double x, const unsigned int n_derivatives, double *values) const
unsigned int degree () const
void scale (const double factor)
void shift (const number2 offset)
Polynomial< doublederivative () const
Polynomial< doubleprimitive () const
Polynomial< double > & operator*= (const double s)
Polynomial< double > & operator*= (const Polynomial< double > &p)
Polynomial< double > & operator+= (const Polynomial< double > &p)
Polynomial< double > & operator-= (const Polynomial< double > &p)
bool operator== (const Polynomial< double > &p) const
void print (std::ostream &out) const
void serialize (Archive &ar, const unsigned int version)
virtual std::size_t memory_consumption () const
- Public Member Functions inherited from Subscriptor
 Subscriptor ()
 Subscriptor (const Subscriptor &)
 Subscriptor (Subscriptor &&) noexcept
virtual ~Subscriptor ()
Subscriptoroperator= (const Subscriptor &)
Subscriptoroperator= (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)

Static Public Member Functions

static std::vector< Polynomial< double > > generate_complete_basis (const unsigned int degree)
- Static Public Member Functions inherited from Subscriptor
static ::ExceptionBaseExcInUse (int arg1, std::string arg2, std::string arg3)
static ::ExceptionBaseExcNoSubscriber (std::string arg1, std::string arg2)

Additional Inherited Members

- Protected Member Functions inherited from Polynomials::Polynomial< double >
void transform_into_standard_form ()
- Static Protected Member Functions inherited from Polynomials::Polynomial< double >
static void scale (std::vector< double > &coefficients, const double factor)
static void shift (std::vector< double > &coefficients, const number2 shift)
static void multiply (std::vector< double > &coefficients, const double factor)
- Protected Attributes inherited from Polynomials::Polynomial< double >
std::vector< doublecoefficients
bool in_lagrange_product_form
std::vector< doublelagrange_support_points
double lagrange_weight

Detailed Description

Polynomials for a variant of Hermite polynomials with better condition number in the interpolation than the basis from HermiteInterpolation.

In analogy to the proper Hermite polynomials, this basis evaluates the first polynomial \(p_0\) to 1 at \(x=0\) and has both a zero value and zero derivative at \(x=1\). Likewise, the last polynomial \(p_n\) evaluates to 1 at \(x=1\) with a zero value and zero derivative at \(x=0\). The second polynomial \(p_1\) and the second to last polynomial \(p_{n-1}\) represent the derivative degree of freedom at \(x=0\) and \(x=1\), respectively. They are zero at both the end points \(x=0, x=1\) and have zero derivative at the opposite end, \(p_1'(1)=0\) and \(p_{n-1}'(0)=0\). As opposed to the original Hermite polynomials, \(p_0\) does not have zero derivative at \(x=0\). The additional degree of freedom is used to make \(p_0\) and \(p_1\) orthogonal, which for \(n=3\) results in a root at \(x=\frac{2}{7}\) for \(p_0\) and at \(x=\frac{5}{7}\) for \(p_n\), respectively. Furthermore, the extension of these polynomials to higher degrees \(n>3\) is constructed by adding additional nodes inside the unit interval, again ensuring better conditioning. The nodes are computed as the roots of the Jacobi polynomials for \(\alpha=\beta=4\), which are orthogonal against the square of the generating function \(x^2(1-x)^2\) with the Hermite property. Then, these polynomials are constructed in the usual way as Lagrange polynomials with double roots at \(x=0\) and \(x=1\). For example with \(n=4\), all of \(p_0, p_1, p_3, p_4\) get an additional root at \(x=0.5\) through the factor \((x-0.5)\). In summary, this basis is dominated by nodal contributions, but it is not a nodal one because the second and second to last polynomials that are non-nodal, and due to the presence of double nodes in \(x=0\) and \(x=1\). The weights of the basis functions are set such that the sum of all polynomials with unit weight represents the constant function 1, similarly to Lagrange polynomials.

The basis only contains Hermite information for degree>=3, but it is also implemented for degrees between 0 and two. For the linear case, the usual hat functions are implemented, whereas the polynomials for degree=2 are \(p_0(x)=(1-x)^2\), \(p_1(x)=2x(x-1)\), and \(p_2(x)=x^2\), in accordance with the construction principle for degree 3.

These two relaxations improve the condition number of the mass matrix (i.e., interpolation) significantly, as can be seen from the following table:

  Condition number mass matrix
degree HermiteInterpolation HermiteLikeInterpolation
n=3 1057 17.18
n=4 6580 16.83
n=5 1.875e+04 15.99
n=6 6.033e+04 16.34
n=10 9.756e+05 20.70
n=15 9.431e+06 27.91
n=25 2.220e+08 43.54
n=35 2.109e+09 59.51

This polynomial inherits the advantageous property of Hermite polynomials where only two functions have value and/or derivative nonzero on a face advantageous for discontinuous Galerkin methods but gives better condition numbers of interpolation, which improves the performance of some iterative schemes like conjugate gradients with point-Jacobi. This polynomial is used in FE_DGQHermite.

Definition at line 693 of file polynomial.h.

Constructor & Destructor Documentation

◆ HermiteLikeInterpolation()

Polynomials::HermiteLikeInterpolation::HermiteLikeInterpolation ( const unsigned int  degree,
const unsigned int  index 

Constructor for the polynomial with index index within the set up polynomials of degree degree.

Definition at line 1307 of file

Member Function Documentation

◆ generate_complete_basis()

std::vector< Polynomial< double > > Polynomials::HermiteLikeInterpolation::generate_complete_basis ( const unsigned int  degree)

Return the polynomials with index 0 up to degree+1 in a space of degree up to degree.

Definition at line 1537 of file

The documentation for this class was generated from the following files: