MixedGFEAssembler: Pass local stiffness by r-value, l-value, shared_ptr

See merge request !151

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.

Make BulkCosseratDensity interface more standard-like

See merge request !149

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.

I don't see why this has to be kept after the migration.

Add missing regularization term in the quality measurement for step acceptance

See merge request !147

Use plain std::vector<double> for element energy gradients

See merge request !148

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.

There is no point in testing assemblers that only exist in the test
itself.  Historically, they may have been useful when developing
the dune-gfe assembler framework because they were simpler (they
compute the Euclidean derivatives, not the Riemannian ones).
Nowadays, they just waste CPU cycles.

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.

MixedRiemannianPNSolver

See merge request osander/dune-gfe!145

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 11 months 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.

Implement GlobalP2Mapper for 3d grids even without dune-parmg

See merge request osander/dune-gfe!146

Previously this wouldn't compile, because GlobalP2Mapper only supported
1d and 2d grids when used without dune-parmg.  This has now been fixed,
so we can enable filmonsubstratetest and filmonsubstratetest-mixed
(which involve a 3d grid) also for the situation without dune-parmg.

Strangely, the test without the -mixed produces different results
depending on whether the dune-parmg version of GlobalP2Mapper is used
or not. Minor differences are to be expected because the precise
behavior of multigrid methods (which are used by the TR solver) depends
on the dof ordering.  But the difference seen here is a bit large
for my taste.

I don't quite understand this, so this commit introduces some
subcasing to make CI pass, and document the current behavior.

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.

These tests have started to time out. I have no idea why.

There is no need to wrap the std::function that stores the
Neumann force density into a std::shared_ptr.

Steps towards using LocalIntegralEnergy instead of problem-specific energy classes

See merge request osander/dune-gfe!144

... if dune-common is newer than 2.9

The current build system does not require this argument
anymore.

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.