Additions for the upcoming createMatrix() implementation for BlockFunctions

See merge request !445

The previous implementation relied on directly using the templated
free function numberOfLocalDoFs(). In order to call the correct one
a switch statement was used based on the FunctionKind of the
corresponding sub-function.

Consequently we would need to update this code piece for every new
type of sub-function that we want to use.

The new implementation is directly using
GenericFunction::getNumberOfLocalDoFs().

The FunctionWrapper class no longer typedefs FunctionType to its
func_t argument. IMHO that was pretty useless. Instead we get a
```
template< typename VType >
using WrappedFuncKind =
typename WrappedFuncType::template FunctionType< VType >;
```
For this to work functions the get wrapped need to provide a templated
FunctionType. So this is added to
- DGFunction
- and all already exisiting children of the BlockFunction class.

Our usual tag-based approach to the numberOfLocalDoFs() free functions
cannot work with Generic- and BlockFunctions, as for those we need an
object instance of the class to determine that value.

In order to remain somewhat compatible with the current approach this
commit adds a version of numberOfLocalDoFs() that takes as input a
function object. For our standard function classes work is then delegated
to the existing free functions by determining the function tag. For the
Generic- and BlockFunction we have special implementations that call
their getNumberOfLocalDoFs() member function.

For the case of the GenericFunction this member function is implemented
by this commit. As usual it is purely virtual and the actual implementation
happens in the FunctionWrapper class.

We use this new function variant in the construction of PETScVector for
testing and as this is where we will need it when converting
GenericFunction objects to PETScVector objects.

Additionally this commit implements enumerate() without an offset in
GenericFunction and FunctionWrapper.

Allow writing Function with different value types through same VTKOuptut object

See merge request !444

Commit makes VTKOutput::add() accept Generic- and BlockFunctions of
other value types than real_t.

We can now export all of the following functions
- P[1,2]Function
- P[1,2]VectorFunction
- EdgeDoFFunction
- DGFunction
for all of the following value types
- double
- int32_t
- int64_t

Commit extends VTKOutputTest to check that this works and also
makes some details of the implementations in VTK*Writer classes
more consistent.

Commit replace int / long by int32_t / int64_t and adds explicit
instantiations for these two types where they were missing. Also
we convert all real_t to double.

This commit changes VTKOutput so that it export also functions of the
following kind:
- P1Function< int32_t >
- P1Function< int64_t >
and not only P1Function< double >.

For this we replace the std::vector< P1Function< real_t > > in the class
by an object of type FunctionMultiStore. This new class allows to store
multiple functions from the same family, which can but need not differ in
their value types.

Opening and closing of <DataArray> element is now handled inside
writeScalarFunction and writeVectorFunction.

After recent changes the following two function members of VTKOutput
had no implementation anymore:
- writeHeader()
- writeFooterAndFile()

Commit moves all tests in HyteG/tests/hyteg whose name starts with Function
as well as teh FindMaxMinMagTest test into a new functions subdirectory.

Changing integer types in explicit function instantiation

See merge request !443

Commit changes the data types when explicitely requesting instantion of
- VertexDoFFunction
- EdgeDoFFunction
- P2Function
from int and long to the more explicit and fully specified int32_t and
int64_t.

Implements PETScVector conversions for P[1,2]VectorFunction

See merge request !442

Like with the P[12]Function classes with allows us to generate from an
template instance another instance with a different value type.

Instead of passing two template parameters

- SrcVecFuncType
- DstVecFuncType

we now use three

- ValueType
- SrcVecFuncKind
- DstVecFuncKind

This influences the derived classes, so e.g. we now have

typedef VectorMassOperator< real_t,
                            P1VectorFunction,
                            P1ConstantMassOperator >
                            P1ConstantVectorMassOperator;

instead of the previous

typedef VectorMassOperator< P1VectorFunction< real_t >,
                            P1ConstantMassOperator >
                            P1ConstantVectorMassOperator;

In detail we can now call the following free functions using objects
of type P[1,2]VectorFunction
- createVectorFromFunction()
- createFunctionFromVector()
- applyDirichletBC()

Commit also adds a simple VectorFunctionPetscTest that checks that
conversion to and from works.

We also rename the first argument of createFunctionFromVector() in
PETScVector from src to dst, as this seems more self-explanatory.

Implements enumerate() for Vector and BlockFunctions

See merge request !441

Commit
- makes EdgeDoFFunction::enumerate() public
- adds inclusion of FunctionProperties.hpp in BlockFunction.hpp
- performs a hotfix in DGFunction class, as there was an inconsistency
  between uint_t and ValueType (low level implementation in DGVertex,
  DGEdge and DGFace expects to receive uint_t, but was passed ValueType,
  which fails e.g. for double)

In order to implement enumerate for the BlockFunction class, we needed
to also implement enumerate( level, offset ) in the GenericFunction and
the FunctionWrapper class.

Commit extends BlockFunctionBasicTest to check enumeration works for the
case of a P2P1TaylorHoodBlockFunction.

Commit adds a new member function to the BlockFunction class and a new
specialisation for P2P1TaylorHoodBlockFunctionTag of the numberOfLocalDoFs
free function. The latter is used to test the new member function in
BlockFunctionBasicTest.

The commit brings two versions of enumerate() for the CFSVectorFunction
class. The first one performs a global enumeration which implies MPI
communication. The other version just performs local operations and
receives an offset for starting the indexing.

We extend VectorFunctionBasicTest to test enumerating.

In order to get enumerate working for P1VectorFunction<int>, the commit
makes enumerate() with offset public in VertexDoFFunction.