The h1SemiNorm was only setup when the instrumented-flag was true.
	These are however independent functionalities.

They were expected to be the factors of a ProductManifold which is
also a template parameter.

Expecting the product and the factors is redundant.  We simply
extract the factors from the product now.

Previously, it expected two factor spaces, as separate template
parameters.  Taking a single ProductManifold type is more consistent
with GeodesicFEAssembler, and it allows to eventually generalize
the code to more factors, if desired.

... but disallow a plain pointer.  This increases consistency with the
GeodesicFEAssembler class.

In the wake of this, remove all Cosserat nomenclature.

We keep the restriction to two factor spaces, because I see no
short-time need for more generality.

Not all densities depend on the function value (e.g., elasticity),
and not all of them depend on the derivative (e.g., dead volume loads).
If the TargetSpace is a product manifold, not every density depends
on all factors.  This commit introduces an interface that allows
the assembler to query what quantities of what factor a density
depends on, to skip GFE interpolation that are later unused.

dune-elasticity also has densities, but they implement a slightly
different interface.  Instead of having special code for such
densities in the LocalIntegralAssembler, add a wrapper that
makes densities from dune-elasticity look like dune-gfe densities.

Use the standard operator() method instead.

Non-composite settings use Dune::Matrix<double>,
composite settings use a FieldMatrix where each entry
is Dune::Matrix<double>.

This is not quite as simple as the dune-functions convention,
which is to use Dune::Matrix in all cases.  But it is still
simpler than before.

This is what dune-function mandates.  We don't actually use
dune-functions here a lot, but it is still nice to stay in the spirit.
Also, I am thinking about using dune-functions bases for *some*
indexing work in the future.

Plus, I hope that getting rid of the blocking will improve run-times
of debug builds a little bit, in particular in the
LocalIntegralStiffness class.

Lisa Julia Nebel authored 4 years ago and Sander, Oliver committed 11 months ago

The MixedRiemannianPNSolver can assemble when different finite element
spaces are used for deformations and rotations (in, e.g., a Cosserat
model).  CHOLMOD is used for the inner solver.

This can be much faster than the MixedRiemannianTRSolver.

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

It is used by both TR and PN solvers, hence having it in a
separate file is a cleaner design.

While at it we also move it into the namespace Dune::GFE.

It is pretty confusing to have the behavior of the solvers depend
on the value of a preprocessor macro that is only used in this
module in only a very inconsistent way.

Unfortunately, this code is used even in sequential situations,
but previously the code only supported 1d- and 2d grids.
And as we still support installations without dune-parmg,
this commit adds an implementation for hypercube grids
of all dimensions.

Plus some minor cleanup

This makes for a cleaner design.  Also, the density is identical
to the one in nonplanarcosseratenergy.hh.  Eventually, we will
replace the density code there with the new density class
introduced here.

The new density CosseratShellDensity does not implement a particular
interface yet.  It is not clear to me yet how such an interface
would look like, exactly.

This replaces the dedicated implementation of the quadrature loop
for harmonic energies -- that is not needed anymore.

In particular this means that the test for it can be removed.
In theory it should be replaced with a test for the harmonic
energy *density*, but that density implementation is so short
that it doesn't really require a separate test.

Rather than using preprocessor switches.  That's too fragile
and not extensible.

If the target manifold is a product space, then ProductManifold must be
used, and not a variadic list of the factor space types.

Together with the new test, this commit also contains a number
of fixes for the SurfaceCosseratEnergy class.  This class was
not unit-tested previously, and unintentionally I messed it up
badly during my recent modernization work.

Finally, SurfaceCosseratEnergy had apparently never been tested
without dune-curvedgeometry, which is however only an optional
dependency.  The commit therefore also adds the necessary
conditionals.

Then problem then is that the derivative of the outer normal
of an intersection is not available from the standard grid interface.
If dune-curvedgeometry is not available, this derivative is
simply set to a zero matrix.  Depending on the grid manager
this may not actually be correct, though.

CollectiveCommunication has been deprecated for a while, and has
recently been removed from dune-grid.

They do the same thing, essentially.

This is what the non-mixed ADOL-C assembler does, and I want to
merge the two.

Both classes are meant to do the same thing.

This makes the interface more consistent.

These two exist in base classes, and they are inherited anyway.

This allows to get rid of a lot of (all) multiple inheritance.

Previously, LocalEnergy would accept an arbitrary number of
template arguments, and (with the exception of the first one)
they would be interpreted as the factors of a product target space.
This patch replaces this template list by a single template
parameter, which has to be ProductManifold if a product space
is desired.

This has implications throughout the code.  In particular, there are
now two energy methods: One that still accepts coefficients sets
in the form

  std::vector<TargetSpace>

and a second one which accepts

  TupleVector<std::vector<Factors>...>

The second one really only makes sense for product manifolds.
However, as the 'energy' methods are pure virtual, they cannot be
disabled by SFINAE or C++20 concepts.  Therefore, the second 'energy'
method exists always, accepting

  TupleVector<std::vector<TargetSpace> >

if TargetSpace is not a product.

In the long run this is cleaner than setting up the type in
the LocalStiffness class itself.

This will later simplify merging the mixed and non-mixed versions
of the assembler code.