Commit wraps implementation in HYTEG_BUILD_WITH_PETSC macro guards.

The commit introduces implementations for two free functions
- createVectorFromFunction()
- createFunctionFromVector()
for arguments of type BlockFunction< PetscReal >.

BlockFunctionBasicTest gets extended to check that compilation and
execution works.

The commit introduces implementations of
- createVectorFromFunction()
- createFunctionFromVector()
for functions of type GenericFunction< PetscReal >.

The two free functions reside in the new file GenericFunctionPetsc.hpp.
Because of the peculiarities of GenericFunctions these free functions
are, however, only wrappers that call the corresponding one of the two
new member functions
- GenericFunction::toVector()
- GenericFunction::fromVector()
As usual these are pure virtual and the actual work happens inside
the member functions of the FunctionWrapper class.

We extend the FunctionWrapperTest to check compilation and execution
for various kinds of wrapped functions.

Note that due to instantiation requirements the commit also implements
- createVectorFromFunction()
- createFunctionFromVector()
for functions of type DGFunction. However, these implementations are
pseudo only and will abort.

Wagnandr/facedoffunction

See merge request !446

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;