[finiteelementmap] add a simple implementation of QkPkFEM
[finiteelementmap] allow to set the order of pkqkfem at runtime
[OneStepGridOperator] Remove unused class OneStepLocalJacobianResidualAssemblerEngine

For some reason, there are two different engine implementations for
concurrently assembling residuals and jacobian in an explicit
time-stepping scheme. However, only the class
OneStepExplicitLocalJacobianResidualAssemblerEngine is used anywhere in
PDELab, so this patch removes the other one to avoid unnecessary confusion.
[Constraints] Track presence of non-Dirichlet constraints in constraints container

This patch extends the ConstraintsTransformation interface with a new
method containsNonDirichletConstraints(), making it possible for the
assembly process to exploit the common case of only having to
incorporate Dirichlet constraints.

The value of this flag is cached in the default implementation, so it is
important to only add new constraints by means of the method
import_local_transformation(), which takes care of updating the cached value.
[LFSIndexCache] Make the caching of constraints controllable via a run-time parameter

The LFSIndexCache currently insists on always caching the constraints
for the DOFs of the currently bound LFS; that behavior can only be
deactivated by passing an EmptyTransformation for the type of the
constraints container, as the cache is specialized for that case and
then completely disables all constraints handling.

However, this way of disabling constraints caching modifies the type of
the LFSIndexCache, which creates a problem for the GridOperator engines,
which need the precise type to instantiate local views for the LA
containers and which creates problems in the case of the combined
residual and jacobian engine of the OneStepGridOperator, where the
residual doesn't require constraints caching, but the jacobian does,
causing a compilation failure.

Moreover, it would be beneficial to control the caching at run-time, as
the full-blown constraints handling that requires caching is only needed
in the presence of non-Dirichlet constraints, something that can only be
queried at runtime.

So this patch adds a new runtime flag to the LFSIndexCache that can be
used to enable or disable constraints caching. It can be passed as a
third parameter to the constructor, but is optional right now and
defaults to true. It is also possible to query the state of the flag
using the new method constraintsCachingEnabled().
[GridOperator] Make constraints caching controllable at run time

This patch switches the query mechanism of the global assembler for the
constraints caching requirements from a compile time interface (static
const bool needs_constraints_caching) to a run time mehod
needsConstraintsCaching(cu,cv). This new method is passed the
constraints containers for both spaces to allow decisions based on the
actual structure of the constraints (e.g. presence of non-Dirichlet
constraints).

Moreover, the patch also changes the non-constrained LFSCache typedefs
in the local assembler to be identical to the constrained ones, as the
caching-decision now happens at run time. This change makes it possible
to use the residual engine in settings without constraints
caching (e.g. when directly calling residual() ) as well as in the
context of the combined residual / jacobian assembly of the
ExplicitGridOperator, where the jacobian might enforce constraints
caching, even though the residual does not need it.

Finally, the patch changes the default constraints caching policy of
several engines:

- The residual engine never required constraints caching, because the
  residual is constrained in a batch operation after assembly is
  done. For some reason, constraints caching was activated
  anyway (probably because of the issue with the combined residual /
  jacobian method of the OneStepGridOperator). Caching has been disabled
  for this engine.

- The jacobian engine now only enables constraints caching if there are
  non-Dirichlet constraints, as Dirichlet constraints are applied after
  assembly is done, just like the residual.

- The pattern engine also only enables caching in the presence of
  non-Dirichlet constraints.

WARNING: This patch modifies the internal API between global assembler
         and assembler engines! Any users with custom assembler engines
         need to add the method needsConstraintsCaching() to their
         implementations!
[GridOperator] Add new method scatter_jacobian() as front end for etadd() et. al.

The new method scatter_jacobian() on the local assembler should be
called instead of etadd(). It inspects the index caches to decide
if the expensive etadd() method has to be invoked. Otherwise, the local
jacobian will be written back without taking constraints into
consideration.

Moreover, the new method has a parameter symmetric_mode that enables
symmetric assembly of Dirichlet constraints.
[GridOperator] Use new method scatter_jacobian() in JacobianEngine

Use scatter_jacobian() to enable optimized scatter code if there are no
non-Dirichlet constraints.

The symmetric assembly mode is disabled for now.
[GridOperator] Make local matrix writable in utility method etadd_symmetric()

etadd_symmetric() has to modify the local matrix in order to clear out
constrained columns, but the object is passed in by const reference.

Fixed.
[LFSIndexCache] Add constraintsCachingEnabled() to specialization for unconstrained spaces
[GridOperator] Add specialization of scatter_jacobian for EmptyTransformation

Some versions of GCC have a problem with the default implementation of
scatter_jacobian() if constraints have been completely disabled by
specifying EmptyTransformation as the constraints transformation type.

This patch circumvents the problem by specializing scatter_jacobian()
for that case and removing all constraints-related code from the
specialization.
[GridOperator] Remove remaining usage of NoConstraintsLFS{U,V}Cache and deprecate the typedefs

There is no need for the variant anymore, as caching can now be disabled
at runtime, so avoid having useless typedefs lying around.
[localoperator] remove obsolete base classes for linearelasticity
[LocalOperator] Add new tag class DiagonalJacobian

Decorator base class for local operators with diagonal jacobian to avoid
the overhead of a dense local jacobian matrix in that case.
For high-order DG in 3D (5+), the local jacobian becomes really
large (e.g. 2MB for Q7), which completely thrashes the cache, destroying
scalability in the polynomial order. A number of follow-up patches will
use the information provided by this decorator to improve scaling in
that case.
[LocalMatrix] Add iterator over all entries
[GridOperator] Use new iterator-based LocalMatrix API in jacobian scatter methods

Using an iterator-based API allows us to also use sparse local matrices
like a diagonal variant.
[LocalMatrix] Add new DiagonalLocalMatrix

DiagonalLocalMatrix is a version of LocalMatrix that only stores
diagonal entries.
[GridOperator] Use new DiagonalLocalMatrix for local operators that inherit from DiagonalJacobian tag
[Cleanup] Some small fixes to support non-trivial range field types

This patch cleans up some places that assumed automatic conversion from
the range field type to double and / or automatic conversion from int to
the range field type.

With this patch, it becomes possible to use specialized types for things
like counting floating point operations.
[Ordering] Compilation fix for Intel ICC

ICC complains about name shadowing here. Let's just rename the
problematic pieces to shut it up...