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

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.

Fix a few issues that I found using the clang sanitizer

See merge request !28

The svd code contains some index trickery, because the original code
was written in fortran, which numbers arrays starting from '1'
rather than from '0'.  This trickery included having a pointer point
1 int in front of an allocated array, implicitly relying on the
fact that pointer[0] would never be called.  The llvm sanitizer
complains nevertheless, so this patch improves the trickery a little
to avoid the objected pointer.

Scalar bases used to work for that, but that feature got
removed a long time ago.

Do this by making RodAssembler more similar to the generic
GeodesicFEAssembler: the constructor argument is now a
general LocalGeodesicFEStiffness, and not something particular
to rod problems.

Harmonicmap integration test

See merge request !25

The predicates do implement operator(), so let's use that.

This is needed to test against the 2.6 core modules.

This new test computes a harmonic map from a square to a sphere.
In other words, rather than testing some specific aspect of some
class, it does a whole simulation.  It should therefore cover
much more of the dune-gfe code.

Automatic testing of the RiemannianTrustRegionSolver class requires
to know what it did on the previous run.  This patch adds
some infrastructure to collect this information.