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.

Extension of P2Function::getMaxValue() and others

See merge request !440

Refactoring of VTKOutput class

See merge request !439

The three member functions
- getMaxValue()
- getMinValue()
- getMaxMagnitude()
of the P2Function class now allow to pass a bool mpiReduce. If this
is false no communication happens and each process returns its local
value.

Rationale:

- The interface is now consistenct with that of VertexDoFFunction
  and EdgeDoFFunctions.
- Change fixes the problem that, so far, we could not instantiate
  P2VectorFunction::getMaxMagnitude()

Commit additionally changes P2VectorFunction::getMaxComponentMagnitude()
so that only one MPI communication step instead of dim is required.
It also extends the VectorFunctionBasicTest to check that instantiation
works.

add gcc 11 to CI

See merge request !435

Occurences of double and "Float64" get replaced by real_t and
typeToString< real_t >().

The private methods
- void writeCells2D()
- void writeCells3D()
- writePointsForMicroVertices()
- writePointsForMicroEdges()
are now members of a new VTKMeshWriter friend class.

The private methods
- writeEdgeDoFs()
- writeEdgeDoFData()
are now members of a new VTKEdgeDoFWriter friend class.

Makes enumeration vtk::DataFormat scoped for forward declarations

Having DoFType as private enum inside VTKOuput will not work together
smoothly with the VTK*Writer friend classes when we need to pass a
DoFType. E.g. we cannot forward declare it. So the commit makes it an
enum inside the vtk namespace instead.

Commits places the following free functions in the new file VTKHelpers.hpp
- writeXMLHeader()
- writeXMLFooter()
- writePieceHeader()
- writePieceFooter()
They now belong to the namespace vtk.

We also convert VTKOutput::openDataElement() into a free function, placed
in the same file and namespace as above.

Additionally we remove the class enum VTKOutput::VTK_DATA_FORMAT and replace
it by vtk::DataFormat.

The private methods
- writeP1()
- writeVertexDoFData()
- writeP1VectorFunctionData()
are now members of a new VTKP1Writer friend class.

The private methods
- writeP2()
- writeSingleP2Function()
- writeSingleP2VectorFunction()
are now members of a new VTKP2Writer friend class.
The private method
- writeDGDoF()
is now a member of a new VTKDGDoFWriter friend class.

Finally we modify the VTKOutputTest so that some data are actually written
in base64 encoded binary

Close issue #159

Closes #159

See merge request !438

Removes some deprecated HyTeG forms

See merge request !436

Replaces Taylorhood by TaylorHood in two filenames

See merge request !437

Fixing names two header files so that the reflect their associated classes
and follow our naming convention.

The new HFG forms do not sport an integrate() method. Although they have
an integrateRow0() method which does the same thing. However, for replacing
some of the deprecated old forms integrate() is required. Since the manual
HyTeG forms do no offer either integrate() or integrateRow0() this commit
does a transitional implementation based in integrateAll() which is of course
slow. Cleanup is definitely required.

The commit removes the following forms and associated tests:
- P1FormMass
- P1FormLaplace
- P1FormEpsilon
- P2FormEpsilon
Where forms appeared in operator typedefs and instantiations
they get replaced by forms generated with HFG.

Implementation of P2EpsilonOperator classes

See merge request !433

The new classes are children of the VectorToVectorOperator and called
1. P2ConstantEpsilonOperator
2. P2ElementwiseAffineEpsilonOperator
3. P2ElementwiseBlendingEpsilonOperator

Operator 1 uses the FEniCS forms p2_(tet_)stokes_epsilon(_tet) while
the other use corresponding HyTeG forms. These are the var variants
and, thus, need a callback function for the variable vicosity. This
is to be passed to the constructor of the operators. They will use
it to generate objects for the sub-forms and pass them to the
constructors of their Elementwise sub-operators.

Additionally commit implements a P2ConstantFullViscousOperator.
The latter is based on FEniCS forms. So it does support neither
blending nor variable viscosity.

Adds a ViscousOperatorsTest that checks generation of objects of the
four new operator types for a 2D and a 3D setting.

Commit adds
- a FEniCS ufl file for a pseudo 2D version, i.e. using 1/3 as factor
  instead of 1/2
- a corresponding ufl file for 3D
- and the generated form files for P1 and P2 elements
Updates ufc_traits.hpp, as we need additional template specialisations
in this file for the two new p[12]_tet_stokes_full_tet forms.

Add tokamak application

See merge request !430

disable FP exceptions for all clang compilers in release mode

See merge request !431