Migrate from dune-fufem to dune-functions bases

See merge request !48

This is currently the faster solver

Use GFE::LocalEnergy, GFE::LocalIntegralEnergy, GFE::SumEnergy (and delete GFE::SumCosseratEnergy).

Add localintegralenergy.hh and neumannenergy.hh, they assemble the energy for a single element and work with a CompositeBasis

These classes work similarly to Dune::Elasticity::LocalIntegralEnergy and Dune::Elasticity::NeumannEnergy,
where the ones in Dune::Elasticity with a power basis (for the displacement function) and
Dune::GFE::LocalIntegralEnergy / Dune::GFE::NeumannEnergy work with a CompositeBasis (for the displacement AND the rotation),
so the indices to access the different parts of the basis are different.

Enhancements

See merge request !61

Only compile geodesicfeassemblerwrappertest if the version of dune-elasticity is greater or equal 2.7

film-on-substrate uses a class of dune-elasticity that is not available in earlier versions

Add sumenergy.hh, this class assembles the a sum of energies for a single element by summing up the energies of each GFE::LocalEnergy.

This class works similarly to the class Dune::Elasticity::SumEnergy, where Dune::Elasticity::SumEnergy extends
Dune::Elasticity::LocalEnergy and Dune::GFE::SumEnergy extends Dune::GFE::LocalEnergy.

Correct typo in the calculation of the alternator tensor

See merge request !60

Change TargetSpace of GFE::LocalEnergy to be a variadic template and Change from Virtual Function to lambda function in cosserat-continuum

See merge request !57

    With this it will be possible to for the SumCosseratEnergy and the SurfaceCosseratEnergy
    to extend GFE::LocalEnergy, as they need multiple types of TargetSpaces.

Virtual Function is deprecated after dune 2.7.

Remove homegrown VTKReader, use dune-vtk instead

See merge request !58

Simon Praetorius' dune-vtk module has much better support for reading
and writing than my old hacks in dune-gfe.  Let's start adopting
dune-vtk for VTK I/O.

In this initial step, dune-vtk becomes a dependency of dune-gfe,
but only an optional one.  This may change.

Add a GeodesicFEAssemblerWrapper - it wraps a MixedGFEAssembler so it can be...

See merge request !55

Add a GeodesicFEAssemblerWrapper - it wraps a MixedGFEAssembler so it can be used like a GeodesicFEAssembler

The GeodesicFEAssemblerWrapper assembles the Gradient and the Hessian using the MixedGFEAssembler and then
resturctures them so they can be used with the normal RiemannianTRSolver.
This only works, if the FE spaces have the same order.

Enhancements

See merge request !53

The GeodesicFEAssemblerWrapper needs to access the MatrixType.

Also adjust CosseratEnergyStiffness and MixedGFEAssembler for the use with a CompositeBasis instead of a PowerBasis

Enhancements

See merge request !52

This makes it possible to use other Assemblers

This makes it possible to do parallel assembly

WHITESPACES: Wrap energy calculation and solve-call in the Mixed-Riemannian-TR solver in a try-catch statement

In case an error occurs while solving or calculating the energy, the program does not stop
but the error is handled in the Mixed-Riemannian-Trust-Region solver and the program continues
with a smaller trustregion-radius.

Do not test with libc++

See merge request !51

Apparently it is not used.

* Do not test with libc++. As ADOL-C is built using libstd++ we get strange
  linker and run-time errors.

* Mention that the problem with return value of the ADOL-C adouble
  comparison operators has been fixed in version 2.7.2.
  This will allow to eventually remove the code that patches dune-common
  for the CI system.

* Add gcc test with Dune 2.7.

* Remove the clang test with Dune 2.6.  It makes clang crash, but this
  case is not important enough to make me debug it.

foo

Feature/proximal newton solver

See merge request !45

Read in deformation function on each process  and adapt riemannian trustregion solver - parallel assembly works again!

See merge request !44

This is where they actually belong, create an own file for identity-dirichlet-values;
before we 'abused' a copy of the file cantilever-dirichlet-values.py

Add first version of the Riemannian Proximal Newton solver, as an alternative to the Trust-Region Solver.

In each step of these two iterative solvers, we try to find a correction
that decreases the energy of the nonlinear functional of the current iterate x.
The correction is calculated using the Taylor expansion around x,
resulting in the problem: Hessian(x) * correction = -gradient(x).
Within a certain radius around x, the functional can be approximated correctly and then
the corrections causes an energy decrease.
1) The trust-region algorithm ensures this using a trust-region.
2) The proximal newton method ensures this by punishing
   large corrections using a regularization factor.