The sparsity pattern of the matrix is defined implicitly while
assembling the matrix.

call the matrix "Matrix" instead.

The given implementation only makes sense for a BCRSMAtrix, thus it should
only be used for such. This is in line with ISTLs general coding style.
Also added bit of doc.

This wrapper allows code to use the BCRSMode in implicit
build mode with the default operator[][] API during the
initial build stage.

Mpi flags were not added to pamgtest if parmetis was not present.
This is of course unwanted behaviour. The patch adds pamgtest to
the mpi tests (in addition to being part of the parmetis tests)

The config.h entry for ENABLE_UMFPACK should be in the same module
as the test for UMFPack, to avoid future conflicts with multiple
modules running the test for umfpack.

It is not needed here and does not compile with g++-4.4

The current ISTL test system relies heavily on test problems generated
with setupAnisotropic2d() from dune/istl/paamg/anisotropic.hh . The code
there was written in a fashion that forbid the use of an allocator different
than std::allocator on the BcrsMatrix.

This patch fixes this issue by giving the matrix type as template parameter
to the matrix setup instead of blocksize and fieldtype. This also makes
code easier to read. All (hopefully) tests in ISTL are adpated to the change.

Restores the old twolevelmethodtest and adds a new one to test multithreaded
computation. Fixes the autotools build system to run the multithreaded tests
too. Furthermore introduces multithreaded test with superlu/umfpack.

There was a typename used outside of template which caused
failed compilation of twolevelmethodest (at least for gcc-4.4).
This patch removes the bogus typename.

This was a left over from  resolving the conflicts from rebasing the
feature/twolevel branch.

This patch fixes a memory leak when using AMG as a coarse level solver
for the two level method. As there was no need to store the solver as
a pointer (it was copied anyway), we now simply store it by value.

[twolevelmethod][bugfix] Copy coarse level solver for thread safety. (2nd tparam of TwolevelMethod changed!)

Previously all copies of the twolevel method used the same
coarse level solver. In the case of AMG this resulted in wrong
results as it stores internal data across several applications.
This patch now always copies the internal coarse level data.

In addition the left hand side given to AMG as a coarse level solver
is copied to use it for the post method in the constructor.

Note that the meaning of the template parameters of TwolevelMethod is
changed. Its second parameter is now the type of the coarse level
solver rather than the coarse level linear operator. The latter is
deduced from the previous now. This was needed to supportt copying of
the coarse level solver.

Previously copying of TowLevelMethod did not compile. In addition
the coarse solver was not copied as it should. This patch fixes this.

The LevelTransferPolicies have internal storage for lhs and rhs that
should be cloned in each copy to prevent overwriting values. This
patch accomplishes this.

Previously the current residual was not updated after the coarse
grid correction. This patch fixes this by storing the only the
prolongated coarse grid correction in context.lhs and updating the
accumulated update. During postsmoothing the currently residual is
updated according to context.lhs.

For the postsmmothing to work we have to reset context.lhs to 0
which still contains the update from the last presmoothing step.
This patch does this.

1. do call postsmooth instead of pre smoothing for post smoothing.
2. Prolongate coarse grid correction to correct fine level vector.
3. Changed test to use regular patches and schwarz mod that mimics
   regular smoother for better comparison.
4. Improved documentation.

Previously setting the define overwrote the flags for superlu.

With this addition it is possible to construct a twolevel method by
specifying a fine level smoother (e.g. SeqOverlappingSchwarz), a
policy for the grid transfer, and a policy for constructing the
coarse level solver.