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.

Then each process knows the initial stress free configuration and
can assemble its own part of the grid.

Do not call loadBalance() after each refinement.

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)!

Move all generic low-level matrix methods to a central place

See merge request !50

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.

Remove unused parameters q and kappa from surfacecosseratenergy

See merge request !47

Reduce quadrature order, before 16 quadrature points were used, an amount...

See merge request !46

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.

Feature/python function for material parameters

See merge request !41

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

Minor improvements

See merge request !32

In 3D and for second order elements the globaldofmapper from dune-parmg is needed.

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'