Unify LagrangeSimplexFiniteElement across dimensions

See merge request !296

The implementation supports arbitrary order, but the test is only
implemented for order up to 2.

We can implement arbitrary order derivatives by a simple recursion.
Notice that the effort grows exponentially with the total order because
the number of terms from the product rule is 2^totalOrder. Furthermore
the stack-storage grows linearly with the dynamic total order. Hence
we need to use a dynamic-to-static switch using an explicit enumeration
of the supported static derivative orders. Since derivatives of order >k
are zero, the number of these cases is known at compile time.

Instead of evaluating the barycentric factors during the loop
over the Lagrange nodes, it is simpler and more efficient to
do this once in advance. This also adds the prcisice formula
for the basis functions to the doxygen documentation.

The `LagrangeSimplexFiniteElement` contains 5 different code paths
to implement the basis and its derivatives:

* A special implementation for order 0 in any dimension.
* A special implementation for order 1 in any dimension.
* An implementation for any order in dimension 1.
* An implementation for any order in dimension 2.
* An implementation for any order in dimension 3.

There are good reasons for the first two special cases.
Unfortunately the ones for dim=1,2,3 are all implemented
differently for no good reason (except history) makes the
code hard to read and understand.

This patch unifies the latter three implementations. While
there are still three branches, there is a very simple common
structure making the now making the code much simpler to understand.
The unified implementation basically follows the former
`evaluateFunction()` implementation of the 3d case:

1. Rescale the simplex by `k` such that Lagrange points have integer
   coordinates.
2. Transform to barycentric coordinates in the scaled simplex.
3. Loop over Lagrange points in lexicographic order.
4. Compute basis functions as products of univariate
   Lagrange-polynomials wrt. barycentric coordinates.

This approach is now also used for `evaluateJacobian()`
and first order derivatives in `partial()` extending the
support of the latter to dim=1 and dim=2.

For now the special implementation of second order
partial derivatives in 2d is kept, but could be updated
accordingly.

[cleanup] Avoid deprecation warning due to PQ22DLFE

See merge request !298

Don't issue the warning when building the tests
and when including `lagrange.hh`.

[test] Cleanup lagrangeshapefunctiontest

See merge request !293

Add TypeErasedLocalFiniteElement

See merge request !292

Deprecate PQ22DLocalFiniteElement

See merge request !295

The stored `unique_prt` was accidentally const which prevents
assignment. This is now fixed and a test for assignment is added.

This uses `LocalFiniteElementVirtualInterface` and
`LocalFiniteElementVirtualImp` internally to implement
type erasure but encapsulates dynamic memory management
and provides value semantics like `std::function`.

Revert removal of deprecated LagrangeSimplexLFE  constructor and undeprecate it

See merge request !297

Commit cd117ede removed this constructor. The reason of its deprecation seems to be a mistake. The message pointing at the deprecation apparently was introduced when an alternative constructor existed in f4655053. However, the deprecation warning was shortly removed in 50cdcd56, but it forgot to remove the message from the previous commit (both commits were done the same day). With no alternative constructor and the history of the comment, this deprecation comment seems to be void.

[cleanup] Remove features deprecated in 2.10

See merge request !294

This class has originally been introduced to demonstrate how
to manually implement a local finite element for a mixed grid.
Today you can implement mixed elements easily using `LocalFiniteElementVariant`
or `LocalFiniteElementVirtualInterface`.
Since we don't have such classes for other cases (1d, 3d, order!=2)
I don't see why we need this one.

The class was deprecated in 2.10 and can be removed.

The was deprecated in 2.10 and can be removed.

Now the header is empty and deprecated as a whole
which we forgot in 2.10.

The class was deprecated in 2.10 and can be removed.

Now the header is empty and deprecated as a whole
which we forgot in 2.10.

The constructor of `LagrangeSimplexLocalFiniteElement` templated wrt
the `VertexMap` was deprecated in 2.10 and can be removed.

On the one hand the test so far checked several LFE implementations
twice, on the other hand, some (e.g. higher order in 1d) where not
checked sufficiently. This patch unifies the checks among all checked
Lagrange LFE implementations including several cases missing before
and making use of `Dune::TestSuite`.
Furthermore all checked LFE implementations are now also checked when
wrapped once or twice in the virtual wrapper. While the compile time
is increased due to the increased coverage, it's still moderate.

deprecate `Dune::Precision`

See merge request !258

Ansgar Burchardt authored 3 years ago and Christoph Grüninger committed 3 weeks ago

There is already a comment that the definition here is not clear and
that `Precision` should be removed.

[bugfix] Explicitly call std::fill instead or relying on ADL

See merge request !290

Here we used an unqualified `fill(it, end, 0)`. Because there's no global
`fill(...)` and because the iterators are always from an `std::vector`
the `std::fill` function is found via ADL. Since this is not meant to be
a customization point and we really want to call `std::fill`, beeing explicit
is better than implicit. This is less error prone, more readable, and more
consistent with all the other cases where we explicitly call `std::*` algorithms.

[bugfix] Fix monomial basis on pyramids

See merge request !289

Commit d6e8bbee from merge request
!190
broke the monomials (and thus the derived Lagrange basis)
by removing the special case for pyramids and thus the
Duffy transform. This patch reverts the parts of the
commit affecting the header `monomialbasis.hh` to fix
the problem. Additionally this incorporates the minor
changes applied to the header after the offending commit.

This adds a check of the trace space for the dynamic order
Lagrange bases. The check interpolates each basis function
on each face into a trace FE space of the desired order
and compares the results on a set of sample points.

Pass Domain and Range type to PolynomialBasis

See merge request !162

Add a discontinuous meta finitelement

See merge request !274

Properly export size() in python if static or instance member

See merge request !286

Remove spurious 'template' keyword

See merge request !283

For clang 19 (currently in Debian testing) it is an error.

Set up default include directories on module target

See merge request !282