Moving to CHOLMOD was a mistake:  After all, the brittle-fracture
increment functional is non-convex, and hence second derivatives
can be indefinite.

The blocks of the evaluation matrix are sparse.  In particular,
they have a block-diagonal structure.  Previously, the implementation
used a FieldMatrix for these blocks.  Which, in theory, is wasteful
because of the matrix sparsity.

This commit introduces a block-diagonal matrix with compile-time size
for this.

Unfortunately, initial tests do not show any speedup.

Rather, the only the gradients of scalar shape functions, and compute
the strains on the fly.  This makes the evaluation matrices quite
a bit smaller (roughly by a factor dim).

This seems to reduce the number of TNNMG iterations in a few cases.

The method IntegralDirectionalRestriction::subDifferential
computed the product of the evaluation matrix and the direction
vector again and again, even though neither the matrix nor
the direction change during the life time of the restriction
object.

This patch precomputes the product in the constructor of the
IntegralDirectionalRestriction class.  According to the
gprof profiler, this should remove almost 10% of the overall
run-time.  The measured speed-up is not that large, but it is
noticeable.

This roughly halves the run-time of the method.  And that run-time is
considerable: According to gprof it is 25% of a 2d 4-levels run.

By error, the class ProjectedNewtonStep was in namespace

  Dune::FracturePhaseFields

 whereas everything else is in

  Dune::FracturePhasefields

It does not exist anymore.

While we're here, keep this subDictionary in a dedicated
variable.

In the first version of the manuscript, we used to control convergence
with an energy norm where the elasticity part was scaled with the
residual stiffness 'k'.  As far as I remember it this wasn't really
intentional, but the matrix for that norm just "happened to be
available".

When we started to implement the operator-splitting algorithm we wanted
to consolidate the convergence criterion, and we replaced the scaled
energy norm by the true energy norm.  As it turned out, this
overestimates the error in some situations where there is a complete
crack.  This is particularly noticeable for the models with spectrally
split energy, for reasons that we don't quite understand.

This patch puts the scaling back into the norm.  From a theoretical
point of view the scaled energy norm is not worse than the unscaled
one, but the iteration numbers look much better this way.

Use the values from crackSurfaceDensity instead.

That's too much magic for my taste:  If no material model type
is provided in the parameter file and the command line options,
then throw an error.

This seems to be more stable.

It needs it to compute a proper quadrature order.

This does not lead to any functional change, but avoids some
senseless copying of values.

The value-formulation is buggy in a subtle way, and this is why
we moved from the value-formulation to the correction formulation
in brittlefractureosstep.hh a while ago.  This patch does the
same change for brittlefracturehfieldosstep.hh

Add CrackSurfaceAssembler and remove PDElab dependency

See merge request !46

* Remove no longer user pdelab local operator implementations
* Remove dependency on dune-pdelab module
* Remove dependency from .pc.in file
* Remove pdelab from ci

This allows to get rid of the PDElab assembler.

dune-plasticity is only needed for the 'ductile-fracture'
program.  My current aim is to make building the
brittle-fracture codes easier.  That way, building
a Docker container for the benchmarks of the
brittle-fracture paper will be easier, too.

With this patch we can build the current dune-fracture-phasefields
with Release 2.8 of dune-istl, hence with the dune-istl Debian package.

The new implementation now exactly follows the description in
Bertsekas: "Projected Newton Methods for Optimization Problems
with Simple Constraints" (1982).

It also exchanges a projection of the correction onto the defect
obstacle for a projection of the new iterate onto the admissible
set.  The old way did not work reliably:  In some case adding
the projected correction to the old iterate would lead to an
unadmissible new iterate (due to round-off errors).

'sigma' is what Bertsekas uses.

Also, change the value from 0.5 to 0.49.  It needs to be strictly
below 0.5.

* Use infinity_norm instead of two_norm of the projected gradient
* Provide a maximum value 'epsilon', as suggested by Bertsekas (1982)
* Currently this value is hard-wired to 1e-5.  Eventually, this should
  be made configurable.

Carsten and I are not perfectly sure whether this is really needed,
but let's put it there just in case.

Drop obsolete members of energy densities

See merge request !45

The crack surface density parameters are part of CrackSurfaceDensity
now.

That factor got lost when I rewrote the preconditioned smoother.
The +k is very small, but it is required for the convergence
theory.  Without it, the quadratic model used by the preconditioner
is not dominating.

They are symmetric after all.

This does not lead to a measurable speedup for the benchmark problems
in the Gräser/Kienle/Sander paper, but it avoids having to explain
why we are using a nonsymmetric solver for symmetric problems.

Use degree() instead of deprecated CHILDREN for typetree nodes

See merge request !44

Feature/extend cracksurfacedensity

See merge request !43