GitLab

Merge branch 'implement-global-valued-bases' into 'master'

ref:staging/dune-functions\> We do this by introducing a new
LocalFiniteElement implementation called GlobalValuedLocalFiniteElement. This
new implementation wraps existing LocalFiniteElement implementations, but
applies a transformation to the evaluated shape function values (and
derivatives etc.). The transformation is a template parameter and can be
replaced. Currently only the contravariant Piola transform (for H(div) spaces)
is implemented.

See merge request [!241]

  [!241]: gitlab.dune-project.org/staging/dune-functions/merge_requests/241

We do this by introducing a new LocalFiniteElement implementation
called GlobalValuedLocalFiniteElement.  This new implementation wraps
existing LocalFiniteElement implementations, but applies a
transformation to the evaluated shape function values (and
derivatives etc.).  The transformation is a template parameter
and can be replaced.  Currently only the contravariant Piola transform
(for H(div) spaces) is implemented.

Note that while this patch updates the poisson-mfem example,
the example nevertheless produces a slightly different result now.
The reason is that the example uses the 'interpolate' method,
which did not return the correct values for Raviart-Thomas elements
before this patch.

Merge branch 'feature/improve-continuity-check' into 'master'

ref:staging/dune-functions\> This is a follow up MR to [!163] motivated by
some insight after merging:

For a nontrivial tree you may want to use different continuity checks for
different leaf nodes. In part this could be achieved by switching with the
node type. But this lacks some information, because the same (local) node may
have different global continuity properties. This is e.g. the case for the
LagrangeBasis and the LagrangeDGBasis. Hence we miss some information if we do
not pass the tree path.

See merge request [!247]

  [!163]: gitlab.dune-project.org/NoneNone/merge_requests/163
  [!247]: gitlab.dune-project.org/staging/dune-functions/merge_requests/247

This was an oversight in the initial version of the continuity check:
For a nontrivial tree you may want to use different continuity checks
for different leaf nodes. In part this could be achieved by switching
with the node type. But this lacks some information, because the same
(local) node may have different global continuity properties. This
is e.g. the case for the `LagrangeBasis` and the `LagrangeDGBasis`.
Hence we miss some information if we do not pass the tree path.

Merge branch 'feature/basis-continuity-test' into 'master'

ref:staging/dune-functions\> This extends the global basis check checkBasis()
by incorporating the check for zero-basis functions and adding a check for
continuity of basis functions across intersections. The continuity check first
matches inside and outside DOFs on an intersection via their global indices.
Then it performs a local check which can be customized:.

-   You can enable a continuity check by passing EnableContinuityCheck() to
    checkBasis().
-   The default is checking if the norm of the jump is zero (this is simple
    continuity).
-   By deriving from EnableContinuityCheck and overloading
    localContinuityCheck() this can be customized.
-   A simple form of customization is to implement localContinuityCheck()
    using localJumpContinuityCheck() which allows to compute other pointwise
    jump-expressions like, e.g., the normal jump.
-   Full customization is possible by a hand-crafted implementation of
    localContinuityCheck(). This e.g. allows to check continuity in edge
    midpoints only.
-   A checking for the normal jump is implemented in
    EnableNormalContinuityCheck (but not tested so far).

See merge request [!163]

  [!163]: gitlab.dune-project.org/staging/dune-functions/merge_requests/163

The global continuity check now does all the generic stuff:
* Loop over elements
* Find neighbors
* Loop over all inside leaf nodes
* Find corresponding outside leaf node
* Match inside DOFs to outside DOFs using global indices

Using this information it executes a local continuity check.
The latter gets passed the intersection, inside- and outside-node,
and the map from inside to outside DOF (if existent). The result
of the local check should be a random access range indicating
for each (inside) basis function if is is continuous across the
intersection.

These are also more general now. Since gridviewfunctionspacebasistest.cc
executes the other tests, we can remove the parts that have an analouge
there.

This checks for continuity of basis functions across intersections.
Hence not all bases should pass it. Currently it's not called at all
and there's two possibilities to include this:
* Call the check manually for C^0 conforming bases
* Include the check conditionally into checkBasis() and
  and a flag to enable it.

One can also think of other variants for different types of
bases:
* A strong discontinuity check, that ensures that each basis function
  only appears in a single element (for DG-basis)
* A weak continuity check, that is parametrized with a basis-specific
  per-intersection check (for nonconforming bases, e.g. Crouzeix-Raviart).

Merge branch 'feature/drop-old-stuff' into 'master'

See merge request [!246]

  [!246]: Nonestaging/dune-functions/merge_requests/246

This replaces `Dune::TypeTree::Indices` by `Dune::Indices`
and removes all remaining useless typetree includes.

Merge branch 'feature/use-std-optional' into 'master'

ref:staging/dune-functions\> The fallback implementations have been removed
and the now deprecated names just forward to std::optional. This also
deprecates functions/common/optional.hh which is essentially empty for some
time.

See merge request [!245]

  [!245]: gitlab.dune-project.org/staging/dune-functions/merge_requests/245

This just forwarded to dune/common/std/optional.hh for some time.
The latter now just pulls `std::optional` into `Dune::Std::`.

Merge branch 'feature/stop-using-old-function-interface' into 'master'

ref:staging/dune-functions\> This removes all direct usages and references to
the old evaluate() based function interface:

-   No longer pass old function interface to dune-localfunction's
    interpolate()
-   Remove no longer used includes
-   Remove remainders in comments

There's a few places where the old interface is still visible:

-   The header common/callable.hh wraps an evaluate()-based function into an
    operator()-based function. It still exists but is not used any more in
    dune-functions.
-   The header common/funtionfromcallable.hh wraps an operator()-based
    function into an evaluate()-based function. It still exists but is not
    used any more in dune-functions.
-   By including local finite element implementations from dune-localfunctions
    we still include dune/common/function.hh indirectly.

See merge request [!244]

  [!244]: gitlab.dune-project.org/staging/dune-functions/merge_requests/244

The header was no longer used anyway, so there's no need to adapt
actual code here.

So far we explicitly wrapped a callable into a function
providing the `evaluate()` interface. For some time this
is again wrapped in dune-localfunction's `interpolate()`
methods into a callable.

This patch removes the wrapper in dune-functions such that
no wrapper will be created in dune-localfunctions either.

Merge branch 'bugfix/bsplinebasis-lfe-copy' into 'master'

ref:staging/dune-functions\> Since the local basis stores a reference to the
LFE, we must implement a copy constructor to avoid a dangling reerence. Due to
guaranteed copy elision there is no copy when storing the BSplineNode in the
LocalView. Hence this problem does not show up in practice.

The situation is different when using a power of a BSplineBasis. Then the
PowerNode stores several copies. Hence accessing the basis fails with a
segfault due to the dangling reference.

This is the reason why the extended basis check failed with a segfault for the
BSplineBasis.

See merge request [!243]

  [!243]: gitlab.dune-project.org/staging/dune-functions/merge_requests/243

Since the local basis stores a reference to the LFE,
we must implement a copy constructor to avoid a dangling
reerence. Due to guaranteed copy elision there is no
copy when storing the `BSplineNode` in the `LocalView`.
Hence this problem does not show up in practice.

The situation is different when using a power of
a `BSplineBasis`. Then the `PowerNode` stores several
copies. Hence accessing the basis fails with a segfault
due to the dangling reference.

This is the reason why the extended basis check failed
with a segfault for the `BSplineBasis`.

Merge branch 'feature/replace-ifelse' into 'master'

See merge request [!242]

  [!242]: Nonestaging/dune-functions/merge_requests/242

Merge branch 'replace-hybrid-ifelse-by-if-constexpr' into 'master'

ref:staging/dune-functions\> This simplifies compiler error messages

See merge request [!240]

  [!240]: gitlab.dune-project.org/staging/dune-functions/merge_requests/240

This simplifies compiler error messages

Merge branch 'do-not-use-dune-shared-ptr' into 'master'

ref:staging/dune-functions Up to dune-common 2.7, Dune::shared_ptr was also
possible.

See merge request [!234]

  [!234]: gitlab.dune-project.org/staging/dune-functions/merge_requests/234

Up to dune-common 2.7, Dune::shared_ptr was also possible.

Merge branch 'feature/bump-to-2.8' into 'master'

See merge request [!231]

  [!231]: Nonestaging/dune-functions/merge_requests/231

Merge branch 'feature/simplify-discreteglobalbasisfunction' into 'master'

ref:staging/dune-functions This implements several
simplifications/improvements in DiscreteGlobalBasisFunction

-   Remove the useless tree_ member.
-   Use forEachLeafNode instead of appyToTree to reduce indirection.
-   Replace Dune::Functions::TreeData by Dune::TypeTree::TreeContainer

This MR acts on top of [!226]. Hence merging would include the changes in
[!226].

The code can be even more simplified if [dune-typetree!61] gets
merged.

See merge request [!228]

  [!226]: gitlab.dune-project.org/NoneNone/merge_requests/226
  [dune-typetree!61]: gitlab.dune-project.org/staging/dune-typetree/merge_requests/61
  [!228]: gitlab.dune-project.org/staging/dune-functions/merge_requests/228