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.

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.

    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.

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

The GeodesicFEAssemblerWrapper needs to access the MatrixType.

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

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.

Apparently it is not used.

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.

In case the solve step (which is only done on process 0) goes wrong
communicate it to all processes.

Print out assembly time for each process on each process and
print out the gradient norms only on one process.

This array contains the global numbering for the degrees of freedom
on the whole grid hierarchy, not only on the coarsest level.

This actually enforced writing of three tape files of ADOL-C (see taping.h)!

Several energy density implementations contained code for matrix methods
like sym, skew, transpose etc.  This patch moves them all to the file
linearalgebra.hh, to get rid of the redundancy.

Reduce quadrature order, before 16 quadrature points were used, an amount that's sufficient to integrate over a 3D-element, but as the integral is on the boundary, now 9 quadrature points, which are enough for 2D, are used.

Add option to read in a displacement file that will be used for the stress-free configuration of the shell elements
When startFromFile is set to true, then the stress-free configuration is read from the given file - this file needs to match the *finest* level of the grid
When startFromFile is set to false, the stress-free configuration can be given in as a function

Catch an exception that might be thrown by the localEnergy_ and solve the problem again using a smaller trust region.
Also make sure the ADOLC-Tape gets closed properly

Print total time, total assembly time and total time needed for solving at the end of the trust-region solver run

WHITESPACES: Continue with Trust-Region-Algorithm if IPOPT threw an error while solving, treat this case as an 'unsuccessful iteration'

Continue with Trust-Region-Algorithm if IPOPT threw an error while solving, treat this case as an 'unsuccessful iteration'

Lisa Julia Nebel authored 5 years ago and Sander, Oliver committed 5 years ago

This class will gradually replace the current implementations
GlobalP1Mapper and GlobalP2Mapper, because dune-gfe is not
the proper place for infrastructure for distributed computing.
Plus, the stuff in dune-parmg already is more flexible and
powerful.

Up until dune-common 2.7, the Dune namespace contained shared_ptr:
First as an actual implementation, later simply as a namespace
import.  Dune-common post-2.7 has removed that import,
and users of shared_ptr really have to explicitly specify
the std:: namespace prefix.