From 299a9478761fa6f8388faed9bbeb4db1973fc11d Mon Sep 17 00:00:00 2001
From: David Wells <wellsd2@rpi.edu>
Date: Fri, 30 Oct 2015 10:44:50 -0400
Subject: [PATCH] MATRIX to MatrixType, part 1

---
 include/deal.II/lac/arpack_solver.h           |  20 +-
 include/deal.II/lac/block_matrix.h            |  24 +-
 include/deal.II/lac/block_matrix_array.h      |  65 +--
 include/deal.II/lac/eigen.h                   |  34 +-
 include/deal.II/lac/filtered_matrix.h         |  20 +-
 include/deal.II/lac/full_matrix.h             |  36 +-
 include/deal.II/lac/householder.h             |   3 +-
 include/deal.II/lac/iterative_inverse.h       |   8 +-
 include/deal.II/lac/lapack_full_matrix.h      |  39 +-
 include/deal.II/lac/matrix_block.h            | 305 +++++++-------
 include/deal.II/lac/matrix_lib.h              |  71 ++--
 include/deal.II/lac/parpack_solver.h          |  30 +-
 include/deal.II/lac/pointer_matrix.h          | 164 ++++----
 include/deal.II/lac/precondition.h            | 306 +++++++-------
 include/deal.II/lac/precondition_block.h      | 199 +++++----
 .../lac/precondition_block.templates.h        | 256 ++++++------
 include/deal.II/lac/precondition_selector.h   |  48 +--
 include/deal.II/lac/relaxation_block.h        |  76 ++--
 .../deal.II/lac/relaxation_block.templates.h  |  96 +++--
 include/deal.II/lac/shifted_matrix.h          |  77 ++--
 include/deal.II/lac/solver_bicgstab.h         |  34 +-
 include/deal.II/lac/solver_cg.h               |   8 +-
 include/deal.II/lac/solver_gmres.h            |  16 +-
 include/deal.II/lac/solver_minres.h           |   8 +-
 include/deal.II/lac/solver_qmrs.h             |  16 +-
 include/deal.II/lac/solver_relaxation.h       |   8 +-
 include/deal.II/lac/solver_richardson.h       |  16 +-
 include/deal.II/lac/sparse_matrix_ez.h        |  64 +--
 include/deal.II/lac/transpose_matrix.h        |  65 ++-
 include/deal.II/meshworker/assembler.h        | 379 +++++++++---------
 include/deal.II/meshworker/local_results.h    |  26 +-
 include/deal.II/meshworker/simple.h           | 242 +++++------
 include/deal.II/multigrid/mg_block_smoother.h |  80 ++--
 include/deal.II/multigrid/mg_coarse.h         |  59 ++-
 include/deal.II/multigrid/mg_matrix.h         |  88 ++--
 include/deal.II/multigrid/mg_smoother.h       | 261 ++++++------
 36 files changed, 1612 insertions(+), 1635 deletions(-)

diff --git a/include/deal.II/lac/arpack_solver.h b/include/deal.II/lac/arpack_solver.h
index cef7851e2d..48afdb8cc5 100644
--- a/include/deal.II/lac/arpack_solver.h
+++ b/include/deal.II/lac/arpack_solver.h
@@ -172,14 +172,14 @@ public:
    * Leave it at its default zero, which will be reset to the size of
    * <code>eigenvalues</code> internally.
    */
-  template <typename VectorType, typename MATRIX1,
-            typename MATRIX2, typename INVERSE>
-  void solve (const MATRIX1                      &A,
-              const MATRIX2                      &B,
+  template <typename VectorType, typename MatrixType1,
+            typename MatrixType2, typename INVERSE>
+  void solve (const MatrixType1                  &A,
+              const MatrixType2                  &B,
               const INVERSE                      &inverse,
               std::vector<std::complex<double> > &eigenvalues,
               std::vector<VectorType>            &eigenvectors,
-              const unsigned int                 n_eigenvalues = 0);
+              const unsigned int                  n_eigenvalues = 0);
 
 protected:
 
@@ -257,15 +257,15 @@ ArpackSolver::ArpackSolver (SolverControl &control,
 {}
 
 
-template <typename VectorType, typename MATRIX1,
-          typename MATRIX2, typename INVERSE>
+template <typename VectorType, typename MatrixType1,
+          typename MatrixType2, typename INVERSE>
 inline
-void ArpackSolver::solve (const MATRIX1                      &system_matrix,
-                          const MATRIX2                      &mass_matrix,
+void ArpackSolver::solve (const MatrixType1                  &system_matrix,
+                          const MatrixType2                  &mass_matrix,
                           const INVERSE                      &inverse,
                           std::vector<std::complex<double> > &eigenvalues,
                           std::vector<VectorType>            &eigenvectors,
-                          const unsigned int                 n_eigenvalues)
+                          const unsigned int                  n_eigenvalues)
 {
   //inside the routines of ARPACK the
   //values change magically, so store
diff --git a/include/deal.II/lac/block_matrix.h b/include/deal.II/lac/block_matrix.h
index a90ba86df6..fac76f86e4 100644
--- a/include/deal.II/lac/block_matrix.h
+++ b/include/deal.II/lac/block_matrix.h
@@ -47,7 +47,7 @@ DEAL_II_NAMESPACE_OPEN
  * @ref GlossBlockLA "Block (linear algebra)"
  * @author Guido Kanschat, 2000
  */
-template <class MATRIX>
+template <typename MatrixType>
 class BlockDiagonalMatrix : public Subscriptor
 {
 public:
@@ -55,7 +55,7 @@ public:
    * Constructor for an @p n_blocks by @p n_blocks matrix with diagonal blocks
    * @p M.
    */
-  BlockDiagonalMatrix (const MATRIX       &M,
+  BlockDiagonalMatrix (const MatrixType   &M,
                        const unsigned int  n_blocks);
 
   /**
@@ -80,26 +80,26 @@ private:
   /**
    * Diagonal entry.
    */
-  SmartPointer<const MATRIX,BlockDiagonalMatrix<MATRIX> > matrix;
+  SmartPointer<const MatrixType,BlockDiagonalMatrix<MatrixType> > matrix;
 };
 
 /*@}*/
 //---------------------------------------------------------------------------
 
-template <class MATRIX>
-BlockDiagonalMatrix<MATRIX>::BlockDiagonalMatrix (const MATRIX &M,
-                                                  const unsigned int num_blocks)
+template <typename MatrixType>
+BlockDiagonalMatrix<MatrixType>::BlockDiagonalMatrix (const MatrixType &M,
+                                                      const unsigned int num_blocks)
   :
   num_blocks (num_blocks),
   matrix(&M)
 {}
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template <typename number1, typename number2>
 void
-BlockDiagonalMatrix<MATRIX>::vmult (BlockVector<number1> &dst,
-                                    const BlockVector<number2> &src) const
+BlockDiagonalMatrix<MatrixType>::vmult (BlockVector<number1>       &dst,
+                                        const BlockVector<number2> &src) const
 {
   Assert (dst.n_blocks()==num_blocks,
           ExcDimensionMismatch(dst.n_blocks(),num_blocks));
@@ -111,11 +111,11 @@ BlockDiagonalMatrix<MATRIX>::vmult (BlockVector<number1> &dst,
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template <typename number1, typename number2>
 void
-BlockDiagonalMatrix<MATRIX>::Tvmult (BlockVector<number1> &dst,
-                                     const BlockVector<number2> &src) const
+BlockDiagonalMatrix<MatrixType>::Tvmult (BlockVector<number1>       &dst,
+                                         const BlockVector<number2> &src) const
 {
   Assert (dst.n_blocks()==num_blocks,
           ExcDimensionMismatch(dst.n_blocks(),num_blocks));
diff --git a/include/deal.II/lac/block_matrix_array.h b/include/deal.II/lac/block_matrix_array.h
index e54a70a352..854ffd9c3c 100644
--- a/include/deal.II/lac/block_matrix_array.h
+++ b/include/deal.II/lac/block_matrix_array.h
@@ -60,9 +60,9 @@ DEAL_II_NAMESPACE_OPEN
  * this class. If you need a preconditioner for a BlockMatrixArray object, use
  * BlockTrianglePrecondition.
  *
- * <h3>Requirements on MATRIX</h3>
+ * <h3>Requirements on MatrixType</h3>
  *
- * The template argument <tt>MATRIX</tt> is a class providing the matrix-
+ * The template argument <tt>MatrixType</tt> is a class providing the matrix-
  * vector multiplication functions vmult(), Tvmult(), vmult_add() and
  * Tvmult_add() used in this class, but with arguments of type
  * Vector&lt;number&gt; instead of BlockVector&lt;number&gt;. Every matrix
@@ -154,8 +154,8 @@ public:
    * entering a block of wrong dimension here will only lead to a
    * ExcDimensionMismatch in one of the multiplication functions.
    */
-  template <class MATRIX>
-  void enter (const MATRIX       &matrix,
+  template <typename MatrixType>
+  void enter (const MatrixType   &matrix,
               const unsigned int  row,
               const unsigned int  col,
               const number        prefix = 1.,
@@ -272,10 +272,12 @@ protected:
      * Constructor initializing all data fields. A PointerMatrix object is
      * generated for <tt>matrix</tt>.
      */
-    template<class MATRIX>
-    Entry (const MATRIX &matrix,
-           size_type row, size_type col,
-           number prefix, bool transpose);
+    template<typename MatrixType>
+    Entry (const MatrixType &matrix,
+           size_type row,
+           size_type col,
+           number prefix,
+           bool transpose);
 
     /**
      * Copy constructor invalidating the old object. Since it is only used for
@@ -423,12 +425,12 @@ public:
    * Enter a block. This calls BlockMatrixArray::enter(). Remember that the
    * diagonal blocks should actually be inverse matrices or preconditioners.
    */
-  template <class MATRIX>
-  void enter (const MATRIX   &matrix,
-              const size_type row,
-              const size_type col,
-              const number    prefix = 1.,
-              const bool      transpose = false);
+  template <typename MatrixType>
+  void enter (const MatrixType &matrix,
+              const size_type   row,
+              const size_type   col,
+              const number      prefix    = 1.,
+              const bool        transpose = false);
 
   /**
    * Preconditioning.
@@ -513,14 +515,14 @@ private:
 //---------------------------------------------------------------------------
 
 template <typename number, typename BLOCK_VECTOR>
-template <class MATRIX>
+template <typename MatrixType>
 inline
 BlockMatrixArray<number, BLOCK_VECTOR>::Entry::Entry (
-  const MATRIX &m,
-  size_type row,
-  size_type col,
-  number prefix,
-  bool transpose)
+  const MatrixType &m,
+  size_type         row,
+  size_type         col,
+  number            prefix,
+  bool              transpose)
   :
   row (row),
   col (col),
@@ -532,15 +534,14 @@ BlockMatrixArray<number, BLOCK_VECTOR>::Entry::Entry (
 
 
 template <typename number, typename BLOCK_VECTOR>
-template <class MATRIX>
+template <typename MatrixType>
 inline
 void
-BlockMatrixArray<number, BLOCK_VECTOR>::enter (
-  const MATRIX &matrix,
-  unsigned int row,
-  unsigned int col,
-  number prefix,
-  bool transpose)
+BlockMatrixArray<number, BLOCK_VECTOR>::enter (const MatrixType &matrix,
+                                               unsigned int      row,
+                                               unsigned int      col,
+                                               number            prefix,
+                                               bool              transpose)
 {
   Assert(row<n_block_rows(), ExcIndexRange(row, 0, n_block_rows()));
   Assert(col<n_block_cols(), ExcIndexRange(col, 0, n_block_cols()));
@@ -612,12 +613,14 @@ BlockMatrixArray<number, BLOCK_VECTOR>::print_latex (STREAM &out) const
 }
 
 template <typename number, typename BLOCK_VECTOR>
-template <class MATRIX>
+template <typename MatrixType>
 inline
 void
-BlockTrianglePrecondition<number, BLOCK_VECTOR>::enter (const MATRIX &matrix,
-                                                        size_type row, size_type col,
-                                                        number prefix, bool transpose)
+BlockTrianglePrecondition<number, BLOCK_VECTOR>::enter (const MatrixType &matrix,
+                                                        size_type         row,
+                                                        size_type         col,
+                                                        number            prefix,
+                                                        bool              transpose)
 {
   BlockMatrixArray<number, BLOCK_VECTOR>::enter(matrix, row, col, prefix, transpose);
 }
diff --git a/include/deal.II/lac/eigen.h b/include/deal.II/lac/eigen.h
index e4c56bed90..9d874d234e 100644
--- a/include/deal.II/lac/eigen.h
+++ b/include/deal.II/lac/eigen.h
@@ -97,11 +97,11 @@ public:
    * approximated eigenvalue and @p x is the corresponding eigenvector,
    * normalized with respect to the l2-norm.
    */
-  template <class MATRIX>
+  template <typename MatrixType>
   void
-  solve (double       &value,
-         const MATRIX &A,
-         VectorType   &x);
+  solve (double           &value,
+         const MatrixType &A,
+         VectorType       &x);
 
 protected:
   /**
@@ -194,11 +194,11 @@ public:
    * eigenvalue and @p x is the corresponding eigenvector, normalized with
    * respect to the l2-norm.
    */
-  template <class MATRIX>
+  template <typename MatrixType>
   void
-  solve (double       &value,
-         const MATRIX &A,
-         VectorType   &x);
+  solve (double           &value,
+         const MatrixType &A,
+         VectorType       &x);
 
 protected:
   /**
@@ -229,11 +229,11 @@ EigenPower<VectorType>::~EigenPower ()
 
 
 template <class VectorType>
-template <class MATRIX>
+template <typename MatrixType>
 void
-EigenPower<VectorType>::solve (double       &value,
-                               const MATRIX &A,
-                               VectorType   &x)
+EigenPower<VectorType>::solve (double           &value,
+                               const MatrixType &A,
+                               VectorType       &x)
 {
   SolverControl::State conv=SolverControl::iterate;
 
@@ -323,18 +323,18 @@ EigenInverse<VectorType>::~EigenInverse ()
 
 
 template <class VectorType>
-template <class MATRIX>
+template <typename MatrixType>
 void
-EigenInverse<VectorType>::solve (double       &value,
-                                 const MATRIX &A,
-                                 VectorType   &x)
+EigenInverse<VectorType>::solve (double           &value,
+                                 const MatrixType &A,
+                                 VectorType       &x)
 {
   deallog.push("Wielandt");
 
   SolverControl::State conv=SolverControl::iterate;
 
   // Prepare matrix for solver
-  ShiftedMatrix <MATRIX> A_s(A, -value);
+  ShiftedMatrix <MatrixType> A_s(A, -value);
 
   // Define solver
   ReductionControl inner_control (5000, 1.e-16, 1.e-5, false, false);
diff --git a/include/deal.II/lac/filtered_matrix.h b/include/deal.II/lac/filtered_matrix.h
index 306607548b..289cfb9dfc 100644
--- a/include/deal.II/lac/filtered_matrix.h
+++ b/include/deal.II/lac/filtered_matrix.h
@@ -341,9 +341,9 @@ public:
    * @arg @p expect_constrained_source: See documentation of
    * #expect_constrained_source.
    */
-  template <class MATRIX>
-  FilteredMatrix (const MATRIX &matrix,
-                  bool expect_constrained_source = false);
+  template <typename MatrixType>
+  FilteredMatrix (const MatrixType &matrix,
+                  bool              expect_constrained_source = false);
 
   /**
    * Copy operator. Take over matrix and constraints from the other object.
@@ -359,9 +359,9 @@ public:
    * @arg @p expect_constrained_source: See documentation of
    * #expect_constrained_source.
    */
-  template <class MATRIX>
-  void initialize (const MATRIX &m,
-                   bool expect_constrained_source = false);
+  template <typename MatrixType>
+  void initialize (const MatrixType &m,
+                   bool              expect_constrained_source = false);
 
   /**
    * Delete all constraints and the matrix pointer.
@@ -700,10 +700,10 @@ operator () (const IndexValuePair &i1,
 
 
 template <typename VectorType>
-template <class MATRIX>
+template <typename MatrixType>
 inline
 void
-FilteredMatrix<VectorType>::initialize (const MATRIX &m, bool ecs)
+FilteredMatrix<VectorType>::initialize (const MatrixType &m, bool ecs)
 {
   matrix.reset (new_pointer_matrix_base(m, VectorType()));
 
@@ -732,10 +732,10 @@ FilteredMatrix<VectorType>::FilteredMatrix (const FilteredMatrix &fm)
 
 
 template <typename VectorType>
-template <class MATRIX>
+template <typename MatrixType>
 inline
 FilteredMatrix<VectorType>::
-FilteredMatrix (const MATRIX &m, bool ecs)
+FilteredMatrix (const MatrixType &m, bool ecs)
 {
   initialize (m, ecs);
 }
diff --git a/include/deal.II/lac/full_matrix.h b/include/deal.II/lac/full_matrix.h
index 933b1d50cd..0aadc96c7c 100644
--- a/include/deal.II/lac/full_matrix.h
+++ b/include/deal.II/lac/full_matrix.h
@@ -312,19 +312,19 @@ public:
 
   /**
    * Assignment from different matrix classes. This assignment operator uses
-   * iterators of the class MATRIX. Therefore, sparse matrices are possible
+   * iterators of the typename MatrixType. Therefore, sparse matrices are possible
    * sources.
    */
-  template <class MATRIX>
-  void copy_from (const MATRIX &);
+  template <typename MatrixType>
+  void copy_from (const MatrixType &);
 
   /**
    * Transposing assignment from different matrix classes. This assignment
-   * operator uses iterators of the class MATRIX. Therefore, sparse matrices
+   * operator uses iterators of the typename MatrixType. Therefore, sparse matrices
    * are possible sources.
    */
-  template <class MATRIX>
-  void copy_transposed (const MATRIX &);
+  template <typename MatrixType>
+  void copy_transposed (const MatrixType &);
 
   /**
    * Fill matrix with elements extracted from a tensor, taking rows included
@@ -373,7 +373,7 @@ public:
    * this operation.
    */
   template <typename MatrixType, typename index_type>
-  void extract_submatrix_from (const MatrixType &matrix,
+  void extract_submatrix_from (const MatrixType              &matrix,
                                const std::vector<index_type> &row_index_set,
                                const std::vector<index_type> &column_index_set);
 
@@ -393,7 +393,7 @@ public:
   void
   scatter_matrix_to (const std::vector<index_type> &row_index_set,
                      const std::vector<index_type> &column_index_set,
-                     MatrixType &matrix) const;
+                     MatrixType                    &matrix) const;
 
   /**
    * Fill rectangular block.
@@ -1206,9 +1206,9 @@ void FullMatrix<number>::fill (const number2 *src)
 
 
 template <typename number>
-template <class MATRIX>
+template <typename MatrixType>
 void
-FullMatrix<number>::copy_from (const MATRIX &M)
+FullMatrix<number>::copy_from (const MatrixType &M)
 {
   this->reinit (M.m(), M.n());
 
@@ -1217,8 +1217,8 @@ FullMatrix<number>::copy_from (const MATRIX &M)
   // copy them into the current object
   for (size_type row = 0; row < M.m(); ++row)
     {
-      const typename MATRIX::const_iterator end_row = M.end(row);
-      for (typename MATRIX::const_iterator entry = M.begin(row);
+      const typename MatrixType::const_iterator end_row = M.end(row);
+      for (typename MatrixType::const_iterator entry = M.begin(row);
            entry != end_row; ++entry)
         this->el(row, entry->column()) = entry->value();
     }
@@ -1227,9 +1227,9 @@ FullMatrix<number>::copy_from (const MATRIX &M)
 
 
 template <typename number>
-template <class MATRIX>
+template <typename MatrixType>
 void
-FullMatrix<number>::copy_transposed (const MATRIX &M)
+FullMatrix<number>::copy_transposed (const MatrixType &M)
 {
   this->reinit (M.n(), M.m());
 
@@ -1238,8 +1238,8 @@ FullMatrix<number>::copy_transposed (const MATRIX &M)
   // copy them into the current object
   for (size_type row = 0; row < M.m(); ++row)
     {
-      const typename MATRIX::const_iterator end_row = M.end(row);
-      for (typename MATRIX::const_iterator entry = M.begin(row);
+      const typename MatrixType::const_iterator end_row = M.end(row);
+      for (typename MatrixType::const_iterator entry = M.begin(row);
            entry != end_row; ++entry)
         this->el(entry->column(), row) = entry->value();
     }
@@ -1251,7 +1251,7 @@ template <typename number>
 template <typename MatrixType, typename index_type>
 inline
 void
-FullMatrix<number>::extract_submatrix_from (const MatrixType &matrix,
+FullMatrix<number>::extract_submatrix_from (const MatrixType              &matrix,
                                             const std::vector<index_type> &row_index_set,
                                             const std::vector<index_type> &column_index_set)
 {
@@ -1274,7 +1274,7 @@ inline
 void
 FullMatrix<number>::scatter_matrix_to (const std::vector<index_type> &row_index_set,
                                        const std::vector<index_type> &column_index_set,
-                                       MatrixType &matrix) const
+                                       MatrixType                    &matrix) const
 {
   AssertDimension(row_index_set.size(), this->n_rows());
   AssertDimension(column_index_set.size(), this->n_cols());
diff --git a/include/deal.II/lac/householder.h b/include/deal.II/lac/householder.h
index da3045a128..932c51db32 100644
--- a/include/deal.II/lac/householder.h
+++ b/include/deal.II/lac/householder.h
@@ -101,7 +101,8 @@ public:
                         const BlockVector<number2> &src) const;
 
   /**
-   * A wrapper to least_squares(), implementing the standard MATRIX interface.
+   * A wrapper to least_squares(), implementing the standard MatrixType
+   * interface.
    */
   template<class VectorType>
   void vmult (VectorType &dst, const VectorType &src) const;
diff --git a/include/deal.II/lac/iterative_inverse.h b/include/deal.II/lac/iterative_inverse.h
index 3fd6f6f6f0..53cc554919 100644
--- a/include/deal.II/lac/iterative_inverse.h
+++ b/include/deal.II/lac/iterative_inverse.h
@@ -83,8 +83,8 @@ public:
    * Initialization function. Provide a matrix and preconditioner for the
    * solve in vmult().
    */
-  template <class MATRIX, class PRECONDITION>
-  void initialize (const MATRIX &, const PRECONDITION &);
+  template <typename MatrixType, class PRECONDITION>
+  void initialize (const MatrixType &, const PRECONDITION &);
 
   /**
    * Delete the pointers to matrix and preconditioner.
@@ -124,10 +124,10 @@ private:
 
 
 template <typename VectorType>
-template <class MATRIX, class PRECONDITION>
+template <typename MatrixType, class PRECONDITION>
 inline
 void
-IterativeInverse<VectorType>::initialize(const MATRIX &m, const PRECONDITION &p)
+IterativeInverse<VectorType>::initialize(const MatrixType &m, const PRECONDITION &p)
 {
   // dummy variable
   VectorType *v = 0;
diff --git a/include/deal.II/lac/lapack_full_matrix.h b/include/deal.II/lac/lapack_full_matrix.h
index d2b1405226..ecf25ee85f 100644
--- a/include/deal.II/lac/lapack_full_matrix.h
+++ b/include/deal.II/lac/lapack_full_matrix.h
@@ -124,11 +124,11 @@ public:
   /**
    * Assignment from different matrix classes, performing the usual conversion
    * to the transposed format expected by LAPACK. This assignment operator
-   * uses iterators of the class MATRIX. Therefore, sparse matrices are
+   * uses iterators of the typename MatrixType. Therefore, sparse matrices are
    * possible sources.
    */
-  template <class MATRIX>
-  void copy_from (const MATRIX &);
+  template <typename MatrixType>
+  void copy_from (const MatrixType &);
 
   /**
    * Regenerate the current matrix by one that has the same properties as if
@@ -172,8 +172,8 @@ public:
    * The final two arguments allow to enter a multiple of the source or its
    * transpose.
    */
-  template<class MATRIX>
-  void fill (const MATRIX &src,
+  template<typename MatrixType>
+  void fill (const MatrixType &src,
              const size_type dst_offset_i = 0,
              const size_type dst_offset_j = 0,
              const size_type src_offset_i = 0,
@@ -702,9 +702,9 @@ LAPACKFullMatrix<number>::n () const
 }
 
 template <typename number>
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-LAPACKFullMatrix<number>::copy_from (const MATRIX &M)
+LAPACKFullMatrix<number>::copy_from (const MatrixType &M)
 {
   this->reinit (M.m(), M.n());
 
@@ -713,8 +713,8 @@ LAPACKFullMatrix<number>::copy_from (const MATRIX &M)
   // copy them into the current object
   for (size_type row = 0; row < M.m(); ++row)
     {
-      const typename MATRIX::const_iterator end_row = M.end(row);
-      for (typename MATRIX::const_iterator entry = M.begin(row);
+      const typename MatrixType::const_iterator end_row = M.end(row);
+      for (typename MatrixType::const_iterator entry = M.begin(row);
            entry != end_row; ++entry)
         this->el(row, entry->column()) = entry->value();
     }
@@ -725,23 +725,22 @@ LAPACKFullMatrix<number>::copy_from (const MATRIX &M)
 
 
 template <typename number>
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-LAPACKFullMatrix<number>::fill (
-  const MATRIX &M,
-  const size_type dst_offset_i,
-  const size_type dst_offset_j,
-  const size_type src_offset_i,
-  const size_type src_offset_j,
-  const number factor,
-  const bool transpose)
+LAPACKFullMatrix<number>::fill (const MatrixType &M,
+                                const size_type   dst_offset_i,
+                                const size_type   dst_offset_j,
+                                const size_type   src_offset_i,
+                                const size_type   src_offset_j,
+                                const number      factor,
+                                const bool        transpose)
 {
   // loop over the elements of the argument matrix row by row, as suggested
   // in the documentation of the sparse matrix iterator class
   for (size_type row = src_offset_i; row < M.m(); ++row)
     {
-      const typename MATRIX::const_iterator end_row = M.end(row);
-      for (typename MATRIX::const_iterator entry = M.begin(row);
+      const typename MatrixType::const_iterator end_row = M.end(row);
+      for (typename MatrixType::const_iterator entry = M.begin(row);
            entry != end_row; ++entry)
         {
           const size_type i = transpose ? entry->column() : row;
diff --git a/include/deal.II/lac/matrix_block.h b/include/deal.II/lac/matrix_block.h
index 59a51810b3..b5a16bc3c2 100644
--- a/include/deal.II/lac/matrix_block.h
+++ b/include/deal.II/lac/matrix_block.h
@@ -30,13 +30,13 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-template <class MATRIX> class MatrixBlock;
+template <typename MatrixType> class MatrixBlock;
 
 namespace internal
 {
-  template <class MATRIX>
+  template <typename MatrixType>
   void
-  reinit(MatrixBlock<MATRIX> &v,
+  reinit(MatrixBlock<MatrixType> &v,
          const BlockSparsityPattern &p);
 
   template <typename number>
@@ -65,7 +65,7 @@ namespace internal
  *
  * While the add() functions make a MatrixBlock appear like a block matrix for
  * assembling, the functions vmult(), Tvmult(), vmult_add(), and Tvmult_add()
- * make it behave like a MATRIX, when it comes to applying it to a vector.
+ * make it behave like a MatrixType, when it comes to applying it to a vector.
  * This behavior allows us to store MatrixBlock objects in vectors, for
  * instance in MGLevelObject without extracting the #matrix first.
  *
@@ -100,7 +100,7 @@ namespace internal
  * @ref GlossBlockLA "Block (linear algebra)"
  * @author Guido Kanschat, 2006
  */
-template <class MATRIX>
+template <typename MatrixType>
 class MatrixBlock
   : public Subscriptor
 {
@@ -113,7 +113,7 @@ public:
   /**
    * Declare a type for matrix entries.
    */
-  typedef typename MATRIX::value_type value_type;
+  typedef typename MatrixType::value_type value_type;
 
   /**
    * Constructor rendering an uninitialized object.
@@ -123,7 +123,7 @@ public:
   /**
    * Copy constructor.
    */
-  MatrixBlock(const MatrixBlock<MATRIX> &M);
+  MatrixBlock(const MatrixBlock<MatrixType> &M);
 
   /**
    * Constructor setting block coordinates, but not initializing the matrix.
@@ -140,16 +140,16 @@ public:
    */
   void reinit(const BlockSparsityPattern &sparsity);
 
-  operator MATRIX &();
-  operator const MATRIX &() const;
+  operator MatrixType &();
+  operator const MatrixType &() const;
 
   /**
    * Add <tt>value</tt> to the element (<i>i,j</i>). Throws an error if the
    * entry does not exist or if it is in a different block.
    */
-  void add (const size_type i,
-            const size_type j,
-            const typename MATRIX::value_type value);
+  void add (const size_type                       i,
+            const size_type                       j,
+            const typename MatrixType::value_type value);
 
   /**
    * Add all elements in a FullMatrix into sparse matrix locations given by
@@ -231,7 +231,7 @@ public:
             const bool       col_indices_are_sorted = false);
 
   /**
-   * Matrix-vector-multiplication, forwarding to the same function in MATRIX.
+   * Matrix-vector-multiplication, forwarding to the same function in MatrixType.
    * No index computations are done, thus, the vectors need to have sizes
    * matching #matrix.
    */
@@ -239,7 +239,7 @@ public:
   void vmult (VectorType &w, const VectorType &v) const;
 
   /**
-   * Matrix-vector-multiplication, forwarding to the same function in MATRIX.
+   * Matrix-vector-multiplication, forwarding to the same function in MatrixType.
    * No index computations are done, thus, the vectors need to have sizes
    * matching #matrix.
    */
@@ -247,7 +247,7 @@ public:
   void vmult_add (VectorType &w, const VectorType &v) const;
 
   /**
-   * Matrix-vector-multiplication, forwarding to the same function in MATRIX.
+   * Matrix-vector-multiplication, forwarding to the same function in MatrixType.
    * No index computations are done, thus, the vectors need to have sizes
    * matching #matrix.
    */
@@ -255,7 +255,7 @@ public:
   void Tvmult (VectorType &w, const VectorType &v) const;
 
   /**
-   * Matrix-vector-multiplication, forwarding to the same function in MATRIX.
+   * Matrix-vector-multiplication, forwarding to the same function in MatrixType.
    * No index computations are done, thus, the vectors need to have sizes
    * matching #matrix.
    */
@@ -288,7 +288,7 @@ public:
   /**
    * The matrix itself
    */
-  MATRIX matrix;
+  MatrixType matrix;
 
 private:
   /**
@@ -303,9 +303,9 @@ private:
    */
   BlockIndices column_indices;
 
-  template <class OTHER_MATRIX>
+  template <class OTHER_MatrixType>
   friend
-  void dealii::internal::reinit(MatrixBlock<OTHER_MATRIX> &,
+  void dealii::internal::reinit(MatrixBlock<OTHER_MatrixType> &,
                                 const BlockSparsityPattern &);
 
   template <typename number>
@@ -324,7 +324,7 @@ private:
  * @ingroup vector_valued
  * @author Baerbel Janssen, Guido Kanschat, 2010
  */
-template <class MATRIX>
+template <typename MatrixType>
 class MatrixBlockVector
   :
   private AnyData
@@ -338,7 +338,7 @@ public:
   /**
    * The type of object stored.
    */
-  typedef MatrixBlock<MATRIX> value_type;
+  typedef MatrixBlock<MatrixType> value_type;
 
   /**
    * The pointer type used for storing the objects. We use a shard pointer,
@@ -388,7 +388,7 @@ public:
   /**
    * Access the matrix at position <i>i</i> for read and write access.
    */
-  MATRIX &matrix(size_type i);
+  MatrixType &matrix(size_type i);
 
   /**
    * import functions from private base class
@@ -409,7 +409,7 @@ public:
  * @ingroup vector_valued
  * @author Baerbel Janssen, Guido Kanschat, 2010
  */
-template <class MATRIX>
+template <typename MatrixType>
 class MGMatrixBlockVector
   : public Subscriptor
 {
@@ -422,7 +422,7 @@ public:
   /**
    * The type of object stored.
    */
-  typedef MGLevelObject<MatrixBlock<MATRIX> > value_type;
+  typedef MGLevelObject<MatrixBlock<MatrixType> > value_type;
   /**
    * Constructor, determining which matrices should be stored.
    *
@@ -567,9 +567,9 @@ private:
 
 namespace internal
 {
-  template <class MATRIX>
+  template <typename MatrixType>
   void
-  reinit(MatrixBlock<MATRIX> &v,
+  reinit(MatrixBlock<MatrixType> &v,
          const BlockSparsityPattern &p)
   {
     v.row_indices = p.get_row_indices();
@@ -589,18 +589,18 @@ namespace internal
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline
-MatrixBlock<MATRIX>::MatrixBlock()
+MatrixBlock<MatrixType>::MatrixBlock ()
   :
   row(numbers::invalid_size_type),
   column(numbers::invalid_size_type)
 {}
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline
-MatrixBlock<MATRIX>::MatrixBlock(const MatrixBlock<MATRIX> &M)
+MatrixBlock<MatrixType>::MatrixBlock (const MatrixBlock<MatrixType> &M)
   :
   Subscriptor(),
   row(M.row),
@@ -611,45 +611,44 @@ MatrixBlock<MATRIX>::MatrixBlock(const MatrixBlock<MATRIX> &M)
 {}
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline
-MatrixBlock<MATRIX>::MatrixBlock(size_type i, size_type j)
+MatrixBlock<MatrixType>::MatrixBlock (size_type i, size_type j)
   :
   row(i), column(j)
 {}
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline
 void
-MatrixBlock<MATRIX>::reinit(const BlockSparsityPattern &sparsity)
+MatrixBlock<MatrixType>::reinit (const BlockSparsityPattern &sparsity)
 {
   internal::reinit(*this, sparsity);
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline
-MatrixBlock<MATRIX>::operator MATRIX &()
+MatrixBlock<MatrixType>::operator MatrixType &()
 {
   return matrix;
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline
-MatrixBlock<MATRIX>::operator const MATRIX &() const
+MatrixBlock<MatrixType>::operator const MatrixType &() const
 {
   return matrix;
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-MatrixBlock<MATRIX>::add (
-  const size_type gi,
-  const size_type gj,
-  const typename MATRIX::value_type value)
+MatrixBlock<MatrixType>::add (const size_type gi,
+                              const size_type gj,
+                              const typename MatrixType::value_type value)
 {
   Assert(row_indices.size() != 0, ExcNotInitialized());
   Assert(column_indices.size() != 0, ExcNotInitialized());
@@ -666,14 +665,14 @@ MatrixBlock<MATRIX>::add (
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template <typename number>
 inline
 void
-MatrixBlock<MATRIX>::add (const std::vector<size_type> &r_indices,
-                          const std::vector<size_type> &c_indices,
-                          const FullMatrix<number>     &values,
-                          const bool                    elide_zero_values)
+MatrixBlock<MatrixType>::add (const std::vector<size_type> &r_indices,
+                              const std::vector<size_type> &c_indices,
+                              const FullMatrix<number>     &values,
+                              const bool                    elide_zero_values)
 {
   Assert(row_indices.size() != 0, ExcNotInitialized());
   Assert(column_indices.size() != 0, ExcNotInitialized());
@@ -687,16 +686,16 @@ MatrixBlock<MATRIX>::add (const std::vector<size_type> &r_indices,
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template <typename number>
 inline
 void
-MatrixBlock<MATRIX>::add (const size_type  b_row,
-                          const size_type  n_cols,
-                          const size_type *col_indices,
-                          const number    *values,
-                          const bool,
-                          const bool)
+MatrixBlock<MatrixType>::add (const size_type  b_row,
+                              const size_type  n_cols,
+                              const size_type *col_indices,
+                              const number    *values,
+                              const bool,
+                              const bool)
 {
   Assert(row_indices.size() != 0, ExcNotInitialized());
   Assert(column_indices.size() != 0, ExcNotInitialized());
@@ -727,13 +726,13 @@ MatrixBlock<MATRIX>::add (const size_type  b_row,
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template <typename number>
 inline
 void
-MatrixBlock<MATRIX>::add (const std::vector<size_type> &indices,
-                          const FullMatrix<number>     &values,
-                          const bool                    elide_zero_values)
+MatrixBlock<MatrixType>::add (const std::vector<size_type> &indices,
+                              const FullMatrix<number>     &values,
+                              const bool                    elide_zero_values)
 {
   Assert(row_indices.size() != 0, ExcNotInitialized());
   Assert(column_indices.size() != 0, ExcNotInitialized());
@@ -748,14 +747,14 @@ MatrixBlock<MATRIX>::add (const std::vector<size_type> &indices,
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template <typename number>
 inline
 void
-MatrixBlock<MATRIX>::add (const size_type               row,
-                          const std::vector<size_type> &col_indices,
-                          const std::vector<number>    &values,
-                          const bool                    elide_zero_values)
+MatrixBlock<MatrixType>::add (const size_type               row,
+                              const std::vector<size_type> &col_indices,
+                              const std::vector<number>    &values,
+                              const bool                    elide_zero_values)
 {
   Assert(row_indices.size() != 0, ExcNotInitialized());
   Assert(column_indices.size() != 0, ExcNotInitialized());
@@ -766,50 +765,50 @@ MatrixBlock<MATRIX>::add (const size_type               row,
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template <class VectorType>
 inline
 void
-MatrixBlock<MATRIX>::vmult (VectorType &w, const VectorType &v) const
+MatrixBlock<MatrixType>::vmult (VectorType &w, const VectorType &v) const
 {
   matrix.vmult(w,v);
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template <class VectorType>
 inline
 void
-MatrixBlock<MATRIX>::vmult_add (VectorType &w, const VectorType &v) const
+MatrixBlock<MatrixType>::vmult_add (VectorType &w, const VectorType &v) const
 {
   matrix.vmult_add(w,v);
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template <class VectorType>
 inline
 void
-MatrixBlock<MATRIX>::Tvmult (VectorType &w, const VectorType &v) const
+MatrixBlock<MatrixType>::Tvmult (VectorType &w, const VectorType &v) const
 {
   matrix.Tvmult(w,v);
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template <class VectorType>
 inline
 void
-MatrixBlock<MATRIX>::Tvmult_add (VectorType &w, const VectorType &v) const
+MatrixBlock<MatrixType>::Tvmult_add (VectorType &w, const VectorType &v) const
 {
   matrix.Tvmult_add(w,v);
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline
 std::size_t
-MatrixBlock<MATRIX>::memory_consumption () const
+MatrixBlock<MatrixType>::memory_consumption () const
 {
   return (sizeof(*this)
           + MemoryConsumption::memory_consumption(matrix)
@@ -818,20 +817,20 @@ MatrixBlock<MATRIX>::memory_consumption () const
 
 //----------------------------------------------------------------------//
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-MatrixBlockVector<MATRIX>::add(
-  size_type row, size_type column,
-  const std::string &name)
+MatrixBlockVector<MatrixType>::add(size_type          row,
+                                   size_type          column,
+                                   const std::string &name)
 {
   ptr_type p(new value_type(row, column));
   AnyData::add(p, name);
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-MatrixBlockVector<MATRIX>::reinit(const BlockSparsityPattern &sparsity)
+MatrixBlockVector<MatrixType>::reinit (const BlockSparsityPattern &sparsity)
 {
   for (size_type i=0; i<this->size(); ++i)
     {
@@ -840,9 +839,9 @@ MatrixBlockVector<MATRIX>::reinit(const BlockSparsityPattern &sparsity)
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-MatrixBlockVector<MATRIX>::clear(bool really_clean)
+MatrixBlockVector<MatrixType>::clear (bool really_clean)
 {
   if (really_clean)
     {
@@ -857,25 +856,25 @@ MatrixBlockVector<MATRIX>::clear(bool really_clean)
 
 
 
-template <class MATRIX>
-inline const MatrixBlock<MATRIX> &
-MatrixBlockVector<MATRIX>::block(size_type i) const
+template <typename MatrixType>
+inline const MatrixBlock<MatrixType> &
+MatrixBlockVector<MatrixType>::block (size_type i) const
 {
   return *this->read<ptr_type>(i);
 }
 
 
-template <class MATRIX>
-inline MatrixBlock<MATRIX> &
-MatrixBlockVector<MATRIX>::block(size_type i)
+template <typename MatrixType>
+inline MatrixBlock<MatrixType> &
+MatrixBlockVector<MatrixType>::block (size_type i)
 {
   return *this->entry<ptr_type>(i);
 }
 
 
-template <class MATRIX>
-inline MATRIX &
-MatrixBlockVector<MATRIX>::matrix(size_type i)
+template <typename MatrixType>
+inline MatrixType &
+MatrixBlockVector<MatrixType>::matrix (size_type i)
 {
   return this->entry<ptr_type>(i)->matrix;
 }
@@ -884,32 +883,31 @@ MatrixBlockVector<MATRIX>::matrix(size_type i)
 
 //----------------------------------------------------------------------//
 
-template <class MATRIX>
+template <typename MatrixType>
 inline
-MGMatrixBlockVector<MATRIX>::MGMatrixBlockVector(
-  const bool e, const bool f)
+MGMatrixBlockVector<MatrixType>::MGMatrixBlockVector(const bool e, const bool f)
   :
   edge_matrices(e),
   edge_flux_matrices(f)
 {}
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline
 unsigned int
-MGMatrixBlockVector<MATRIX>::size () const
+MGMatrixBlockVector<MatrixType>::size () const
 {
   return matrices.size();
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-MGMatrixBlockVector<MATRIX>::add(
+MGMatrixBlockVector<MatrixType>::add(
   size_type row, size_type column,
   const std::string &name)
 {
-  MGLevelObject<MatrixBlock<MATRIX> > p(0, 1);
+  MGLevelObject<MatrixBlock<MatrixType> > p(0, 1);
   p[0].row = row;
   p[0].column = column;
 
@@ -927,93 +925,93 @@ MGMatrixBlockVector<MATRIX>::add(
 }
 
 
-template <class MATRIX>
-inline const MGLevelObject<MatrixBlock<MATRIX> > &
-MGMatrixBlockVector<MATRIX>::block(size_type i) const
+template <typename MatrixType>
+inline const MGLevelObject<MatrixBlock<MatrixType> > &
+MGMatrixBlockVector<MatrixType>::block(size_type i) const
 {
-  return *matrices.read<const MGLevelObject<MATRIX>* >(i);
+  return *matrices.read<const MGLevelObject<MatrixType>* >(i);
 }
 
 
-template <class MATRIX>
-inline MGLevelObject<MatrixBlock<MATRIX> > &
-MGMatrixBlockVector<MATRIX>::block(size_type i)
+template <typename MatrixType>
+inline MGLevelObject<MatrixBlock<MatrixType> > &
+MGMatrixBlockVector<MatrixType>::block(size_type i)
 {
-  return *matrices.entry<MGLevelObject<MATRIX>* >(i);
+  return *matrices.entry<MGLevelObject<MatrixType>* >(i);
 }
 
 
-template <class MATRIX>
-inline const MGLevelObject<MatrixBlock<MATRIX> > &
-MGMatrixBlockVector<MATRIX>::block_in(size_type i) const
+template <typename MatrixType>
+inline const MGLevelObject<MatrixBlock<MatrixType> > &
+MGMatrixBlockVector<MatrixType>::block_in(size_type i) const
 {
-  return *matrices_in.read<const MGLevelObject<MATRIX>* >(i);
+  return *matrices_in.read<const MGLevelObject<MatrixType>* >(i);
 }
 
 
-template <class MATRIX>
-inline MGLevelObject<MatrixBlock<MATRIX> > &
-MGMatrixBlockVector<MATRIX>::block_in(size_type i)
+template <typename MatrixType>
+inline MGLevelObject<MatrixBlock<MatrixType> > &
+MGMatrixBlockVector<MatrixType>::block_in(size_type i)
 {
-  return *matrices_in.entry<MGLevelObject<MATRIX>* >(i);
+  return *matrices_in.entry<MGLevelObject<MatrixType>* >(i);
 }
 
 
-template <class MATRIX>
-inline const MGLevelObject<MatrixBlock<MATRIX> > &
-MGMatrixBlockVector<MATRIX>::block_out(size_type i) const
+template <typename MatrixType>
+inline const MGLevelObject<MatrixBlock<MatrixType> > &
+MGMatrixBlockVector<MatrixType>::block_out(size_type i) const
 {
-  return *matrices_out.read<const MGLevelObject<MATRIX>* >(i);
+  return *matrices_out.read<const MGLevelObject<MatrixType>* >(i);
 }
 
 
-template <class MATRIX>
-inline MGLevelObject<MatrixBlock<MATRIX> > &
-MGMatrixBlockVector<MATRIX>::block_out(size_type i)
+template <typename MatrixType>
+inline MGLevelObject<MatrixBlock<MatrixType> > &
+MGMatrixBlockVector<MatrixType>::block_out(size_type i)
 {
-  return *matrices_out.entry<MGLevelObject<MATRIX>* >(i);
+  return *matrices_out.entry<MGLevelObject<MatrixType>* >(i);
 }
 
 
-template <class MATRIX>
-inline const MGLevelObject<MatrixBlock<MATRIX> > &
-MGMatrixBlockVector<MATRIX>::block_up(size_type i) const
+template <typename MatrixType>
+inline const MGLevelObject<MatrixBlock<MatrixType> > &
+MGMatrixBlockVector<MatrixType>::block_up(size_type i) const
 {
-  return *flux_matrices_up.read<const MGLevelObject<MATRIX>* >(i);
+  return *flux_matrices_up.read<const MGLevelObject<MatrixType>* >(i);
 }
 
 
-template <class MATRIX>
-inline MGLevelObject<MatrixBlock<MATRIX> > &
-MGMatrixBlockVector<MATRIX>::block_up(size_type i)
+template <typename MatrixType>
+inline MGLevelObject<MatrixBlock<MatrixType> > &
+MGMatrixBlockVector<MatrixType>::block_up(size_type i)
 {
-  return *flux_matrices_up.entry<MGLevelObject<MATRIX>* >(i);
+  return *flux_matrices_up.entry<MGLevelObject<MatrixType>* >(i);
 }
 
 
-template <class MATRIX>
-inline const MGLevelObject<MatrixBlock<MATRIX> > &
-MGMatrixBlockVector<MATRIX>::block_down(size_type i) const
+template <typename MatrixType>
+inline const MGLevelObject<MatrixBlock<MatrixType> > &
+MGMatrixBlockVector<MatrixType>::block_down(size_type i) const
 {
-  return *flux_matrices_down.read<const MGLevelObject<MATRIX>* >(i);
+  return *flux_matrices_down.read<const MGLevelObject<MatrixType>* >(i);
 }
 
 
-template <class MATRIX>
-inline MGLevelObject<MatrixBlock<MATRIX> > &
-MGMatrixBlockVector<MATRIX>::block_down(size_type i)
+template <typename MatrixType>
+inline MGLevelObject<MatrixBlock<MatrixType> > &
+MGMatrixBlockVector<MatrixType>::block_down(size_type i)
 {
-  return *flux_matrices_down.entry<MGLevelObject<MATRIX>* >(i);
+  return *flux_matrices_down.entry<MGLevelObject<MatrixType>* >(i);
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-MGMatrixBlockVector<MATRIX>::reinit_matrix(const MGLevelObject<BlockSparsityPattern> &sparsity)
+MGMatrixBlockVector<MatrixType>::reinit_matrix(const MGLevelObject<BlockSparsityPattern> &sparsity)
 {
   for (size_type i=0; i<this->size(); ++i)
     {
-      MGLevelObject<MatrixBlock<MATRIX> > &o = block(i);
+      MGLevelObject<MatrixBlock<MatrixType> > &o = block(i);
       const size_type row = o[o.min_level()].row;
       const size_type col = o[o.min_level()].column;
 
@@ -1028,13 +1026,13 @@ MGMatrixBlockVector<MATRIX>::reinit_matrix(const MGLevelObject<BlockSparsityPatt
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-MGMatrixBlockVector<MATRIX>::reinit_edge(const MGLevelObject<BlockSparsityPattern> &sparsity)
+MGMatrixBlockVector<MatrixType>::reinit_edge(const MGLevelObject<BlockSparsityPattern> &sparsity)
 {
   for (size_type i=0; i<this->size(); ++i)
     {
-      MGLevelObject<MatrixBlock<MATRIX> > &o = block(i);
+      MGLevelObject<MatrixBlock<MatrixType> > &o = block(i);
       const size_type row = o[o.min_level()].row;
       const size_type col = o[o.min_level()].column;
 
@@ -1053,13 +1051,14 @@ MGMatrixBlockVector<MATRIX>::reinit_edge(const MGLevelObject<BlockSparsityPatter
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-MGMatrixBlockVector<MATRIX>::reinit_edge_flux(const MGLevelObject<BlockSparsityPattern> &sparsity)
+MGMatrixBlockVector<MatrixType>::reinit_edge_flux
+(const MGLevelObject<BlockSparsityPattern> &sparsity)
 {
   for (size_type i=0; i<this->size(); ++i)
     {
-      MGLevelObject<MatrixBlock<MATRIX> > &o = block(i);
+      MGLevelObject<MatrixBlock<MatrixType> > &o = block(i);
       const size_type row = o[o.min_level()].row;
       const size_type col = o[o.min_level()].column;
 
@@ -1079,22 +1078,22 @@ MGMatrixBlockVector<MATRIX>::reinit_edge_flux(const MGLevelObject<BlockSparsityP
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-MGMatrixBlockVector<MATRIX>::clear_object(AnyData &mo)
+MGMatrixBlockVector<MatrixType>::clear_object (AnyData &mo)
 {
   for (size_type i=0; i<mo.size(); ++i)
     {
-      MGLevelObject<MatrixBlock<MATRIX> > &o = mo.entry<MGLevelObject<MATRIX>* >(i);
+      MGLevelObject<MatrixBlock<MatrixType> > &o = mo.entry<MGLevelObject<MatrixType>* >(i);
       for (size_type level = o.min_level(); level <= o.max_level(); ++level)
         o[level].matrix.clear();
     }
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-MGMatrixBlockVector<MATRIX>::clear(bool really_clean)
+MGMatrixBlockVector<MatrixType>::clear (bool really_clean)
 {
   if (really_clean)
     {
diff --git a/include/deal.II/lac/matrix_lib.h b/include/deal.II/lac/matrix_lib.h
index 9ccd73b2a0..adcc672693 100644
--- a/include/deal.II/lac/matrix_lib.h
+++ b/include/deal.II/lac/matrix_lib.h
@@ -71,9 +71,9 @@ public:
    * Constructor.  Additionally to the two constituting matrices, a memory
    * pool for the auxiliary vector must be provided.
    */
-  template <class MATRIX1, class MATRIX2>
-  ProductMatrix (const MATRIX1            &m1,
-                 const MATRIX2            &m2,
+  template <typename MatrixType1, typename MatrixType2>
+  ProductMatrix (const MatrixType1        &m1,
+                 const MatrixType2        &m2,
                  VectorMemory<VectorType> &mem);
 
   /**
@@ -84,15 +84,16 @@ public:
   /**
    * Change the matrices.
    */
-  template <class MATRIX1, class MATRIX2>
-  void reinit(const MATRIX1 &m1, const MATRIX2 &m2);
+  template <typename MatrixType1, typename MatrixType2>
+  void reinit (const MatrixType1 &m1, const MatrixType2 &m2);
 
   /**
    * Change the matrices and memory pool.
    */
-  template <class MATRIX1, class MATRIX2>
-  void initialize(const MATRIX1 &m1, const MATRIX2 &m2,
-                  VectorMemory<VectorType> &mem);
+  template <typename MatrixType1, typename MatrixType2>
+  void initialize (const MatrixType1 &m1,
+                   const MatrixType2 &m2,
+                   VectorMemory<VectorType> &mem);
 
   // Doc in PointerMatrixBase
   void clear();
@@ -165,8 +166,8 @@ public:
   /**
    * Constructor with initialization.
    */
-  template <class MATRIX>
-  ScaledMatrix (const MATRIX &M, const double factor);
+  template <typename MatrixType>
+  ScaledMatrix (const MatrixType &M, const double factor);
 
   /**
    * Destructor
@@ -175,8 +176,8 @@ public:
   /**
    * Initialize for use with a new matrix and factor.
    */
-  template <class MATRIX>
-  void initialize (const MATRIX &M, const double factor);
+  template <typename MatrixType>
+  void initialize (const MatrixType &M, const double factor);
 
   /**
    * Reset the object to its original state.
@@ -448,8 +449,8 @@ public:
    * Initialization function. Provide a solver object, a matrix, and another
    * preconditioner for this.
    */
-  template <class MATRIX, class PRECONDITION>
-  void initialize (const MATRIX &,
+  template <typename MatrixType, class PRECONDITION>
+  void initialize (const MatrixType &,
                    const PRECONDITION &);
 
   /**
@@ -515,9 +516,9 @@ ScaledMatrix<VectorType>::ScaledMatrix()
 
 
 template<typename VectorType>
-template<class MATRIX>
+template<typename MatrixType>
 inline
-ScaledMatrix<VectorType>::ScaledMatrix(const MATRIX &mat, const double factor)
+ScaledMatrix<VectorType>::ScaledMatrix(const MatrixType &mat, const double factor)
   :
   m(new_pointer_matrix_base(mat, VectorType())),
   factor(factor)
@@ -526,10 +527,10 @@ ScaledMatrix<VectorType>::ScaledMatrix(const MATRIX &mat, const double factor)
 
 
 template<typename VectorType>
-template<class MATRIX>
+template<typename MatrixType>
 inline
 void
-ScaledMatrix<VectorType>::initialize(const MATRIX &mat, const double f)
+ScaledMatrix<VectorType>::initialize(const MatrixType &mat, const double f)
 {
   if (m) delete m;
   m = new_pointer_matrix_base(mat, VectorType());
@@ -592,41 +593,41 @@ ProductMatrix<VectorType>::ProductMatrix (VectorMemory<VectorType> &m)
 
 
 template<typename VectorType>
-template<class MATRIX1, class MATRIX2>
-ProductMatrix<VectorType>::ProductMatrix (const MATRIX1            &mat1,
-                                          const MATRIX2            &mat2,
+template<typename MatrixType1, typename MatrixType2>
+ProductMatrix<VectorType>::ProductMatrix (const MatrixType1        &mat1,
+                                          const MatrixType2        &mat2,
                                           VectorMemory<VectorType> &m)
   : mem(&m)
 {
-  m1 = new PointerMatrix<MATRIX1, VectorType>(&mat1, typeid(*this).name());
-  m2 = new PointerMatrix<MATRIX2, VectorType>(&mat2, typeid(*this).name());
+  m1 = new PointerMatrix<MatrixType1, VectorType>(&mat1, typeid(*this).name());
+  m2 = new PointerMatrix<MatrixType2, VectorType>(&mat2, typeid(*this).name());
 }
 
 
 template<typename VectorType>
-template<class MATRIX1, class MATRIX2>
+template<typename MatrixType1, typename MatrixType2>
 void
-ProductMatrix<VectorType>::reinit (const MATRIX1 &mat1, const MATRIX2 &mat2)
+ProductMatrix<VectorType>::reinit (const MatrixType1 &mat1, const MatrixType2 &mat2)
 {
   if (m1) delete m1;
   if (m2) delete m2;
-  m1 = new PointerMatrix<MATRIX1, VectorType>(&mat1, typeid(*this).name());
-  m2 = new PointerMatrix<MATRIX2, VectorType>(&mat2, typeid(*this).name());
+  m1 = new PointerMatrix<MatrixType1, VectorType>(&mat1, typeid(*this).name());
+  m2 = new PointerMatrix<MatrixType2, VectorType>(&mat2, typeid(*this).name());
 }
 
 
 template<typename VectorType>
-template<class MATRIX1, class MATRIX2>
+template<typename MatrixType1, typename MatrixType2>
 void
-ProductMatrix<VectorType>::initialize (const MATRIX1            &mat1,
-                                       const MATRIX2            &mat2,
+ProductMatrix<VectorType>::initialize (const MatrixType1        &mat1,
+                                       const MatrixType2        &mat2,
                                        VectorMemory<VectorType> &memory)
 {
   mem = &memory;
   if (m1) delete m1;
   if (m2) delete m2;
-  m1 = new PointerMatrix<MATRIX1, VectorType>(&mat1, typeid(*this).name());
-  m2 = new PointerMatrix<MATRIX2, VectorType>(&mat2, typeid(*this).name());
+  m1 = new PointerMatrix<MatrixType1, VectorType>(&mat1, typeid(*this).name());
+  m2 = new PointerMatrix<MatrixType2, VectorType>(&mat2, typeid(*this).name());
 }
 
 
@@ -734,13 +735,13 @@ MeanValueFilter::Tvmult_add(VectorType &, const VectorType &) const
 //-----------------------------------------------------------------------//
 
 template <typename VectorType>
-template <class MATRIX, class PRECONDITION>
+template <typename MatrixType, class PRECONDITION>
 inline void
-InverseMatrixRichardson<VectorType>::initialize (const MATRIX &m, const PRECONDITION &p)
+InverseMatrixRichardson<VectorType>::initialize (const MatrixType &m, const PRECONDITION &p)
 {
   if (matrix != 0)
     delete matrix;
-  matrix = new PointerMatrix<MATRIX, VectorType>(&m);
+  matrix = new PointerMatrix<MatrixType, VectorType>(&m);
   if (precondition != 0)
     delete precondition;
   precondition = new PointerMatrix<PRECONDITION, VectorType>(&p);
diff --git a/include/deal.II/lac/parpack_solver.h b/include/deal.II/lac/parpack_solver.h
index 5da03105c2..9f0a359938 100644
--- a/include/deal.II/lac/parpack_solver.h
+++ b/include/deal.II/lac/parpack_solver.h
@@ -159,7 +159,7 @@ public:
   /**
    * Auxiliary class to represent <code>A-sigma*B</code> operator.
    */
-  template <typename MATRIX>
+  template <typename MatrixType>
   class Shift : public dealii::Subscriptor
   {
   public:
@@ -167,9 +167,9 @@ public:
     /**
      * Constructor.
      */
-    Shift (const MATRIX &A,
-           const MATRIX &B,
-           const double sigma)
+    Shift (const MatrixType &A,
+           const MatrixType &B,
+           const double      sigma)
       :
       A(A),
       B(B),
@@ -197,8 +197,8 @@ public:
     }
 
   private:
-    const MATRIX &A;
-    const MATRIX &B;
+    const MatrixType &A;
+    const MatrixType &B;
     const double sigma;
   };
 
@@ -244,15 +244,15 @@ public:
    * calling the <code>pd(n/s)eupd</code> and <code>pd(n/s)aupd</code>
    * functions of PARPACK.
    */
-  template <typename MATRIX1,
-            typename MATRIX2, typename INVERSE>
+  template <typename MatrixType1,
+            typename MatrixType2, typename INVERSE>
   void solve
-  (const MATRIX1                      &A,
-   const MATRIX2                      &B,
+  (const MatrixType1                  &A,
+   const MatrixType2                  &B,
    const INVERSE                      &inverse,
    std::vector<std::complex<double> > &eigenvalues,
    std::vector<VectorType>            &eigenvectors,
-   const unsigned int                 n_eigenvalues);
+   const unsigned int                  n_eigenvalues);
 
   std::size_t memory_consumption() const;
 
@@ -517,14 +517,14 @@ void PArpackSolver<VectorType>::reinit(const dealii::IndexSet &locally_owned_dof
 }
 
 template <typename VectorType>
-template <typename MATRIX1,typename MATRIX2, typename INVERSE>
+template <typename MatrixType1,typename MatrixType2, typename INVERSE>
 void PArpackSolver<VectorType>::solve
-(const MATRIX1                      &/*system_matrix*/,
- const MATRIX2                      &mass_matrix,
+(const MatrixType1                  &/*system_matrix*/,
+ const MatrixType2                  &mass_matrix,
  const INVERSE                      &inverse,
  std::vector<std::complex<double> > &eigenvalues,
  std::vector<VectorType>            &eigenvectors,
- const unsigned int                 n_eigenvalues)
+ const unsigned int                  n_eigenvalues)
 {
 
   Assert (n_eigenvalues <= eigenvectors.size(),
diff --git a/include/deal.II/lac/pointer_matrix.h b/include/deal.II/lac/pointer_matrix.h
index ed0088c0ee..d778c60b28 100644
--- a/include/deal.II/lac/pointer_matrix.h
+++ b/include/deal.II/lac/pointer_matrix.h
@@ -109,7 +109,7 @@ public:
  *
  * @author Guido Kanschat 2000, 2001, 2002
  */
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 class PointerMatrix : public PointerMatrixBase<VectorType>
 {
 public:
@@ -120,7 +120,7 @@ public:
    *
    * If <tt>M</tt> is zero, no matrix is stored.
    */
-  PointerMatrix (const MATRIX *M=0);
+  PointerMatrix (const MatrixType *M=0);
 
   /**
    * Constructor.
@@ -145,7 +145,7 @@ public:
    * argument to this function is used to this end, i.e., you can in essence
    * assign a name to the current PointerMatrix object.
    */
-  PointerMatrix(const MATRIX *M,
+  PointerMatrix(const MatrixType *M,
                 const char *name);
 
   // Use doc from base class
@@ -161,7 +161,7 @@ public:
    * matrix.
    * @see SmartPointer
    */
-  const PointerMatrix &operator= (const MATRIX *M);
+  const PointerMatrix &operator= (const MatrixType *M);
 
   /**
    * Matrix-vector product.
@@ -191,7 +191,7 @@ private:
   /**
    * The pointer to the actual matrix.
    */
-  SmartPointer<const MATRIX,PointerMatrix<MATRIX,VectorType> > m;
+  SmartPointer<const MatrixType,PointerMatrix<MatrixType,VectorType> > m;
 };
 
 
@@ -205,11 +205,11 @@ private:
  *
  * This class differs form PointerMatrix by its additional VectorMemory object
  * and by the fact that it implements the functions vmult_add() and
- * Tvmult_add() only using vmult() and Tvmult() of the MATRIX.
+ * Tvmult_add() only using vmult() and Tvmult() of the MatrixType.
  *
  * @author Guido Kanschat 2006
  */
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 class PointerMatrixAux : public PointerMatrixBase<VectorType>
 {
 public:
@@ -223,7 +223,7 @@ public:
    * If <tt>mem</tt> is zero, then GrowingVectorMemory is used.
    */
   PointerMatrixAux (VectorMemory<VectorType> *mem = 0,
-                    const MATRIX             *M=0);
+                    const MatrixType         *M = 0);
 
   /**
    * Constructor not using a matrix.
@@ -250,7 +250,7 @@ public:
    * assign a name to the current PointerMatrix object.
    */
   PointerMatrixAux(VectorMemory<VectorType> *mem,
-                   const MATRIX             *M,
+                   const MatrixType         *M,
                    const char               *name);
 
   // Use doc from base class
@@ -271,7 +271,7 @@ public:
    * matrix.
    * @see SmartPointer
    */
-  const PointerMatrixAux &operator= (const MATRIX *M);
+  const PointerMatrixAux &operator= (const MatrixType *M);
 
   /**
    * Matrix-vector product.
@@ -306,12 +306,12 @@ private:
   /**
    * Object for getting the auxiliary vector.
    */
-  mutable SmartPointer<VectorMemory<VectorType>,PointerMatrixAux<MATRIX,VectorType> > mem;
+  mutable SmartPointer<VectorMemory<VectorType>,PointerMatrixAux<MatrixType,VectorType> > mem;
 
   /**
    * The pointer to the actual matrix.
    */
-  SmartPointer<const MATRIX,PointerMatrixAux<MATRIX,VectorType> > m;
+  SmartPointer<const MatrixType,PointerMatrixAux<MatrixType,VectorType> > m;
 };
 
 
@@ -444,12 +444,12 @@ private:
  *
  * @relates PointerMatrixBase @relates PointerMatrixAux
  */
-template <typename VectorType, class MATRIX>
+template <typename VectorType, typename MatrixType>
 inline
 PointerMatrixBase<VectorType> *
-new_pointer_matrix_base(MATRIX &matrix, const VectorType &, const char *name = "PointerMatrixAux")
+new_pointer_matrix_base(MatrixType &matrix, const VectorType &, const char *name = "PointerMatrixAux")
 {
-  return new PointerMatrixAux<MATRIX, VectorType>(0, &matrix, name);
+  return new PointerMatrixAux<MatrixType, VectorType>(0, &matrix, name);
 }
 
 /**
@@ -583,85 +583,85 @@ PointerMatrixBase<VectorType>::~PointerMatrixBase ()
 //----------------------------------------------------------------------//
 
 
-template<class MATRIX, typename VectorType>
-PointerMatrix<MATRIX, VectorType>::PointerMatrix (const MATRIX *M)
+template<typename MatrixType, typename VectorType>
+PointerMatrix<MatrixType, VectorType>::PointerMatrix (const MatrixType *M)
   : m(M, typeid(*this).name())
 {}
 
 
-template<class MATRIX, typename VectorType>
-PointerMatrix<MATRIX, VectorType>::PointerMatrix (const char *name)
+template<typename MatrixType, typename VectorType>
+PointerMatrix<MatrixType, VectorType>::PointerMatrix (const char *name)
   : m(0, name)
 {}
 
 
-template<class MATRIX, typename VectorType>
-PointerMatrix<MATRIX, VectorType>::PointerMatrix (const MATRIX *M,
-                                                  const char *name)
+template<typename MatrixType, typename VectorType>
+PointerMatrix<MatrixType, VectorType>::PointerMatrix (const MatrixType *M,
+                                                      const char       *name)
   : m(M, name)
 {}
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-PointerMatrix<MATRIX, VectorType>::clear ()
+PointerMatrix<MatrixType, VectorType>::clear ()
 {
   m = 0;
 }
 
 
-template<class MATRIX, typename VectorType>
-inline const PointerMatrix<MATRIX, VectorType> &
-PointerMatrix<MATRIX, VectorType>::operator= (const MATRIX *M)
+template<typename MatrixType, typename VectorType>
+inline const PointerMatrix<MatrixType, VectorType> &
+PointerMatrix<MatrixType, VectorType>::operator= (const MatrixType *M)
 {
   m = M;
   return *this;
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline bool
-PointerMatrix<MATRIX, VectorType>::empty () const
+PointerMatrix<MatrixType, VectorType>::empty () const
 {
   if (m == 0)
     return true;
   return m->empty();
 }
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-PointerMatrix<MATRIX, VectorType>::vmult (VectorType       &dst,
-                                          const VectorType &src) const
+PointerMatrix<MatrixType, VectorType>::vmult (VectorType       &dst,
+                                              const VectorType &src) const
 {
   Assert (m != 0, ExcNotInitialized());
   m->vmult (dst, src);
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-PointerMatrix<MATRIX, VectorType>::Tvmult (VectorType       &dst,
-                                           const VectorType &src) const
+PointerMatrix<MatrixType, VectorType>::Tvmult (VectorType       &dst,
+                                               const VectorType &src) const
 {
   Assert (m != 0, ExcNotInitialized());
   m->Tvmult (dst, src);
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-PointerMatrix<MATRIX, VectorType>::vmult_add (VectorType       &dst,
-                                              const VectorType &src) const
+PointerMatrix<MatrixType, VectorType>::vmult_add (VectorType       &dst,
+                                                  const VectorType &src) const
 {
   Assert (m != 0, ExcNotInitialized());
   m->vmult_add (dst, src);
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-PointerMatrix<MATRIX, VectorType>::Tvmult_add (VectorType       &dst,
-                                               const VectorType &src) const
+PointerMatrix<MatrixType, VectorType>::Tvmult_add (VectorType       &dst,
+                                                   const VectorType &src) const
 {
   Assert (m != 0, ExcNotInitialized());
   m->Tvmult_add (dst, src);
@@ -672,10 +672,9 @@ PointerMatrix<MATRIX, VectorType>::Tvmult_add (VectorType       &dst,
 //----------------------------------------------------------------------//
 
 
-template<class MATRIX, typename VectorType>
-PointerMatrixAux<MATRIX, VectorType>::PointerMatrixAux (
-  VectorMemory<VectorType> *mem,
-  const MATRIX *M)
+template<typename MatrixType, typename VectorType>
+PointerMatrixAux<MatrixType, VectorType>::PointerMatrixAux (VectorMemory<VectorType> *mem,
+                                                            const MatrixType *M)
   : mem(mem, typeid(*this).name()),
     m(M, typeid(*this).name())
 {
@@ -683,10 +682,9 @@ PointerMatrixAux<MATRIX, VectorType>::PointerMatrixAux (
 }
 
 
-template<class MATRIX, typename VectorType>
-PointerMatrixAux<MATRIX, VectorType>::PointerMatrixAux (
-  VectorMemory<VectorType> *mem,
-  const char *name)
+template<typename MatrixType, typename VectorType>
+PointerMatrixAux<MatrixType, VectorType>::PointerMatrixAux (VectorMemory<VectorType> *mem,
+                                                            const char               *name)
   : mem(mem, name),
     m(0, name)
 {
@@ -694,11 +692,10 @@ PointerMatrixAux<MATRIX, VectorType>::PointerMatrixAux (
 }
 
 
-template<class MATRIX, typename VectorType>
-PointerMatrixAux<MATRIX, VectorType>::PointerMatrixAux (
-  VectorMemory<VectorType> *mem,
-  const MATRIX *M,
-  const char *name)
+template<typename MatrixType, typename VectorType>
+PointerMatrixAux<MatrixType, VectorType>::PointerMatrixAux (VectorMemory<VectorType> *mem,
+                                                            const MatrixType         *M,
+                                                            const char               *name)
   : mem(mem, name),
     m(M, name)
 {
@@ -706,26 +703,26 @@ PointerMatrixAux<MATRIX, VectorType>::PointerMatrixAux (
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-PointerMatrixAux<MATRIX, VectorType>::clear ()
+PointerMatrixAux<MatrixType, VectorType>::clear ()
 {
   m = 0;
 }
 
 
-template<class MATRIX, typename VectorType>
-inline const PointerMatrixAux<MATRIX, VectorType> &
-PointerMatrixAux<MATRIX, VectorType>::operator= (const MATRIX *M)
+template<typename MatrixType, typename VectorType>
+inline const PointerMatrixAux<MatrixType, VectorType> &
+PointerMatrixAux<MatrixType, VectorType>::operator= (const MatrixType *M)
 {
   m = M;
   return *this;
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-PointerMatrixAux<MATRIX, VectorType>::set_memory(VectorMemory<VectorType> *M)
+PointerMatrixAux<MatrixType, VectorType>::set_memory(VectorMemory<VectorType> *M)
 {
   mem = M;
   if (mem == 0)
@@ -733,18 +730,18 @@ PointerMatrixAux<MATRIX, VectorType>::set_memory(VectorMemory<VectorType> *M)
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline bool
-PointerMatrixAux<MATRIX, VectorType>::empty () const
+PointerMatrixAux<MatrixType, VectorType>::empty () const
 {
   if (m == 0)
     return true;
   return m->empty();
 }
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-PointerMatrixAux<MATRIX, VectorType>::vmult (VectorType       &dst,
+PointerMatrixAux<MatrixType, VectorType>::vmult (VectorType       &dst,
                                              const VectorType &src) const
 {
   if (mem == 0)
@@ -755,9 +752,9 @@ PointerMatrixAux<MATRIX, VectorType>::vmult (VectorType       &dst,
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-PointerMatrixAux<MATRIX, VectorType>::Tvmult (VectorType       &dst,
+PointerMatrixAux<MatrixType, VectorType>::Tvmult (VectorType       &dst,
                                               const VectorType &src) const
 {
   if (mem == 0)
@@ -768,9 +765,9 @@ PointerMatrixAux<MATRIX, VectorType>::Tvmult (VectorType       &dst,
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-PointerMatrixAux<MATRIX, VectorType>::vmult_add (VectorType       &dst,
+PointerMatrixAux<MatrixType, VectorType>::vmult_add (VectorType       &dst,
                                                  const VectorType &src) const
 {
   if (mem == 0)
@@ -785,9 +782,9 @@ PointerMatrixAux<MATRIX, VectorType>::vmult_add (VectorType       &dst,
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-PointerMatrixAux<MATRIX, VectorType>::Tvmult_add (VectorType       &dst,
+PointerMatrixAux<MatrixType, VectorType>::Tvmult_add (VectorType       &dst,
                                                   const VectorType &src) const
 {
   if (mem == 0)
@@ -818,9 +815,8 @@ PointerMatrixVector<number>::PointerMatrixVector (const char *name)
 
 
 template<typename number>
-PointerMatrixVector<number>::PointerMatrixVector (
-  const Vector<number> *M,
-  const char *name)
+PointerMatrixVector<number>::PointerMatrixVector (const Vector<number> *M,
+                                                  const char           *name)
   : m(M, name)
 {}
 
@@ -853,9 +849,8 @@ PointerMatrixVector<number>::empty () const
 
 template<typename number>
 inline void
-PointerMatrixVector<number>::vmult (
-  Vector<number> &dst,
-  const Vector<number> &src) const
+PointerMatrixVector<number>::vmult (Vector<number>       &dst,
+                                    const Vector<number> &src) const
 {
   Assert (m != 0, ExcNotInitialized());
   Assert (dst.size() == 1, ExcDimensionMismatch(dst.size(), 1));
@@ -866,9 +861,8 @@ PointerMatrixVector<number>::vmult (
 
 template<typename number>
 inline void
-PointerMatrixVector<number>::Tvmult (
-  Vector<number> &dst,
-  const Vector<number> &src) const
+PointerMatrixVector<number>::Tvmult (Vector<number>       &dst,
+                                     const Vector<number> &src) const
 {
   Assert (m != 0, ExcNotInitialized());
   Assert(src.size() == 1, ExcDimensionMismatch(src.size(), 1));
@@ -879,9 +873,8 @@ PointerMatrixVector<number>::Tvmult (
 
 template<typename number>
 inline void
-PointerMatrixVector<number>::vmult_add (
-  Vector<number> &dst,
-  const Vector<number> &src) const
+PointerMatrixVector<number>::vmult_add (Vector<number>       &dst,
+                                        const Vector<number> &src) const
 {
   Assert (m != 0, ExcNotInitialized());
   Assert (dst.size() == 1, ExcDimensionMismatch(dst.size(), 1));
@@ -892,9 +885,8 @@ PointerMatrixVector<number>::vmult_add (
 
 template<typename number>
 inline void
-PointerMatrixVector<number>::Tvmult_add (
-  Vector<number> &dst,
-  const Vector<number> &src) const
+PointerMatrixVector<number>::Tvmult_add (Vector<number>       &dst,
+                                         const Vector<number> &src) const
 {
   Assert (m != 0, ExcNotInitialized());
   Assert(src.size() == 1, ExcDimensionMismatch(src.size(), 1));
diff --git a/include/deal.II/lac/precondition.h b/include/deal.II/lac/precondition.h
index f806b60733..c55d6ec85e 100644
--- a/include/deal.II/lac/precondition.h
+++ b/include/deal.II/lac/precondition.h
@@ -98,8 +98,8 @@ public:
    * The matrix argument is ignored and here just for compatibility with more
    * complex preconditioners.
    */
-  template <class MATRIX>
-  void initialize (const MATRIX         &matrix,
+  template <typename MatrixType>
+  void initialize (const MatrixType     &matrix,
                    const AdditionalData &additional_data = AdditionalData());
 
   /**
@@ -221,8 +221,8 @@ public:
    * preconditioners. The matrix argument is ignored and here just for
    * compatibility with more complex preconditioners.
    */
-  template <class MATRIX>
-  void initialize (const MATRIX &matrix,
+  template <typename MatrixType>
+  void initialize (const MatrixType     &matrix,
                    const AdditionalData &parameters);
 
   /**
@@ -333,21 +333,21 @@ private:
  *
  * @author Guido Kanschat, Wolfgang Bangerth, 1999
  */
-template<class MATRIX = SparseMatrix<double>, class VectorType = Vector<double> >
+template<typename MatrixType = SparseMatrix<double>, class VectorType = Vector<double> >
 class PreconditionUseMatrix : public Subscriptor
 {
 public:
   /**
    * Type of the preconditioning function of the matrix.
    */
-  typedef void ( MATRIX::* function_ptr)(VectorType &, const VectorType &) const;
+  typedef void ( MatrixType::* function_ptr)(VectorType &, const VectorType &) const;
 
   /**
    * Constructor.  This constructor stores a reference to the matrix object
    * for later use and selects a preconditioning method, which must be a
    * member function of that matrix.
    */
-  PreconditionUseMatrix(const MATRIX      &M,
+  PreconditionUseMatrix(const MatrixType  &M,
                         const function_ptr method);
 
   /**
@@ -361,7 +361,7 @@ private:
   /**
    * Pointer to the matrix in use.
    */
-  const MATRIX &matrix;
+  const MatrixType &matrix;
 
   /**
    * Pointer to the preconditioning function.
@@ -379,14 +379,14 @@ private:
  * @author Guido Kanschat, 2000; extension for full compatibility with
  * LinearOperator class: Jean-Paul Pelteret, 2015
  */
-template<class MATRIX = SparseMatrix<double> >
+template<typename MatrixType = SparseMatrix<double> >
 class PreconditionRelaxation : public Subscriptor
 {
 public:
   /**
    * Declare type for container size.
    */
-  typedef typename MATRIX::size_type size_type;
+  typedef typename MatrixType::size_type size_type;
 
   /**
    * Class for parameters.
@@ -410,7 +410,7 @@ public:
    * the preconditioner object. The relaxation parameter should be larger than
    * zero and smaller than 2 for numerical reasons. It defaults to 1.
    */
-  void initialize (const MATRIX &A,
+  void initialize (const MatrixType     &A,
                    const AdditionalData &parameters = AdditionalData());
 
   /**
@@ -434,7 +434,7 @@ protected:
   /**
    * Pointer to the matrix object.
    */
-  SmartPointer<const MATRIX, PreconditionRelaxation<MATRIX> > A;
+  SmartPointer<const MatrixType, PreconditionRelaxation<MatrixType> > A;
 
   /**
    * Relaxation parameter.
@@ -445,7 +445,7 @@ protected:
 
 
 /**
- * Jacobi preconditioner using matrix built-in function.  The <tt>MATRIX</tt>
+ * Jacobi preconditioner using matrix built-in function.  The <tt>MatrixType</tt>
  * class used is required to have a function <tt>precondition_Jacobi(VectorType&,
  * const VectorType&, double</tt>)
  *
@@ -469,8 +469,8 @@ protected:
  *
  * @author Guido Kanschat, 2000
  */
-template <class MATRIX = SparseMatrix<double> >
-class PreconditionJacobi : public PreconditionRelaxation<MATRIX>
+template <typename MatrixType = SparseMatrix<double> >
+class PreconditionJacobi : public PreconditionRelaxation<MatrixType>
 {
 public:
   /**
@@ -520,7 +520,7 @@ public:
  * Using the right hand side <i>b</i> and the previous iterate <i>x</i>, this
  * is the operation implemented by step().
  *
- * The MATRIX class used is required to have functions
+ * The MatrixType class used is required to have functions
  * <tt>precondition_SOR(VectorType&, const VectorType&, double)</tt> and
  * <tt>precondition_TSOR(VectorType&, const VectorType&, double)</tt>.
  *
@@ -544,8 +544,8 @@ public:
  *
  * @author Guido Kanschat, 2000
  */
-template <class MATRIX = SparseMatrix<double> >
-class PreconditionSOR : public PreconditionRelaxation<MATRIX>
+template <typename MatrixType = SparseMatrix<double> >
+class PreconditionSOR : public PreconditionRelaxation<MatrixType>
 {
 public:
   /**
@@ -576,7 +576,7 @@ public:
 
 
 /**
- * SSOR preconditioner using matrix built-in function.  The <tt>MATRIX</tt>
+ * SSOR preconditioner using matrix built-in function.  The <tt>MatrixType</tt>
  * class used is required to have a function <tt>precondition_SSOR(VectorType&,
  * const VectorType&, double)</tt>
  *
@@ -600,19 +600,19 @@ public:
  *
  * @author Guido Kanschat, 2000
  */
-template <class MATRIX = SparseMatrix<double> >
-class PreconditionSSOR : public PreconditionRelaxation<MATRIX>
+template <typename MatrixType = SparseMatrix<double> >
+class PreconditionSSOR : public PreconditionRelaxation<MatrixType>
 {
 public:
   /**
    * Declare type for container size.
    */
-  typedef typename MATRIX::size_type size_type;
+  typedef typename MatrixType::size_type size_type;
 
   /**
    * A typedef to the base class.
    */
-  typedef PreconditionRelaxation<MATRIX> BaseClass;
+  typedef PreconditionRelaxation<MatrixType> BaseClass;
 
 
   /**
@@ -620,7 +620,7 @@ public:
    * the preconditioner object. The relaxation parameter should be larger than
    * zero and smaller than 2 for numerical reasons. It defaults to 1.
    */
-  void initialize (const MATRIX &A,
+  void initialize (const MatrixType &A,
                    const typename BaseClass::AdditionalData &parameters = typename BaseClass::AdditionalData());
 
   /**
@@ -660,7 +660,7 @@ private:
 
 /**
  * Permuted SOR preconditioner using matrix built-in function.  The
- * <tt>MATRIX</tt> class used is required to have functions <tt>PSOR(VectorType&,
+ * <tt>MatrixType</tt> class used is required to have functions <tt>PSOR(VectorType&,
  * const VectorType&, double)</tt> and <tt>TPSOR(VectorType&, const VectorType&,
  * double)</tt>.
  *
@@ -690,14 +690,14 @@ private:
  * @author Guido Kanschat, 2003; extension for full compatibility with
  * LinearOperator class: Jean-Paul Pelteret, 2015
  */
-template <class MATRIX = SparseMatrix<double> >
-class PreconditionPSOR : public PreconditionRelaxation<MATRIX>
+template <typename MatrixType = SparseMatrix<double> >
+class PreconditionPSOR : public PreconditionRelaxation<MatrixType>
 {
 public:
   /**
    * Declare type for container size.
    */
-  typedef typename MATRIX::size_type size_type;
+  typedef typename MatrixType::size_type size_type;
 
   /**
     * Parameters for PreconditionPSOR.
@@ -717,8 +717,8 @@ public:
      */
     AdditionalData (const std::vector<size_type> &permutation,
                     const std::vector<size_type> &inverse_permutation,
-                    const typename PreconditionRelaxation<MATRIX>::AdditionalData
-                    &parameters = typename PreconditionRelaxation<MATRIX>::AdditionalData());
+                    const typename PreconditionRelaxation<MatrixType>::AdditionalData
+                    &parameters = typename PreconditionRelaxation<MatrixType>::AdditionalData());
 
     /**
      * Storage for the permutation vector.
@@ -731,7 +731,7 @@ public:
     /**
      * Relaxation parameters
      */
-    typename PreconditionRelaxation<MATRIX>::AdditionalData parameters;
+    typename PreconditionRelaxation<MatrixType>::AdditionalData parameters;
   };
 
   /**
@@ -745,11 +745,11 @@ public:
    * The relaxation parameter should be larger than zero and smaller than 2
    * for numerical reasons. It defaults to 1.
    */
-  void initialize (const MATRIX &A,
+  void initialize (const MatrixType             &A,
                    const std::vector<size_type> &permutation,
                    const std::vector<size_type> &inverse_permutation,
-                   const typename PreconditionRelaxation<MATRIX>::AdditionalData &
-                   parameters = typename PreconditionRelaxation<MATRIX>::AdditionalData());
+                   const typename PreconditionRelaxation<MatrixType>::AdditionalData &
+                   parameters = typename PreconditionRelaxation<MatrixType>::AdditionalData());
 
   /**
    * Initialize matrix and relaxation parameter. The matrix is just stored in
@@ -761,7 +761,7 @@ public:
    * After this function is called the preconditioner is ready to be used
    * (using the <code>vmult</code> function of derived classes).
    */
-  void initialize (const MATRIX &A,
+  void initialize (const MatrixType &A,
                    const AdditionalData &additional_data);
 
   /**
@@ -803,7 +803,7 @@ private:
  * @author Martin Kronbichler, 2009; extension for full compatibility with
  * LinearOperator class: Jean-Paul Pelteret, 2015
  */
-template <class MATRIX=SparseMatrix<double>, class VectorType=Vector<double> >
+template <typename MatrixType=SparseMatrix<double>, class VectorType=Vector<double> >
 class PreconditionChebyshev : public Subscriptor
 {
 public:
@@ -899,7 +899,7 @@ public:
    * matrix weighted by its diagonal using a modified CG iteration in case the
    * given number of iterations is positive.
    */
-  void initialize (const MATRIX         &matrix,
+  void initialize (const MatrixType     &matrix,
                    const AdditionalData &additional_data = AdditionalData());
 
   /**
@@ -938,7 +938,7 @@ private:
   /**
    * A pointer to the underlying matrix.
    */
-  SmartPointer<const MATRIX,PreconditionChebyshev<MATRIX,VectorType> > matrix_ptr;
+  SmartPointer<const MatrixType,PreconditionChebyshev<MatrixType,VectorType> > matrix_ptr;
 
   /**
    * Internal vector used for the <tt>vmult</tt> operation.
@@ -986,11 +986,10 @@ PreconditionIdentity::PreconditionIdentity ()
   n_columns (0)
 {}
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-PreconditionIdentity::initialize (
-  const MATRIX &matrix,
-  const PreconditionIdentity::AdditionalData &)
+PreconditionIdentity::initialize (const MatrixType &matrix,
+                                  const PreconditionIdentity::AdditionalData &)
 {
   n_rows = matrix.m();
   n_columns = matrix.n();
@@ -1046,8 +1045,7 @@ PreconditionIdentity::n () const
 //---------------------------------------------------------------------------
 
 inline
-PreconditionRichardson::AdditionalData::AdditionalData (
-  const double relaxation)
+PreconditionRichardson::AdditionalData::AdditionalData (const double relaxation)
   :
   relaxation(relaxation)
 {}
@@ -1067,19 +1065,19 @@ PreconditionRichardson::PreconditionRichardson ()
 
 
 inline void
-PreconditionRichardson::initialize (
-  const PreconditionRichardson::AdditionalData &parameters)
+PreconditionRichardson::initialize
+(const PreconditionRichardson::AdditionalData &parameters)
 {
   relaxation = parameters.relaxation;
 }
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-PreconditionRichardson::initialize (
-  const MATRIX &matrix,
-  const PreconditionRichardson::AdditionalData &parameters)
+PreconditionRichardson::initialize
+(const MatrixType                             &matrix,
+ const PreconditionRichardson::AdditionalData &parameters)
 {
   relaxation = parameters.relaxation;
   n_rows = matrix.m();
@@ -1160,34 +1158,34 @@ PreconditionRichardson::n () const
 
 //---------------------------------------------------------------------------
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-PreconditionRelaxation<MATRIX>::initialize (const MATRIX &rA,
-                                            const AdditionalData &parameters)
+PreconditionRelaxation<MatrixType>::initialize (const MatrixType     &rA,
+                                                const AdditionalData &parameters)
 {
   A = &rA;
   relaxation = parameters.relaxation;
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-PreconditionRelaxation<MATRIX>::clear ()
+PreconditionRelaxation<MatrixType>::clear ()
 {
   A = 0;
 }
 
-template <class MATRIX>
-inline typename PreconditionRelaxation<MATRIX>::size_type
-PreconditionRelaxation<MATRIX>::m () const
+template <typename MatrixType>
+inline typename PreconditionRelaxation<MatrixType>::size_type
+PreconditionRelaxation<MatrixType>::m () const
 {
   Assert (A!=0, ExcNotInitialized());
   return A->m();
 }
 
-template <class MATRIX>
-inline typename PreconditionRelaxation<MATRIX>::size_type
-PreconditionRelaxation<MATRIX>::n () const
+template <typename MatrixType>
+inline typename PreconditionRelaxation<MatrixType>::size_type
+PreconditionRelaxation<MatrixType>::n () const
 {
   Assert (A!=0, ExcNotInitialized());
   return A->n();
@@ -1195,14 +1193,14 @@ PreconditionRelaxation<MATRIX>::n () const
 
 //---------------------------------------------------------------------------
 
-template <class MATRIX>
+template <typename MatrixType>
 template<class VectorType>
 inline void
-PreconditionJacobi<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
+PreconditionJacobi<MatrixType>::vmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionJacobi<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionJacobi<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionJacobi and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1212,14 +1210,14 @@ PreconditionJacobi<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template<class VectorType>
 inline void
-PreconditionJacobi<MATRIX>::Tvmult (VectorType &dst, const VectorType &src) const
+PreconditionJacobi<MatrixType>::Tvmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionJacobi<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionJacobi<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionJacobi and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1229,14 +1227,14 @@ PreconditionJacobi<MATRIX>::Tvmult (VectorType &dst, const VectorType &src) cons
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template<class VectorType>
 inline void
-PreconditionJacobi<MATRIX>::step (VectorType &dst, const VectorType &src) const
+PreconditionJacobi<MatrixType>::step (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionJacobi<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionJacobi<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionJacobi and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1246,14 +1244,14 @@ PreconditionJacobi<MATRIX>::step (VectorType &dst, const VectorType &src) const
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template<class VectorType>
 inline void
-PreconditionJacobi<MATRIX>::Tstep (VectorType &dst, const VectorType &src) const
+PreconditionJacobi<MatrixType>::Tstep (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionJacobi<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionJacobi<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionJacobi and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1264,14 +1262,14 @@ PreconditionJacobi<MATRIX>::Tstep (VectorType &dst, const VectorType &src) const
 
 //---------------------------------------------------------------------------
 
-template <class MATRIX>
+template <typename MatrixType>
 template<class VectorType>
 inline void
-PreconditionSOR<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
+PreconditionSOR<MatrixType>::vmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1281,14 +1279,14 @@ PreconditionSOR<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template<class VectorType>
 inline void
-PreconditionSOR<MATRIX>::Tvmult (VectorType &dst, const VectorType &src) const
+PreconditionSOR<MatrixType>::Tvmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1298,14 +1296,14 @@ PreconditionSOR<MATRIX>::Tvmult (VectorType &dst, const VectorType &src) const
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template<class VectorType>
 inline void
-PreconditionSOR<MATRIX>::step (VectorType &dst, const VectorType &src) const
+PreconditionSOR<MatrixType>::step (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1315,14 +1313,14 @@ PreconditionSOR<MATRIX>::step (VectorType &dst, const VectorType &src) const
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template<class VectorType>
 inline void
-PreconditionSOR<MATRIX>::Tstep (VectorType &dst, const VectorType &src) const
+PreconditionSOR<MatrixType>::Tstep (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1334,17 +1332,17 @@ PreconditionSOR<MATRIX>::Tstep (VectorType &dst, const VectorType &src) const
 
 //---------------------------------------------------------------------------
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-PreconditionSSOR<MATRIX>::initialize (const MATRIX &rA,
+PreconditionSSOR<MatrixType>::initialize (const MatrixType                     &rA,
                                       const typename BaseClass::AdditionalData &parameters)
 {
-  this->PreconditionRelaxation<MATRIX>::initialize (rA, parameters);
+  this->PreconditionRelaxation<MatrixType>::initialize (rA, parameters);
 
   // in case we have a SparseMatrix class, we can extract information about
   // the diagonal.
-  const SparseMatrix<typename MATRIX::value_type> *mat =
-    dynamic_cast<const SparseMatrix<typename MATRIX::value_type> *>(&*this->A);
+  const SparseMatrix<typename MatrixType::value_type> *mat =
+    dynamic_cast<const SparseMatrix<typename MatrixType::value_type> *>(&*this->A);
 
   // calculate the positions first after the diagonal.
   if (mat != 0)
@@ -1357,7 +1355,7 @@ PreconditionSSOR<MATRIX>::initialize (const MATRIX &rA,
           // diagonal.  we need to precondition with the elements on the left
           // only. note: the first entry in each line denotes the diagonal
           // element, which we need not check.
-          typename SparseMatrix<typename MATRIX::value_type>::const_iterator
+          typename SparseMatrix<typename MatrixType::value_type>::const_iterator
           it = mat->begin(row)+1;
           for ( ; it < mat->end(row); ++it)
             if (it->column() > row)
@@ -1368,14 +1366,14 @@ PreconditionSSOR<MATRIX>::initialize (const MATRIX &rA,
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template<class VectorType>
 inline void
-PreconditionSSOR<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
+PreconditionSSOR<MatrixType>::vmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionSSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionSSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1385,14 +1383,14 @@ PreconditionSSOR<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template<class VectorType>
 inline void
-PreconditionSSOR<MATRIX>::Tvmult (VectorType &dst, const VectorType &src) const
+PreconditionSSOR<MatrixType>::Tvmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionSSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionSSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1402,14 +1400,14 @@ PreconditionSSOR<MATRIX>::Tvmult (VectorType &dst, const VectorType &src) const
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template<class VectorType>
 inline void
-PreconditionSSOR<MATRIX>::step (VectorType &dst, const VectorType &src) const
+PreconditionSSOR<MatrixType>::step (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionSSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionSSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1419,14 +1417,14 @@ PreconditionSSOR<MATRIX>::step (VectorType &dst, const VectorType &src) const
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template<class VectorType>
 inline void
-PreconditionSSOR<MATRIX>::Tstep (VectorType &dst, const VectorType &src) const
+PreconditionSSOR<MatrixType>::Tstep (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionSSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionSSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionSSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1437,25 +1435,24 @@ PreconditionSSOR<MATRIX>::Tstep (VectorType &dst, const VectorType &src) const
 
 //---------------------------------------------------------------------------
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-PreconditionPSOR<MATRIX>::initialize (
-  const MATRIX &rA,
-  const std::vector<size_type> &p,
-  const std::vector<size_type> &ip,
-  const typename PreconditionRelaxation<MATRIX>::AdditionalData &parameters)
+PreconditionPSOR<MatrixType>::initialize
+(const MatrixType             &rA,
+ const std::vector<size_type> &p,
+ const std::vector<size_type> &ip,
+ const typename PreconditionRelaxation<MatrixType>::AdditionalData &parameters)
 {
   permutation = &p;
   inverse_permutation = &ip;
-  PreconditionRelaxation<MATRIX>::initialize(rA, parameters);
+  PreconditionRelaxation<MatrixType>::initialize(rA, parameters);
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-PreconditionPSOR<MATRIX>::initialize (
-  const MATRIX         &A,
-  const AdditionalData &additional_data)
+PreconditionPSOR<MatrixType>::initialize (const MatrixType     &A,
+                                          const AdditionalData &additional_data)
 {
   initialize(A,
              additional_data.permutation,
@@ -1464,14 +1461,14 @@ PreconditionPSOR<MATRIX>::initialize (
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template <typename VectorType>
 inline void
-PreconditionPSOR<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
+PreconditionPSOR<MatrixType>::vmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionPSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionPSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionPSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1482,14 +1479,14 @@ PreconditionPSOR<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template<class VectorType>
 inline void
-PreconditionPSOR<MATRIX>::Tvmult (VectorType &dst, const VectorType &src) const
+PreconditionPSOR<MatrixType>::Tvmult (VectorType &dst, const VectorType &src) const
 {
 #ifdef DEAL_II_WITH_CXX11
   static_assert(
-    std::is_same<typename PreconditionPSOR<MATRIX>::size_type, typename VectorType::size_type>::value,
+    std::is_same<typename PreconditionPSOR<MatrixType>::size_type, typename VectorType::size_type>::value,
     "PreconditionPSOR and VectorType must have the same size_type.");
 #endif // DEAL_II_WITH_CXX11
 
@@ -1498,11 +1495,11 @@ PreconditionPSOR<MATRIX>::Tvmult (VectorType &dst, const VectorType &src) const
   this->A->TPSOR (dst, *permutation, *inverse_permutation, this->relaxation);
 }
 
-template <class MATRIX>
-PreconditionPSOR<MATRIX>::AdditionalData::AdditionalData (
-  const std::vector<size_type> &permutation,
-  const std::vector<size_type> &inverse_permutation,
-  const typename PreconditionRelaxation<MATRIX>::AdditionalData &parameters)
+template <typename MatrixType>
+PreconditionPSOR<MatrixType>::AdditionalData::AdditionalData
+(const std::vector<size_type> &permutation,
+ const std::vector<size_type> &inverse_permutation,
+ const typename PreconditionRelaxation<MatrixType>::AdditionalData &parameters)
   :
   permutation(permutation),
   inverse_permutation(inverse_permutation),
@@ -1515,28 +1512,28 @@ PreconditionPSOR<MATRIX>::AdditionalData::AdditionalData (
 //---------------------------------------------------------------------------
 
 
-template<class MATRIX, class VectorType>
-PreconditionUseMatrix<MATRIX,VectorType>::PreconditionUseMatrix(const MATRIX       &M,
-                                                                const function_ptr method)
+template<typename MatrixType, class VectorType>
+PreconditionUseMatrix<MatrixType,VectorType>::PreconditionUseMatrix(const MatrixType   &M,
+                                                                    const function_ptr method)
   :
   matrix(M), precondition(method)
 {}
 
 
 
-template<class MATRIX, class VectorType>
+template<typename MatrixType, class VectorType>
 void
-PreconditionUseMatrix<MATRIX,VectorType>::vmult (VectorType       &dst,
-                                                 const VectorType &src) const
+PreconditionUseMatrix<MatrixType,VectorType>::vmult (VectorType       &dst,
+                                                     const VectorType &src) const
 {
   (matrix.*precondition)(dst, src);
 }
 
 //---------------------------------------------------------------------------
 
-template<class MATRIX>
+template<typename MatrixType>
 inline
-PreconditionRelaxation<MATRIX>::AdditionalData::
+PreconditionRelaxation<MatrixType>::AdditionalData::
 AdditionalData (const double relaxation)
   :
   relaxation (relaxation)
@@ -1761,9 +1758,9 @@ namespace internal
 
 
 
-template <class MATRIX, class VectorType>
+template <typename MatrixType, class VectorType>
 inline
-PreconditionChebyshev<MATRIX,VectorType>::AdditionalData::
+PreconditionChebyshev<MatrixType,VectorType>::AdditionalData::
 AdditionalData (const unsigned int degree,
                 const double       smoothing_range,
                 const bool         nonzero_starting,
@@ -1781,9 +1778,9 @@ AdditionalData (const unsigned int degree,
 
 
 
-template <class MATRIX, class VectorType>
+template <typename MatrixType, class VectorType>
 inline
-PreconditionChebyshev<MATRIX,VectorType>::PreconditionChebyshev ()
+PreconditionChebyshev<MatrixType,VectorType>::PreconditionChebyshev ()
   :
   is_initialized (false)
 {
@@ -1796,11 +1793,12 @@ PreconditionChebyshev<MATRIX,VectorType>::PreconditionChebyshev ()
 
 
 
-template <class MATRIX, class VectorType>
+template <typename MatrixType, class VectorType>
 inline
 void
-PreconditionChebyshev<MATRIX,VectorType>::initialize (const MATRIX         &matrix,
-                                                      const AdditionalData &additional_data)
+PreconditionChebyshev<MatrixType,VectorType>::initialize
+(const MatrixType     &matrix,
+ const AdditionalData &additional_data)
 {
   matrix_ptr = &matrix;
   data = additional_data;
@@ -1892,11 +1890,11 @@ PreconditionChebyshev<MATRIX,VectorType>::initialize (const MATRIX         &matr
 
 
 
-template <class MATRIX, class VectorType>
+template <typename MatrixType, class VectorType>
 inline
 void
-PreconditionChebyshev<MATRIX,VectorType>::vmult (VectorType       &dst,
-                                                 const VectorType &src) const
+PreconditionChebyshev<MatrixType,VectorType>::vmult (VectorType       &dst,
+                                                     const VectorType &src) const
 {
   Assert (is_initialized, ExcMessage("Preconditioner not initialized"));
   double rhok  = delta / theta,  sigma = theta / delta;
@@ -1926,11 +1924,11 @@ PreconditionChebyshev<MATRIX,VectorType>::vmult (VectorType       &dst,
 
 
 
-template <class MATRIX, class VectorType>
+template <typename MatrixType, class VectorType>
 inline
 void
-PreconditionChebyshev<MATRIX,VectorType>::Tvmult (VectorType       &dst,
-                                                  const VectorType &src) const
+PreconditionChebyshev<MatrixType,VectorType>::Tvmult (VectorType       &dst,
+                                                      const VectorType &src) const
 {
   Assert (is_initialized, ExcMessage("Preconditioner not initialized"));
   double rhok  = delta / theta,  sigma = theta / delta;
@@ -1960,9 +1958,9 @@ PreconditionChebyshev<MATRIX,VectorType>::Tvmult (VectorType       &dst,
 
 
 
-template <class MATRIX, typename VectorType>
+template <typename MatrixType, typename VectorType>
 inline
-void PreconditionChebyshev<MATRIX,VectorType>::clear ()
+void PreconditionChebyshev<MatrixType,VectorType>::clear ()
 {
   is_initialized = false;
   matrix_ptr = 0;
@@ -1972,20 +1970,20 @@ void PreconditionChebyshev<MATRIX,VectorType>::clear ()
 }
 
 
-template <class MATRIX, typename VectorType>
+template <typename MatrixType, typename VectorType>
 inline
-typename PreconditionChebyshev<MATRIX,VectorType>::size_type
-PreconditionChebyshev<MATRIX,VectorType>::m () const
+typename PreconditionChebyshev<MatrixType,VectorType>::size_type
+PreconditionChebyshev<MatrixType,VectorType>::m () const
 {
   Assert (matrix_ptr!=0, ExcNotInitialized());
   return matrix_ptr->m();
 }
 
 
-template <class MATRIX, typename VectorType>
+template <typename MatrixType, typename VectorType>
 inline
-typename PreconditionChebyshev<MATRIX,VectorType>::size_type
-PreconditionChebyshev<MATRIX,VectorType>::n () const
+typename PreconditionChebyshev<MatrixType,VectorType>::size_type
+PreconditionChebyshev<MatrixType,VectorType>::n () const
 {
   Assert (matrix_ptr!=0, ExcNotInitialized());
   return matrix_ptr->n();
diff --git a/include/deal.II/lac/precondition_block.h b/include/deal.II/lac/precondition_block.h
index 472b70b75d..80e321ab0e 100644
--- a/include/deal.II/lac/precondition_block.h
+++ b/include/deal.II/lac/precondition_block.h
@@ -27,7 +27,7 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 class PreconditionBlockJacobi;
 
 /*! @addtogroup Preconditioners
@@ -37,7 +37,7 @@ class PreconditionBlockJacobi;
 
 /**
  * Base class for actual block preconditioners. This class assumes the
- * <tt>MATRIX</tt> consisting of invertible blocks of @p blocksize on the
+ * <tt>MatrixType</tt> consisting of invertible blocks of @p blocksize on the
  * diagonal and provides the inversion of the diagonal blocks of the matrix.
  * It is not necessary for this class that the matrix be block diagonal;
  * rather, it applies to matrices of arbitrary structure with the minimal
@@ -80,7 +80,7 @@ class PreconditionBlockJacobi;
  * @author Ralf Hartmann, Guido Kanschat
  * @date 1999, 2000, 2010
  */
-template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
+template<typename MatrixType, typename inverse_type = typename MatrixType::value_type>
 class PreconditionBlock
   : public virtual Subscriptor,
     protected PreconditionBlockBase<inverse_type>
@@ -89,7 +89,7 @@ private:
   /**
    * Define number type of matrix.
    */
-  typedef typename MATRIX::value_type number;
+  typedef typename MatrixType::value_type number;
 
   /**
    * Value type for inverse matrices.
@@ -167,7 +167,7 @@ public:
    *
    * Additionally, a relaxation parameter for derived classes may be provided.
    */
-  void initialize (const MATRIX &A,
+  void initialize (const MatrixType &A,
                    const AdditionalData parameters);
 protected:
   /**
@@ -181,7 +181,7 @@ protected:
    *
    * Additionally, a relaxation parameter for derived classes may be provided.
    */
-  void initialize (const MATRIX &A,
+  void initialize (const MatrixType &A,
                    const std::vector<size_type> &permutation,
                    const std::vector<size_type> &inverse_permutation,
                    const AdditionalData parameters);
@@ -215,9 +215,8 @@ protected:
   /**
    * Replacement of invert_diagblocks() for permuted preconditioning.
    */
-  void invert_permuted_diagblocks(
-    const std::vector<size_type> &permutation,
-    const std::vector<size_type> &inverse_permutation);
+  void invert_permuted_diagblocks(const std::vector<size_type> &permutation,
+                                  const std::vector<size_type> &inverse_permutation);
 public:
   /**
    * Deletes the inverse diagonal block matrices if existent, sets the
@@ -267,11 +266,10 @@ public:
    * function.
    */
   template <typename number2>
-  void forward_step (
-    Vector<number2>       &dst,
-    const Vector<number2> &prev,
-    const Vector<number2> &src,
-    const bool transpose_diagonal) const;
+  void forward_step (Vector<number2>       &dst,
+                     const Vector<number2> &prev,
+                     const Vector<number2> &src,
+                     const bool             transpose_diagonal) const;
 
   /**
    * Perform one block relaxation step in backward numbering.
@@ -285,11 +283,10 @@ public:
    * function.
    */
   template <typename number2>
-  void backward_step (
-    Vector<number2>       &dst,
-    const Vector<number2> &prev,
-    const Vector<number2> &src,
-    const bool transpose_diagonal) const;
+  void backward_step (Vector<number2>       &dst,
+                      const Vector<number2> &prev,
+                      const Vector<number2> &src,
+                      const bool             transpose_diagonal) const;
 
 
   /**
@@ -338,7 +335,7 @@ protected:
    * inverse matrices should not be stored) until the last call of the
    * preconditoining @p vmult function of the derived classes.
    */
-  SmartPointer<const MATRIX,PreconditionBlock<MATRIX,inverse_type> > A;
+  SmartPointer<const MatrixType,PreconditionBlock<MatrixType,inverse_type> > A;
   /**
    * Relaxation parameter to be used by derived classes.
    */
@@ -369,15 +366,15 @@ protected:
  *
  * @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2003
  */
-template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
+template<typename MatrixType, typename inverse_type = typename MatrixType::value_type>
 class PreconditionBlockJacobi : public virtual Subscriptor,
-  private PreconditionBlock<MATRIX, inverse_type>
+  private PreconditionBlock<MatrixType, inverse_type>
 {
 private:
   /**
    * Define number type of matrix.
    */
-  typedef typename MATRIX::value_type number;
+  typedef typename MatrixType::value_type number;
 
 public:
   /**
@@ -401,7 +398,7 @@ public:
        * Constructor. Since we use accessors only for read access, a const
        * matrix pointer is sufficient.
        */
-      Accessor (const PreconditionBlockJacobi<MATRIX, inverse_type> *matrix,
+      Accessor (const PreconditionBlockJacobi<MatrixType, inverse_type> *matrix,
                 const size_type row);
 
       /**
@@ -423,7 +420,7 @@ public:
       /**
        * The matrix accessed.
        */
-      const PreconditionBlockJacobi<MATRIX, inverse_type> *matrix;
+      const PreconditionBlockJacobi<MatrixType, inverse_type> *matrix;
 
       /**
        * Save block size here for further reference.
@@ -455,7 +452,7 @@ public:
     /**
      * Constructor.
      */
-    const_iterator(const PreconditionBlockJacobi<MATRIX, inverse_type> *matrix,
+    const_iterator(const PreconditionBlockJacobi<MatrixType, inverse_type> *matrix,
                    const size_type row);
 
     /**
@@ -503,19 +500,19 @@ public:
   /**
    * import functions from private base class
    */
-  using PreconditionBlock<MATRIX, inverse_type>::initialize;
-  using PreconditionBlock<MATRIX, inverse_type>::clear;
-  using PreconditionBlock<MATRIX, inverse_type>::empty;
-  using PreconditionBlock<MATRIX, inverse_type>::el;
-  using PreconditionBlock<MATRIX, inverse_type>::set_same_diagonal;
-  using PreconditionBlock<MATRIX, inverse_type>::invert_diagblocks;
-  using PreconditionBlock<MATRIX, inverse_type>::block_size;
+  using PreconditionBlock<MatrixType, inverse_type>::initialize;
+  using PreconditionBlock<MatrixType, inverse_type>::clear;
+  using PreconditionBlock<MatrixType, inverse_type>::empty;
+  using PreconditionBlock<MatrixType, inverse_type>::el;
+  using PreconditionBlock<MatrixType, inverse_type>::set_same_diagonal;
+  using PreconditionBlock<MatrixType, inverse_type>::invert_diagblocks;
+  using PreconditionBlock<MatrixType, inverse_type>::block_size;
   using PreconditionBlockBase<inverse_type>::size;
   using PreconditionBlockBase<inverse_type>::inverse;
   using PreconditionBlockBase<inverse_type>::inverse_householder;
   using PreconditionBlockBase<inverse_type>::inverse_svd;
   using PreconditionBlockBase<inverse_type>::log_statistics;
-  using PreconditionBlock<MATRIX, inverse_type>::set_permutation;
+  using PreconditionBlock<MatrixType, inverse_type>::set_permutation;
 
   /**
    * Execute block Jacobi preconditioning.
@@ -633,9 +630,9 @@ private:
  *
  * @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2001, 2002, 2003
  */
-template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
+template<typename MatrixType, typename inverse_type = typename MatrixType::value_type>
 class PreconditionBlockSOR : public virtual Subscriptor,
-  protected PreconditionBlock<MATRIX, inverse_type>
+  protected PreconditionBlock<MatrixType, inverse_type>
 {
 public:
   /**
@@ -651,23 +648,23 @@ public:
   /**
    * Define number type of matrix.
    */
-  typedef typename MATRIX::value_type number;
+  typedef typename MatrixType::value_type number;
 
   /**
    * import types and functions from protected base class.
    */
-  using typename PreconditionBlock<MATRIX,inverse_type>::AdditionalData;
-  using PreconditionBlock<MATRIX, inverse_type>::initialize;
-  using PreconditionBlock<MATRIX, inverse_type>::clear;
-  using PreconditionBlock<MATRIX, inverse_type>::empty;
+  using typename PreconditionBlock<MatrixType,inverse_type>::AdditionalData;
+  using PreconditionBlock<MatrixType, inverse_type>::initialize;
+  using PreconditionBlock<MatrixType, inverse_type>::clear;
+  using PreconditionBlock<MatrixType, inverse_type>::empty;
   using PreconditionBlockBase<inverse_type>::size;
   using PreconditionBlockBase<inverse_type>::inverse;
   using PreconditionBlockBase<inverse_type>::inverse_householder;
   using PreconditionBlockBase<inverse_type>::inverse_svd;
-  using PreconditionBlock<MATRIX, inverse_type>::el;
-  using PreconditionBlock<MATRIX, inverse_type>::set_same_diagonal;
-  using PreconditionBlock<MATRIX, inverse_type>::invert_diagblocks;
-  using PreconditionBlock<MATRIX, inverse_type>::set_permutation;
+  using PreconditionBlock<MatrixType, inverse_type>::el;
+  using PreconditionBlock<MatrixType, inverse_type>::set_same_diagonal;
+  using PreconditionBlock<MatrixType, inverse_type>::invert_diagblocks;
+  using PreconditionBlock<MatrixType, inverse_type>::set_permutation;
   using PreconditionBlockBase<inverse_type>::log_statistics;
 
   /**
@@ -790,9 +787,9 @@ protected:
  *
  * @author Ralf Hartmann, Guido Kanschat, 1999, 2000
  */
-template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
+template<typename MatrixType, typename inverse_type = typename MatrixType::value_type>
 class PreconditionBlockSSOR : public virtual Subscriptor,
-  private PreconditionBlockSOR<MATRIX, inverse_type>
+  private PreconditionBlockSOR<MatrixType, inverse_type>
 {
 public:
   /**
@@ -803,7 +800,7 @@ public:
   /**
    * Define number type of matrix.
    */
-  typedef typename MATRIX::value_type number;
+  typedef typename MatrixType::value_type number;
 
   /**
    * Constructor.
@@ -811,7 +808,7 @@ public:
   PreconditionBlockSSOR ();
 
   // Keep AdditionalData accessible
-  using typename PreconditionBlockSOR<MATRIX,inverse_type>::AdditionalData;
+  using typename PreconditionBlockSOR<MatrixType,inverse_type>::AdditionalData;
 
   // The following are the
   // functions of the base classes
@@ -820,18 +817,18 @@ public:
   /**
    * Make initialization function publicly available.
    */
-  using PreconditionBlockSOR<MATRIX,inverse_type>::initialize;
-  using PreconditionBlockSOR<MATRIX,inverse_type>::clear;
+  using PreconditionBlockSOR<MatrixType,inverse_type>::initialize;
+  using PreconditionBlockSOR<MatrixType,inverse_type>::clear;
   using PreconditionBlockBase<inverse_type>::size;
   using PreconditionBlockBase<inverse_type>::inverse;
   using PreconditionBlockBase<inverse_type>::inverse_householder;
   using PreconditionBlockBase<inverse_type>::inverse_svd;
   using PreconditionBlockBase<inverse_type>::log_statistics;
-  using PreconditionBlockSOR<MATRIX,inverse_type>::set_permutation;
-  using PreconditionBlockSOR<MATRIX, inverse_type>::empty;
-  using PreconditionBlockSOR<MATRIX, inverse_type>::el;
-  using PreconditionBlockSOR<MATRIX,inverse_type>::set_same_diagonal;
-  using PreconditionBlockSOR<MATRIX,inverse_type>::invert_diagblocks;
+  using PreconditionBlockSOR<MatrixType,inverse_type>::set_permutation;
+  using PreconditionBlockSOR<MatrixType, inverse_type>::empty;
+  using PreconditionBlockSOR<MatrixType, inverse_type>::el;
+  using PreconditionBlockSOR<MatrixType,inverse_type>::set_same_diagonal;
+  using PreconditionBlockSOR<MatrixType,inverse_type>::invert_diagblocks;
 
   /**
    * Execute block SSOR preconditioning.
@@ -867,9 +864,9 @@ public:
 
 #ifndef DOXYGEN
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline bool
-PreconditionBlock<MATRIX, inverse_type>::empty () const
+PreconditionBlock<MatrixType, inverse_type>::empty () const
 {
   if (A == 0)
     return true;
@@ -877,9 +874,9 @@ PreconditionBlock<MATRIX, inverse_type>::empty () const
 }
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline inverse_type
-PreconditionBlock<MATRIX, inverse_type>::el (
+PreconditionBlock<MatrixType, inverse_type>::el (
   size_type i,
   size_type j) const
 {
@@ -901,10 +898,10 @@ PreconditionBlock<MATRIX, inverse_type>::el (
 
 //---------------------------------------------------------------------------
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
-PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::Accessor::
-Accessor (const PreconditionBlockJacobi<MATRIX, inverse_type> *matrix,
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::Accessor::
+Accessor (const PreconditionBlockJacobi<MatrixType, inverse_type> *matrix,
           const size_type row)
   :
   matrix(matrix),
@@ -929,10 +926,10 @@ Accessor (const PreconditionBlockJacobi<MATRIX, inverse_type> *matrix,
 }
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
-typename PreconditionBlockJacobi<MATRIX, inverse_type>::size_type
-PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::Accessor::row() const
+typename PreconditionBlockJacobi<MatrixType, inverse_type>::size_type
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::Accessor::row() const
 {
   Assert (a_block < matrix->size(),
           ExcIteratorPastEnd());
@@ -941,10 +938,10 @@ PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::Accessor::row() c
 }
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
-typename PreconditionBlockJacobi<MATRIX, inverse_type>::size_type
-PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::Accessor::column() const
+typename PreconditionBlockJacobi<MatrixType, inverse_type>::size_type
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::Accessor::column() const
 {
   Assert (a_block < matrix->size(),
           ExcIteratorPastEnd());
@@ -953,10 +950,10 @@ PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::Accessor::column(
 }
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
 inverse_type
-PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::Accessor::value() const
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::Accessor::value() const
 {
   Assert (a_block < matrix->size(),
           ExcIteratorPastEnd());
@@ -965,20 +962,20 @@ PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::Accessor::value()
 }
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
-PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::
-const_iterator(const PreconditionBlockJacobi<MATRIX, inverse_type> *matrix,
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
+const_iterator(const PreconditionBlockJacobi<MatrixType, inverse_type> *matrix,
                const size_type row)
   :
   accessor(matrix, row)
 {}
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
-typename PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator &
-PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::operator++ ()
+typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator &
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::operator++ ()
 {
   Assert (*this != accessor.matrix->end(), ExcIteratorPastEnd());
 
@@ -997,28 +994,28 @@ PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::operator++ ()
 }
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
-const typename PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::Accessor &
-PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::operator* () const
+const typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::Accessor &
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::operator* () const
 {
   return accessor;
 }
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
-const typename PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::Accessor *
-PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::operator-> () const
+const typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::Accessor *
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::operator-> () const
 {
   return &accessor;
 }
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
 bool
-PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
 operator == (const const_iterator &other) const
 {
   if (accessor.a_block == accessor.matrix->size() &&
@@ -1033,20 +1030,20 @@ operator == (const const_iterator &other) const
 }
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
 bool
-PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
 operator != (const const_iterator &other) const
 {
   return ! (*this == other);
 }
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
 bool
-PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator::
+PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator::
 operator < (const const_iterator &other) const
 {
   return (accessor.row() < other.accessor.row() ||
@@ -1055,28 +1052,28 @@ operator < (const const_iterator &other) const
 }
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
-typename PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator
-PreconditionBlockJacobi<MATRIX, inverse_type>::begin () const
+typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator
+PreconditionBlockJacobi<MatrixType, inverse_type>::begin () const
 {
   return const_iterator(this, 0);
 }
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
-typename PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator
-PreconditionBlockJacobi<MATRIX, inverse_type>::end () const
+typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator
+PreconditionBlockJacobi<MatrixType, inverse_type>::end () const
 {
   return const_iterator(this, this->size() * this->block_size());
 }
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
-typename PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator
-PreconditionBlockJacobi<MATRIX, inverse_type>::begin (
+typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator
+PreconditionBlockJacobi<MatrixType, inverse_type>::begin (
   const size_type r) const
 {
   Assert (r < this->A->m(), ExcIndexRange(r, 0, this->A->m()));
@@ -1085,10 +1082,10 @@ PreconditionBlockJacobi<MATRIX, inverse_type>::begin (
 
 
 
-template<class MATRIX, typename inverse_type>
+template<typename MatrixType, typename inverse_type>
 inline
-typename PreconditionBlockJacobi<MATRIX, inverse_type>::const_iterator
-PreconditionBlockJacobi<MATRIX, inverse_type>::end (
+typename PreconditionBlockJacobi<MatrixType, inverse_type>::const_iterator
+PreconditionBlockJacobi<MatrixType, inverse_type>::end (
   const size_type r) const
 {
   Assert (r < this->A->m(), ExcIndexRange(r, 0, this->A->m()));
diff --git a/include/deal.II/lac/precondition_block.templates.h b/include/deal.II/lac/precondition_block.templates.h
index 260b1f2fea..468815acb8 100644
--- a/include/deal.II/lac/precondition_block.templates.h
+++ b/include/deal.II/lac/precondition_block.templates.h
@@ -29,12 +29,12 @@
 DEAL_II_NAMESPACE_OPEN
 
 
-template<class MATRIX, typename inverse_type>
-PreconditionBlock<MATRIX, inverse_type>::AdditionalData::
+template<typename MatrixType, typename inverse_type>
+PreconditionBlock<MatrixType, inverse_type>::AdditionalData::
 AdditionalData (const size_type block_size,
-                const double relaxation,
-                const bool invert_diagonal,
-                const bool same_diagonal)
+                const double    relaxation,
+                const bool      invert_diagonal,
+                const bool      same_diagonal)
   :
   relaxation (relaxation),
   block_size(block_size),
@@ -50,21 +50,21 @@ PreconditionBlockBase<number>::~PreconditionBlockBase ()
 {}
 
 
-template <class MATRIX, typename inverse_type>
-PreconditionBlock<MATRIX,inverse_type>::PreconditionBlock (bool store)
+template <typename MatrixType, typename inverse_type>
+PreconditionBlock<MatrixType,inverse_type>::PreconditionBlock (bool store)
   : PreconditionBlockBase<inverse_type>(store),
     blocksize(0),
     A(0, typeid(*this).name())
 {}
 
 
-template <class MATRIX, typename inverse_type>
-PreconditionBlock<MATRIX,inverse_type>::~PreconditionBlock ()
+template <typename MatrixType, typename inverse_type>
+PreconditionBlock<MatrixType,inverse_type>::~PreconditionBlock ()
 {}
 
 
-template <class MATRIX, typename inverse_type>
-void PreconditionBlock<MATRIX,inverse_type>::clear ()
+template <typename MatrixType, typename inverse_type>
+void PreconditionBlock<MatrixType,inverse_type>::clear ()
 {
   PreconditionBlockBase<inverse_type>::clear();
   blocksize     = 0;
@@ -72,10 +72,10 @@ void PreconditionBlock<MATRIX,inverse_type>::clear ()
 }
 
 
-template <class MATRIX, typename inverse_type>
-void PreconditionBlock<MATRIX,inverse_type>::initialize (
-  const MATRIX &M,
-  const AdditionalData parameters)
+template <typename MatrixType, typename inverse_type>
+void PreconditionBlock<MatrixType,inverse_type>::initialize
+(const MatrixType     &M,
+ const AdditionalData  parameters)
 {
   const size_type bsize = parameters.block_size;
 
@@ -100,26 +100,26 @@ void PreconditionBlock<MATRIX,inverse_type>::initialize (
 }
 
 
-template <class MATRIX, typename inverse_type>
-void PreconditionBlock<MATRIX,inverse_type>::initialize (
-  const MATRIX &M,
-  const std::vector<size_type> &permutation,
-  const std::vector<size_type> &inverse_permutation,
-  const AdditionalData parameters)
+template <typename MatrixType, typename inverse_type>
+void PreconditionBlock<MatrixType,inverse_type>::initialize
+(const MatrixType             &M,
+ const std::vector<size_type> &permutation,
+ const std::vector<size_type> &inverse_permutation,
+ const AdditionalData          parameters)
 {
   set_permutation(permutation, inverse_permutation);
   initialize(M, parameters);
 }
 
-template <class MATRIX, typename inverse_type>
-void PreconditionBlock<MATRIX,inverse_type>::invert_permuted_diagblocks(
-  const std::vector<size_type> &permutation,
-  const std::vector<size_type> &inverse_permutation)
+template <typename MatrixType, typename inverse_type>
+void PreconditionBlock<MatrixType,inverse_type>::invert_permuted_diagblocks
+(const std::vector<size_type> &permutation,
+ const std::vector<size_type> &inverse_permutation)
 {
   Assert (A!=0, ExcNotInitialized());
   Assert (blocksize!=0, ExcNotInitialized());
 
-  const MATRIX &M=*A;
+  const MatrixType &M=*A;
   Assert (this->inverses_ready()==0, ExcInverseMatricesAlreadyExist());
   AssertDimension (permutation.size(), M.m());
   AssertDimension (inverse_permutation.size(), M.m());
@@ -132,8 +132,8 @@ void PreconditionBlock<MATRIX,inverse_type>::invert_permuted_diagblocks(
 
       for (size_type row_cell=0; row_cell<blocksize; ++row_cell)
         {
-          typename MATRIX::const_iterator entry = M.begin(row_cell);
-          const typename MATRIX::const_iterator row_end = M.end(row_cell);
+          typename MatrixType::const_iterator entry = M.begin(row_cell);
+          const typename MatrixType::const_iterator row_end = M.end(row_cell);
           while (entry != row_end)
             {
               if (entry->column() < blocksize)
@@ -180,8 +180,8 @@ void PreconditionBlock<MATRIX,inverse_type>::invert_permuted_diagblocks(
 
               const size_type row = permutation[urow];
 
-              typename MATRIX::const_iterator entry = M.begin(row);
-              const typename MATRIX::const_iterator row_end = M.end(row);
+              typename MatrixType::const_iterator entry = M.begin(row);
+              const typename MatrixType::const_iterator row_end = M.end(row);
 
               for (; entry != row_end; ++entry)
                 {
@@ -221,17 +221,17 @@ void PreconditionBlock<MATRIX,inverse_type>::invert_permuted_diagblocks(
 
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlock<MATRIX,inverse_type>::forward_step (
-  Vector<number2>       &dst,
-  const Vector<number2> &prev,
-  const Vector<number2> &src,
-  const bool transpose_diagonal) const
+void PreconditionBlock<MatrixType,inverse_type>::forward_step
+(Vector<number2>       &dst,
+ const Vector<number2> &prev,
+ const Vector<number2> &src,
+ const bool             transpose_diagonal) const
 {
   Assert (this->A!=0, ExcNotInitialized());
 
-  const MATRIX &M=*this->A;
+  const MatrixType &M=*this->A;
 
   if (permutation.size() != 0)
     Assert (permutation.size() == M.m() || permutation.size() == this->size(),
@@ -272,8 +272,8 @@ void PreconditionBlock<MATRIX,inverse_type>::forward_step (
            ++row_cell, ++row)
         {
 //        deallog << ' ' << row;
-          const typename MATRIX::const_iterator row_end = M.end(row);
-          typename MATRIX::const_iterator entry = M.begin(row);
+          const typename MatrixType::const_iterator row_end = M.end(row);
+          typename MatrixType::const_iterator entry = M.begin(row);
 
           b_cell_row=src(row);
           for (; entry != row_end; ++entry)
@@ -319,17 +319,17 @@ void PreconditionBlock<MATRIX,inverse_type>::forward_step (
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlock<MATRIX,inverse_type>::backward_step (
-  Vector<number2>       &dst,
-  const Vector<number2> &prev,
-  const Vector<number2> &src,
-  const bool transpose_diagonal) const
+void PreconditionBlock<MatrixType,inverse_type>::backward_step
+(Vector<number2>       &dst,
+ const Vector<number2> &prev,
+ const Vector<number2> &src,
+ const bool             transpose_diagonal) const
 {
   Assert (this->A!=0, ExcNotInitialized());
 
-  const MATRIX &M=*this->A;
+  const MatrixType &M=*this->A;
 
   if (permutation.size() != 0)
     Assert (permutation.size() == M.m() || permutation.size() == this->size(),
@@ -364,8 +364,8 @@ void PreconditionBlock<MATRIX,inverse_type>::backward_step (
            row_cell<this->blocksize;
            ++row_cell, ++row)
         {
-          const typename MATRIX::const_iterator row_end = M.end(row);
-          typename MATRIX::const_iterator entry = M.begin(row);
+          const typename MatrixType::const_iterator row_end = M.end(row);
+          typename MatrixType::const_iterator entry = M.begin(row);
 
           b_cell_row=src(row);
           for (; entry != row_end; ++entry)
@@ -417,21 +417,21 @@ void PreconditionBlock<MATRIX,inverse_type>::backward_step (
 }
 
 
-template <class MATRIX, typename inverse_type>
-typename PreconditionBlock<MATRIX,inverse_type>::size_type
-PreconditionBlock<MATRIX,inverse_type>::block_size() const
+template <typename MatrixType, typename inverse_type>
+typename PreconditionBlock<MatrixType,inverse_type>::size_type
+PreconditionBlock<MatrixType,inverse_type>::block_size() const
 {
   return blocksize;
 }
 
 
-template <class MATRIX, typename inverse_type>
-void PreconditionBlock<MATRIX,inverse_type>::invert_diagblocks()
+template <typename MatrixType, typename inverse_type>
+void PreconditionBlock<MatrixType,inverse_type>::invert_diagblocks()
 {
   Assert (A!=0, ExcNotInitialized());
   Assert (blocksize!=0, ExcNotInitialized());
 
-  const MATRIX &M=*A;
+  const MatrixType &M=*A;
   Assert (this->inverses_ready()==0, ExcInverseMatricesAlreadyExist());
 
   FullMatrix<inverse_type> M_cell(blocksize);
@@ -441,8 +441,8 @@ void PreconditionBlock<MATRIX,inverse_type>::invert_diagblocks()
       deallog << "PreconditionBlock uses only one diagonal block" << std::endl;
       for (size_type row_cell=0; row_cell<blocksize; ++row_cell)
         {
-          typename MATRIX::const_iterator entry = M.begin(row_cell);
-          const typename MATRIX::const_iterator row_end = M.end(row_cell);
+          typename MatrixType::const_iterator entry = M.begin(row_cell);
+          const typename MatrixType::const_iterator row_end = M.end(row_cell);
           while (entry != row_end)
             {
               if (entry->column() < blocksize)
@@ -478,8 +478,8 @@ void PreconditionBlock<MATRIX,inverse_type>::invert_diagblocks()
           for (size_type row_cell=0; row_cell<blocksize; ++row_cell)
             {
               const size_type row = row_cell + cell_start;
-              typename MATRIX::const_iterator entry = M.begin(row);
-              const typename MATRIX::const_iterator row_end = M.end(row);
+              typename MatrixType::const_iterator entry = M.begin(row);
+              const typename MatrixType::const_iterator row_end = M.end(row);
 
               for (; entry != row_end; ++entry)
                 {
@@ -517,10 +517,10 @@ void PreconditionBlock<MATRIX,inverse_type>::invert_diagblocks()
 
 
 
-template <class MATRIX, typename inverse_type>
-void PreconditionBlock<MATRIX,inverse_type>::set_permutation (
-  const std::vector<size_type> &p,
-  const std::vector<size_type> &i)
+template <typename MatrixType, typename inverse_type>
+void PreconditionBlock<MatrixType,inverse_type>::set_permutation
+(const std::vector<size_type> &p,
+ const std::vector<size_type> &i)
 {
   Assert (p.size() == i.size(), ExcDimensionMismatch(p.size(), i.size()));
 
@@ -539,9 +539,9 @@ void PreconditionBlock<MATRIX,inverse_type>::set_permutation (
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 std::size_t
-PreconditionBlock<MATRIX,inverse_type>::memory_consumption () const
+PreconditionBlock<MatrixType,inverse_type>::memory_consumption () const
 {
   return (sizeof(*this)
           - sizeof(PreconditionBlockBase<inverse_type>)
@@ -554,16 +554,16 @@ PreconditionBlock<MATRIX,inverse_type>::memory_consumption () const
 /*--------------------- PreconditionBlockJacobi -----------------------*/
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockJacobi<MATRIX,inverse_type>
+void PreconditionBlockJacobi<MatrixType,inverse_type>
 ::do_vmult (Vector<number2>       &dst,
             const Vector<number2> &src,
-            bool adding) const
+            bool                   adding) const
 {
   Assert(this->A!=0, ExcNotInitialized());
 
-  const MATRIX &M=*this->A;
+  const MatrixType &M=*this->A;
 
   Vector<number2> b_cell(this->blocksize), x_cell(this->blocksize);
 
@@ -629,9 +629,9 @@ void PreconditionBlockJacobi<MATRIX,inverse_type>
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockJacobi<MATRIX,inverse_type>
+void PreconditionBlockJacobi<MatrixType,inverse_type>
 ::vmult (Vector<number2>       &dst,
          const Vector<number2> &src) const
 {
@@ -639,9 +639,9 @@ void PreconditionBlockJacobi<MATRIX,inverse_type>
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockJacobi<MATRIX,inverse_type>
+void PreconditionBlockJacobi<MatrixType,inverse_type>
 ::Tvmult (Vector<number2>       &dst,
           const Vector<number2> &src) const
 {
@@ -649,9 +649,9 @@ void PreconditionBlockJacobi<MATRIX,inverse_type>
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockJacobi<MATRIX,inverse_type>
+void PreconditionBlockJacobi<MatrixType,inverse_type>
 ::vmult_add (Vector<number2>       &dst,
              const Vector<number2> &src) const
 {
@@ -659,9 +659,9 @@ void PreconditionBlockJacobi<MATRIX,inverse_type>
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockJacobi<MATRIX,inverse_type>
+void PreconditionBlockJacobi<MatrixType,inverse_type>
 ::Tvmult_add (Vector<number2>       &dst,
               const Vector<number2> &src) const
 {
@@ -669,9 +669,9 @@ void PreconditionBlockJacobi<MATRIX,inverse_type>
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockJacobi<MATRIX,inverse_type>
+void PreconditionBlockJacobi<MatrixType,inverse_type>
 ::step (Vector<number2>       &dst,
         const Vector<number2> &src) const
 {
@@ -684,9 +684,9 @@ void PreconditionBlockJacobi<MATRIX,inverse_type>
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockJacobi<MATRIX,inverse_type>
+void PreconditionBlockJacobi<MatrixType,inverse_type>
 ::Tstep (Vector<number2>       &dst,
          const Vector<number2> &src) const
 {
@@ -704,29 +704,29 @@ void PreconditionBlockJacobi<MATRIX,inverse_type>
 /*--------------------- PreconditionBlockSOR -----------------------*/
 
 
-template <class MATRIX, typename inverse_type>
-PreconditionBlockSOR<MATRIX,inverse_type>::PreconditionBlockSOR ()
-  : PreconditionBlock<MATRIX,inverse_type> (false)
+template <typename MatrixType, typename inverse_type>
+PreconditionBlockSOR<MatrixType,inverse_type>::PreconditionBlockSOR ()
+  : PreconditionBlock<MatrixType,inverse_type> (false)
 
 {}
 
-template <class MATRIX, typename inverse_type>
-PreconditionBlockSOR<MATRIX,inverse_type>::PreconditionBlockSOR (bool store)
-  : PreconditionBlock<MATRIX,inverse_type> (store)
+template <typename MatrixType, typename inverse_type>
+PreconditionBlockSOR<MatrixType,inverse_type>::PreconditionBlockSOR (bool store)
+  : PreconditionBlock<MatrixType,inverse_type> (store)
 
 {}
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockSOR<MATRIX,inverse_type>::forward (
-  Vector<number2>       &dst,
-  const Vector<number2> &src,
-  const bool transpose_diagonal,
-  const bool) const
+void PreconditionBlockSOR<MatrixType,inverse_type>::forward
+(Vector<number2>       &dst,
+ const Vector<number2> &src,
+ const bool             transpose_diagonal,
+ const bool) const
 {
   Assert (this->A!=0, ExcNotInitialized());
 
-  const MATRIX &M=*this->A;
+  const MatrixType &M=*this->A;
   const bool permuted = (this->permutation.size() != 0);
   if (permuted)
     {
@@ -758,8 +758,8 @@ void PreconditionBlockSOR<MATRIX,inverse_type>::forward (
            row_cell < this->blocksize;
            ++row_cell, ++row)
         {
-          const typename MATRIX::const_iterator row_end = M.end(row);
-          typename MATRIX::const_iterator entry = M.begin(row);
+          const typename MatrixType::const_iterator row_end = M.end(row);
+          typename MatrixType::const_iterator entry = M.begin(row);
 
           b_cell_row=src(row);
           for (; entry != row_end; ++entry)
@@ -806,17 +806,17 @@ void PreconditionBlockSOR<MATRIX,inverse_type>::forward (
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockSOR<MATRIX,inverse_type>::backward (
-  Vector<number2>       &dst,
-  const Vector<number2> &src,
-  const bool transpose_diagonal,
-  const bool) const
+void PreconditionBlockSOR<MatrixType,inverse_type>::backward
+(Vector<number2>       &dst,
+ const Vector<number2> &src,
+ const bool              transpose_diagonal,
+ const bool) const
 {
   Assert (this->A!=0, ExcNotInitialized());
 
-  const MATRIX &M=*this->A;
+  const MatrixType &M=*this->A;
   const bool permuted = (this->permutation.size() != 0);
   if (permuted)
     {
@@ -849,8 +849,8 @@ void PreconditionBlockSOR<MATRIX,inverse_type>::backward (
            row_cell<this->blocksize;
            ++row_cell, ++row)
         {
-          const typename MATRIX::const_iterator row_end = M.end(row);
-          typename MATRIX::const_iterator entry = M.begin(row);
+          const typename MatrixType::const_iterator row_end = M.end(row);
+          typename MatrixType::const_iterator entry = M.begin(row);
 
           b_cell_row=src(row);
           for (; entry != row_end; ++entry)
@@ -903,9 +903,9 @@ void PreconditionBlockSOR<MATRIX,inverse_type>::backward (
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockSOR<MATRIX,inverse_type>
+void PreconditionBlockSOR<MatrixType,inverse_type>
 ::vmult (Vector<number2>       &dst,
          const Vector<number2> &src) const
 {
@@ -913,9 +913,9 @@ void PreconditionBlockSOR<MATRIX,inverse_type>
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockSOR<MATRIX,inverse_type>
+void PreconditionBlockSOR<MatrixType,inverse_type>
 ::vmult_add (Vector<number2>       &dst,
              const Vector<number2> &src) const
 {
@@ -923,9 +923,9 @@ void PreconditionBlockSOR<MATRIX,inverse_type>
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockSOR<MATRIX,inverse_type>
+void PreconditionBlockSOR<MatrixType,inverse_type>
 ::Tvmult (Vector<number2>       &dst,
           const Vector<number2> &src) const
 {
@@ -933,9 +933,9 @@ void PreconditionBlockSOR<MATRIX,inverse_type>
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockSOR<MATRIX,inverse_type>
+void PreconditionBlockSOR<MatrixType,inverse_type>
 ::Tvmult_add (Vector<number2>       &dst,
               const Vector<number2> &src) const
 {
@@ -944,9 +944,9 @@ void PreconditionBlockSOR<MATRIX,inverse_type>
 
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockSOR<MATRIX,inverse_type>
+void PreconditionBlockSOR<MatrixType,inverse_type>
 ::step (Vector<number2>       &dst,
         const Vector<number2> &src) const
 {
@@ -954,9 +954,9 @@ void PreconditionBlockSOR<MATRIX,inverse_type>
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockSOR<MATRIX,inverse_type>
+void PreconditionBlockSOR<MatrixType,inverse_type>
 ::Tstep (Vector<number2>       &dst,
          const Vector<number2> &src) const
 {
@@ -969,16 +969,16 @@ void PreconditionBlockSOR<MATRIX,inverse_type>
 //---------------------------------------------------------------------------
 
 
-template <class MATRIX, typename inverse_type>
-PreconditionBlockSSOR<MATRIX,inverse_type>::PreconditionBlockSSOR ()
-  : PreconditionBlockSOR<MATRIX,inverse_type> (true)
+template <typename MatrixType, typename inverse_type>
+PreconditionBlockSSOR<MatrixType,inverse_type>::PreconditionBlockSSOR ()
+  : PreconditionBlockSOR<MatrixType,inverse_type> (true)
 
 {}
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockSSOR<MATRIX,inverse_type>::vmult (Vector<number2>       &dst,
+void PreconditionBlockSSOR<MatrixType,inverse_type>::vmult (Vector<number2>       &dst,
                                                         const Vector<number2> &src) const
 {
   Vector<number2> help;
@@ -1007,10 +1007,10 @@ void PreconditionBlockSSOR<MATRIX,inverse_type>::vmult (Vector<number2>       &d
   this->backward(dst, help, false, false);
 }
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockSSOR<MATRIX,inverse_type>::Tvmult (Vector<number2>       &dst,
-                                                         const Vector<number2> &src) const
+void PreconditionBlockSSOR<MatrixType,inverse_type>::Tvmult (Vector<number2>       &dst,
+                                                             const Vector<number2> &src) const
 {
   Vector<number2> help;
   help.reinit(dst);
@@ -1039,9 +1039,9 @@ void PreconditionBlockSSOR<MATRIX,inverse_type>::Tvmult (Vector<number2>       &
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockSSOR<MATRIX,inverse_type>
+void PreconditionBlockSSOR<MatrixType,inverse_type>
 ::step (Vector<number2>       &dst,
         const Vector<number2> &src) const
 {
@@ -1050,9 +1050,9 @@ void PreconditionBlockSSOR<MATRIX,inverse_type>
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void PreconditionBlockSSOR<MATRIX,inverse_type>
+void PreconditionBlockSSOR<MatrixType,inverse_type>
 ::Tstep (Vector<number2>       &dst,
          const Vector<number2> &src) const
 {
diff --git a/include/deal.II/lac/precondition_selector.h b/include/deal.II/lac/precondition_selector.h
index f6bbe079fb..aa1f548aaa 100644
--- a/include/deal.II/lac/precondition_selector.h
+++ b/include/deal.II/lac/precondition_selector.h
@@ -90,7 +90,7 @@ template <class number> class SparseMatrix;
  * @author Ralf Hartmann, 1999; extension for full compatibility with
  * LinearOperator class: Jean-Paul Pelteret, 2015
  */
-template <class MATRIX = SparseMatrix<double>,
+template <typename MatrixType = SparseMatrix<double>,
           typename VectorType = dealii::Vector<double> >
 class PreconditionSelector : public Subscriptor
 {
@@ -98,7 +98,7 @@ public:
   /**
    * Declare type for container size.
    */
-  typedef typename MATRIX::size_type size_type;
+  typedef typename MatrixType::size_type size_type;
 
   /**
    * Constructor. @p omega denotes the damping parameter of the
@@ -116,7 +116,7 @@ public:
    * Takes the matrix that is needed for preconditionings that involves a
    * matrix. e.g. for @p precondition_jacobi, <tt>~_sor</tt>, <tt>~_ssor</tt>.
    */
-  void use_matrix(const MATRIX &M);
+  void use_matrix(const MatrixType &M);
 
   /**
    * Return the dimension of the codomain (or range) space. To remember: the
@@ -171,7 +171,7 @@ private:
    * Matrix that is used for the matrix-builtin preconditioning function. cf.
    * also @p PreconditionUseMatrix.
    */
-  SmartPointer<const MATRIX,PreconditionSelector<MATRIX,VectorType> > A;
+  SmartPointer<const MatrixType,PreconditionSelector<MatrixType,VectorType> > A;
 
   /**
    * Stores the damping parameter of the preconditioner.
@@ -183,42 +183,42 @@ private:
 /* --------------------- Inline and template functions ------------------- */
 
 
-template <class MATRIX, typename VectorType>
-PreconditionSelector<MATRIX,VectorType>
+template <typename MatrixType, typename VectorType>
+PreconditionSelector<MatrixType,VectorType>
 ::PreconditionSelector(const std::string                     &preconditioning,
                        const typename VectorType::value_type &omega) :
   preconditioning(preconditioning),
   omega(omega)  {}
 
 
-template <class MATRIX, typename VectorType>
-PreconditionSelector<MATRIX,VectorType>::~PreconditionSelector()
+template <typename MatrixType, typename VectorType>
+PreconditionSelector<MatrixType,VectorType>::~PreconditionSelector()
 {
   // release the matrix A
   A=0;
 }
 
 
-template <class MATRIX, typename VectorType>
-void PreconditionSelector<MATRIX,VectorType>::use_matrix(const MATRIX &M)
+template <typename MatrixType, typename VectorType>
+void PreconditionSelector<MatrixType,VectorType>::use_matrix(const MatrixType &M)
 {
   A=&M;
 }
 
 <<<<<<< fc87b7c22812a5fc7751b36c66b20e6fa54df72c
 
-template <class MATRIX, typename VectorType>
-inline typename PreconditionSelector<MATRIX,VectorType>::size_type
-PreconditionSelector<MATRIX,VectorType>::m () const
+template <typename MatrixType, typename VectorType>
+inline typename PreconditionSelector<MatrixType,VectorType>::size_type
+PreconditionSelector<MatrixType,VectorType>::m () const
 {
   Assert(A!=0, ExcNoMatrixGivenToUse());
   return A->m();
 }
 
 
-template <class MATRIX, typename VectorType>
-inline typename PreconditionSelector<MATRIX,VectorType>::size_type
-PreconditionSelector<MATRIX,VectorType>::n () const
+template <typename MatrixType, typename VectorType>
+inline typename PreconditionSelector<MatrixType,VectorType>::size_type
+PreconditionSelector<MatrixType,VectorType>::n () const
 {
   Assert(A!=0, ExcNoMatrixGivenToUse());
   return A->n();
@@ -226,9 +226,9 @@ PreconditionSelector<MATRIX,VectorType>::n () const
 
 
 
-template <class MATRIX, typename VectorType>
-void PreconditionSelector<MATRIX,VectorType>::vmult (VectorType       &dst,
-                                                     const VectorType &src) const
+template <typename MatrixType, typename VectorType>
+void PreconditionSelector<MatrixType,VectorType>::vmult (VectorType &dst,
+                                                         const VectorType &src) const
 {
   if (preconditioning=="none")
     {
@@ -256,9 +256,9 @@ void PreconditionSelector<MATRIX,VectorType>::vmult (VectorType       &dst,
 }
 
 
-template <class MATRIX, typename VectorType>
-void PreconditionSelector<MATRIX,VectorType>::Tvmult (VectorType       &dst,
-                                                      const VectorType &src) const
+template <typename MatrixType, typename VectorType>
+void PreconditionSelector<MatrixType,VectorType>::Tvmult (VectorType &dst,
+                                                          const VectorType &src) const
 {
   if (preconditioning=="none")
     {
@@ -286,8 +286,8 @@ void PreconditionSelector<MATRIX,VectorType>::Tvmult (VectorType       &dst,
 }
 
 
-template <class MATRIX, typename VectorType>
-std::string PreconditionSelector<MATRIX,VectorType>::get_precondition_names()
+template <typename MatrixType, typename VectorType>
+std::string PreconditionSelector<MatrixType,VectorType>::get_precondition_names()
 {
   return "none|jacobi|sor|ssor";
 }
diff --git a/include/deal.II/lac/relaxation_block.h b/include/deal.II/lac/relaxation_block.h
index 0b807d82ca..42949c5ff3 100644
--- a/include/deal.II/lac/relaxation_block.h
+++ b/include/deal.II/lac/relaxation_block.h
@@ -47,7 +47,7 @@ DEAL_II_NAMESPACE_OPEN
  * @author Guido Kanschat
  * @date 2010
  */
-template <class MATRIX, typename inverse_type=typename MATRIX::value_type>
+template <typename MatrixType, typename inverse_type=typename MatrixType::value_type>
 class RelaxationBlock :
   protected PreconditionBlockBase<inverse_type>
 {
@@ -55,7 +55,7 @@ private:
   /**
    * Define number type of matrix.
    */
-  typedef typename MATRIX::value_type number;
+  typedef typename MatrixType::value_type number;
 
   /**
    * Value type for inverse matrices.
@@ -162,7 +162,7 @@ public:
    * rather a pointer is stored. Thus, the lifetime of
    * <code>additional_data</code> hast to exceed the lifetime of this object.
    */
-  void initialize (const MATRIX &A,
+  void initialize (const MatrixType     &A,
                    const AdditionalData &parameters);
 
   /**
@@ -222,12 +222,12 @@ protected:
    * inverse matrices should not be stored) until the last call of the
    * preconditioning @p vmult function of the derived classes.
    */
-  SmartPointer<const MATRIX,RelaxationBlock<MATRIX,inverse_type> > A;
+  SmartPointer<const MatrixType,RelaxationBlock<MatrixType,inverse_type> > A;
 
   /**
    * Control information.
    */
-  SmartPointer<const AdditionalData, RelaxationBlock<MATRIX,inverse_type> > additional_data;
+  SmartPointer<const AdditionalData, RelaxationBlock<MatrixType,inverse_type> > additional_data;
 };
 
 
@@ -245,9 +245,9 @@ protected:
  * @author Guido Kanschat
  * @date 2010
  */
-template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
+template<typename MatrixType, typename inverse_type = typename MatrixType::value_type>
 class RelaxationBlockJacobi : public virtual Subscriptor,
-  protected RelaxationBlock<MATRIX, inverse_type>
+  protected RelaxationBlock<MatrixType, inverse_type>
 {
 public:
   /**
@@ -258,43 +258,43 @@ public:
   /**
    * Define number type of matrix.
    */
-  typedef typename MATRIX::value_type number;
+  typedef typename MatrixType::value_type number;
 
   /**
    * Make type publicly available.
    */
-  using typename RelaxationBlock<MATRIX,inverse_type>::AdditionalData;
+  using typename RelaxationBlock<MatrixType,inverse_type>::AdditionalData;
 
   /**
    * Make initialization function publicly available.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::initialize;
+  using RelaxationBlock<MatrixType, inverse_type>::initialize;
 
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::clear;
+  using RelaxationBlock<MatrixType, inverse_type>::clear;
 
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::empty;
+  using RelaxationBlock<MatrixType, inverse_type>::empty;
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::size;
+  using RelaxationBlock<MatrixType, inverse_type>::size;
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::inverse;
+  using RelaxationBlock<MatrixType, inverse_type>::inverse;
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::inverse_householder;
+  using RelaxationBlock<MatrixType, inverse_type>::inverse_householder;
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::inverse_svd;
+  using RelaxationBlock<MatrixType, inverse_type>::inverse_svd;
   using PreconditionBlockBase<inverse_type>::log_statistics;
   /**
    * Perform one step of the Jacobi iteration.
@@ -329,9 +329,9 @@ public:
  * @author Guido Kanschat
  * @date 2010
  */
-template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
+template<typename MatrixType, typename inverse_type = typename MatrixType::value_type>
 class RelaxationBlockSOR : public virtual Subscriptor,
-  protected RelaxationBlock<MATRIX, inverse_type>
+  protected RelaxationBlock<MatrixType, inverse_type>
 {
 public:
   /**
@@ -342,43 +342,43 @@ public:
   /**
    * Define number type of matrix.
    */
-  typedef typename MATRIX::value_type number;
+  typedef typename MatrixType::value_type number;
 
   /**
    * Make type publicly available.
    */
-  using typename RelaxationBlock<MATRIX,inverse_type>::AdditionalData;
+  using typename RelaxationBlock<MatrixType,inverse_type>::AdditionalData;
 
   /**
    * Make initialization function publicly available.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::initialize;
+  using RelaxationBlock<MatrixType, inverse_type>::initialize;
 
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::clear;
+  using RelaxationBlock<MatrixType, inverse_type>::clear;
 
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::empty;
+  using RelaxationBlock<MatrixType, inverse_type>::empty;
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::size;
+  using RelaxationBlock<MatrixType, inverse_type>::size;
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::inverse;
+  using RelaxationBlock<MatrixType, inverse_type>::inverse;
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::inverse_householder;
+  using RelaxationBlock<MatrixType, inverse_type>::inverse_householder;
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::inverse_svd;
+  using RelaxationBlock<MatrixType, inverse_type>::inverse_svd;
   using PreconditionBlockBase<inverse_type>::log_statistics;
   /**
    * Perform one step of the SOR iteration.
@@ -409,52 +409,52 @@ public:
  * @author Guido Kanschat
  * @date 2010
  */
-template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
+template<typename MatrixType, typename inverse_type = typename MatrixType::value_type>
 class RelaxationBlockSSOR : public virtual Subscriptor,
-  protected RelaxationBlock<MATRIX, inverse_type>
+  protected RelaxationBlock<MatrixType, inverse_type>
 {
 public:
   /**
    * Define number type of matrix.
    */
-  typedef typename MATRIX::value_type number;
+  typedef typename MatrixType::value_type number;
 
   /**
    * Make type publicly available.
    */
-  using typename RelaxationBlock<MATRIX,inverse_type>::AdditionalData;
+  using typename RelaxationBlock<MatrixType,inverse_type>::AdditionalData;
 
   /**
    * Make initialization function publicly available.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::initialize;
+  using RelaxationBlock<MatrixType, inverse_type>::initialize;
 
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::clear;
+  using RelaxationBlock<MatrixType, inverse_type>::clear;
 
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::empty;
+  using RelaxationBlock<MatrixType, inverse_type>::empty;
 
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::size;
+  using RelaxationBlock<MatrixType, inverse_type>::size;
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::inverse;
+  using RelaxationBlock<MatrixType, inverse_type>::inverse;
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::inverse_householder;
+  using RelaxationBlock<MatrixType, inverse_type>::inverse_householder;
   /**
    * Make function of base class public again.
    */
-  using RelaxationBlock<MATRIX, inverse_type>::inverse_svd;
+  using RelaxationBlock<MatrixType, inverse_type>::inverse_svd;
   using PreconditionBlockBase<inverse_type>::log_statistics;
   /**
    * Perform one step of the SOR iteration.
diff --git a/include/deal.II/lac/relaxation_block.templates.h b/include/deal.II/lac/relaxation_block.templates.h
index f458df189b..513f14b7b3 100644
--- a/include/deal.II/lac/relaxation_block.templates.h
+++ b/include/deal.II/lac/relaxation_block.templates.h
@@ -22,12 +22,12 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 inline
-RelaxationBlock<MATRIX,inverse_type>::AdditionalData::AdditionalData (
-  const double relaxation,
-  const bool invert_diagonal,
-  const bool same_diagonal)
+RelaxationBlock<MatrixType,inverse_type>::AdditionalData::AdditionalData
+(const double relaxation,
+ const bool   invert_diagonal,
+ const bool   same_diagonal)
   :
   relaxation(relaxation),
   invert_diagonal(invert_diagonal),
@@ -37,10 +37,10 @@ RelaxationBlock<MATRIX,inverse_type>::AdditionalData::AdditionalData (
 {}
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 inline
 std::size_t
-RelaxationBlock<MATRIX,inverse_type>::AdditionalData::memory_consumption() const
+RelaxationBlock<MatrixType,inverse_type>::AdditionalData::memory_consumption() const
 {
   std::size_t result = sizeof(*this)
                        + - sizeof(block_list) + block_list.memory_consumption();
@@ -50,12 +50,11 @@ RelaxationBlock<MATRIX,inverse_type>::AdditionalData::memory_consumption() const
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 inline
 void
-RelaxationBlock<MATRIX,inverse_type>::initialize (
-  const MATRIX &M,
-  const AdditionalData &parameters)
+RelaxationBlock<MatrixType,inverse_type>::initialize (const MatrixType     &M,
+                                                      const AdditionalData &parameters)
 {
   Assert (parameters.invert_diagonal, ExcNotImplemented());
 
@@ -73,10 +72,10 @@ RelaxationBlock<MATRIX,inverse_type>::initialize (
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 inline
 void
-RelaxationBlock<MATRIX,inverse_type>::clear ()
+RelaxationBlock<MatrixType,inverse_type>::clear ()
 {
   A = 0;
   additional_data = 0;
@@ -84,12 +83,12 @@ RelaxationBlock<MATRIX,inverse_type>::clear ()
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 inline
 void
-RelaxationBlock<MATRIX,inverse_type>::invert_diagblocks ()
+RelaxationBlock<MatrixType,inverse_type>::invert_diagblocks ()
 {
-  const MATRIX &M=*A;
+  const MatrixType &M=*A;
   FullMatrix<inverse_type> M_cell;
 
   if (this->same_diagonal())
@@ -111,7 +110,7 @@ RelaxationBlock<MATRIX,inverse_type>::invert_diagblocks ()
           for (size_type row_cell=0; row_cell<bs; ++row_cell, ++row)
             {
 //TODO:[GK] Optimize here
-              for (typename MATRIX::const_iterator entry = M.begin(row->column());
+              for (typename MatrixType::const_iterator entry = M.begin(row->column());
                    entry != M.end(row->column()); ++entry)
                 {
                   const size_type column = entry->column();
@@ -152,19 +151,18 @@ RelaxationBlock<MATRIX,inverse_type>::invert_diagblocks ()
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
 inline
 void
-RelaxationBlock<MATRIX,inverse_type>::do_step (
-  Vector<number2>       &dst,
-  const Vector<number2> &prev,
-  const Vector<number2> &src,
-  const bool backward) const
+RelaxationBlock<MatrixType,inverse_type>::do_step (Vector<number2>       &dst,
+                                                   const Vector<number2> &prev,
+                                                   const Vector<number2> &src,
+                                                   const bool             backward) const
 {
   Assert (additional_data->invert_diagonal, ExcNotImplemented());
 
-  const MATRIX &M=*this->A;
+  const MatrixType &M=*this->A;
   Vector<number2> b_cell, x_cell;
 
   const bool permutation_empty = additional_data->order.size() == 0;
@@ -196,7 +194,7 @@ RelaxationBlock<MATRIX,inverse_type>::do_step (
           for (size_type row_cell=0; row_cell<bs; ++row_cell, ++row)
             {
               b_cell(row_cell) = src(row->column());
-              for (typename MATRIX::const_iterator entry = M.begin(row->column());
+              for (typename MatrixType::const_iterator entry = M.begin(row->column());
                    entry != M.end(row->column()); ++entry)
                 b_cell(row_cell) -= entry->value() * prev(entry->column());
             }
@@ -219,11 +217,11 @@ RelaxationBlock<MATRIX,inverse_type>::do_step (
 
 //----------------------------------------------------------------------//
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void RelaxationBlockJacobi<MATRIX,inverse_type>::step (
-  Vector<number2>       &dst,
-  const Vector<number2> &src) const
+void RelaxationBlockJacobi<MatrixType,inverse_type>::step
+(Vector<number2>       &dst,
+ const Vector<number2> &src) const
 {
   GrowingVectorMemory<Vector<number2> > mem;
   typename VectorMemory<Vector<number2> >::Pointer aux = mem;
@@ -233,11 +231,11 @@ void RelaxationBlockJacobi<MATRIX,inverse_type>::step (
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void RelaxationBlockJacobi<MATRIX,inverse_type>::Tstep (
-  Vector<number2>       &dst,
-  const Vector<number2> &src) const
+void RelaxationBlockJacobi<MatrixType,inverse_type>::Tstep
+(Vector<number2>       &dst,
+ const Vector<number2> &src) const
 {
   GrowingVectorMemory<Vector<number2> > mem;
   typename VectorMemory<Vector<number2> >::Pointer aux = mem;
@@ -249,21 +247,21 @@ void RelaxationBlockJacobi<MATRIX,inverse_type>::Tstep (
 
 //----------------------------------------------------------------------//
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void RelaxationBlockSOR<MATRIX,inverse_type>::step (
-  Vector<number2>       &dst,
-  const Vector<number2> &src) const
+void RelaxationBlockSOR<MatrixType,inverse_type>::step
+(Vector<number2> &dst,
+ const Vector<number2> &src) const
 {
   this->do_step(dst, dst, src, false);
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void RelaxationBlockSOR<MATRIX,inverse_type>::Tstep (
-  Vector<number2>       &dst,
-  const Vector<number2> &src) const
+void RelaxationBlockSOR<MatrixType,inverse_type>::Tstep
+(Vector<number2>       &dst,
+ const Vector<number2> &src) const
 {
   this->do_step(dst, dst, src, true);
 }
@@ -271,22 +269,22 @@ void RelaxationBlockSOR<MATRIX,inverse_type>::Tstep (
 
 //----------------------------------------------------------------------//
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void RelaxationBlockSSOR<MATRIX,inverse_type>::step (
-  Vector<number2>       &dst,
-  const Vector<number2> &src) const
+void RelaxationBlockSSOR<MatrixType,inverse_type>::step
+(Vector<number2>       &dst,
+ const Vector<number2> &src) const
 {
   this->do_step(dst, dst, src, false);
   this->do_step(dst, dst, src, true);
 }
 
 
-template <class MATRIX, typename inverse_type>
+template <typename MatrixType, typename inverse_type>
 template <typename number2>
-void RelaxationBlockSSOR<MATRIX,inverse_type>::Tstep (
-  Vector<number2>       &dst,
-  const Vector<number2> &src) const
+void RelaxationBlockSSOR<MatrixType,inverse_type>::Tstep
+(Vector<number2>       &dst,
+ const Vector<number2> &src) const
 {
   this->do_step(dst, dst, src, true);
   this->do_step(dst, dst, src, false);
diff --git a/include/deal.II/lac/shifted_matrix.h b/include/deal.II/lac/shifted_matrix.h
index d754edb124..38ff84a326 100644
--- a/include/deal.II/lac/shifted_matrix.h
+++ b/include/deal.II/lac/shifted_matrix.h
@@ -39,14 +39,14 @@ DEAL_II_NAMESPACE_OPEN
  *
  * @author Guido Kanschat, 2000, 2001
  */
-template<class MATRIX>
+template<typename MatrixType>
 class ShiftedMatrix
 {
 public:
   /**
    * Constructor.  Provide the base matrix and a shift parameter.
    */
-  ShiftedMatrix (const MATRIX &A, const double sigma);
+  ShiftedMatrix (const MatrixType &A, const double sigma);
 
   /**
    * Set the shift parameter.
@@ -74,7 +74,7 @@ private:
   /**
    * Storage for base matrix.
    */
-  SmartPointer<const MATRIX,ShiftedMatrix<MATRIX> > A;
+  SmartPointer<const MatrixType,ShiftedMatrix<MatrixType> > A;
 
   /**
    * Auxiliary vector.
@@ -103,16 +103,16 @@ private:
  *
  * @author Guido Kanschat, 2001
  */
-template<class MATRIX, class MASSMATRIX, class VectorType>
+template<typename MatrixType, class MASSMatrixType, class VectorType>
 class ShiftedMatrixGeneralized
 {
 public:
   /**
    * Constructor. Provide the base matrix and a shift parameter.
    */
-  ShiftedMatrixGeneralized (const MATRIX &A,
-                            const MASSMATRIX &M,
-                            const double sigma);
+  ShiftedMatrixGeneralized (const MatrixType     &A,
+                            const MASSMatrixType &M,
+                            const double          sigma);
 
   /**
    * Set the shift parameter.
@@ -138,11 +138,11 @@ private:
   /**
    * Storage for base matrix.
    */
-  SmartPointer<const MATRIX,ShiftedMatrixGeneralized<MATRIX,MASSMATRIX,VectorType> > A;
+  SmartPointer<const MatrixType,ShiftedMatrixGeneralized<MatrixType,MASSMatrixType,VectorType> > A;
   /**
    * Storage for mass matrix.
    */
-  SmartPointer<const MASSMATRIX,ShiftedMatrixGeneralized<MATRIX,MASSMATRIX,VectorType> > M;
+  SmartPointer<const MASSMatrixType,ShiftedMatrixGeneralized<MatrixType,MASSMatrixType,VectorType> > M;
 
   /**
    * Auxiliary vector.
@@ -159,36 +159,37 @@ private:
 /*@}*/
 //---------------------------------------------------------------------------
 
-template <class MATRIX>
+template <typename MatrixType>
 inline
-ShiftedMatrix<MATRIX>::ShiftedMatrix (const MATRIX &A, const double sigma)
+ShiftedMatrix<MatrixType>::ShiftedMatrix (const MatrixType &A,
+                                          const double      sigma)
   :
   A(&A), sigma(sigma)
 {}
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline void
-ShiftedMatrix<MATRIX>::shift (const double s)
+ShiftedMatrix<MatrixType>::shift (const double s)
 {
   sigma = s;
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 inline double
-ShiftedMatrix<MATRIX>::shift () const
+ShiftedMatrix<MatrixType>::shift () const
 {
   return sigma;
 }
 
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template <class VectorType>
 inline void
-ShiftedMatrix<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
+ShiftedMatrix<MatrixType>::vmult (VectorType &dst, const VectorType &src) const
 {
   A->vmult(dst, src);
   if (sigma != 0.)
@@ -196,12 +197,12 @@ ShiftedMatrix<MATRIX>::vmult (VectorType &dst, const VectorType &src) const
 }
 
 
-template <class MATRIX>
+template <typename MatrixType>
 template <class VectorType>
 inline double
-ShiftedMatrix<MATRIX>::residual (VectorType       &dst,
-                                 const VectorType &src,
-                                 const VectorType &rhs) const
+ShiftedMatrix<MatrixType>::residual (VectorType       &dst,
+                                     const VectorType &src,
+                                     const VectorType &rhs) const
 {
   A->vmult(dst, src);
   if (sigma != 0.)
@@ -212,36 +213,37 @@ ShiftedMatrix<MATRIX>::residual (VectorType       &dst,
 
 
 //---------------------------------------------------------------------------
-template <class MATRIX, class MASSMATRIX, class VectorType>
+template <typename MatrixType, class MASSMatrixType, class VectorType>
 inline
-ShiftedMatrixGeneralized<MATRIX, MASSMATRIX, VectorType>
-::ShiftedMatrixGeneralized (const MATRIX     &A,
-                            const MASSMATRIX &M,
-                            const double     sigma)
+ShiftedMatrixGeneralized<MatrixType, MASSMatrixType, VectorType>
+::ShiftedMatrixGeneralized (const MatrixType     &A,
+                            const MASSMatrixType &M,
+                            const double          sigma)
   :
   A(&A), M(&M), sigma(sigma)
 {}
 
 
-template <class MATRIX, class MASSMATRIX, class VectorType>
+template <typename MatrixType, class MASSMatrixType, class VectorType>
 inline void
-ShiftedMatrixGeneralized<MATRIX, MASSMATRIX, VectorType>::shift (const double s)
+ShiftedMatrixGeneralized<MatrixType, MASSMatrixType, VectorType>::shift (const double s)
 {
   sigma = s;
 }
 
-template <class MATRIX, class MASSMATRIX, class VectorType>
+template <typename MatrixType, class MASSMatrixType, class VectorType>
 inline double
-ShiftedMatrixGeneralized<MATRIX, MASSMATRIX, VectorType>::shift () const
+ShiftedMatrixGeneralized<MatrixType, MASSMatrixType, VectorType>::shift () const
 {
   return sigma;
 }
 
 
-template <class MATRIX, class MASSMATRIX, class VectorType>
+template <typename MatrixType, class MASSMatrixType, class VectorType>
 inline void
-ShiftedMatrixGeneralized<MATRIX, MASSMATRIX, VectorType>::vmult (VectorType       &dst,
-                                                                 const VectorType &src) const
+ShiftedMatrixGeneralized<MatrixType, MASSMatrixType, VectorType>::vmult
+(VectorType       &dst,
+ const VectorType &src) const
 {
   A->vmult(dst, src);
   if (sigma != 0.)
@@ -253,11 +255,12 @@ ShiftedMatrixGeneralized<MATRIX, MASSMATRIX, VectorType>::vmult (VectorType
 }
 
 
-template <class MATRIX, class MASSMATRIX, class VectorType>
+template <typename MatrixType, class MASSMatrixType, class VectorType>
 inline double
-ShiftedMatrixGeneralized<MATRIX, MASSMATRIX, VectorType>::residual (VectorType       &dst,
-                                                                    const VectorType &src,
-                                                                    const VectorType &rhs) const
+ShiftedMatrixGeneralized<MatrixType, MASSMatrixType, VectorType>::residual
+(VectorType       &dst,
+ const VectorType &src,
+ const VectorType &rhs) const
 {
   A->vmult(dst, src);
   if (sigma != 0.)
diff --git a/include/deal.II/lac/solver_bicgstab.h b/include/deal.II/lac/solver_bicgstab.h
index 40f6852931..0ffc4ab648 100644
--- a/include/deal.II/lac/solver_bicgstab.h
+++ b/include/deal.II/lac/solver_bicgstab.h
@@ -128,9 +128,9 @@ public:
   /**
    * Solve primal problem only.
    */
-  template<class MATRIX, class PRECONDITIONER>
+  template<typename MatrixType, class PRECONDITIONER>
   void
-  solve (const MATRIX         &A,
+  solve (const MatrixType     &A,
          VectorType           &x,
          const VectorType     &b,
          const PRECONDITIONER &precondition);
@@ -139,8 +139,8 @@ protected:
   /**
    * Computation of the stopping criterion.
    */
-  template <class MATRIX>
-  double criterion (const MATRIX &A, const VectorType &x, const VectorType &b);
+  template <typename MatrixType>
+  double criterion (const MatrixType &A, const VectorType &x, const VectorType &b);
 
   /**
    * Interface for derived class.  This function gets the current iteration
@@ -229,8 +229,8 @@ private:
   /**
    * Everything before the iteration loop.
    */
-  template <class MATRIX>
-  SolverControl::State start(const MATRIX &A);
+  template <typename MatrixType>
+  SolverControl::State start(const MatrixType &A);
 
   /**
    * A structure returned by the iterate() function representing what it found
@@ -253,9 +253,9 @@ private:
    * The iteration loop itself. The function returns a structure indicating
    * what happened in this function.
    */
-  template<class MATRIX, class PRECONDITIONER>
+  template<typename MatrixType, class PRECONDITIONER>
   IterationResult
-  iterate(const MATRIX &A,
+  iterate(const MatrixType     &A,
           const PRECONDITIONER &precondition);
 };
 
@@ -307,9 +307,11 @@ SolverBicgstab<VectorType>::~SolverBicgstab ()
 
 
 template <typename VectorType>
-template <class MATRIX>
+template <typename MatrixType>
 double
-SolverBicgstab<VectorType>::criterion (const MATRIX &A, const VectorType &x, const VectorType &b)
+SolverBicgstab<VectorType>::criterion (const MatrixType &A,
+                                       const VectorType &x,
+                                       const VectorType &b)
 {
   A.vmult(*Vt, x);
   Vt->add(-1.,b);
@@ -321,9 +323,9 @@ SolverBicgstab<VectorType>::criterion (const MATRIX &A, const VectorType &x, con
 
 
 template <typename VectorType >
-template <class MATRIX>
+template <typename MatrixType>
 SolverControl::State
-SolverBicgstab<VectorType>::start(const MATRIX &A)
+SolverBicgstab<VectorType>::start (const MatrixType &A)
 {
   A.vmult(*Vr, *Vx);
   Vr->sadd(-1.,1.,*Vb);
@@ -345,9 +347,9 @@ SolverBicgstab<VectorType>::print_vectors(const unsigned int,
 
 
 template<typename VectorType>
-template<class MATRIX, class PRECONDITIONER>
+template<typename MatrixType, class PRECONDITIONER>
 typename SolverBicgstab<VectorType>::IterationResult
-SolverBicgstab<VectorType>::iterate(const MATRIX         &A,
+SolverBicgstab<VectorType>::iterate(const MatrixType     &A,
                                     const PRECONDITIONER &precondition)
 {
 //TODO:[GK] Implement "use the length of the computed orthogonal residual" in the BiCGStab method.
@@ -432,9 +434,9 @@ SolverBicgstab<VectorType>::iterate(const MATRIX         &A,
 
 
 template<typename VectorType>
-template<class MATRIX, class PRECONDITIONER>
+template<typename MatrixType, class PRECONDITIONER>
 void
-SolverBicgstab<VectorType>::solve(const MATRIX         &A,
+SolverBicgstab<VectorType>::solve(const MatrixType     &A,
                                   VectorType           &x,
                                   const VectorType     &b,
                                   const PRECONDITIONER &precondition)
diff --git a/include/deal.II/lac/solver_cg.h b/include/deal.II/lac/solver_cg.h
index 2829124fcc..942ca5429b 100644
--- a/include/deal.II/lac/solver_cg.h
+++ b/include/deal.II/lac/solver_cg.h
@@ -175,9 +175,9 @@ public:
   /**
    * Solve the linear system $Ax=b$ for x.
    */
-  template <class MATRIX, class PRECONDITIONER>
+  template <typename MatrixType, class PRECONDITIONER>
   void
-  solve (const MATRIX         &A,
+  solve (const MatrixType     &A,
          VectorType           &x,
          const VectorType     &b,
          const PRECONDITIONER &precondition);
@@ -453,9 +453,9 @@ SolverCG<VectorType>::compute_eigs_and_cond
 
 
 template <typename VectorType>
-template <class MATRIX, class PRECONDITIONER>
+template <typename MatrixType, class PRECONDITIONER>
 void
-SolverCG<VectorType>::solve (const MATRIX         &A,
+SolverCG<VectorType>::solve (const MatrixType     &A,
                              VectorType           &x,
                              const VectorType     &b,
                              const PRECONDITIONER &precondition)
diff --git a/include/deal.II/lac/solver_gmres.h b/include/deal.II/lac/solver_gmres.h
index 650b7411b1..2a9ec8ce1d 100644
--- a/include/deal.II/lac/solver_gmres.h
+++ b/include/deal.II/lac/solver_gmres.h
@@ -259,9 +259,9 @@ public:
   /**
    * Solve the linear system $Ax=b$ for x.
    */
-  template<class MATRIX, class PRECONDITIONER>
+  template<typename MatrixType, class PRECONDITIONER>
   void
-  solve (const MATRIX         &A,
+  solve (const MatrixType     &A,
          VectorType           &x,
          const VectorType     &b,
          const PRECONDITIONER &precondition);
@@ -452,9 +452,9 @@ public:
   /**
    * Solve the linear system $Ax=b$ for x.
    */
-  template<class MATRIX, class PRECONDITIONER>
+  template<typename MatrixType, class PRECONDITIONER>
   void
-  solve (const MATRIX         &A,
+  solve (const MatrixType     &A,
          VectorType           &x,
          const VectorType     &b,
          const PRECONDITIONER &precondition);
@@ -746,9 +746,9 @@ SolverGMRES<VectorType>::compute_eigs_and_cond
 
 
 template<class VectorType>
-template<class MATRIX, class PRECONDITIONER>
+template<typename MatrixType, class PRECONDITIONER>
 void
-SolverGMRES<VectorType>::solve (const MATRIX         &A,
+SolverGMRES<VectorType>::solve (const MatrixType     &A,
                                 VectorType           &x,
                                 const VectorType     &b,
                                 const PRECONDITIONER &precondition)
@@ -1114,9 +1114,9 @@ SolverFGMRES<VectorType>::SolverFGMRES (SolverControl        &cn,
 
 
 template<class VectorType>
-template<class MATRIX, class PRECONDITIONER>
+template<typename MatrixType, class PRECONDITIONER>
 void
-SolverFGMRES<VectorType>::solve (const MATRIX         &A,
+SolverFGMRES<VectorType>::solve (const MatrixType     &A,
                                  VectorType           &x,
                                  const VectorType     &b,
                                  const PRECONDITIONER &precondition)
diff --git a/include/deal.II/lac/solver_minres.h b/include/deal.II/lac/solver_minres.h
index 05d14847a1..c334cd7f21 100644
--- a/include/deal.II/lac/solver_minres.h
+++ b/include/deal.II/lac/solver_minres.h
@@ -98,9 +98,9 @@ public:
   /**
    * Solve the linear system $Ax=b$ for x.
    */
-  template<class MATRIX, class PRECONDITIONER>
+  template<typename MatrixType, class PRECONDITIONER>
   void
-  solve (const MATRIX         &A,
+  solve (const MatrixType     &A,
          VectorType           &x,
          const VectorType     &b,
          const PRECONDITIONER &precondition);
@@ -196,9 +196,9 @@ SolverMinRes<VectorType>::print_vectors(const unsigned int,
 
 
 template<class VectorType>
-template<class MATRIX, class PRECONDITIONER>
+template<typename MatrixType, class PRECONDITIONER>
 void
-SolverMinRes<VectorType>::solve (const MATRIX         &A,
+SolverMinRes<VectorType>::solve (const MatrixType     &A,
                                  VectorType           &x,
                                  const VectorType     &b,
                                  const PRECONDITIONER &precondition)
diff --git a/include/deal.II/lac/solver_qmrs.h b/include/deal.II/lac/solver_qmrs.h
index 5f20184ae9..dc128bb2ef 100644
--- a/include/deal.II/lac/solver_qmrs.h
+++ b/include/deal.II/lac/solver_qmrs.h
@@ -125,9 +125,9 @@ public:
   /**
    * Solve the linear system $Ax=b$ for x.
    */
-  template<class MATRIX, class PRECONDITIONER>
+  template<typename MatrixType, class PRECONDITIONER>
   void
-  solve (const MATRIX         &A,
+  solve (const MatrixType     &A,
          VectorType           &x,
          const VectorType     &b,
          const PRECONDITIONER &precondition);
@@ -198,9 +198,9 @@ private:
    * The iteration loop itself. The function returns a structure indicating
    * what happened in this function.
    */
-  template<class MATRIX, class PRECONDITIONER>
+  template<typename MatrixType, class PRECONDITIONER>
   IterationResult
-  iterate (const MATRIX &A,
+  iterate (const MatrixType     &A,
            const PRECONDITIONER &precondition);
 
   /**
@@ -264,9 +264,9 @@ SolverQMRS<VectorType>::print_vectors(const unsigned int,
 
 
 template<class VectorType>
-template<class MATRIX, class PRECONDITIONER>
+template<typename MatrixType, class PRECONDITIONER>
 void
-SolverQMRS<VectorType>::solve (const MATRIX         &A,
+SolverQMRS<VectorType>::solve (const MatrixType     &A,
                                VectorType           &x,
                                const VectorType     &b,
                                const PRECONDITIONER &precondition)
@@ -322,9 +322,9 @@ SolverQMRS<VectorType>::solve (const MATRIX         &A,
 
 
 template<class VectorType>
-template<class MATRIX, class PRECONDITIONER>
+template<typename MatrixType, class PRECONDITIONER>
 typename SolverQMRS<VectorType>::IterationResult
-SolverQMRS<VectorType>::iterate(const MATRIX         &A,
+SolverQMRS<VectorType>::iterate(const MatrixType     &A,
                                 const PRECONDITIONER &precondition)
 {
   /* Remark: the matrix A in the article is the preconditioned matrix.
diff --git a/include/deal.II/lac/solver_relaxation.h b/include/deal.II/lac/solver_relaxation.h
index b371f63df8..1c67e3080e 100644
--- a/include/deal.II/lac/solver_relaxation.h
+++ b/include/deal.II/lac/solver_relaxation.h
@@ -79,9 +79,9 @@ public:
    * R(x_k,b)$. The matrix <i>A</i> itself is only used to compute the
    * residual.
    */
-  template<class MATRIX, class RELAXATION>
+  template<typename MatrixType, class RELAXATION>
   void
-  solve (const MATRIX     &A,
+  solve (const MatrixType &A,
          VectorType       &x,
          const VectorType &b,
          const RELAXATION &R);
@@ -104,9 +104,9 @@ SolverRelaxation<VectorType>::~SolverRelaxation()
 
 
 template <class VectorType>
-template <class MATRIX, class RELAXATION>
+template <typename MatrixType, class RELAXATION>
 void
-SolverRelaxation<VectorType>::solve (const MATRIX     &A,
+SolverRelaxation<VectorType>::solve (const MatrixType &A,
                                      VectorType       &x,
                                      const VectorType &b,
                                      const RELAXATION &R)
diff --git a/include/deal.II/lac/solver_richardson.h b/include/deal.II/lac/solver_richardson.h
index ac8e3e1144..34d6bb9638 100644
--- a/include/deal.II/lac/solver_richardson.h
+++ b/include/deal.II/lac/solver_richardson.h
@@ -107,9 +107,9 @@ public:
   /**
    * Solve the linear system $Ax=b$ for x.
    */
-  template<class MATRIX, class PRECONDITIONER>
+  template<typename MatrixType, class PRECONDITIONER>
   void
-  solve (const MATRIX         &A,
+  solve (const MatrixType     &A,
          VectorType           &x,
          const VectorType     &b,
          const PRECONDITIONER &precondition);
@@ -117,9 +117,9 @@ public:
   /**
    * Solve $A^Tx=b$ for $x$.
    */
-  template<class MATRIX, class PRECONDITIONER>
+  template<typename MatrixType, class PRECONDITIONER>
   void
-  Tsolve (const MATRIX         &A,
+  Tsolve (const MatrixType     &A,
           VectorType           &x,
           const VectorType     &b,
           const PRECONDITIONER &precondition);
@@ -214,9 +214,9 @@ SolverRichardson<VectorType>::~SolverRichardson()
 
 
 template <class VectorType>
-template <class MATRIX, class PRECONDITIONER>
+template <typename MatrixType, class PRECONDITIONER>
 void
-SolverRichardson<VectorType>::solve (const MATRIX         &A,
+SolverRichardson<VectorType>::solve (const MatrixType     &A,
                                      VectorType           &x,
                                      const VectorType     &b,
                                      const PRECONDITIONER &precondition)
@@ -285,9 +285,9 @@ SolverRichardson<VectorType>::solve (const MATRIX         &A,
 
 
 template <class VectorType>
-template <class MATRIX, class PRECONDITIONER>
+template <typename MatrixType, class PRECONDITIONER>
 void
-SolverRichardson<VectorType>::Tsolve (const MATRIX         &A,
+SolverRichardson<VectorType>::Tsolve (const MatrixType     &A,
                                       VectorType           &x,
                                       const VectorType     &b,
                                       const PRECONDITIONER &precondition)
diff --git a/include/deal.II/lac/sparse_matrix_ez.h b/include/deal.II/lac/sparse_matrix_ez.h
index ad4f3b2c5e..b75558a04d 100644
--- a/include/deal.II/lac/sparse_matrix_ez.h
+++ b/include/deal.II/lac/sparse_matrix_ez.h
@@ -539,9 +539,9 @@ public:
    *
    * The function returns a reference to @p this.
    */
-  template <class MATRIX>
+  template <typename MatrixType>
   SparseMatrixEZ<number> &
-  copy_from (const MATRIX &source, const bool elide_zero_values = true);
+  copy_from (const MatrixType &source, const bool elide_zero_values = true);
 
   /**
    * Add @p matrix scaled by @p factor to this matrix.
@@ -550,9 +550,9 @@ public:
    * type is convertible to the data type of this matrix and it has the
    * standard @p const_iterator.
    */
-  template <class MATRIX>
-  void add (const number factor,
-            const MATRIX &matrix);
+  template <typename MatrixType>
+  void add (const number      factor,
+            const MatrixType &matrix);
 //@}
   /**
    * @name Entry Access
@@ -673,10 +673,10 @@ public:
    * matrix entries and that @p A has a function <tt>el(i,j)</tt> for access
    * to a specific entry.
    */
-  template <class MATRIXA, class MATRIXB>
-  void conjugate_add (const MATRIXA &A,
-                      const MATRIXB &B,
-                      const bool transpose = false);
+  template <typename MatrixTypeA, typename MatrixTypeB>
+  void conjugate_add (const MatrixTypeA &A,
+                      const MatrixTypeB &B,
+                      const bool         transpose = false);
 //@}
   /**
    * @name Iterators
@@ -1392,10 +1392,10 @@ SparseMatrixEZ<number>::end (const size_type r) const
 }
 
 template<typename number>
-template <class MATRIX>
+template <typename MatrixType>
 inline
 SparseMatrixEZ<number> &
-SparseMatrixEZ<number>::copy_from (const MATRIX &M, const bool elide_zero_values)
+SparseMatrixEZ<number>::copy_from (const MatrixType &M, const bool elide_zero_values)
 {
   reinit(M.m(),
          M.n(),
@@ -1407,8 +1407,8 @@ SparseMatrixEZ<number>::copy_from (const MATRIX &M, const bool elide_zero_values
   // copy them into the current object
   for (size_type row = 0; row < M.m(); ++row)
     {
-      const typename MATRIX::const_iterator end_row = M.end(row);
-      for (typename MATRIX::const_iterator entry = M.begin(row);
+      const typename MatrixType::const_iterator end_row = M.end(row);
+      for (typename MatrixType::const_iterator entry = M.begin(row);
            entry != end_row; ++entry)
         set(row, entry->column(), entry->value(), elide_zero_values);
     }
@@ -1417,11 +1417,11 @@ SparseMatrixEZ<number>::copy_from (const MATRIX &M, const bool elide_zero_values
 }
 
 template<typename number>
-template <class MATRIX>
+template <typename MatrixType>
 inline
 void
-SparseMatrixEZ<number>::add (const number factor,
-                             const MATRIX &M)
+SparseMatrixEZ<number>::add (const number      factor,
+                             const MatrixType &M)
 {
   Assert (M.m() == m(), ExcDimensionMismatch(M.m(), m()));
   Assert (M.n() == n(), ExcDimensionMismatch(M.n(), n()));
@@ -1434,8 +1434,8 @@ SparseMatrixEZ<number>::add (const number factor,
   // add them into the current object
   for (size_type row = 0; row < M.m(); ++row)
     {
-      const typename MATRIX::const_iterator end_row = M.end(row);
-      for (typename MATRIX::const_iterator entry = M.begin(row);
+      const typename MatrixType::const_iterator end_row = M.end(row);
+      for (typename MatrixType::const_iterator entry = M.begin(row);
            entry != end_row; ++entry)
         if (entry->value() != 0)
           add(row, entry->column(), factor * entry->value());
@@ -1445,11 +1445,11 @@ SparseMatrixEZ<number>::add (const number factor,
 
 
 template<typename number>
-template <class MATRIXA, class MATRIXB>
+template <typename MatrixTypeA, typename MatrixTypeB>
 inline void
-SparseMatrixEZ<number>::conjugate_add (const MATRIXA &A,
-                                       const MATRIXB &B,
-                                       const bool transpose)
+SparseMatrixEZ<number>::conjugate_add (const MatrixTypeA &A,
+                                       const MatrixTypeB &B,
+                                       const bool         transpose)
 {
 // Compute the result
 // r_ij = \sum_kl b_ik b_jl a_kl
@@ -1467,20 +1467,20 @@ SparseMatrixEZ<number>::conjugate_add (const MATRIXA &A,
   // corresponding rows of B only.
   // For the non-transpose case, we
   // must find a trick.
-  typename MATRIXB::const_iterator b1 = B.begin();
-  const typename MATRIXB::const_iterator b_final = B.end();
+  typename MatrixTypeB::const_iterator b1 = B.begin();
+  const typename MatrixTypeB::const_iterator b_final = B.end();
   if (transpose)
     while (b1 != b_final)
       {
         const size_type i = b1->column();
         const size_type k = b1->row();
-        typename MATRIXB::const_iterator b2 = B.begin();
+        typename MatrixTypeB::const_iterator b2 = B.begin();
         while (b2 != b_final)
           {
             const size_type j = b2->column();
             const size_type l = b2->row();
 
-            const typename MATRIXA::value_type a = A.el(k,l);
+            const typename MatrixTypeA::value_type a = A.el(k,l);
 
             if (a != 0.)
               add (i, j, a * b1->value() * b2->value());
@@ -1506,12 +1506,12 @@ SparseMatrixEZ<number>::conjugate_add (const MATRIXA &A,
           ++b1;
         }
 
-      typename MATRIXA::const_iterator ai = A.begin();
-      const typename MATRIXA::const_iterator ae = A.end();
+      typename MatrixTypeA::const_iterator ai = A.begin();
+      const typename MatrixTypeA::const_iterator ae = A.end();
 
       while (ai != ae)
         {
-          const typename MATRIXA::value_type a = ai->value();
+          const typename MatrixTypeA::value_type a = ai->value();
           // Don't do anything if
           // this entry is zero.
           if (a == 0.) continue;
@@ -1521,9 +1521,9 @@ SparseMatrixEZ<number>::conjugate_add (const MATRIXA &A,
           // nonzero entry in column
           // ai->row()
           b1 = B.begin(minrow[ai->row()]);
-          const typename MATRIXB::const_iterator
+          const typename MatrixTypeB::const_iterator
           be1 = B.end(maxrow[ai->row()]);
-          const typename MATRIXB::const_iterator
+          const typename MatrixTypeB::const_iterator
           be2 = B.end(maxrow[ai->column()]);
 
           while (b1 != be1)
@@ -1537,7 +1537,7 @@ SparseMatrixEZ<number>::conjugate_add (const MATRIXA &A,
                 {
                   const size_type i = b1->row();
 
-                  typename MATRIXB::const_iterator
+                  typename MatrixTypeB::const_iterator
                   b2 = B.begin(minrow[ai->column()]);
                   while (b2 != be2)
                     {
diff --git a/include/deal.II/lac/transpose_matrix.h b/include/deal.II/lac/transpose_matrix.h
index 34ccd08d7d..bfb4790480 100644
--- a/include/deal.II/lac/transpose_matrix.h
+++ b/include/deal.II/lac/transpose_matrix.h
@@ -40,7 +40,7 @@ DEAL_II_NAMESPACE_OPEN
  * @ingroup Matrix2
  * @author Guido Kanschat, 2006
  */
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 class
   TransposeMatrix : public PointerMatrixBase<VectorType>
 {
@@ -52,7 +52,7 @@ public:
    *
    * If <tt>M</tt> is zero, no matrix is stored.
    */
-  TransposeMatrix (const MATRIX *M=0);
+  TransposeMatrix (const MatrixType *M=0);
 
   /**
    * Constructor. The name argument is used to identify the SmartPointer for
@@ -65,8 +65,8 @@ public:
    * the TransposeMatrix. The name argument is used to identify the
    * SmartPointer for this object.
    */
-  TransposeMatrix(const MATRIX *M,
-                  const char *name);
+  TransposeMatrix(const MatrixType *M,
+                  const char       *name);
 
   // Use doc from base class
   virtual void clear();
@@ -81,7 +81,7 @@ public:
    * matrix.
    * @see SmartPointer
    */
-  const TransposeMatrix &operator= (const MATRIX *M);
+  const TransposeMatrix &operator= (const MatrixType *M);
 
   /**
    * Matrix-vector product.
@@ -111,93 +111,92 @@ private:
   /**
    * The pointer to the actual matrix.
    */
-  SmartPointer<const MATRIX,TransposeMatrix<MATRIX,VectorType> > m;
+  SmartPointer<const MatrixType,TransposeMatrix<MatrixType,VectorType> > m;
 };
 
 
 //----------------------------------------------------------------------//
 
 
-template<class MATRIX, typename VectorType>
-TransposeMatrix<MATRIX, VectorType>::TransposeMatrix (const MATRIX *M)
+template<typename MatrixType, typename VectorType>
+TransposeMatrix<MatrixType, VectorType>::TransposeMatrix (const MatrixType *M)
   : m(M)
 {}
 
 
-template<class MATRIX, typename VectorType>
-TransposeMatrix<MATRIX, VectorType>::TransposeMatrix (const char *name)
+template<typename MatrixType, typename VectorType>
+TransposeMatrix<MatrixType, VectorType>::TransposeMatrix (const char *name)
   : m(0, name)
 {}
 
 
-template<class MATRIX, typename VectorType>
-TransposeMatrix<MATRIX, VectorType>::TransposeMatrix (
-  const MATRIX *M,
-  const char *name)
+template<typename MatrixType, typename VectorType>
+TransposeMatrix<MatrixType, VectorType>::TransposeMatrix (const MatrixType *M,
+                                                          const char       *name)
   : m(M, name)
 {}
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-TransposeMatrix<MATRIX, VectorType>::clear ()
+TransposeMatrix<MatrixType, VectorType>::clear ()
 {
   m = 0;
 }
 
 
-template<class MATRIX, typename VectorType>
-inline const TransposeMatrix<MATRIX, VectorType> &
-TransposeMatrix<MATRIX, VectorType>::operator= (const MATRIX *M)
+template<typename MatrixType, typename VectorType>
+inline const TransposeMatrix<MatrixType, VectorType> &
+TransposeMatrix<MatrixType, VectorType>::operator= (const MatrixType *M)
 {
   m = M;
   return *this;
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline bool
-TransposeMatrix<MATRIX, VectorType>::empty () const
+TransposeMatrix<MatrixType, VectorType>::empty () const
 {
   if (m == 0)
     return true;
   return m->empty();
 }
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-TransposeMatrix<MATRIX, VectorType>::vmult (VectorType       &dst,
-                                            const VectorType &src) const
+TransposeMatrix<MatrixType, VectorType>::vmult (VectorType       &dst,
+                                                const VectorType &src) const
 {
   Assert (m != 0, ExcNotInitialized());
   m->Tvmult (dst, src);
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-TransposeMatrix<MATRIX, VectorType>::Tvmult (VectorType       &dst,
-                                             const VectorType &src) const
+TransposeMatrix<MatrixType, VectorType>::Tvmult (VectorType       &dst,
+                                                 const VectorType &src) const
 {
   Assert (m != 0, ExcNotInitialized());
   m->vmult (dst, src);
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-TransposeMatrix<MATRIX, VectorType>::vmult_add (VectorType       &dst,
-                                                const VectorType &src) const
+TransposeMatrix<MatrixType, VectorType>::vmult_add (VectorType       &dst,
+                                                    const VectorType &src) const
 {
   Assert (m != 0, ExcNotInitialized());
   m->Tvmult_add (dst, src);
 }
 
 
-template<class MATRIX, typename VectorType>
+template<typename MatrixType, typename VectorType>
 inline void
-TransposeMatrix<MATRIX, VectorType>::Tvmult_add (VectorType       &dst,
-                                                 const VectorType &src) const
+TransposeMatrix<MatrixType, VectorType>::Tvmult_add (VectorType       &dst,
+                                                     const VectorType &src) const
 {
   Assert (m != 0, ExcNotInitialized());
   m->vmult_add (dst, src);
diff --git a/include/deal.II/meshworker/assembler.h b/include/deal.II/meshworker/assembler.h
index 9d1e78e04e..b63c138c83 100644
--- a/include/deal.II/meshworker/assembler.h
+++ b/include/deal.II/meshworker/assembler.h
@@ -93,8 +93,8 @@ namespace MeshWorker
      * used locally.
      *
      * In the block model, each of the blocks of the local vectors corresponds
-     * to the restriction of a single block of the system to this cell (
-     * @ref GlossBlock).
+     * to the restriction of a single block of the system to this cell
+     (* @ref GlossBlock).
      * Thus, the size of this local block is the number of degrees of freedom
      * of the corresponding base element of the FESystem.
      *
@@ -192,7 +192,7 @@ namespace MeshWorker
      * @ingroup MeshWorker
      * @author Guido Kanschat, 2009
      */
-    template <class MATRIX, typename number = double>
+    template <typename MatrixType, typename number = double>
     class MatrixLocalBlocksToGlobalBlocks
     {
     public:
@@ -207,7 +207,7 @@ namespace MeshWorker
        * initialize cell matrix vectors.
        */
       void initialize(const BlockInfo *block_info,
-                      MatrixBlockVector<MATRIX> &matrices);
+                      MatrixBlockVector<MatrixType> &matrices);
 
       /**
        * Initialize the constraints.
@@ -241,30 +241,29 @@ namespace MeshWorker
       /**
        * Assemble a single local matrix into a global one.
        */
-      void assemble(
-        MatrixBlock<MATRIX> &global,
-        const FullMatrix<number> &local,
-        const unsigned int block_row,
-        const unsigned int block_col,
-        const std::vector<types::global_dof_index> &dof1,
-        const std::vector<types::global_dof_index> &dof2);
+      void assemble(MatrixBlock<MatrixType>                    &global,
+                    const FullMatrix<number>                   &local,
+                    const unsigned int                          block_row,
+                    const unsigned int                          block_col,
+                    const std::vector<types::global_dof_index> &dof1,
+                    const std::vector<types::global_dof_index> &dof2);
 
       /**
        * The global matrices, stored as a vector of pointers.
        */
-      SmartPointer<MatrixBlockVector<MATRIX>,
-                   MatrixLocalBlocksToGlobalBlocks<MATRIX, number> > matrices;
+      SmartPointer<MatrixBlockVector<MatrixType>,
+                   MatrixLocalBlocksToGlobalBlocks<MatrixType, number> > matrices;
 
       /**
        * A pointer to the object containing the block structure.
        */
       SmartPointer<const BlockInfo,
-                   MatrixLocalBlocksToGlobalBlocks<MATRIX, number> > block_info;
+                   MatrixLocalBlocksToGlobalBlocks<MatrixType, number> > block_info;
       /**
        * A pointer to the object containing constraints.
        */
       SmartPointer<const ConstraintMatrix,
-                   MatrixLocalBlocksToGlobalBlocks<MATRIX,number> > constraints;
+                   MatrixLocalBlocksToGlobalBlocks<MatrixType,number> > constraints;
 
       /**
        * The smallest positive number that will be entered into the global
@@ -299,12 +298,12 @@ namespace MeshWorker
      * @ingroup MeshWorker
      * @author Guido Kanschat, 2009
      */
-    template <class MATRIX, typename number = double>
+    template <typename MatrixType, typename number = double>
     class MGMatrixLocalBlocksToGlobalBlocks
     {
     public:
-      typedef MGMatrixBlockVector<MATRIX> MatrixPtrVector;
-      typedef SmartPointer<MatrixPtrVector, MGMatrixLocalBlocksToGlobalBlocks<MATRIX,number> >
+      typedef MGMatrixBlockVector<MatrixType> MatrixPtrVector;
+      typedef SmartPointer<MatrixPtrVector, MGMatrixLocalBlocksToGlobalBlocks<MatrixType,number> >
       MatrixPtrVectorPtr;
 
       /**
@@ -366,81 +365,75 @@ namespace MeshWorker
       /**
        * Assemble a single local matrix into a global one.
        */
-      void assemble(
-        MATRIX &global,
-        const FullMatrix<number> &local,
-        const unsigned int block_row,
-        const unsigned int block_col,
-        const std::vector<types::global_dof_index> &dof1,
-        const std::vector<types::global_dof_index> &dof2,
-        const unsigned int level1,
-        const unsigned int level2,
-        bool transpose = false);
+      void assemble(MatrixType                                 &global,
+                    const FullMatrix<number>                   &local,
+                    const unsigned int                          block_row,
+                    const unsigned int                          block_col,
+                    const std::vector<types::global_dof_index> &dof1,
+                    const std::vector<types::global_dof_index> &dof2,
+                    const unsigned int                          level1,
+                    const unsigned int                          level2,
+                    bool                                        transpose = false);
 
       /**
        * Assemble a single local matrix into a global one.
        */
-      void assemble_fluxes(
-        MATRIX &global,
-        const FullMatrix<number> &local,
-        const unsigned int block_row,
-        const unsigned int block_col,
-        const std::vector<types::global_dof_index> &dof1,
-        const std::vector<types::global_dof_index> &dof2,
-        const unsigned int level1,
-        const unsigned int level2);
+      void assemble_fluxes(MatrixType                                 &global,
+                           const FullMatrix<number>                   &local,
+                           const unsigned int                          block_row,
+                           const unsigned int                          block_col,
+                           const std::vector<types::global_dof_index> &dof1,
+                           const std::vector<types::global_dof_index> &dof2,
+                           const unsigned int                          level1,
+                           const unsigned int                          level2);
 
       /**
        * Assemble a single local matrix into a global one.
        */
-      void assemble_up(
-        MATRIX &global,
-        const FullMatrix<number> &local,
-        const unsigned int block_row,
-        const unsigned int block_col,
-        const std::vector<types::global_dof_index> &dof1,
-        const std::vector<types::global_dof_index> &dof2,
-        const unsigned int level1,
-        const unsigned int level2);
+      void assemble_up(MatrixType                                 &global,
+                       const FullMatrix<number>                   &local,
+                       const unsigned int                          block_row,
+                       const unsigned int                          block_col,
+                       const std::vector<types::global_dof_index> &dof1,
+                       const std::vector<types::global_dof_index> &dof2,
+                       const unsigned int                          level1,
+                       const unsigned int                          level2);
 
       /**
        * Assemble a single local matrix into a global one.
        */
-      void assemble_down(
-        MATRIX &global,
-        const FullMatrix<number> &local,
-        const unsigned int block_row,
-        const unsigned int block_col,
-        const std::vector<types::global_dof_index> &dof1,
-        const std::vector<types::global_dof_index> &dof2,
-        const unsigned int level1,
-        const unsigned int level2);
+      void assemble_down(MatrixType                                 &global,
+                         const FullMatrix<number>                   &local,
+                         const unsigned int                          block_row,
+                         const unsigned int                          block_col,
+                         const std::vector<types::global_dof_index> &dof1,
+                         const std::vector<types::global_dof_index> &dof2,
+                         const unsigned int                          level1,
+                         const unsigned int                          level2);
 
       /**
        * Assemble a single local matrix into a global one.
        */
-      void assemble_in(
-        MATRIX &global,
-        const FullMatrix<number> &local,
-        const unsigned int block_row,
-        const unsigned int block_col,
-        const std::vector<types::global_dof_index> &dof1,
-        const std::vector<types::global_dof_index> &dof2,
-        const unsigned int level1,
-        const unsigned int level2);
+      void assemble_in(MatrixType                                 &global,
+                       const FullMatrix<number>                   &local,
+                       const unsigned int                          block_row,
+                       const unsigned int                          block_col,
+                       const std::vector<types::global_dof_index> &dof1,
+                       const std::vector<types::global_dof_index> &dof2,
+                       const unsigned int                          level1,
+                       const unsigned int                          level2);
 
       /**
        * Assemble a single local matrix into a global one.
        */
-      void assemble_out(
-        MATRIX &global,
-        const FullMatrix<number> &local,
-        const unsigned int block_row,
-        const unsigned int block_col,
-        const std::vector<types::global_dof_index> &dof1,
-        const std::vector<types::global_dof_index> &dof2,
-        const unsigned int level1,
-        const unsigned int level2);
+      void assemble_out(MatrixType                                 &global,
+                        const FullMatrix<number>                   &local,
+                        const unsigned int                          block_row,
+                        const unsigned int                          block_col,
+                        const std::vector<types::global_dof_index> &dof1,
+                        const std::vector<types::global_dof_index> &dof2,
+                        const unsigned int                          level1,
+                        const unsigned int                          level2);
 
       /**
        * The level matrices, stored as a vector of pointers.
@@ -474,12 +467,12 @@ namespace MeshWorker
       /**
        * A pointer to the object containing the block structure.
        */
-      SmartPointer<const BlockInfo, MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number> > block_info;
+      SmartPointer<const BlockInfo, MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number> > block_info;
 
       /**
        * A pointer to the object containing constraints.
        */
-      SmartPointer<const MGConstrainedDoFs,MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number> > mg_constrained_dofs;
+      SmartPointer<const MGConstrainedDoFs,MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number> > mg_constrained_dofs;
 
 
       /**
@@ -577,20 +570,20 @@ namespace MeshWorker
 
 //----------------------------------------------------------------------//
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline
-    MatrixLocalBlocksToGlobalBlocks<MATRIX, number>::MatrixLocalBlocksToGlobalBlocks(
-      double threshold)
+    MatrixLocalBlocksToGlobalBlocks<MatrixType, number>::MatrixLocalBlocksToGlobalBlocks
+    (double threshold)
       :
       threshold(threshold)
     {}
 
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline void
-    MatrixLocalBlocksToGlobalBlocks<MATRIX, number>::initialize(
-      const BlockInfo *b,
-      MatrixBlockVector<MATRIX> &m)
+    MatrixLocalBlocksToGlobalBlocks<MatrixType, number>::initialize
+    (const BlockInfo               *b,
+     MatrixBlockVector<MatrixType> &m)
     {
       block_info = b;
       matrices = &m;
@@ -598,37 +591,37 @@ namespace MeshWorker
 
 
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline void
-    MatrixLocalBlocksToGlobalBlocks<MATRIX, number>::initialize(
-      const ConstraintMatrix &c)
+    MatrixLocalBlocksToGlobalBlocks<MatrixType, number>::initialize
+    (const ConstraintMatrix &c)
     {
       constraints = &c;
     }
 
 
 
-    template <class MATRIX ,typename number>
+    template <typename MatrixType ,typename number>
     template <class DOFINFO>
     inline void
-    MatrixLocalBlocksToGlobalBlocks<MATRIX, number>::initialize_info(
-      DOFINFO &info,
-      bool face) const
+    MatrixLocalBlocksToGlobalBlocks<MatrixType, number>::initialize_info
+    (DOFINFO &info,
+     bool face) const
     {
       info.initialize_matrices(*matrices, face);
     }
 
 
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline void
-    MatrixLocalBlocksToGlobalBlocks<MATRIX, number>::assemble(
-      MatrixBlock<MATRIX> &global,
-      const FullMatrix<number> &local,
-      const unsigned int block_row,
-      const unsigned int block_col,
-      const std::vector<types::global_dof_index> &dof1,
-      const std::vector<types::global_dof_index> &dof2)
+    MatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble
+    (MatrixBlock<MatrixType>                    &global,
+     const FullMatrix<number>                   &local,
+     const unsigned int                          block_row,
+     const unsigned int                          block_col,
+     const std::vector<types::global_dof_index> &dof1,
+     const std::vector<types::global_dof_index> &dof2)
     {
       if (constraints == 0)
         {
@@ -667,11 +660,10 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     template <class DOFINFO>
     inline void
-    MatrixLocalBlocksToGlobalBlocks<MATRIX, number>::assemble(
-      const DOFINFO &info)
+    MatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble (const DOFINFO &info)
     {
       for (unsigned int i=0; i<matrices->size(); ++i)
         {
@@ -685,12 +677,11 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     template <class DOFINFO>
     inline void
-    MatrixLocalBlocksToGlobalBlocks<MATRIX, number>::assemble(
-      const DOFINFO &info1,
-      const DOFINFO &info2)
+    MatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble (const DOFINFO &info1,
+        const DOFINFO &info2)
     {
       for (unsigned int i=0; i<matrices->size(); ++i)
         {
@@ -709,20 +700,20 @@ namespace MeshWorker
 
 // ----------------------------------------------------------------------//
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::MGMatrixLocalBlocksToGlobalBlocks(
-      double threshold)
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::MGMatrixLocalBlocksToGlobalBlocks
+    (double threshold)
       :
       threshold(threshold)
     {}
 
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline void
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::initialize(
-      const BlockInfo *b,
-      MatrixPtrVector &m)
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::initialize
+    (const BlockInfo *b,
+     MatrixPtrVector &m)
     {
       block_info = b;
       AssertDimension(block_info->local().size(), block_info->global().size());
@@ -730,61 +721,61 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline void
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::initialize(
-      const MGConstrainedDoFs &mg_c)
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::initialize
+    (const MGConstrainedDoFs &mg_c)
     {
       mg_constrained_dofs = &mg_c;
     }
 
 
-    template <class MATRIX ,typename number>
+    template <typename MatrixType ,typename number>
     template <class DOFINFO>
     inline void
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::initialize_info(
-      DOFINFO &info,
-      bool face) const
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::initialize_info
+    (DOFINFO &info,
+     bool face) const
     {
       info.initialize_matrices(*matrices, face);
     }
 
 
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline void
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::initialize_edge_flux(
-      MatrixPtrVector &up,
-      MatrixPtrVector &down)
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::initialize_edge_flux
+    (MatrixPtrVector &up,
+     MatrixPtrVector &down)
     {
       flux_up = up;
       flux_down = down;
     }
 
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline void
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::initialize_interfaces(
-      MatrixPtrVector &in,
-      MatrixPtrVector &out)
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::initialize_interfaces
+    (MatrixPtrVector &in,
+     MatrixPtrVector &out)
     {
       interface_in = in;
       interface_out = out;
     }
 
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline void
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::assemble(
-      MATRIX &global,
-      const FullMatrix<number> &local,
-      const unsigned int block_row,
-      const unsigned int block_col,
-      const std::vector<types::global_dof_index> &dof1,
-      const std::vector<types::global_dof_index> &dof2,
-      const unsigned int level1,
-      const unsigned int level2,
-      bool transpose)
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble
+    (MatrixType                                 &global,
+     const FullMatrix<number>                   &local,
+     const unsigned int                          block_row,
+     const unsigned int                          block_col,
+     const std::vector<types::global_dof_index> &dof1,
+     const std::vector<types::global_dof_index> &dof2,
+     const unsigned int                          level1,
+     const unsigned int                          level2,
+     bool                                        transpose)
     {
       for (unsigned int j=0; j<local.n_rows(); ++j)
         for (unsigned int k=0; k<local.n_cols(); ++k)
@@ -852,17 +843,17 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline void
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::assemble_fluxes(
-      MATRIX &global,
-      const FullMatrix<number> &local,
-      const unsigned int block_row,
-      const unsigned int block_col,
-      const std::vector<types::global_dof_index> &dof1,
-      const std::vector<types::global_dof_index> &dof2,
-      const unsigned int level1,
-      const unsigned int level2)
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble_fluxes
+    (MatrixType                                 &global,
+     const FullMatrix<number>                   &local,
+     const unsigned int                          block_row,
+     const unsigned int                          block_col,
+     const std::vector<types::global_dof_index> &dof1,
+     const std::vector<types::global_dof_index> &dof2,
+     const unsigned int                          level1,
+     const unsigned int                          level2)
     {
       for (unsigned int j=0; j<local.n_rows(); ++j)
         for (unsigned int k=0; k<local.n_cols(); ++k)
@@ -905,17 +896,17 @@ namespace MeshWorker
             }
     }
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline void
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::assemble_up(
-      MATRIX &global,
-      const FullMatrix<number> &local,
-      const unsigned int block_row,
-      const unsigned int block_col,
-      const std::vector<types::global_dof_index> &dof1,
-      const std::vector<types::global_dof_index> &dof2,
-      const unsigned int level1,
-      const unsigned int level2)
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble_up
+    (MatrixType                                 &global,
+     const FullMatrix<number>                   &local,
+     const unsigned int                          block_row,
+     const unsigned int                          block_col,
+     const std::vector<types::global_dof_index> &dof1,
+     const std::vector<types::global_dof_index> &dof2,
+     const unsigned int                          level1,
+     const unsigned int                          level2)
     {
       for (unsigned int j=0; j<local.n_rows(); ++j)
         for (unsigned int k=0; k<local.n_cols(); ++k)
@@ -958,17 +949,17 @@ namespace MeshWorker
             }
     }
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline void
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::assemble_down(
-      MATRIX &global,
-      const FullMatrix<number> &local,
-      const unsigned int block_row,
-      const unsigned int block_col,
-      const std::vector<types::global_dof_index> &dof1,
-      const std::vector<types::global_dof_index> &dof2,
-      const unsigned int level1,
-      const unsigned int level2)
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble_down
+    (MatrixType                                 &global,
+     const FullMatrix<number>                   &local,
+     const unsigned int                          block_row,
+     const unsigned int                          block_col,
+     const std::vector<types::global_dof_index> &dof1,
+     const std::vector<types::global_dof_index> &dof2,
+     const unsigned int                          level1,
+     const unsigned int                          level2)
     {
       for (unsigned int j=0; j<local.n_rows(); ++j)
         for (unsigned int k=0; k<local.n_cols(); ++k)
@@ -1011,17 +1002,17 @@ namespace MeshWorker
             }
     }
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline void
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::assemble_in(
-      MATRIX &global,
-      const FullMatrix<number> &local,
-      const unsigned int block_row,
-      const unsigned int block_col,
-      const std::vector<types::global_dof_index> &dof1,
-      const std::vector<types::global_dof_index> &dof2,
-      const unsigned int level1,
-      const unsigned int level2)
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble_in
+    (MatrixType                                 &global,
+     const FullMatrix<number>                   &local,
+     const unsigned int                          block_row,
+     const unsigned int                          block_col,
+     const std::vector<types::global_dof_index> &dof1,
+     const std::vector<types::global_dof_index> &dof2,
+     const unsigned int                          level1,
+     const unsigned int                          level2)
     {
 //      AssertDimension(local.n(), dof1.size());
 //      AssertDimension(local.m(), dof2.size());
@@ -1076,17 +1067,17 @@ namespace MeshWorker
             }
     }
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     inline void
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::assemble_out(
-      MATRIX &global,
-      const FullMatrix<number> &local,
-      const unsigned int block_row,
-      const unsigned int block_col,
-      const std::vector<types::global_dof_index> &dof1,
-      const std::vector<types::global_dof_index> &dof2,
-      const unsigned int level1,
-      const unsigned int level2)
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble_out
+    (MatrixType                                 &global,
+     const FullMatrix<number>                   &local,
+     const unsigned int                          block_row,
+     const unsigned int                          block_col,
+     const std::vector<types::global_dof_index> &dof1,
+     const std::vector<types::global_dof_index> &dof2,
+     const unsigned int                          level1,
+     const unsigned int                          level2)
     {
 //      AssertDimension(local.n(), dof1.size());
 //      AssertDimension(local.m(), dof2.size());
@@ -1142,10 +1133,10 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     template <class DOFINFO>
     inline void
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::assemble(const DOFINFO &info)
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble(const DOFINFO &info)
     {
       const unsigned int level = info.cell->level();
 
@@ -1176,19 +1167,19 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX, typename number>
+    template <typename MatrixType, typename number>
     template <class DOFINFO>
     inline void
-    MGMatrixLocalBlocksToGlobalBlocks<MATRIX, number>::assemble(
-      const DOFINFO &info1,
-      const DOFINFO &info2)
+    MGMatrixLocalBlocksToGlobalBlocks<MatrixType, number>::assemble
+    (const DOFINFO &info1,
+     const DOFINFO &info2)
     {
       const unsigned int level1 = info1.cell->level();
       const unsigned int level2 = info2.cell->level();
 
       for (unsigned int i=0; i<matrices->size(); ++i)
         {
-          MGLevelObject<MatrixBlock<MATRIX> > &o = matrices->block(i);
+          MGLevelObject<MatrixBlock<MatrixType> > &o = matrices->block(i);
 
           // Row and column index of
           // the block we are dealing with
diff --git a/include/deal.II/meshworker/local_results.h b/include/deal.II/meshworker/local_results.h
index d518774741..637103a126 100644
--- a/include/deal.II/meshworker/local_results.h
+++ b/include/deal.II/meshworker/local_results.h
@@ -321,8 +321,8 @@ namespace MeshWorker
      *
      * @note This function is usually only called by the assembler.
      */
-    template <class MATRIX>
-    void initialize_matrices(const MatrixBlockVector<MATRIX> &matrices,
+    template <typename MatrixType>
+    void initialize_matrices(const MatrixBlockVector<MatrixType> &matrices,
                              bool both);
 
     /**
@@ -332,8 +332,8 @@ namespace MeshWorker
      *
      * @note This function is usually only called by the assembler.
      */
-    template <class MATRIX>
-    void initialize_matrices(const MGMatrixBlockVector<MATRIX> &matrices,
+    template <typename MatrixType>
+    void initialize_matrices(const MGMatrixBlockVector<MatrixType> &matrices,
                              bool both);
 
     /**
@@ -416,11 +416,11 @@ namespace MeshWorker
 
 
   template <typename number>
-  template <class MATRIX>
+  template <typename MatrixType>
   inline void
-  LocalResults<number>::initialize_matrices(
-    const MatrixBlockVector<MATRIX> &matrices,
-    bool both)
+  LocalResults<number>::initialize_matrices
+  (const MatrixBlockVector<MatrixType> &matrices,
+   bool                                 both)
   {
     M1.resize(matrices.size());
     if (both)
@@ -442,18 +442,18 @@ namespace MeshWorker
 
 
   template <typename number>
-  template <class MATRIX>
+  template <typename MatrixType>
   inline void
-  LocalResults<number>::initialize_matrices(
-    const MGMatrixBlockVector<MATRIX> &matrices,
-    bool both)
+  LocalResults<number>::initialize_matrices
+  (const MGMatrixBlockVector<MatrixType> &matrices,
+   bool                                   both)
   {
     M1.resize(matrices.size());
     if (both)
       M2.resize(matrices.size());
     for (unsigned int i=0; i<matrices.size(); ++i)
       {
-        const MGLevelObject<MatrixBlock<MATRIX> > &o = matrices.block(i);
+        const MGLevelObject<MatrixBlock<MatrixType> > &o = matrices.block(i);
         const unsigned int row = o[o.min_level()].row;
         const unsigned int col = o[o.min_level()].column;
 
diff --git a/include/deal.II/meshworker/simple.h b/include/deal.II/meshworker/simple.h
index 58e6a039c2..8fc1d01009 100644
--- a/include/deal.II/meshworker/simple.h
+++ b/include/deal.II/meshworker/simple.h
@@ -150,7 +150,7 @@ namespace MeshWorker
      * @ingroup MeshWorker
      * @author Guido Kanschat, 2009
      */
-    template <class MATRIX>
+    template <typename MatrixType>
     class MatrixSimple
     {
     public:
@@ -163,12 +163,12 @@ namespace MeshWorker
       /**
        * Store the result matrix for later assembling.
        */
-      void initialize(MATRIX &m);
+      void initialize(MatrixType &m);
 
       /**
        * Store several result matrices for later assembling.
        */
-      void initialize(std::vector<MATRIX> &m);
+      void initialize(std::vector<MatrixType> &m);
 
       /**
        * Initialize the constraints. After this function has been called with
@@ -216,11 +216,11 @@ namespace MeshWorker
       /**
        * The vector of global matrices being assembled.
        */
-      std::vector<SmartPointer<MATRIX,MatrixSimple<MATRIX> > > matrix;
+      std::vector<SmartPointer<MatrixType,MatrixSimple<MatrixType> > > matrix;
       /**
        * A pointer to the object containing constraints.
        */
-      SmartPointer<const ConstraintMatrix,MatrixSimple<MATRIX> > constraints;
+      SmartPointer<const ConstraintMatrix,MatrixSimple<MatrixType> > constraints;
 
       /**
        * The smallest positive number that will be entered into the global
@@ -242,7 +242,7 @@ namespace MeshWorker
      * @ingroup MeshWorker
      * @author Guido Kanschat, 2009
      */
-    template <class MATRIX>
+    template <typename MatrixType>
     class MGMatrixSimple
     {
     public:
@@ -255,7 +255,7 @@ namespace MeshWorker
       /**
        * Store the result matrix for later assembling.
        */
-      void initialize(MGLevelObject<MATRIX> &m);
+      void initialize(MGLevelObject<MatrixType> &m);
 
       /**
        * Initialize the multilevel constraints.
@@ -266,16 +266,16 @@ namespace MeshWorker
        * Initialize the matrices #flux_up and #flux_down used for local
        * refinement with discontinuous Galerkin methods.
        */
-      void initialize_fluxes(MGLevelObject<MATRIX> &flux_up,
-                             MGLevelObject<MATRIX> &flux_down);
+      void initialize_fluxes(MGLevelObject<MatrixType> &flux_up,
+                             MGLevelObject<MatrixType> &flux_down);
 
       /**
        * Initialize the matrices #interface_in and #interface_out used for
        * local refinement with continuous Galerkin methods.
        */
 
-      void initialize_interfaces(MGLevelObject<MATRIX> &interface_in,
-                                 MGLevelObject<MATRIX> &interface_out);
+      void initialize_interfaces(MGLevelObject<MatrixType> &interface_in,
+                                 MGLevelObject<MatrixType> &interface_out);
       /**
        * Initialize the local data in the DoFInfo object used later for
        * assembling.
@@ -303,7 +303,7 @@ namespace MeshWorker
       /**
        * Assemble a single matrix into a global matrix.
        */
-      void assemble(MATRIX &G,
+      void assemble(MatrixType &G,
                     const FullMatrix<double> &M,
                     const std::vector<types::global_dof_index> &i1,
                     const std::vector<types::global_dof_index> &i2);
@@ -311,7 +311,7 @@ namespace MeshWorker
       /**
        * Assemble a single matrix into a global matrix.
        */
-      void assemble(MATRIX &G,
+      void assemble(MatrixType &G,
                     const FullMatrix<double> &M,
                     const std::vector<types::global_dof_index> &i1,
                     const std::vector<types::global_dof_index> &i2,
@@ -321,7 +321,7 @@ namespace MeshWorker
        * Assemble a single matrix into a global matrix.
        */
 
-      void assemble_up(MATRIX &G,
+      void assemble_up(MatrixType &G,
                        const FullMatrix<double> &M,
                        const std::vector<types::global_dof_index> &i1,
                        const std::vector<types::global_dof_index> &i2,
@@ -330,7 +330,7 @@ namespace MeshWorker
        * Assemble a single matrix into a global matrix.
        */
 
-      void assemble_down(MATRIX &G,
+      void assemble_down(MatrixType &G,
                          const FullMatrix<double> &M,
                          const std::vector<types::global_dof_index> &i1,
                          const std::vector<types::global_dof_index> &i2,
@@ -340,7 +340,7 @@ namespace MeshWorker
        * Assemble a single matrix into a global matrix.
        */
 
-      void assemble_in(MATRIX &G,
+      void assemble_in(MatrixType &G,
                        const FullMatrix<double> &M,
                        const std::vector<types::global_dof_index> &i1,
                        const std::vector<types::global_dof_index> &i2,
@@ -350,7 +350,7 @@ namespace MeshWorker
        * Assemble a single matrix into a global matrix.
        */
 
-      void assemble_out(MATRIX &G,
+      void assemble_out(MatrixType &G,
                         const FullMatrix<double> &M,
                         const std::vector<types::global_dof_index> &i1,
                         const std::vector<types::global_dof_index> &i2,
@@ -359,35 +359,35 @@ namespace MeshWorker
       /**
        * The global matrix being assembled.
        */
-      SmartPointer<MGLevelObject<MATRIX>,MGMatrixSimple<MATRIX> > matrix;
+      SmartPointer<MGLevelObject<MatrixType>,MGMatrixSimple<MatrixType> > matrix;
 
       /**
        * The matrix used for face flux terms across the refinement edge,
        * coupling coarse to fine.
        */
-      SmartPointer<MGLevelObject<MATRIX>,MGMatrixSimple<MATRIX> > flux_up;
+      SmartPointer<MGLevelObject<MatrixType>,MGMatrixSimple<MatrixType> > flux_up;
 
       /**
        * The matrix used for face flux terms across the refinement edge,
        * coupling fine to coarse.
        */
-      SmartPointer<MGLevelObject<MATRIX>,MGMatrixSimple<MATRIX> > flux_down;
+      SmartPointer<MGLevelObject<MatrixType>,MGMatrixSimple<MatrixType> > flux_down;
 
       /**
        * The matrix used for face contributions for continuous elements across
        * the refinement edge, coupling coarse to fine.
        */
-      SmartPointer<MGLevelObject<MATRIX>,MGMatrixSimple<MATRIX> > interface_in;
+      SmartPointer<MGLevelObject<MatrixType>,MGMatrixSimple<MatrixType> > interface_in;
 
       /**
        * The matrix used for face contributions for continuous elements across
        * the refinement edge, coupling fine to coarse.
        */
-      SmartPointer<MGLevelObject<MATRIX>,MGMatrixSimple<MATRIX> > interface_out;
+      SmartPointer<MGLevelObject<MatrixType>,MGMatrixSimple<MatrixType> > interface_out;
       /**
        * A pointer to the object containing constraints.
        */
-      SmartPointer<const MGConstrainedDoFs,MGMatrixSimple<MATRIX> > mg_constrained_dofs;
+      SmartPointer<const MGConstrainedDoFs,MGMatrixSimple<MatrixType> > mg_constrained_dofs;
 
       /**
        * The smallest positive number that will be entered into the global
@@ -409,9 +409,9 @@ namespace MeshWorker
      * @ingroup MeshWorker
      * @author Guido Kanschat, 2009
      */
-    template <class MATRIX, typename VectorType>
+    template <typename MatrixType, typename VectorType>
     class SystemSimple :
-      private MatrixSimple<MATRIX>,
+      private MatrixSimple<MatrixType>,
       private ResidualSimple<VectorType>
     {
     public:
@@ -423,7 +423,7 @@ namespace MeshWorker
       /**
        * Store the two objects data is assembled into.
        */
-      void initialize(MATRIX &m, VectorType &rhs);
+      void initialize(MatrixType &m, VectorType &rhs);
 
       /**
        * Initialize the constraints. After this function has been called with
@@ -477,9 +477,9 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    ResidualSimple<MATRIX>::initialize_local_blocks(const BlockIndices &)
+    ResidualSimple<MatrixType>::initialize_local_blocks(const BlockIndices &)
     {}
 
 
@@ -562,26 +562,26 @@ namespace MeshWorker
 
 //----------------------------------------------------------------------//
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline
-    MatrixSimple<MATRIX>::MatrixSimple(double threshold)
+    MatrixSimple<MatrixType>::MatrixSimple(double threshold)
       :
       threshold(threshold)
     {}
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MatrixSimple<MATRIX>::initialize(MATRIX &m)
+    MatrixSimple<MatrixType>::initialize(MatrixType &m)
     {
       matrix.resize(1);
       matrix[0] = &m;
     }
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MatrixSimple<MATRIX>::initialize(std::vector<MATRIX> &m)
+    MatrixSimple<MatrixType>::initialize(std::vector<MatrixType> &m)
     {
       matrix.resize(m.size());
       for (unsigned int i=0; i<m.size(); ++i)
@@ -589,18 +589,18 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MatrixSimple<MATRIX>::initialize(const ConstraintMatrix &c)
+    MatrixSimple<MatrixType>::initialize(const ConstraintMatrix &c)
     {
       constraints = &c;
     }
 
 
-    template <class MATRIX >
+    template <typename MatrixType >
     template <class DOFINFO>
     inline void
-    MatrixSimple<MATRIX>::initialize_info(DOFINFO &info, bool face) const
+    MatrixSimple<MatrixType>::initialize_info(DOFINFO &info, bool face) const
     {
       Assert(matrix.size() != 0, ExcNotInitialized());
 
@@ -629,9 +629,9 @@ namespace MeshWorker
 
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MatrixSimple<MATRIX>::assemble(const FullMatrix<double> &M,
+    MatrixSimple<MatrixType>::assemble(const FullMatrix<double> &M,
                                    const unsigned int index,
                                    const std::vector<types::global_dof_index> &i1,
                                    const std::vector<types::global_dof_index> &i2)
@@ -651,10 +651,10 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     template <class DOFINFO>
     inline void
-    MatrixSimple<MATRIX>::assemble(const DOFINFO &info)
+    MatrixSimple<MatrixType>::assemble(const DOFINFO &info)
     {
       Assert(!info.level_cell, ExcMessage("Cell may not access level dofs"));
       const unsigned int n = info.indices_by_block.size();
@@ -675,10 +675,10 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     template <class DOFINFO>
     inline void
-    MatrixSimple<MATRIX>::assemble(const DOFINFO &info1, const DOFINFO &info2)
+    MatrixSimple<MatrixType>::assemble(const DOFINFO &info1, const DOFINFO &info2)
     {
       Assert(!info1.level_cell, ExcMessage("Cell may not access level dofs"));
       Assert(!info2.level_cell, ExcMessage("Cell may not access level dofs"));
@@ -719,53 +719,53 @@ namespace MeshWorker
 
 //----------------------------------------------------------------------//
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline
-    MGMatrixSimple<MATRIX>::MGMatrixSimple(double threshold)
+    MGMatrixSimple<MatrixType>::MGMatrixSimple(double threshold)
       :
       threshold(threshold)
     {}
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MGMatrixSimple<MATRIX>::initialize(MGLevelObject<MATRIX> &m)
+    MGMatrixSimple<MatrixType>::initialize(MGLevelObject<MatrixType> &m)
     {
       matrix = &m;
     }
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MGMatrixSimple<MATRIX>::initialize(const MGConstrainedDoFs &c)
+    MGMatrixSimple<MatrixType>::initialize(const MGConstrainedDoFs &c)
     {
       mg_constrained_dofs = &c;
     }
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MGMatrixSimple<MATRIX>::initialize_fluxes(
-      MGLevelObject<MATRIX> &up, MGLevelObject<MATRIX> &down)
+    MGMatrixSimple<MatrixType>::initialize_fluxes(MGLevelObject<MatrixType> &up,
+                                                  MGLevelObject<MatrixType> &down)
     {
       flux_up = &up;
       flux_down = &down;
     }
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MGMatrixSimple<MATRIX>::initialize_interfaces(
-      MGLevelObject<MATRIX> &in, MGLevelObject<MATRIX> &out)
+    MGMatrixSimple<MatrixType>::initialize_interfaces
+    (MGLevelObject<MatrixType> &in, MGLevelObject<MatrixType> &out)
     {
       interface_in = &in;
       interface_out = &out;
     }
 
 
-    template <class MATRIX >
+    template <typename MatrixType >
     template <class DOFINFO>
     inline void
-    MGMatrixSimple<MATRIX>::initialize_info(DOFINFO &info, bool face) const
+    MGMatrixSimple<MatrixType>::initialize_info(DOFINFO &info, bool face) const
     {
       const unsigned int n = info.indices_by_block.size();
 
@@ -790,13 +790,13 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MGMatrixSimple<MATRIX>::assemble(
-      MATRIX &G,
-      const FullMatrix<double> &M,
-      const std::vector<types::global_dof_index> &i1,
-      const std::vector<types::global_dof_index> &i2)
+    MGMatrixSimple<MatrixType>::assemble
+    (MatrixType                                 &G,
+     const FullMatrix<double>                   &M,
+     const std::vector<types::global_dof_index> &i1,
+     const std::vector<types::global_dof_index> &i2)
     {
       AssertDimension(M.m(), i1.size());
       AssertDimension(M.n(), i2.size());
@@ -810,14 +810,14 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MGMatrixSimple<MATRIX>::assemble(
-      MATRIX &G,
-      const FullMatrix<double> &M,
-      const std::vector<types::global_dof_index> &i1,
-      const std::vector<types::global_dof_index> &i2,
-      const unsigned int level)
+    MGMatrixSimple<MatrixType>::assemble
+    (MatrixType                                 &G,
+     const FullMatrix<double>                   &M,
+     const std::vector<types::global_dof_index> &i1,
+     const std::vector<types::global_dof_index> &i2,
+     const unsigned int                          level)
     {
       AssertDimension(M.m(), i1.size());
       AssertDimension(M.n(), i2.size());
@@ -863,14 +863,14 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MGMatrixSimple<MATRIX>::assemble_up(
-      MATRIX &G,
-      const FullMatrix<double> &M,
-      const std::vector<types::global_dof_index> &i1,
-      const std::vector<types::global_dof_index> &i2,
-      const unsigned int level)
+    MGMatrixSimple<MatrixType>::assemble_up
+    (MatrixType                                 &G,
+     const FullMatrix<double>                   &M,
+     const std::vector<types::global_dof_index> &i1,
+     const std::vector<types::global_dof_index> &i2,
+     const unsigned int                          level)
     {
       AssertDimension(M.n(), i1.size());
       AssertDimension(M.m(), i2.size());
@@ -892,14 +892,14 @@ namespace MeshWorker
         }
     }
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MGMatrixSimple<MATRIX>::assemble_down(
-      MATRIX &G,
-      const FullMatrix<double> &M,
-      const std::vector<types::global_dof_index> &i1,
-      const std::vector<types::global_dof_index> &i2,
-      const unsigned int level)
+    MGMatrixSimple<MatrixType>::assemble_down
+    (MatrixType                                 &G,
+     const FullMatrix<double>                   &M,
+     const std::vector<types::global_dof_index> &i1,
+     const std::vector<types::global_dof_index> &i2,
+     const unsigned int                          level)
     {
       AssertDimension(M.m(), i1.size());
       AssertDimension(M.n(), i2.size());
@@ -921,14 +921,14 @@ namespace MeshWorker
         }
     }
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MGMatrixSimple<MATRIX>::assemble_in(
-      MATRIX &G,
-      const FullMatrix<double> &M,
-      const std::vector<types::global_dof_index> &i1,
-      const std::vector<types::global_dof_index> &i2,
-      const unsigned int level)
+    MGMatrixSimple<MatrixType>::assemble_in
+    (MatrixType                                 &G,
+     const FullMatrix<double>                   &M,
+     const std::vector<types::global_dof_index> &i1,
+     const std::vector<types::global_dof_index> &i2,
+     const unsigned int                          level)
     {
       AssertDimension(M.m(), i1.size());
       AssertDimension(M.n(), i2.size());
@@ -962,14 +962,14 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     inline void
-    MGMatrixSimple<MATRIX>::assemble_out(
-      MATRIX &G,
-      const FullMatrix<double> &M,
-      const std::vector<types::global_dof_index> &i1,
-      const std::vector<types::global_dof_index> &i2,
-      const unsigned int level)
+    MGMatrixSimple<MatrixType>::assemble_out
+    (MatrixType                                 &G,
+     const FullMatrix<double>                   &M,
+     const std::vector<types::global_dof_index> &i1,
+     const std::vector<types::global_dof_index> &i2,
+     const unsigned int                          level)
     {
       AssertDimension(M.n(), i1.size());
       AssertDimension(M.m(), i2.size());
@@ -992,10 +992,10 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     template <class DOFINFO>
     inline void
-    MGMatrixSimple<MATRIX>::assemble(const DOFINFO &info)
+    MGMatrixSimple<MatrixType>::assemble(const DOFINFO &info)
     {
       Assert(info.level_cell, ExcMessage("Cell must access level dofs"));
       const unsigned int level = info.cell->level();
@@ -1032,10 +1032,10 @@ namespace MeshWorker
     }
 
 
-    template <class MATRIX>
+    template <typename MatrixType>
     template <class DOFINFO>
     inline void
-    MGMatrixSimple<MATRIX>::assemble(const DOFINFO &info1,
+    MGMatrixSimple<MatrixType>::assemble(const DOFINFO &info1,
                                      const DOFINFO &info2)
     {
       Assert(info1.level_cell, ExcMessage("Cell must access level dofs"));
@@ -1097,62 +1097,62 @@ namespace MeshWorker
 
 //----------------------------------------------------------------------//
 
-    template <class MATRIX, typename VectorType>
-    SystemSimple<MATRIX,VectorType>::SystemSimple(double t)
+    template <typename MatrixType, typename VectorType>
+    SystemSimple<MatrixType,VectorType>::SystemSimple(double t)
       :
-      MatrixSimple<MATRIX>(t)
+      MatrixSimple<MatrixType>(t)
     {}
 
 
-    template <class MATRIX, typename VectorType>
+    template <typename MatrixType, typename VectorType>
     inline void
-    SystemSimple<MATRIX,VectorType>::initialize(MATRIX &m, VectorType &rhs)
+    SystemSimple<MatrixType,VectorType>::initialize(MatrixType &m, VectorType &rhs)
     {
       AnyData data;
       VectorType *p = &rhs;
       data.add(p, "right hand side");
 
-      MatrixSimple<MATRIX>::initialize(m);
+      MatrixSimple<MatrixType>::initialize(m);
       ResidualSimple<VectorType>::initialize(data);
     }
 
-    template <class MATRIX, typename VectorType>
+    template <typename MatrixType, typename VectorType>
     inline void
-    SystemSimple<MATRIX,VectorType>::initialize(const ConstraintMatrix &c)
+    SystemSimple<MatrixType,VectorType>::initialize(const ConstraintMatrix &c)
     {
-      MatrixSimple<MATRIX>::initialize(c);
+      MatrixSimple<MatrixType>::initialize(c);
       ResidualSimple<VectorType>::initialize(c);
     }
 
 
-    template <class MATRIX, typename VectorType>
+    template <typename MatrixType, typename VectorType>
     template <class DOFINFO>
     inline void
-    SystemSimple<MATRIX,VectorType>::initialize_info(DOFINFO &info,
+    SystemSimple<MatrixType,VectorType>::initialize_info(DOFINFO &info,
                                                      bool    face) const
     {
-      MatrixSimple<MATRIX>::initialize_info(info, face);
+      MatrixSimple<MatrixType>::initialize_info(info, face);
       ResidualSimple<VectorType>::initialize_info(info, face);
     }
 
 
-    template <class MATRIX, typename VectorType>
+    template <typename MatrixType, typename VectorType>
     template <class DOFINFO>
     inline void
-    SystemSimple<MATRIX,VectorType>::assemble(const DOFINFO &info)
+    SystemSimple<MatrixType,VectorType>::assemble(const DOFINFO &info)
     {
-      MatrixSimple<MATRIX>::assemble(info);
+      MatrixSimple<MatrixType>::assemble(info);
       ResidualSimple<VectorType>::assemble(info);
     }
 
 
-    template <class MATRIX, typename VectorType>
+    template <typename MatrixType, typename VectorType>
     template <class DOFINFO>
     inline void
-    SystemSimple<MATRIX,VectorType>::assemble(const DOFINFO &info1,
+    SystemSimple<MatrixType,VectorType>::assemble(const DOFINFO &info1,
                                               const DOFINFO &info2)
     {
-      MatrixSimple<MATRIX>::assemble(info1, info2);
+      MatrixSimple<MatrixType>::assemble(info1, info2);
       ResidualSimple<VectorType>::assemble(info1, info2);
     }
   }
diff --git a/include/deal.II/multigrid/mg_block_smoother.h b/include/deal.II/multigrid/mg_block_smoother.h
index ea3bed848d..a39ef8ee7e 100644
--- a/include/deal.II/multigrid/mg_block_smoother.h
+++ b/include/deal.II/multigrid/mg_block_smoother.h
@@ -43,7 +43,7 @@ DEAL_II_NAMESPACE_OPEN
  *
  * @author Guido Kanschat, 2005
  */
-template <class MATRIX, class RELAX, typename number>
+template <typename MatrixType, class RELAX, typename number>
 class MGSmootherBlock
   : public MGSmootherBase<BlockVector<number> >
 {
@@ -51,18 +51,18 @@ public:
   /**
    * Constructor. Sets memory and smoothing parameters.
    */
-  MGSmootherBlock(VectorMemory<BlockVector<number> > &mem,
-                  const unsigned int steps = 1,
-                  const bool variable = false,
-                  const bool symmetric = false,
-                  const bool transpose = false,
-                  const bool reverse = false);
+  MGSmootherBlock (VectorMemory<BlockVector<number> > &mem,
+                  const unsigned int                   steps     = 1,
+                  const bool                           variable  = false,
+                  const bool                           symmetric = false,
+                  const bool                           transpose = false,
+                  const bool                           reverse   = false);
 
   /**
    * Initialize for matrices. The parameter <tt>matrices</tt> can be any
    * object having functions <tt>get_minlevel()</tt> and
    * <tt>get_maxlevel()</tt> as well as an <tt>operator[]</tt> returning a
-   * reference to @p MATRIX.
+   * reference to @p MatrixType.
    *
    * The same convention is used for the parameter <tt>smoothers</tt>, such
    * that <tt>operator[]</tt> returns the object doing the block-smoothing on
@@ -71,9 +71,9 @@ public:
    * This function stores pointers to the level matrices and smoothing
    * operator for each level.
    */
-  template <class MGMATRIX, class MGRELAX>
-  void initialize (const MGMATRIX &matrices,
-                   const MGRELAX &smoothers);
+  template <class MGMatrixType, class MGRELAX>
+  void initialize (const MGMatrixType &matrices,
+                   const MGRELAX      &smoothers);
 
   /**
    * Empty all vectors.
@@ -117,7 +117,7 @@ private:
   /**
    * Pointer to the matrices.
    */
-  MGLevelObject<PointerMatrix<MATRIX, BlockVector<number> > > matrices;
+  MGLevelObject<PointerMatrix<MatrixType, BlockVector<number> > > matrices;
 
   /**
    * Pointer to the matrices.
@@ -162,15 +162,15 @@ private:
 
 #ifndef DOXYGEN
 
-template <class MATRIX, class RELAX, typename number>
+template <typename MatrixType, class RELAX, typename number>
 inline
-MGSmootherBlock<MATRIX, RELAX, number>::MGSmootherBlock(
-  VectorMemory<BlockVector<number> > &mem,
-  const unsigned int steps,
-  const bool variable,
-  const bool symmetric,
-  const bool transpose,
-  const bool reverse)
+MGSmootherBlock<MatrixType, RELAX, number>::MGSmootherBlock
+(VectorMemory<BlockVector<number> > &mem,
+ const unsigned int                  steps,
+ const bool                          variable,
+ const bool                          symmetric,
+ const bool                          transpose,
+ const bool                          reverse)
   :
   steps(steps),
   variable(variable),
@@ -181,9 +181,9 @@ MGSmootherBlock<MATRIX, RELAX, number>::MGSmootherBlock(
 {}
 
 
-template <class MATRIX, class RELAX, typename number>
+template <typename MatrixType, class RELAX, typename number>
 inline void
-MGSmootherBlock<MATRIX, RELAX, number>::clear ()
+MGSmootherBlock<MatrixType, RELAX, number>::clear ()
 {
   unsigned int i=matrices.min_level(),
                max_level=matrices.max_level();
@@ -195,12 +195,11 @@ MGSmootherBlock<MATRIX, RELAX, number>::clear ()
 }
 
 
-template <class MATRIX, class RELAX, typename number>
-template <class MGMATRIX, class MGRELAX>
+template <typename MatrixType, class RELAX, typename number>
+template <class MGMatrixType, class MGRELAX>
 inline void
-MGSmootherBlock<MATRIX, RELAX, number>::initialize (
-  const MGMATRIX &m,
-  const MGRELAX &s)
+MGSmootherBlock<MatrixType, RELAX, number>::initialize (const MGMatrixType &m,
+                                                        const MGRELAX      &s)
 {
   const unsigned int min = m.min_level();
   const unsigned int max = m.max_level();
@@ -215,56 +214,55 @@ MGSmootherBlock<MATRIX, RELAX, number>::initialize (
     }
 }
 
-template <class MATRIX, class RELAX, typename number>
+template <typename MatrixType, class RELAX, typename number>
 inline void
-MGSmootherBlock<MATRIX, RELAX, number>::
+MGSmootherBlock<MatrixType, RELAX, number>::
 set_steps (const unsigned int s)
 {
   steps = s;
 }
 
 
-template <class MATRIX, class RELAX, typename number>
+template <typename MatrixType, class RELAX, typename number>
 inline void
-MGSmootherBlock<MATRIX, RELAX, number>::
+MGSmootherBlock<MatrixType, RELAX, number>::
 set_variable (const bool flag)
 {
   variable = flag;
 }
 
 
-template <class MATRIX, class RELAX, typename number>
+template <typename MatrixType, class RELAX, typename number>
 inline void
-MGSmootherBlock<MATRIX, RELAX, number>::
+MGSmootherBlock<MatrixType, RELAX, number>::
 set_symmetric (const bool flag)
 {
   symmetric = flag;
 }
 
 
-template <class MATRIX, class RELAX, typename number>
+template <typename MatrixType, class RELAX, typename number>
 inline void
-MGSmootherBlock<MATRIX, RELAX, number>::
+MGSmootherBlock<MatrixType, RELAX, number>::
 set_transpose (const bool flag)
 {
   transpose = flag;
 }
 
 
-template <class MATRIX, class RELAX, typename number>
+template <typename MatrixType, class RELAX, typename number>
 inline void
-MGSmootherBlock<MATRIX, RELAX, number>::
+MGSmootherBlock<MatrixType, RELAX, number>::
 set_reverse (const bool flag)
 {
   reverse = flag;
 }
 
 
-template <class MATRIX, class RELAX, typename number>
+template <typename MatrixType, class RELAX, typename number>
 inline void
-MGSmootherBlock<MATRIX, RELAX, number>::smooth(
-  const unsigned int level,
-  BlockVector<number> &u,
+MGSmootherBlock<MatrixType, RELAX, number>::smooth(const unsigned int   level,
+                                                   BlockVector<number> &u,
   const BlockVector<number> &rhs) const
 {
   deallog.push("Smooth");
diff --git a/include/deal.II/multigrid/mg_coarse.h b/include/deal.II/multigrid/mg_coarse.h
index 74a2a679c3..65a5eaffa5 100644
--- a/include/deal.II/multigrid/mg_coarse.h
+++ b/include/deal.II/multigrid/mg_coarse.h
@@ -32,7 +32,7 @@ DEAL_II_NAMESPACE_OPEN
  * transforming a triplet of iterative solver, matrix and preconditioner into
  * a coarse grid solver.
  *
- * The type of the matrix (i.e. the template parameter @p MATRIX) should be
+ * The type of the matrix (i.e. the template parameter @p MatrixType) should be
  * derived from @p Subscriptor to allow for the use of a smart pointer to it.
  *
  * @author Guido Kanschat, 1999, Ralf Hartmann, 2002.
@@ -50,9 +50,9 @@ public:
    * Constructor. Store solver, matrix and preconditioning method for later
    * use.
    */
-  template<class MATRIX, class PRECOND>
+  template<typename MatrixType, class PRECOND>
   MGCoarseGridLACIteration (SOLVER &,
-                            const MATRIX &,
+                            const MatrixType &,
                             const PRECOND &);
 
   /**
@@ -63,9 +63,9 @@ public:
   /**
    * Initialize new data.
    */
-  template<class MATRIX, class PRECOND>
+  template<typename MatrixType, class PRECOND>
   void initialize (SOLVER &,
-                   const MATRIX &,
+                   const MatrixType &,
                    const PRECOND &);
 
   /**
@@ -85,8 +85,8 @@ public:
    * Sets the matrix. This gives the possibility to replace the matrix that
    * was given to the constructor by a new matrix.
    */
-  template <class MATRIX>
-  void set_matrix (const MATRIX &);
+  template <typename MatrixType>
+  void set_matrix (const MatrixType &);
 
 private:
   /**
@@ -198,15 +198,15 @@ MGCoarseGridLACIteration<SOLVER, VectorType>
 
 
 template<class SOLVER, class VectorType>
-template<class MATRIX, class PRECOND>
+template<typename MatrixType, class PRECOND>
 MGCoarseGridLACIteration<SOLVER, VectorType>
-::MGCoarseGridLACIteration(SOLVER &s,
-                           const MATRIX  &m,
-                           const PRECOND &p)
+::MGCoarseGridLACIteration (SOLVER           &s,
+                            const MatrixType &m,
+                            const PRECOND    &p)
   :
   solver(&s, typeid(*this).name())
 {
-  matrix = new PointerMatrix<MATRIX, VectorType>(&m);
+  matrix = new PointerMatrix<MatrixType, VectorType>(&m);
   precondition = new PointerMatrix<PRECOND, VectorType>(&p);
 }
 
@@ -220,17 +220,17 @@ MGCoarseGridLACIteration<SOLVER, VectorType>
 
 
 template<class SOLVER, class VectorType>
-template<class MATRIX, class PRECOND>
+template<typename MatrixType, class PRECOND>
 void
 MGCoarseGridLACIteration<SOLVER, VectorType>
-::initialize(SOLVER &s,
-             const MATRIX  &m,
-             const PRECOND &p)
+::initialize (SOLVER           &s,
+              const MatrixType &m,
+              const PRECOND    &p)
 {
   solver = &s;
   if (matrix)
     delete matrix;
-  matrix = new PointerMatrix<MATRIX, VectorType>(&m);
+  matrix = new PointerMatrix<MatrixType, VectorType>(&m);
   if (precondition)
     delete precondition;
   precondition = new PointerMatrix<PRECOND, VectorType>(&p);
@@ -267,21 +267,21 @@ MGCoarseGridLACIteration<SOLVER, VectorType>
 
 
 template<class SOLVER, class VectorType>
-template<class MATRIX>
+template<typename MatrixType>
 void
 MGCoarseGridLACIteration<SOLVER, VectorType>
-::set_matrix(const MATRIX &m)
+::set_matrix(const MatrixType &m)
 {
   if (matrix)
     delete matrix;
-  matrix = new PointerMatrix<MATRIX, VectorType>(&m);
+  matrix = new PointerMatrix<MatrixType, VectorType>(&m);
 }
 
 //---------------------------------------------------------------------------
 
 template<typename number, class VectorType>
-MGCoarseGridHouseholder<number, VectorType>::MGCoarseGridHouseholder(
-  const FullMatrix<number> *A)
+MGCoarseGridHouseholder<number, VectorType>::MGCoarseGridHouseholder
+(const FullMatrix<number> *A)
 {
   if (A != 0) householder.initialize(*A);
 }
@@ -290,8 +290,7 @@ MGCoarseGridHouseholder<number, VectorType>::MGCoarseGridHouseholder(
 
 template<typename number, class VectorType>
 void
-MGCoarseGridHouseholder<number, VectorType>::initialize(
-  const FullMatrix<number> &A)
+MGCoarseGridHouseholder<number, VectorType>::initialize(const FullMatrix<number> &A)
 {
   householder.initialize(A);
 }
@@ -300,10 +299,9 @@ MGCoarseGridHouseholder<number, VectorType>::initialize(
 
 template<typename number, class VectorType>
 void
-MGCoarseGridHouseholder<number, VectorType>::operator() (
-  const unsigned int /*level*/,
-  VectorType         &dst,
-  const VectorType   &src) const
+MGCoarseGridHouseholder<number, VectorType>::operator() (const unsigned int /*level*/,
+                                                         VectorType         &dst,
+                                                         const VectorType   &src) const
 {
   householder.least_squares(dst, src);
 }
@@ -319,9 +317,8 @@ MGCoarseGridSVD<number, VectorType>::MGCoarseGridSVD()
 
 template<typename number, class VectorType>
 void
-MGCoarseGridSVD<number, VectorType>::initialize(
-  const FullMatrix<number> &A,
-  double threshold)
+MGCoarseGridSVD<number, VectorType>::initialize (const FullMatrix<number> &A,
+                                                 double                    threshold)
 {
   matrix.reinit(A.n_rows(), A.n_cols());
   matrix = A;
diff --git a/include/deal.II/multigrid/mg_matrix.h b/include/deal.II/multigrid/mg_matrix.h
index 51887c87d7..6301fbda9d 100644
--- a/include/deal.II/multigrid/mg_matrix.h
+++ b/include/deal.II/multigrid/mg_matrix.h
@@ -52,16 +52,16 @@ namespace mg
      * Constructor setting up pointers to the matrices in <tt>M</tt> by
      * calling initialize().
      */
-    template <class MATRIX>
-    Matrix(const MGLevelObject<MATRIX> &M);
+    template <typename MatrixType>
+    Matrix(const MGLevelObject<MatrixType> &M);
 
     /**
      * Initialize the object such that the level multiplication uses the
      * matrices in <tt>M</tt>
      */
-    template <class MATRIX>
+    template <typename MatrixType>
     void
-    initialize(const MGLevelObject<MATRIX> &M);
+    initialize(const MGLevelObject<MatrixType> &M);
 
     /**
      * Access matrix on a level.
@@ -86,7 +86,7 @@ namespace mg
 
 /**
  * Multilevel matrix selecting from block matrices. This class implements the
- * interface defined by MGMatrixBase.  The template parameter @p MATRIX should
+ * interface defined by MGMatrixBase.  The template parameter @p MatrixType should
  * be a block matrix class like BlockSparseMatrix or @p BlockSparseMatrixEZ.
  * Then, this class stores a pointer to a MGLevelObject of this matrix class.
  * In each @p vmult, the block selected on initialization will be multiplied
@@ -94,7 +94,7 @@ namespace mg
  *
  * @author Guido Kanschat, 2002
  */
-template <class MATRIX, typename number>
+template <typename MatrixType, typename number>
 class MGMatrixSelect : public MGMatrixBase<Vector<number> >
 {
 public:
@@ -102,15 +102,15 @@ public:
    * Constructor. @p row and @p col are the coordinate of the selected block.
    * The other argument is handed over to the @p SmartPointer constructor.
    */
-  MGMatrixSelect (const unsigned int row = 0,
-                  const unsigned int col = 0,
-                  MGLevelObject<MATRIX> *matrix = 0);
+  MGMatrixSelect (const unsigned int         row    = 0,
+                  const unsigned int         col    = 0,
+                  MGLevelObject<MatrixType> *matrix = 0);
 
   /**
    * Set the matrix object to be used. The matrix object must exist longer as
    * the @p MGMatrix object, since only a pointer is stored.
    */
-  void set_matrix (MGLevelObject<MATRIX> *M);
+  void set_matrix (MGLevelObject<MatrixType> *M);
 
   /**
    * Select the block for multiplication.
@@ -150,7 +150,7 @@ private:
   /**
    * Pointer to the matrix objects on each level.
    */
-  SmartPointer<MGLevelObject<MATRIX>,MGMatrixSelect<MATRIX,number> > matrix;
+  SmartPointer<MGLevelObject<MatrixType>,MGMatrixSelect<MatrixType,number> > matrix;
   /**
    * Row coordinate of selected block.
    */
@@ -169,10 +169,10 @@ private:
 namespace mg
 {
   template <typename VectorType>
-  template <class MATRIX>
+  template <typename MatrixType>
   inline
   void
-  Matrix<VectorType>::initialize (const MGLevelObject<MATRIX> &p)
+  Matrix<VectorType>::initialize (const MGLevelObject<MatrixType> &p)
   {
     matrices.resize(p.min_level(), p.max_level());
     for (unsigned int level=p.min_level(); level <= p.max_level(); ++level)
@@ -182,9 +182,9 @@ namespace mg
 
 
   template <typename VectorType>
-  template <class MATRIX>
+  template <typename MatrixType>
   inline
-  Matrix<VectorType>::Matrix (const MGLevelObject<MATRIX> &p)
+  Matrix<VectorType>::Matrix (const MGLevelObject<MatrixType> &p)
   {
     initialize(p);
   }
@@ -257,11 +257,11 @@ namespace mg
 
 /*----------------------------------------------------------------------*/
 
-template <class MATRIX, typename number>
-MGMatrixSelect<MATRIX, number>::
-MGMatrixSelect (const unsigned int row,
-                const unsigned int col,
-                MGLevelObject<MATRIX> *p)
+template <typename MatrixType, typename number>
+MGMatrixSelect<MatrixType, number>::
+MGMatrixSelect (const unsigned int         row,
+                const unsigned int         col,
+                MGLevelObject<MatrixType> *p)
   :
   matrix (p, typeid(*this).name()),
   row(row),
@@ -270,17 +270,17 @@ MGMatrixSelect (const unsigned int row,
 
 
 
-template <class MATRIX, typename number>
+template <typename MatrixType, typename number>
 void
-MGMatrixSelect<MATRIX, number>::set_matrix (MGLevelObject<MATRIX> *p)
+MGMatrixSelect<MatrixType, number>::set_matrix (MGLevelObject<MatrixType> *p)
 {
   matrix = p;
 }
 
 
-template <class MATRIX, typename number>
+template <typename MatrixType, typename number>
 void
-MGMatrixSelect<MATRIX, number>::
+MGMatrixSelect<MatrixType, number>::
 select_block (const unsigned int brow,
               const unsigned int bcol)
 {
@@ -289,58 +289,58 @@ select_block (const unsigned int brow,
 }
 
 
-template <class MATRIX, typename number>
+template <typename MatrixType, typename number>
 void
-MGMatrixSelect<MATRIX, number>::
-vmult  (const unsigned int level,
-        Vector<number> &dst,
+MGMatrixSelect<MatrixType, number>::
+vmult  (const unsigned int    level,
+        Vector<number>       &dst,
         const Vector<number> &src) const
 {
   Assert(matrix != 0, ExcNotInitialized());
 
-  const MGLevelObject<MATRIX> &m = *matrix;
+  const MGLevelObject<MatrixType> &m = *matrix;
   m[level].block(row, col).vmult(dst, src);
 }
 
 
-template <class MATRIX, typename number>
+template <typename MatrixType, typename number>
 void
-MGMatrixSelect<MATRIX, number>::
-vmult_add  (const unsigned int level,
-            Vector<number> &dst,
+MGMatrixSelect<MatrixType, number>::
+vmult_add  (const unsigned int    level,
+            Vector<number>       &dst,
             const Vector<number> &src) const
 {
   Assert(matrix != 0, ExcNotInitialized());
 
-  const MGLevelObject<MATRIX> &m = *matrix;
+  const MGLevelObject<MatrixType> &m = *matrix;
   m[level].block(row, col).vmult_add(dst, src);
 }
 
 
-template <class MATRIX, typename number>
+template <typename MatrixType, typename number>
 void
-MGMatrixSelect<MATRIX, number>::
-Tvmult  (const unsigned int level,
-         Vector<number> &dst,
+MGMatrixSelect<MatrixType, number>::
+Tvmult  (const unsigned int    level,
+         Vector<number>       &dst,
          const Vector<number> &src) const
 {
   Assert(matrix != 0, ExcNotInitialized());
 
-  const MGLevelObject<MATRIX> &m = *matrix;
+  const MGLevelObject<MatrixType> &m = *matrix;
   m[level].block(row, col).Tvmult(dst, src);
 }
 
 
-template <class MATRIX, typename number>
+template <typename MatrixType, typename number>
 void
-MGMatrixSelect<MATRIX, number>::
-Tvmult_add  (const unsigned int level,
-             Vector<number> &dst,
+MGMatrixSelect<MatrixType, number>::
+Tvmult_add  (const unsigned int    level,
+             Vector<number>       &dst,
              const Vector<number> &src) const
 {
   Assert(matrix != 0, ExcNotInitialized());
 
-  const MGLevelObject<MATRIX> &m = *matrix;
+  const MGLevelObject<MatrixType> &m = *matrix;
   m[level].block(row, col).Tvmult_add(dst, src);
 }
 
diff --git a/include/deal.II/multigrid/mg_smoother.h b/include/deal.II/multigrid/mg_smoother.h
index 96dcd81dc1..4d999ea068 100644
--- a/include/deal.II/multigrid/mg_smoother.h
+++ b/include/deal.II/multigrid/mg_smoother.h
@@ -199,8 +199,8 @@ namespace mg
      * @p additional_data is an object of type @p RELAX::AdditionalData and is
      * handed to the initialization function of the relaxation method.
      */
-    template <class MATRIX2>
-    void initialize (const MGLevelObject<MATRIX2> &matrices,
+    template <typename MatrixType2>
+    void initialize (const MGLevelObject<MatrixType2>     &matrices,
                      const typename RELAX::AdditionalData &additional_data = typename RELAX::AdditionalData());
 
     /**
@@ -210,9 +210,9 @@ namespace mg
      * common range is utilized. This way, smoothing can be restricted to
      * certain levels even if the matrix was generated for all levels.
      */
-    template <class MATRIX2, class DATA>
-    void initialize (const MGLevelObject<MATRIX2> &matrices,
-                     const MGLevelObject<DATA> &additional_data);
+    template <typename MatrixType2, class DATA>
+    void initialize (const MGLevelObject<MatrixType2> &matrices,
+                     const MGLevelObject<DATA>        &additional_data);
 
     /**
      * Empty all vectors.
@@ -270,7 +270,7 @@ namespace mg
  *
  * @author Guido Kanschat, 2003
  */
-template<class MATRIX, class RELAX, typename VectorType>
+template<typename MatrixType, class RELAX, typename VectorType>
 class MGSmootherRelaxation : public MGSmoother<VectorType>
 {
 public:
@@ -290,8 +290,8 @@ public:
    * @p additional_data is an object of type @p RELAX::AdditionalData and is
    * handed to the initialization function of the relaxation method.
    */
-  template <class MATRIX2>
-  void initialize (const MGLevelObject<MATRIX2> &matrices,
+  template <typename MatrixType2>
+  void initialize (const MGLevelObject<MatrixType2>     &matrices,
                    const typename RELAX::AdditionalData &additional_data = typename RELAX::AdditionalData());
 
   /**
@@ -302,9 +302,9 @@ public:
    * @p additional_data is an object of type @p RELAX::AdditionalData and is
    * handed to the initialization function of the relaxation method.
    */
-  template <class MATRIX2, class DATA>
-  void initialize (const MGLevelObject<MATRIX2> &matrices,
-                   const MGLevelObject<DATA> &additional_data);
+  template <typename MatrixType2, class DATA>
+  void initialize (const MGLevelObject<MatrixType2> &matrices,
+                   const MGLevelObject<DATA>        &additional_data);
 
   /**
    * Initialize for single blocks of matrices. Of this block matrix, the block
@@ -315,11 +315,11 @@ public:
    * @p additional_data is an object of type @p RELAX::AdditionalData and is
    * handed to the initialization function of the relaxation method.
    */
-  template <class MATRIX2, class DATA>
-  void initialize (const MGLevelObject<MATRIX2> &matrices,
-                   const DATA &additional_data,
-                   const unsigned int block_row,
-                   const unsigned int block_col);
+  template <typename MatrixType2, class DATA>
+  void initialize (const MGLevelObject<MatrixType2> &matrices,
+                   const DATA                       &additional_data,
+                   const unsigned int                block_row,
+                   const unsigned int                block_col);
 
   /**
    * Initialize for single blocks of matrices. Of this block matrix, the block
@@ -330,11 +330,11 @@ public:
    * @p additional_data is an object of type @p RELAX::AdditionalData and is
    * handed to the initialization function of the relaxation method.
    */
-  template <class MATRIX2, class DATA>
-  void initialize (const MGLevelObject<MATRIX2> &matrices,
-                   const MGLevelObject<DATA> &additional_data,
-                   const unsigned int block_row,
-                   const unsigned int block_col);
+  template <typename MatrixType2, class DATA>
+  void initialize (const MGLevelObject<MatrixType2> &matrices,
+                   const MGLevelObject<DATA>        &additional_data,
+                   const unsigned int                block_row,
+                   const unsigned int                block_col);
 
   /**
    * Empty all vectors.
@@ -363,7 +363,7 @@ private:
   /**
    * Pointer to the matrices.
    */
-  MGLevelObject<PointerMatrix<MATRIX, VectorType> > matrices;
+  MGLevelObject<PointerMatrix<MatrixType, VectorType> > matrices;
 
 };
 
@@ -399,7 +399,7 @@ private:
  *
  * @author Guido Kanschat, 2009
  */
-template<class MATRIX, class PRECONDITIONER, typename VectorType>
+template<typename MatrixType, class PRECONDITIONER, typename VectorType>
 class MGSmootherPrecondition : public MGSmoother<VectorType>
 {
 public:
@@ -419,8 +419,8 @@ public:
    * @p additional_data is an object of type @p PRECONDITIONER::AdditionalData
    * and is handed to the initialization function of the relaxation method.
    */
-  template <class MATRIX2>
-  void initialize (const MGLevelObject<MATRIX2> &matrices,
+  template <typename MatrixType2>
+  void initialize (const MGLevelObject<MatrixType2> &matrices,
                    const typename PRECONDITIONER::AdditionalData &additional_data = typename PRECONDITIONER::AdditionalData());
 
   /**
@@ -431,9 +431,9 @@ public:
    * @p additional_data is an object of type @p PRECONDITIONER::AdditionalData
    * and is handed to the initialization function of the relaxation method.
    */
-  template <class MATRIX2, class DATA>
-  void initialize (const MGLevelObject<MATRIX2> &matrices,
-                   const MGLevelObject<DATA> &additional_data);
+  template <typename MatrixType2, class DATA>
+  void initialize (const MGLevelObject<MatrixType2> &matrices,
+                   const MGLevelObject<DATA>        &additional_data);
 
   /**
    * Initialize for single blocks of matrices. Of this block matrix, the block
@@ -444,11 +444,11 @@ public:
    * @p additional_data is an object of type @p PRECONDITIONER::AdditionalData
    * and is handed to the initialization function of the relaxation method.
    */
-  template <class MATRIX2, class DATA>
-  void initialize (const MGLevelObject<MATRIX2> &matrices,
-                   const DATA &additional_data,
-                   const unsigned int block_row,
-                   const unsigned int block_col);
+  template <typename MatrixType2, class DATA>
+  void initialize (const MGLevelObject<MatrixType2> &matrices,
+                   const DATA                       &additional_data,
+                   const unsigned int                block_row,
+                   const unsigned int                block_col);
 
   /**
    * Initialize for single blocks of matrices. Of this block matrix, the block
@@ -459,11 +459,11 @@ public:
    * @p additional_data is an object of type @p PRECONDITIONER::AdditionalData
    * and is handed to the initialization function of the relaxation method.
    */
-  template <class MATRIX2, class DATA>
-  void initialize (const MGLevelObject<MATRIX2> &matrices,
-                   const MGLevelObject<DATA> &additional_data,
-                   const unsigned int block_row,
-                   const unsigned int block_col);
+  template <typename MatrixType2, class DATA>
+  void initialize (const MGLevelObject<MatrixType2> &matrices,
+                   const MGLevelObject<DATA>        &additional_data,
+                   const unsigned int                block_row,
+                   const unsigned int                block_col);
 
   /**
    * Empty all vectors.
@@ -492,7 +492,7 @@ private:
   /**
    * Pointer to the matrices.
    */
-  MGLevelObject<PointerMatrix<MATRIX, VectorType> > matrices;
+  MGLevelObject<PointerMatrix<MatrixType, VectorType> > matrices;
 
 };
 
@@ -518,11 +518,10 @@ MGSmootherIdentity<VectorType>::clear ()
 
 template <typename VectorType>
 inline
-MGSmoother<VectorType>::MGSmoother(
-  const unsigned int steps,
-  const bool variable,
-  const bool symmetric,
-  const bool transpose)
+MGSmoother<VectorType>::MGSmoother (const unsigned int steps,
+                                    const bool         variable,
+                                    const bool         symmetric,
+                                    const bool         transpose)
   :
   steps(steps),
   variable(variable),
@@ -577,11 +576,11 @@ namespace mg
 {
   template <class RELAX, typename VectorType>
   inline
-  SmootherRelaxation<RELAX, VectorType>::SmootherRelaxation(
-    const unsigned int steps,
-    const bool variable,
-    const bool symmetric,
-    const bool transpose)
+  SmootherRelaxation<RELAX, VectorType>::SmootherRelaxation
+  (const unsigned int steps,
+   const bool         variable,
+   const bool         symmetric,
+   const bool         transpose)
     : MGSmoother<VectorType>(steps, variable, symmetric, transpose)
   {}
 
@@ -595,11 +594,11 @@ namespace mg
 
 
   template <class RELAX, typename VectorType>
-  template <class MATRIX2>
+  template <typename MatrixType2>
   inline void
-  SmootherRelaxation<RELAX, VectorType>::initialize (
-    const MGLevelObject<MATRIX2> &m,
-    const typename RELAX::AdditionalData &data)
+  SmootherRelaxation<RELAX, VectorType>::initialize
+  (const MGLevelObject<MatrixType2>     &m,
+   const typename RELAX::AdditionalData &data)
   {
     const unsigned int min = m.min_level();
     const unsigned int max = m.max_level();
@@ -612,11 +611,11 @@ namespace mg
 
 
   template <class RELAX, typename VectorType>
-  template <class MATRIX2, class DATA>
+  template <typename MatrixType2, class DATA>
   inline void
-  SmootherRelaxation<RELAX, VectorType>::initialize (
-    const MGLevelObject<MATRIX2> &m,
-    const MGLevelObject<DATA> &data)
+  SmootherRelaxation<RELAX, VectorType>::initialize
+  (const MGLevelObject<MatrixType2> &m,
+   const MGLevelObject<DATA>        &data)
   {
     const unsigned int min = std::max(m.min_level(), data.min_level());
     const unsigned int max = std::min(m.max_level(), data.max_level());
@@ -674,22 +673,22 @@ namespace mg
 
 //----------------------------------------------------------------------//
 
-template <class MATRIX, class RELAX, typename VectorType>
+template <typename MatrixType, class RELAX, typename VectorType>
 inline
-MGSmootherRelaxation<MATRIX, RELAX, VectorType>::MGSmootherRelaxation(
-  const unsigned int steps,
-  const bool variable,
-  const bool symmetric,
-  const bool transpose)
+MGSmootherRelaxation<MatrixType, RELAX, VectorType>::MGSmootherRelaxation
+(const unsigned int steps,
+ const bool         variable,
+ const bool         symmetric,
+ const bool         transpose)
   :
   MGSmoother<VectorType>(steps, variable, symmetric, transpose)
 {}
 
 
 
-template <class MATRIX, class RELAX, typename VectorType>
+template <typename MatrixType, class RELAX, typename VectorType>
 inline void
-MGSmootherRelaxation<MATRIX, RELAX, VectorType>::clear ()
+MGSmootherRelaxation<MatrixType, RELAX, VectorType>::clear ()
 {
   smoothers.clear();
 
@@ -700,12 +699,12 @@ MGSmootherRelaxation<MATRIX, RELAX, VectorType>::clear ()
 }
 
 
-template <class MATRIX, class RELAX, typename VectorType>
-template <class MATRIX2>
+template <typename MatrixType, class RELAX, typename VectorType>
+template <typename MatrixType2>
 inline void
-MGSmootherRelaxation<MATRIX, RELAX, VectorType>::initialize (
-  const MGLevelObject<MATRIX2> &m,
-  const typename RELAX::AdditionalData &data)
+MGSmootherRelaxation<MatrixType, RELAX, VectorType>::initialize
+(const MGLevelObject<MatrixType2>     &m,
+ const typename RELAX::AdditionalData &data)
 {
   const unsigned int min = m.min_level();
   const unsigned int max = m.max_level();
@@ -720,12 +719,12 @@ MGSmootherRelaxation<MATRIX, RELAX, VectorType>::initialize (
     }
 }
 
-template <class MATRIX, class RELAX, typename VectorType>
-template <class MATRIX2, class DATA>
+template <typename MatrixType, class RELAX, typename VectorType>
+template <typename MatrixType2, class DATA>
 inline void
-MGSmootherRelaxation<MATRIX, RELAX, VectorType>::initialize (
-  const MGLevelObject<MATRIX2> &m,
-  const MGLevelObject<DATA> &data)
+MGSmootherRelaxation<MatrixType, RELAX, VectorType>::initialize
+(const MGLevelObject<MatrixType2> &m,
+ const MGLevelObject<DATA>        &data)
 {
   const unsigned int min = m.min_level();
   const unsigned int max = m.max_level();
@@ -745,14 +744,14 @@ MGSmootherRelaxation<MATRIX, RELAX, VectorType>::initialize (
     }
 }
 
-template <class MATRIX, class RELAX, typename VectorType>
-template <class MATRIX2, class DATA>
+template <typename MatrixType, class RELAX, typename VectorType>
+template <typename MatrixType2, class DATA>
 inline void
-MGSmootherRelaxation<MATRIX, RELAX, VectorType>::initialize (
-  const MGLevelObject<MATRIX2> &m,
-  const DATA &data,
-  const unsigned int row,
-  const unsigned int col)
+MGSmootherRelaxation<MatrixType, RELAX, VectorType>::initialize
+(const MGLevelObject<MatrixType2> &m,
+ const DATA                       &data,
+ const unsigned int                row,
+ const unsigned int                col)
 {
   const unsigned int min = m.min_level();
   const unsigned int max = m.max_level();
@@ -767,14 +766,14 @@ MGSmootherRelaxation<MATRIX, RELAX, VectorType>::initialize (
     }
 }
 
-template <class MATRIX, class RELAX, typename VectorType>
-template <class MATRIX2, class DATA>
+template <typename MatrixType, class RELAX, typename VectorType>
+template <typename MatrixType2, class DATA>
 inline void
-MGSmootherRelaxation<MATRIX, RELAX, VectorType>::initialize (
-  const MGLevelObject<MATRIX2> &m,
-  const MGLevelObject<DATA> &data,
-  const unsigned int row,
-  const unsigned int col)
+MGSmootherRelaxation<MatrixType, RELAX, VectorType>::initialize
+(const MGLevelObject<MatrixType2> &m,
+ const MGLevelObject<DATA>        &data,
+ const unsigned int                row,
+ const unsigned int                col)
 {
   const unsigned int min = m.min_level();
   const unsigned int max = m.max_level();
@@ -795,11 +794,11 @@ MGSmootherRelaxation<MATRIX, RELAX, VectorType>::initialize (
 }
 
 
-template <class MATRIX, class RELAX, typename VectorType>
+template <typename MatrixType, class RELAX, typename VectorType>
 inline void
-MGSmootherRelaxation<MATRIX, RELAX, VectorType>::smooth (const unsigned int level,
-                                                         VectorType         &u,
-                                                         const VectorType   &rhs) const
+MGSmootherRelaxation<MatrixType, RELAX, VectorType>::smooth (const unsigned int  level,
+                                                             VectorType         &u,
+                                                             const VectorType   &rhs) const
 {
   unsigned int maxlevel = smoothers.max_level();
   unsigned int steps2 = this->steps;
@@ -826,10 +825,10 @@ MGSmootherRelaxation<MATRIX, RELAX, VectorType>::smooth (const unsigned int leve
 
 
 
-template <class MATRIX, class RELAX, typename VectorType>
+template <typename MatrixType, class RELAX, typename VectorType>
 inline
 std::size_t
-MGSmootherRelaxation<MATRIX, RELAX, VectorType>::
+MGSmootherRelaxation<MatrixType, RELAX, VectorType>::
 memory_consumption () const
 {
   return sizeof(*this)
@@ -841,22 +840,22 @@ memory_consumption () const
 
 //----------------------------------------------------------------------//
 
-template <class MATRIX, class PRECONDITIONER, typename VectorType>
+template <typename MatrixType, class PRECONDITIONER, typename VectorType>
 inline
-MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::MGSmootherPrecondition(
-  const unsigned int steps,
-  const bool variable,
-  const bool symmetric,
-  const bool transpose)
+MGSmootherPrecondition<MatrixType, PRECONDITIONER, VectorType>::MGSmootherPrecondition
+(const unsigned int steps,
+ const bool         variable,
+ const bool         symmetric,
+ const bool         transpose)
   :
   MGSmoother<VectorType>(steps, variable, symmetric, transpose)
 {}
 
 
 
-template <class MATRIX, class PRECONDITIONER, typename VectorType>
+template <typename MatrixType, class PRECONDITIONER, typename VectorType>
 inline void
-MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::clear ()
+MGSmootherPrecondition<MatrixType, PRECONDITIONER, VectorType>::clear ()
 {
   smoothers.clear();
 
@@ -868,12 +867,12 @@ MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::clear ()
 
 
 
-template <class MATRIX, class PRECONDITIONER, typename VectorType>
-template <class MATRIX2>
+template <typename MatrixType, class PRECONDITIONER, typename VectorType>
+template <typename MatrixType2>
 inline void
-MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::initialize (
-  const MGLevelObject<MATRIX2> &m,
-  const typename PRECONDITIONER::AdditionalData &data)
+MGSmootherPrecondition<MatrixType, PRECONDITIONER, VectorType>::initialize
+(const MGLevelObject<MatrixType2>              &m,
+ const typename PRECONDITIONER::AdditionalData &data)
 {
   const unsigned int min = m.min_level();
   const unsigned int max = m.max_level();
@@ -890,12 +889,12 @@ MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::initialize (
 
 
 
-template <class MATRIX, class PRECONDITIONER, typename VectorType>
-template <class MATRIX2, class DATA>
+template <typename MatrixType, class PRECONDITIONER, typename VectorType>
+template <typename MatrixType2, class DATA>
 inline void
-MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::initialize (
-  const MGLevelObject<MATRIX2> &m,
-  const MGLevelObject<DATA> &data)
+MGSmootherPrecondition<MatrixType, PRECONDITIONER, VectorType>::initialize
+(const MGLevelObject<MatrixType2> &m,
+ const MGLevelObject<DATA>        &data)
 {
   const unsigned int min = m.min_level();
   const unsigned int max = m.max_level();
@@ -917,14 +916,14 @@ MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::initialize (
 
 
 
-template <class MATRIX, class PRECONDITIONER, typename VectorType>
-template <class MATRIX2, class DATA>
+template <typename MatrixType, class PRECONDITIONER, typename VectorType>
+template <typename MatrixType2, class DATA>
 inline void
-MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::initialize (
-  const MGLevelObject<MATRIX2> &m,
-  const DATA &data,
-  const unsigned int row,
-  const unsigned int col)
+MGSmootherPrecondition<MatrixType, PRECONDITIONER, VectorType>::initialize
+(const MGLevelObject<MatrixType2> &m,
+ const DATA                       &data,
+ const unsigned int                row,
+ const unsigned int                col)
 {
   const unsigned int min = m.min_level();
   const unsigned int max = m.max_level();
@@ -941,14 +940,14 @@ MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::initialize (
 
 
 
-template <class MATRIX, class PRECONDITIONER, typename VectorType>
-template <class MATRIX2, class DATA>
+template <typename MatrixType, class PRECONDITIONER, typename VectorType>
+template <typename MatrixType2, class DATA>
 inline void
-MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::initialize (
-  const MGLevelObject<MATRIX2> &m,
-  const MGLevelObject<DATA> &data,
-  const unsigned int row,
-  const unsigned int col)
+MGSmootherPrecondition<MatrixType, PRECONDITIONER, VectorType>::initialize
+(const MGLevelObject<MatrixType2> &m,
+ const MGLevelObject<DATA>        &data,
+ const unsigned int                row,
+ const unsigned int                col)
 {
   const unsigned int min = m.min_level();
   const unsigned int max = m.max_level();
@@ -970,9 +969,9 @@ MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::initialize (
 
 
 
-template <class MATRIX, class PRECONDITIONER, typename VectorType>
+template <typename MatrixType, class PRECONDITIONER, typename VectorType>
 inline void
-MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::smooth
+MGSmootherPrecondition<MatrixType, PRECONDITIONER, VectorType>::smooth
 (const unsigned int level,
  VectorType         &u,
  const VectorType   &rhs) const
@@ -1041,10 +1040,10 @@ MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::smooth
 
 
 
-template <class MATRIX, class PRECONDITIONER, typename VectorType>
+template <typename MatrixType, class PRECONDITIONER, typename VectorType>
 inline
 std::size_t
-MGSmootherPrecondition<MATRIX, PRECONDITIONER, VectorType>::
+MGSmootherPrecondition<MatrixType, PRECONDITIONER, VectorType>::
 memory_consumption () const
 {
   return sizeof(*this)
-- 
2.39.5