Fixes bad_cast issue in P2P1ElementwiseBlendingStokesOperator and adds PrintInfoTest

See merge request !500

The test checks that we get neither compile- nor run-time errors, when
trying to print meta information on the build using the functions from
Git.hpp and BuildInfo.hpp.

The sub-operators of P2ElementwiseBlendingVectorLaplaceOperator are of type
P2ElementwiseBlendingLaplaceOperator and not P2ElementwiseLaplaceOperator.

Maybe it would be wiser to cast to
P2ElementwiseBlendingVectorLaplaceOperator::scalarOpType

Updates BuildInfo

See merge request !498

- Commit adds a new function compilerInfo() that will return the
  compiler ID and version as obtained from CMake.
- printBuildInfo() will now include this information.
- We rename buildFlavour() to buildType() for naming consistency with cmake.

WIP: Petsc compare graph

See merge request !396

VectorToVectorOperators, Smoothability and Code Cleanup

See merge request !497

Commit adds a new test that checks that we can perform Chebyshev smoothing
with different VectorLaplace, Epsilon and FullViscous operators.

The test uses a small 2D problem and only checks application, but not
convergence.

We now use different initial guesses for the x- and y-component

When smoothing CSFVectorFunctions we cannot use getMaxMagnitude for
checking whether the diagonal was computed.

We should only perform calls to getInverseDiagonalValues() on upcasted
operators. Otherwise we get compile-time errors instead of run-time
aborts.

Commit makes P1ConstantEpsilonOperator and P2ElementwiseEpsilonOperators
children of OperatorWithInverseDiagonal and implements the required
pure virtual functions, so that the classes becomes Chebyshev smoothable.

Commit adds a new test that checks that we can solve a simple 2D problem
for VectorLaplace, Epsilon and FullViscous operators with CG.

Rebase of branch brought the new CMake structure, but on the branch
P1StokesLaplaceOperator.hpp had been removed.

With respect to the smoothability of children of the VectorToVectorOperator
class this commit performs the following changes/additions:

- We extend the OperatorWithInverseDiagonal class by a second pure virtual
  function computeInverseDiagonalOperatorValues(). The rational for this is
  simple. A call to getInverseDiagonalValues() does not trigger computation
  of the diagonal resp. its inverse. Thus, a class that provides the one
  interface also needs to provide the other. Making the one trigger the
  other seems not sufficient either, as we need to be able to recompute,
  when the material parameter, e.g. viscosity, changes.
- VectorToVectorOperator provides central implementations of both methods
  to which children need only delegate. This is the way we implement it
  in VectorLaplaceOperator and corresponding P1EpsilonOperator and
  P2FullViscousOperator cases.
- The implementation in VectorToVectorOperator will throw, if the diagonal
  operator blocks do not have inherited the OperatorWithInverseDiagonal
  interface and abort, if the operator is not mapping between identical
  spaces.
- NOTE:
  For this to work the commit makes a change to the P1Operator class.
  Its two public member functions compute[Inverse]DiagonalOperatorValues()
  allowed to provide and argument use_variable_stencil_assembly with a
  default value of false. Since this conflicts with the new inheritance
  and as noone ever calls them with a parameter the commit removes this
  argument.
- The new implementation allows to fix the problems in SmoothableTest
  and test additional operators.

In order to be compatible with the Operator class the commit adds
typedefs for
- srcType
- dstType
to the VectorToVectorOperator class. We keep the old (IMHO more talkative)
- SrcVecFuncType
- DstVecFuncType
typedefs for the moment

If one of the smoothing methods of P2ConstantOperator is called for a
dimension for which it is not (yet) implemented, we make the object
throw a runtime_error instead of performing a WALBERLA_ABORT. This is
more in the spirit of the whole inherit smoothable interfaces.

We now also test our Epsilon and FullViscous operators. And hurrah. Testing
revealed an issue with the P1EpsilonOperators. Explicit instantiations for
some of their sub-operators was missing. Commit fixes this.

The new constructor allows to construct a P[12]VectorFunction from an
std::vector of shared pointers to its scalar component functions. We
perform a minimal test of the constructor in VectorFunctionBasicTest.

Obviously, we cannot use a P2FenicsForm here. Must be a P1FenicsForm.

Commit adds a new file P1EpsilonOperator.hpp that defines the three classes
- P1ConstantEpsilonOperator
- P1ElementwiseAffineEpsilonOperator
- P1ElementwiseBlendingEpsilonOperator
The latter two allow to use a variable viscosity.

Using the new operators we can significantly reduce coding in
- P1P1ElementwiseAffineEpsilonStokesOperator
- P1P1ElementwiseAffineEpsilonStokesBlockPreconditioner

Commit significantly reduces code in P2P1ElementwiseAffineEpsilonStokesOperator
by making the class use a P2ElementwiseAffineEpsilonOperator object instead
of nine separate sub-operators.

Similar commit reduces code in
P2P1ElementwiseAffineEpsilonStokesBlockPreconditioner. However, here we
use a P2ConstantEpsilonOperator. Before the preconditioner was using sub-
operators based on the p2_epsiloncc_x_y_affine_q2 forms. Hence, it was
unaware of viscosity anyhow. Instead of introducing a rather boring new
operator the these forms we can also do with the stencil-based operator.

The two preconditioners
- P1StokesBlockPreconditioner.hpp
- P2P1TaylorHoodStokesBlockPreconditioner.hpp
now work with a ConstantVectorLaplaceOperator internally

The class is superseeded by the P1ConstantVectorLaplaceOperator and no
longer need. To demonstrate this the commit changes P1StokesBlockCGTest
into P1VectorLaplaceCGTest.

add manual job to CI that does not have the werror flag

See merge request !496