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

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'

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

Update the image addresses in .gitlab-ci.yml from "duneci/dune:***" to...

See merge request !37

Add mooneyrivlin-parameters, add comments in the parset file

See merge request !40

Update the image addresses in .gitlab-ci.yml from "duneci/dune:***" to "registry.dune-project.org/docker/ci/dune:***", so the dokcer-images are fetched from the official dune-ci

Update to upstream changes

See merge request !39

Previously, the method constructBoundaryDofs would accept scalar bases
together with blocked bit vectors, and would tacitly do
The Right Thing.

This has changed: Nowadays, the basis really has match the blocking
structure of the bit vectors.  This means that we have to introduce
a second type of power basis:  The one that already exists has the
dimension of the embedding space.  That is correct for sampling
initial configurations.  However, the Dirichlet values apply to
corrections, which live in the tangent space.  Therefore, their
'power-order' needs to be the dimension of that, i.e., lower.

Use global index sets by the dune-parmg module

See merge request !27

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.

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

dune-gfe contains a bit of home-grown infrastructure for distributed
assembly of the tangent stiffness matrix.  This will now be removed
in favour of dune-parmg code, for better maintainability.  Also,
eventually we want the parallel solver of dune-parmg in addition to
the parallel assembly.

The new dependency is optional, to cater for people without interest
in distributed computing.

Add missing std prefixes

See merge request !30