This is one step towards turning SurfaceCosseratEnergy into a
generic SurfaceIntegralEnergy class.

They are unused -- all code uses the space-dependent parameters.

For my current clang 19.1.5 they are an error.

This can be used in makeComposedGridFunction to turn quaternion-valued
functions to matrix-type ones, and vice versa.

Previously, the writer requested an FE basis to represent the director
vectors.  With the help of ComposedGridViewFunction this patch allows
to avoid this extra basis, which makes for a much nicer interface
for CosseratVTKWriter.

The NonplanarCosseratShellEnergy class contains a reimplementation of
the energy density of CosseratShellDensity.  The code is much easier
to understand and maintain if the density implementation of
CosseratShellDensity is used instead.

... and with constant Lamé parameters.  In many applications
there are constant, and it is convenient to be able to exploit that.

That is one step towards splitting off the energy density
into a separate class.

Also, it helps to unify the code paths for the different grid dimensions
in cosserat-continuum.cc

And use it in the dim==dimworld part of cosserat-continuum.cc.

The ugly preprocessor switch is still there, but I think
the method is more readable now.

The BulkCosseratDensity class implements three types of curvature
tensors. Previously, the preprocessor was used to select the one
to be actually used.  This patches removes the preprocessors checks
and implements run-time switches instead.

Because the part that computes the curvature energy from the
wryness tensor is identical for all curvature tensors that appear
in this implementation.

Instead, use LocalIntegralEnergy and the newly introduced densities
for bulk models or planar shell models.

While doing so, give an error message when non-trivial volume loads
are requested.  I have no example file that actually uses them
at the moment, and just by looking at the code I find it hard to believe
that they actually worked.  Getting them to work will mean having
introduce a density for volume loads, which don't want to do
until I need them.

Since this is the last use of the CosseratEnergyLocalStiffness class,
this patch remove the entire class as well.

It does not use the main class CosseratEnergyLocalStiffness,
but only the small helper class to access local finite elements
from different types of basis trees.  I am not very happy about
this helper class, but let's be pragmatic and simply copy it
to nonplanarcosseratshellenergy.hh (with a new, unique name).

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.