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

Instead of with LocalGeodesicFEADOLCStiffness.

The latter should be faster.

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.

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.

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 avoid two unsuccessful iterations at the beginning,
and hence reduces the overall time to run the test somewhat.

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.

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.

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.

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.

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.

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

Plus some minor cleanup

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.

'thickness' and 'kappa' are parameters in Cosserat shell models.
They are not necessary for bulk models.  Hence remove them.

They do the same thing, essentially.

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

ADOL-C can compute all derivatives with two different modes:
scalar- and vector mode.  In theory they should produce exactly
the same results, but sometimes there are bugs (I have found
a few of those myself).  adolctest-scalar-and-vector-mode tested
whether the two modes produced the same result for a particular
Cosserat configuration.

I do not think that dune-gfe is the right place for such a test.
It tests for bugs in ADOL-C itself, and that is the job of
ADOL-C's own test suite.  Consequently, I am removing the test.

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

The new method is Fufem::markBoundaryPatchDofs, which apparently
works in just the same way.

Currently, Cosserat materials are hard-wired in the interface.
This patch changes the interface a little bit towards being
more general.

The ProductManifold class generalizes RigidBodyMotion, and can do
everything that the RigidBodyMotion class can.  Therefore there is
no point in keeping RigidBodyMotion any longer.  Having two
implementations for the same thing will just confuse people.