ADOL-C really only has fmin.  I don't know why this worked before.

The old implementation relied on assignment of FieldMatrix
from scalar, and for some strange reason that stopped working.

This removes one use of the CosseratEnergyLocalStiffness class,
which is scheduled for complete removal.

If the grid is 2d we know that determinant is equal to
the determinant of the upper-left 2x2 block.

This extracts the density of the Birsan/Neff Cosserat shell model
with planar reference configuration from the CosseratEnergyStiffness
class.

Even though we know that it is always '3'.  Still, using gridDim
whenever that is meant is more expressive than '3'.

Rather than keeping a duplicate implementation of the bulk
Cosserat density.

Energies of particular models should not implement external loads
themselves, because that would lead to a lot of code duplication
(and possible inconsistencies).  A one step towards that goal,
allow to construct a CosseratEnergyLocalStiffness object
without external loads.

Previously, the NeumannEnergy class assumed that the grid dimension
was equal to the world dimension.  This is not the case for shells,
where the grid is 2d but the world is 3d.

The present patch generalizes to code to also allow for 2d grids.

Previously, the method basically hand-implemented a writer for
VTK files.  Using dune-vtk instead leads to much shorter and
simpler code, and gives us access to all the dune-vtk niceties,
like binary files and high-order grid cells.

Rather than the grid itself.  Because the grid view is all that
a writer needs to know about.

If InterpolationDerivatives is told not to compute the derivatives
for the interpolation value, then it sometimes leaves the corresponding
matrix entries uninitialized.  That's okay: they shall not be used
anyway.

However, the code still did use them: It multiplied them by zero.
This is okay if the matrix entries are actual values, but they may
also be NaNs.  In that case, the NaNs propagate, leading to wrong
results.  Fix this by modifying the matrix products to really omit
the uninitialized values.

This is faster than using ADOL-C, and does not add much code.

This will allow derived densities to implement the derivatives by hand.
In some cases (e.g. the harmonic energy) these derivatives are so simple
that there is no need to accept the AD overhead for this.

Currently the user code that plugs together the assembler for a
particular problems has to know that ADOL-C is used internally
to compute certain derivatives.  In shows because certain objects
need to be instantiated with adouble as the number type.  One such
example is all objects derived from LocalDensity.

However, if this is to be avoided, then assemblers need to have
a way to turn a (e.g.) 'double' version of a density into an
'adouble' one.  This commit provides this way, by adding a
'makeActiveDensity' method.

That construction method is simply enough that the derivatives
can be computed manually.  This avoids the overhead of using
an AD system.

Lisa Julia Nebel authored 1 year ago and Sander, Oliver committed 8 months ago

The LocalIntegralStiffness assembles a tangent matrix by
suitably combining derivatives of the energy density with
derivatives of the geometric FE interpolation.  See the
detailed description in dune-gfe-manual.pdf.

This patch also includes a new test in localintegralstiffnesstest.cc.
It checks if the assembled matrix is the same as the one computed
by LocalGeodesicFEADOLCStiffness.

For a 3d Cosserat material I get a speedup of about 3x.

Remove whitespace in maxProximalNewtonSteps-string @Riemannianpnsolver (causes problem with get-method of parameterTree)

I am not too happy about this method, because for the scalar finite
element is an implementation detail.  But for the time being I need
this method for the upcoming LocalIntegralStiffness.

It is used by the upcoming LocalIntegralStiffness.

It is called 'geodesic interpolation' nowadays, no matter what domain.

Previously they were returned by value, but I do not remember any
actual reason for that.  Return by const reference leads to a
measurable speed increase when computing the derivatives of
projection-based FE onto the sphere.  It also fixed some
undefined behavior in that code, which took const-references
of the returned temporaries.

Returning the coefficients by const reference is more difficult
for product manifolds, because previously the interpolation rules
stored the coefficients separately for each factor space.
With this patch, these rules now store the coefficients twice:
once in the old separate format, and once as needed for returning
them by reference.  Interpolation rules are not meant to exist
in large numbers, and therefore I do not think that this
extra space consumption matters.

They were 'field_type' before, which is 'adouble' when used
together with ADOL-C (the typical case).  But using 'adouble'
for parameters is unnecessary and wasteful.

This broke recently (or never worked), because nonconforming
discretizations were not tested anywhere.  This patch therefore
also generalizes harmonicmaptest to also test with a
nonconforming discretization.

As part of the fix, the interpolation rules get a new method
`evaluateValueAndDerivative`, because the previous way to get
the value and the derivative in a single call (the `evaluateDerivative`
method that takes a value as an argument) only worked for the
conforming case.

This is needed to support nonconforming discretizations.