Removes wrong duplicated code that was introduced while fixing
a merge during a rebase on master.

* The source file for the P2MassOperatorTest is relocated to operators
  sub-directory and renamed to MassOperatorTest.cpp. The reason is that
  we now use the file to also test P1 operators.
* For the same reason the P1MassOperatorTest.cpp is removed.

We now can ask also a P1FenicsForm to compute and hand back the
full local element matrix.

The commit implements the missing setup of the diagonal operator values,
i.e. the central stencil weights, for the case of a 3D simulation with
the P2ElementwiseOperator. Still needs testing, though.

We add a setToZero() method to the following functions
- VertexDoFFunction (aka P1Function)
- EdgeDoFFunction
- P2Function
The method differs from calling interpolate() with a zero constant
in the sense that setToZero() will also set all DoFs in the halos of
the primitives to zero, while interpolate() only touches interior
DoFs. The new method is currently used by the P2ElementwiseOpertor.

- The apply() method now also works correctly for 3D settings and we
  include the P2ElementwiseMassOperator now in the 3D test runs of
  the P2MassOperatorTest.
- EdgeDoFIndexing now provides an additional functional
  getEdgeDoFDataIndicesFromMicroCellFEniCSOrdering()
  which is used in the 3D apply. Need to generalise our approach,
  once we also have our own P2Forms with maybe different local DoF
  numbering.
- Removed them superfluous members of the P2ElementwiseOperator class
  and made computeDiagonalOperatorValues() a public method.
- P2FenicsForm now provides integrateAll() which returns the complete
  local element matrix.
- In PointND we now also typedef a Point10D, for our local vectors
  in the case of a P2Tet.

TODO: Implement computeDiagonalOperatorValues() for 3D setting

This commit adds a minimal test for iterating over all micro-cells in
a macro-cell and getting the indi9ces of vertex and edge dofs associated
with a micro-cell.

The test is not very sophisticated. So it will probably not be sufficient
to assure correctness, but at least should help avoiding regressions.

* The map CellTypeToStr allows to convert variables of the enum
  type CellType, such as e.g. BLUE_UP, to a string.
* vertexdof::getVertexDoFDataIndicesFromMicroCell()
  returns the data indices, i.e. for accessing the dof values,
  of all four vertex dofs associated with a micro-cell inside
  a macro-cell.
* edgedof::getEdgeDoFDataIndicesFromMicroCell()
  returns the data indices, i.e. for accessing the dof values,
  of all six edge dofs associated with a micro-cell inside
  a macro-cell.

The P2MassOperatorTest will now also perform tests for two 3D meshes.
Currently we only run this for the P2ConstantOperator, as the
P2Elementwise is missing implementations for cells, yet.

- apply() method now respects the passed flag parameter and hands it
  on towards communicateAdditively(). Also we no longer update halos
  after the additive communication,
- computeDiagonalOperatorValues() now accepts another parameter called
  invert so that we can store also the inverse of the central stencil
  value. This is now done for diagonalValues_ if needsDiagEntries is
  set to true in the constructor.
- The commit significantly simplifies the implementation of Jacobi
  smoothing, as this now only triggers other methods and no longer
  performs computations of its own. It is now only based on
  - apply()
  - assign()
  - multElementwise()
  Thus, once apply() works for 3D so should Jacobi smoothing.

The test now allows to supply different operators for P2 functions.
We can also combine different mass and laplace operators, such as
P2ElementwiseMassOperator and P2ConstantLaplaceOperator.

It is no longer possible or necessary to pass the primitives to skip
in the constructor of a P2Function. Commit adapts test accordingly.
It also makes the test a little bit more verbose.

This commit implement an invertElementwise() method for the low-level
VertexDoFFunction and EdgeDoFFunction classes. It extends the corresponding
function tests and adds an invertElementwise() method to the P2Function
class.

This commit adds a new operator type that, like the old P1ElementwiseOperator
that we had in the past, is based on a different paradigm than the other
operators. Instead of working stencil-based it operates in an elementwise
fashion, i.e. we locally apply the element matrices to element-local vectors.

For this the P2FenicsForm class has a new integrateAll() method that
hands back the complete local element matrix.

The P2ConstantMassOperatorTest is changed to a P2MassOperatorTest as it
now also, successfully, tests the P2ElementwiseMassOperator.

Note: This is still work in progress; there are some issues with the
additive communication (see issue #111 in this context) and we can only
do 2D so far.

Kohl/experiments

See merge request !294

- set relative tolerances too low to reach
- set default absolute tolerances in minres solvers to 1e-12
- removed Schur prec. test since it takes too long
- minor epsilon fixes