From: David Wells <wellsd2@rpi.edu>
Date: Mon, 23 Nov 2015 00:41:27 +0000 (-0500)
Subject: Prefer DoFHandlerType to DH.
X-Git-Tag: v8.4.0-rc2~189^2~1
X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=873748f2b9268ccc577e3885234bb8343d5a1be8;p=dealii.git

Prefer DoFHandlerType to DH.
---

diff --git a/doc/doxygen/headers/iterators.h b/doc/doxygen/headers/iterators.h
index d8a27561e3..d6a0d6e25a 100644
--- a/doc/doxygen/headers/iterators.h
+++ b/doc/doxygen/headers/iterators.h
@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------
 //
-// Copyright (C) 2013, 2014 by the deal.II authors
+// Copyright (C) 2013, 2015 by the deal.II authors
 //
 // This file is part of the deal.II library.
 //
@@ -397,9 +397,9 @@ stated in the
   internal::Triangulation::Iterators<3,spacedim> classes for Triangulation
   iterators,
 
-- internal::DoFHandler::Iterators<DH<1,spacedim> >,
-  internal::DoFHandler::Iterators<DH<2,spacedim> >, and
-  internal::DoFHandler::Iterators<DH<3,spacedim> > classes for DoFHandler
+- internal::DoFHandler::Iterators<DoFHandlerType<1,spacedim> >,
+  internal::DoFHandler::Iterators<DoFHandlerType<2,spacedim> >, and
+  internal::DoFHandler::Iterators<DoFHandlerType<3,spacedim> > classes for DoFHandler
   and hp::DoFHandler iterators,
 
 
diff --git a/include/deal.II/distributed/solution_transfer.h b/include/deal.II/distributed/solution_transfer.h
index 407fab5483..c87db10408 100644
--- a/include/deal.II/distributed/solution_transfer.h
+++ b/include/deal.II/distributed/solution_transfer.h
@@ -112,14 +112,14 @@ namespace parallel
      * @ingroup distributed
      * @author Timo Heister, 2009-2011
      */
-    template<int dim, typename VectorType, class DH=DoFHandler<dim> >
+    template<int dim, typename VectorType, typename DoFHandlerType=DoFHandler<dim> >
     class SolutionTransfer
     {
     public:
       /**
        * Constructor, takes the current DoFHandler as argument.
        */
-      SolutionTransfer(const DH &dof);
+      SolutionTransfer(const DoFHandlerType &dof);
       /**
        * Destructor.
        */
@@ -200,7 +200,7 @@ namespace parallel
       /**
        * Pointer to the degree of freedom handler to work with.
        */
-      SmartPointer<const DH,SolutionTransfer<dim,VectorType,DH> > dof_handler;
+      SmartPointer<const DoFHandlerType,SolutionTransfer<dim,VectorType,DoFHandlerType> > dof_handler;
 
       /**
        * A vector that stores pointers to all the vectors we are supposed to
diff --git a/include/deal.II/dofs/dof_accessor.h b/include/deal.II/dofs/dof_accessor.h
index 07ed50a94b..a4acb25b5d 100644
--- a/include/deal.II/dofs/dof_accessor.h
+++ b/include/deal.II/dofs/dof_accessor.h
@@ -181,8 +181,8 @@ namespace internal
  * @author Wolfgang Bangerth, 1998, 2006, 2008, Timo Heister, Guido Kanschat,
  * 2012, 2013
  */
-template <int structdim, class DH, bool level_dof_access>
-class DoFAccessor : public dealii::internal::DoFAccessor::Inheritance<structdim, DH::dimension, DH::space_dimension>::BaseClass
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
+class DoFAccessor : public dealii::internal::DoFAccessor::Inheritance<structdim, DoFHandlerType::dimension, DoFHandlerType::space_dimension>::BaseClass
 {
 public:
 
@@ -190,13 +190,13 @@ public:
    * A static variable that allows users of this class to discover the value
    * of the second template argument.
    */
-  static const unsigned int dimension=DH::dimension;
+  static const unsigned int dimension=DoFHandlerType::dimension;
 
   /**
    * A static variable that allows users of this class to discover the value
    * of the third template argument.
    */
-  static const unsigned int space_dimension=DH::space_dimension;
+  static const unsigned int space_dimension=DoFHandlerType::space_dimension;
 
   /**
    * Declare a typedef to the base class to make accessing some of the
@@ -209,7 +209,7 @@ public:
   /**
    * Data type passed by the iterator class.
    */
-  typedef DH AccessorData;
+  typedef DoFHandlerType AccessorData;
 
   /**
    * @name Constructors
@@ -226,10 +226,10 @@ public:
   /**
    * Constructor
    */
-  DoFAccessor (const Triangulation<DH::dimension,DH::space_dimension> *tria,
-               const int                 level,
-               const int                 index,
-               const DH                 *local_data);
+  DoFAccessor (const Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> *tria,
+               const int             level,
+               const int             index,
+               const DoFHandlerType *local_data);
 
   /**
    * Conversion constructor. This constructor exists to make certain
@@ -250,14 +250,14 @@ public:
    * Another conversion operator between objects that don't make sense, just
    * like the previous one.
    */
-  template <int dim2, class DH2, bool level_dof_access2>
-  DoFAccessor (const DoFAccessor<dim2, DH2, level_dof_access2> &);
+  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+  DoFAccessor (const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &);
 
   /**
    * Copy constructor allowing to switch level access and active access.
    */
   template <bool level_dof_access2>
-  DoFAccessor(const DoFAccessor<structdim, DH, level_dof_access2> &);
+  DoFAccessor(const DoFAccessor<structdim, DoFHandlerType, level_dof_access2> &);
   /**
    * @}
    */
@@ -265,20 +265,20 @@ public:
   /**
    * Return a handle on the DoFHandler object which we are using.
    */
-  const DH &
+  const DoFHandlerType &
   get_dof_handler () const;
 
   /**
    * Implement the copy operator needed for the iterator classes.
    */
   template <bool level_dof_access2>
-  void copy_from (const DoFAccessor<structdim, DH, level_dof_access2> &a);
+  void copy_from (const DoFAccessor<structdim, DoFHandlerType, level_dof_access2> &a);
 
   /**
    * Copy operator used by the iterator class. Keeps the previously set dof
    * handler, but sets the object coordinates of the TriaAccessor.
    */
-  void copy_from (const TriaAccessorBase<structdim, DH::dimension, DH::space_dimension> &da);
+  void copy_from (const TriaAccessorBase<structdim, DoFHandlerType::dimension, DoFHandlerType::space_dimension> &da);
 
   /**
    * Tell the caller whether get_active_or_mg_dof_indices() accesses active or
@@ -296,7 +296,7 @@ public:
   /**
    * Return an iterator pointing to the @p c-th child.
    */
-  TriaIterator<DoFAccessor<structdim,DH, level_dof_access> >
+  TriaIterator<DoFAccessor<structdim,DoFHandlerType, level_dof_access> >
   child (const unsigned int c) const;
 
   /**
@@ -304,7 +304,7 @@ public:
    * a line itself, then the only valid index is @p i equals to zero, and the
    * function returns an iterator to itself.
    */
-  typename dealii::internal::DoFHandler::Iterators<DH, level_dof_access>::line_iterator
+  typename dealii::internal::DoFHandler::Iterators<DoFHandlerType, level_dof_access>::line_iterator
   line (const unsigned int i) const;
 
   /**
@@ -312,7 +312,7 @@ public:
    * a quad itself, then the only valid index is @p i equals to zero, and the
    * function returns an iterator to itself.
    */
-  typename dealii::internal::DoFHandler::Iterators<DH, level_dof_access>::quad_iterator
+  typename dealii::internal::DoFHandler::Iterators<DoFHandlerType, level_dof_access>::quad_iterator
   quad (const unsigned int i) const;
 
   /**
@@ -361,7 +361,7 @@ public:
    *
    */
   void get_dof_indices (std::vector<types::global_dof_index> &dof_indices,
-                        const unsigned int fe_index = DH::default_fe_index) const;
+                        const unsigned int fe_index = DoFHandlerType::default_fe_index) const;
 
   /**
    * Return the global multilevel indices of the degrees of freedom that live
@@ -371,14 +371,14 @@ public:
    */
   void get_mg_dof_indices (const int level,
                            std::vector<types::global_dof_index> &dof_indices,
-                           const unsigned int fe_index = DH::default_fe_index) const;
+                           const unsigned int fe_index = DoFHandlerType::default_fe_index) const;
 
   /**
    * Sets the level DoF indices that are returned by get_mg_dof_indices.
    */
   void set_mg_dof_indices (const int level,
                            const std::vector<types::global_dof_index> &dof_indices,
-                           const unsigned int fe_index = DH::default_fe_index);
+                           const unsigned int fe_index = DoFHandlerType::default_fe_index);
 
   /**
    * Global DoF index of the <i>i</i> degree associated with the @p vertexth
@@ -397,19 +397,21 @@ public:
    * a cell object, there can only be a single set of degrees of freedom, and
    * fe_index has to match the result of active_fe_index().
    */
-  types::global_dof_index vertex_dof_index (const unsigned int vertex,
-                                            const unsigned int i,
-                                            const unsigned int fe_index = DH::default_fe_index) const;
+  types::global_dof_index vertex_dof_index
+  (const unsigned int vertex,
+   const unsigned int i,
+   const unsigned int fe_index = DoFHandlerType::default_fe_index) const;
 
   /**
    * Returns the global DoF index of the <code>i</code>th degree of freedom
    * associated with the <code>vertex</code>th vertex on level @p level. Also
    * see vertex_dof_index().
    */
-  types::global_dof_index mg_vertex_dof_index (const int level,
-                                               const unsigned int vertex,
-                                               const unsigned int i,
-                                               const unsigned int fe_index = DH::default_fe_index) const;
+  types::global_dof_index mg_vertex_dof_index
+  (const int level,
+   const unsigned int vertex,
+   const unsigned int i,
+   const unsigned int fe_index = DoFHandlerType::default_fe_index) const;
 
   /**
    * Index of the <i>i</i>th degree of freedom of this object.
@@ -438,8 +440,9 @@ public:
    * produce an exception because no degrees are defined in the interior of
    * the face.
    */
-  types::global_dof_index dof_index (const unsigned int i,
-                                     const unsigned int fe_index = DH::default_fe_index) const;
+  types::global_dof_index dof_index
+  (const unsigned int i,
+   const unsigned int fe_index = DoFHandlerType::default_fe_index) const;
 
   /**
    * Returns the dof_index on the given level. Also see dof_index.
@@ -496,7 +499,7 @@ public:
    * given @p fe_index. @p fe_index must be used on this object, i.e.
    * <code>fe_index_is_active(fe_index)</code> must return true.
    */
-  const FiniteElement<DH::dimension,DH::space_dimension> &
+  const FiniteElement<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &
   get_fe (const unsigned int fe_index) const;
 
   /**
@@ -547,7 +550,7 @@ protected:
   /**
    * Store the address of the DoFHandler object to be accessed.
    */
-  DH *dof_handler;
+  DoFHandlerType *dof_handler;
 public:
   /**
    * Compare for equality. Return <tt>true</tt> if the two accessors refer to
@@ -562,19 +565,19 @@ public:
    * an iterator with level access can be equal to one with access to the
    * active degrees of freedom.
    */
-  template <int dim2, class DH2, bool level_dof_access2>
-  bool operator == (const DoFAccessor<dim2,DH2,level_dof_access2> &) const;
+  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+  bool operator == (const DoFAccessor<dim2,DoFHandlerType2,level_dof_access2> &) const;
 
   /**
    * Compare for inequality. The boolean not of operator==().
    */
-  template <int dim2, class DH2, bool level_dof_access2>
-  bool operator != (const DoFAccessor<dim2,DH2,level_dof_access2> &) const;
+  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+  bool operator != (const DoFAccessor<dim2,DoFHandlerType2,level_dof_access2> &) const;
 protected:
   /**
    * Reset the DoF handler pointer.
    */
-  void set_dof_handler (DH *dh);
+  void set_dof_handler (DoFHandlerType *dh);
 
   /**
    * Set the index of the <i>i</i>th degree of freedom of this object to @p
@@ -593,9 +596,10 @@ protected:
    * a cell object, there can only be a single set of degrees of freedom, and
    * fe_index has to match the result of active_fe_index().
    */
-  void set_dof_index (const unsigned int i,
-                      const types::global_dof_index index,
-                      const unsigned int fe_index = DH::default_fe_index) const;
+  void set_dof_index
+  (const unsigned int i,
+   const types::global_dof_index index,
+   const unsigned int fe_index = DoFHandlerType::default_fe_index) const;
 
   void set_mg_dof_index (const int level, const unsigned int i, const types::global_dof_index index) const;
 
@@ -616,12 +620,18 @@ protected:
    * a cell object, there can only be a single set of degrees of freedom, and
    * fe_index has to match the result of active_fe_index().
    */
-  void set_vertex_dof_index (const unsigned int vertex,
-                             const unsigned int i,
-                             const types::global_dof_index index,
-                             const unsigned int fe_index = DH::default_fe_index) const;
+  void set_vertex_dof_index
+  (const unsigned int            vertex,
+   const unsigned int            i,
+   const types::global_dof_index index,
+   const unsigned int            fe_index = DoFHandlerType::default_fe_index) const;
 
-  void set_mg_vertex_dof_index (const int level, const unsigned int vertex, const unsigned int i, const types::global_dof_index index, const unsigned int fe_index = DH::default_fe_index) const;
+  void set_mg_vertex_dof_index
+  (const int level,
+   const unsigned int vertex,
+   const unsigned int i,
+   const types::global_dof_index index,
+   const unsigned int fe_index = DoFHandlerType::default_fe_index) const;
 
   /**
    * Iterator classes need to be friends because they need to access
@@ -641,8 +651,8 @@ private:
    * Furthermore it is not implemented and will give a linker error if used
    * anyway.
    */
-  DoFAccessor<structdim,DH, level_dof_access> &
-  operator = (const DoFAccessor<structdim,DH, level_dof_access> &da);
+  DoFAccessor<structdim,DoFHandlerType, level_dof_access> &
+  operator = (const DoFAccessor<structdim,DoFHandlerType, level_dof_access> &da);
 
   /**
    * Make the DoFHandler class a friend so that it can call the set_xxx()
@@ -669,8 +679,8 @@ private:
  *
  * @author Wolfgang Bangerth, 2010
  */
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
-class DoFAccessor<0,DH<1,spacedim>, level_dof_access> : public TriaAccessor<0,1,spacedim>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
+class DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access> : public TriaAccessor<0,1,spacedim>
 {
 public:
 
@@ -695,7 +705,7 @@ public:
   /**
    * Data type passed by the iterator class.
    */
-  typedef DH<1,spacedim> AccessorData;
+  typedef DoFHandlerType<1,spacedim> AccessorData;
 
   /**
    * @name Constructors
@@ -725,10 +735,10 @@ public:
    *
    * This iterator can only be called for one-dimensional triangulations.
    */
-  DoFAccessor (const Triangulation<1,spacedim> *tria,
-               const typename TriaAccessor<0,1,spacedim>::VertexKind vertex_kind,
-               const unsigned int    vertex_index,
-               const DH<1,spacedim> *dof_handler);
+  DoFAccessor (const Triangulation<1,spacedim>                       *tria,
+               const typename TriaAccessor<0,1,spacedim>::VertexKind  vertex_kind,
+               const unsigned int                                     vertex_index,
+               const DoFHandlerType<1,spacedim>                      *dof_handler);
 
   /**
    * Constructor. This constructor exists in order to maintain interface
@@ -736,9 +746,9 @@ public:
    * anything useful here and so may not actually be called.
    */
   DoFAccessor (const Triangulation<1,spacedim> *,
-               const int = 0,
-               const int = 0,
-               const DH<1,spacedim> *dof_handler = 0);
+               const                             int         = 0,
+               const                             int         = 0,
+               const DoFHandlerType<1,spacedim> *dof_handler = 0);
 
   /**
    * Conversion constructor. This constructor exists to make certain
@@ -759,8 +769,8 @@ public:
    * Another conversion operator between objects that don't make sense, just
    * like the previous one.
    */
-  template <int dim2, class DH2, bool level_dof_access2>
-  DoFAccessor (const DoFAccessor<dim2, DH2, level_dof_access2> &);
+  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+  DoFAccessor (const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &);
 
   /**
    * @}
@@ -769,20 +779,20 @@ public:
   /**
    * Return a handle on the DoFHandler object which we are using.
    */
-  const DH<1,spacedim> &
+  const DoFHandlerType<1,spacedim> &
   get_dof_handler () const;
 
   /**
    * Copy operator.
    */
-  DoFAccessor<0,DH<1,spacedim>, level_dof_access> &
-  operator = (const DoFAccessor<0,DH<1,spacedim>, level_dof_access> &da);
+  DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access> &
+  operator = (const DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access> &da);
 
   /**
    * Implement the copy operator needed for the iterator classes.
    */
   template <bool level_dof_access2>
-  void copy_from (const DoFAccessor<0, DH<1,spacedim>, level_dof_access2> &a);
+  void copy_from (const DoFAccessor<0, DoFHandlerType<1,spacedim>, level_dof_access2> &a);
 
   /**
    * Copy operator used by the iterator class. Keeps the previously set dof
@@ -802,7 +812,7 @@ public:
    * of the current object. The object is invalid because points (as
    * represented by the current class) do not have children.
    */
-  TriaIterator<DoFAccessor<0,DH<1,spacedim>, level_dof_access > >
+  TriaIterator<DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access > >
   child (const unsigned int c) const;
 
   /**
@@ -810,7 +820,7 @@ public:
    * a line itself, then the only valid index is @p i equals to zero, and the
    * function returns an iterator to itself.
    */
-  typename dealii::internal::DoFHandler::Iterators<DH<1,spacedim>, level_dof_access>::line_iterator
+  typename dealii::internal::DoFHandler::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::line_iterator
   line (const unsigned int i) const;
 
   /**
@@ -818,7 +828,7 @@ public:
    * a quad itself, then the only valid index is @p i equals to zero, and the
    * function returns an iterator to itself.
    */
-  typename dealii::internal::DoFHandler::Iterators<DH<1,spacedim>, level_dof_access>::quad_iterator
+  typename dealii::internal::DoFHandler::Iterators<DoFHandlerType<1,spacedim>, level_dof_access>::quad_iterator
   quad (const unsigned int i) const;
 
   /**
@@ -969,7 +979,7 @@ public:
    * given @p fe_index. @p fe_index must be used on this object, i.e.
    * <code>fe_index_is_active(fe_index)</code> must return true.
    */
-  const FiniteElement<DH<1,spacedim>::dimension,DH<1,spacedim>::space_dimension> &
+  const FiniteElement<DoFHandlerType<1,spacedim>::dimension,DoFHandlerType<1,spacedim>::space_dimension> &
   get_fe (const unsigned int fe_index) const;
 
   /**
@@ -1020,24 +1030,24 @@ protected:
   /**
    * Store the address of the DoFHandler object to be accessed.
    */
-  DH<1,spacedim> *dof_handler;
+  DoFHandlerType<1,spacedim> *dof_handler;
 
   /**
    * Compare for equality.
    */
-  template <int dim2, class DH2, bool level_dof_access2>
-  bool operator == (const DoFAccessor<dim2,DH2,level_dof_access2> &) const;
+  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+  bool operator == (const DoFAccessor<dim2,DoFHandlerType2,level_dof_access2> &) const;
 
   /**
    * Compare for inequality.
    */
-  template <int dim2, class DH2, bool level_dof_access2>
-  bool operator != (const DoFAccessor<dim2,DH2,level_dof_access2> &) const;
+  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+  bool operator != (const DoFAccessor<dim2,DoFHandlerType2,level_dof_access2> &) const;
 
   /**
    * Reset the DoF handler pointer.
    */
-  void set_dof_handler (DH<1,spacedim> *dh);
+  void set_dof_handler (DoFHandlerType<1,spacedim> *dh);
 
   /**
    * Set the index of the <i>i</i>th degree of freedom of this object to @p
@@ -1118,43 +1128,43 @@ protected:
  * @ingroup Accessors
  * @author Wolfgang Bangerth, 1998, Timo Heister, Guido Kanschat, 2012
  */
-template <class DH, bool level_dof_access>
-class DoFCellAccessor :  public DoFAccessor<DH::dimension,DH, level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
+class DoFCellAccessor :  public DoFAccessor<DoFHandlerType::dimension,DoFHandlerType, level_dof_access>
 {
 public:
   /**
-   * Extract dimension from DH.
+   * Extract dimension from DoFHandlerType.
    */
-  static const unsigned int dim = DH::dimension;
+  static const unsigned int dim = DoFHandlerType::dimension;
 
   /**
-   * Extract space dimension from DH.
+   * Extract space dimension from DoFHandlerType.
    */
-  static const unsigned int spacedim = DH::space_dimension;
+  static const unsigned int spacedim = DoFHandlerType::space_dimension;
 
 
   /**
    * Data type passed by the iterator class.
    */
-  typedef DH AccessorData;
+  typedef DoFHandlerType AccessorData;
 
   /**
    * Declare a typedef to the base class to make accessing some of the
    * exception classes simpler.
    */
-  typedef DoFAccessor<DH::dimension,DH, level_dof_access> BaseClass;
+  typedef DoFAccessor<DoFHandlerType::dimension,DoFHandlerType, level_dof_access> BaseClass;
 
   /**
    * Define the type of the container this is part of.
    */
-  typedef DH Container;
+  typedef DoFHandlerType Container;
 
   /**
    * A type for an iterator over the faces of a cell. This is what the face()
    * function returns.
    */
   typedef
-  TriaIterator<DoFAccessor<DH::dimension-1, DH, level_dof_access> >
+  TriaIterator<DoFAccessor<DoFHandlerType::dimension-1, DoFHandlerType, level_dof_access> >
   face_iterator;
 
   /**
@@ -1167,10 +1177,10 @@ public:
   /**
    * Constructor
    */
-  DoFCellAccessor (const Triangulation<DH::dimension,DH::space_dimension> *tria,
-                   const int                 level,
-                   const int                 index,
-                   const AccessorData       *local_data);
+  DoFCellAccessor (const Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> *tria,
+                   const int           level,
+                   const int           index,
+                   const AccessorData *local_data);
 
   /**
    * Conversion constructor. This constructor exists to make certain
@@ -1191,9 +1201,9 @@ public:
    * Another conversion operator between objects that don't make sense, just
    * like the previous one.
    */
-  template <int dim2, class DH2, bool level_dof_access2>
+  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
   explicit
-  DoFCellAccessor (const DoFAccessor<dim2, DH2, level_dof_access2> &);
+  DoFCellAccessor (const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &);
 
   /**
    * @}
@@ -1208,7 +1218,7 @@ public:
    * CellAccessor returns a triangulation cell accessor without access to the
    * DoF data.
    */
-  TriaIterator<DoFCellAccessor<DH, level_dof_access> >
+  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access> >
   parent () const;
 
   /**
@@ -1223,7 +1233,7 @@ public:
    * needed since the neighbor function of the base class returns a cell
    * accessor without access to the DoF data.
    */
-  TriaIterator<DoFCellAccessor<DH, level_dof_access> >
+  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access> >
   neighbor (const unsigned int) const;
 
   /**
@@ -1231,7 +1241,7 @@ public:
    * since the child function of the base class returns a cell accessor
    * without access to the DoF data.
    */
-  TriaIterator<DoFCellAccessor<DH, level_dof_access> >
+  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access> >
   child (const unsigned int) const;
 
   /**
@@ -1249,7 +1259,7 @@ public:
    * function in the base class only returns an iterator with access to the
    * triangulation data).
    */
-  TriaIterator<DoFCellAccessor<DH, level_dof_access> >
+  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access> >
   neighbor_child_on_subface (const unsigned int face_no,
                              const unsigned int subface_no) const;
 
@@ -1382,7 +1392,8 @@ public:
   template <class InputVector, typename number>
   void get_interpolated_dof_values (const InputVector &values,
                                     Vector<number>    &interpolated_values,
-                                    const unsigned int fe_index = DH::default_fe_index) const;
+                                    const unsigned int fe_index
+                                    = DoFHandlerType::default_fe_index) const;
 
   /**
    * This function is the counterpart to get_interpolated_dof_values(): you
@@ -1439,7 +1450,8 @@ public:
   template <class OutputVector, typename number>
   void set_dof_values_by_interpolation (const Vector<number> &local_values,
                                         OutputVector         &values,
-                                        const unsigned int fe_index = DH::default_fe_index) const;
+                                        const unsigned int    fe_index
+                                        = DoFHandlerType::default_fe_index) const;
 
   /**
    * Distribute a local (cell based) vector to a global one by mapping the
@@ -1603,7 +1615,7 @@ public:
    * associated with them without having any degrees of freedom. Consequently,
    * this function will produce an exception when called on non-active cells.
    */
-  const FiniteElement<DH::dimension,DH::space_dimension> &
+  const FiniteElement<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &
   get_fe () const;
 
   /**
@@ -1665,8 +1677,8 @@ private:
    * Furthermore it is not implemented and will give a linker error if used
    * anyway.
    */
-  DoFCellAccessor<DH, level_dof_access> &
-  operator = (const DoFCellAccessor<DH, level_dof_access> &da);
+  DoFCellAccessor<DoFHandlerType, level_dof_access> &
+  operator = (const DoFCellAccessor<DoFHandlerType, level_dof_access> &da);
 
   /**
    * Make the DoFHandler class a friend so that it can call the
@@ -1677,10 +1689,10 @@ private:
 };
 
 
-template <int sd, class DH, bool level_dof_access>
+template <int sd, typename DoFHandlerType, bool level_dof_access>
 inline
 bool
-DoFAccessor<sd, DH, level_dof_access>::is_level_cell()
+DoFAccessor<sd, DoFHandlerType, level_dof_access>::is_level_cell()
 {
   return level_dof_access;
 }
diff --git a/include/deal.II/dofs/dof_accessor.templates.h b/include/deal.II/dofs/dof_accessor.templates.h
index f879e4e0f9..3775c9e1b2 100644
--- a/include/deal.II/dofs/dof_accessor.templates.h
+++ b/include/deal.II/dofs/dof_accessor.templates.h
@@ -37,45 +37,47 @@ DEAL_II_NAMESPACE_OPEN
 /*------------------------- Functions: DoFAccessor ---------------------------*/
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
-DoFAccessor<structdim,DH,level_dof_access>::DoFAccessor ()
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::DoFAccessor ()
 {
   Assert (false, ExcInvalidObject());
 }
 
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
-DoFAccessor<structdim,DH,level_dof_access>::DoFAccessor (
-  const Triangulation<DH::dimension,DH::space_dimension> *tria,
-  const int                 level,
-  const int                 index,
-  const DH                 *dof_handler)
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::DoFAccessor (
+  const Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> *tria,
+  const int             level,
+  const int             index,
+  const DoFHandlerType *dof_handler)
   :
-  dealii::internal::DoFAccessor::Inheritance<structdim,DH::dimension,
-  DH::space_dimension>::BaseClass (tria,
-                                   level,
-                                   index),
-  dof_handler(const_cast<DH *>(dof_handler))
+  dealii::internal::DoFAccessor::Inheritance<structdim,DoFHandlerType::dimension,
+  DoFHandlerType::space_dimension>::BaseClass (tria,
+                                               level,
+                                               index),
+  dof_handler(const_cast<DoFHandlerType *>(dof_handler))
 {}
 
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 template <int structdim2, int dim2, int spacedim2>
-DoFAccessor<structdim,DH,level_dof_access>::DoFAccessor (const InvalidAccessor<structdim2,dim2,spacedim2> &)
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::DoFAccessor
+(const InvalidAccessor<structdim2,dim2,spacedim2> &)
 {
   Assert (false, ExcInvalidObject());
 }
 
 
 
-template <int structdim, class DH, bool level_dof_access>
-template <int dim2, class DH2, bool level_dof_access2>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int dim2, class DoFHandlerType2, bool level_dof_access2>
 inline
-DoFAccessor<structdim,DH,level_dof_access>::DoFAccessor (const DoFAccessor<dim2, DH2, level_dof_access2> &other)
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::DoFAccessor
+(const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &other)
   : BaseClass(other),
     dof_handler(0)
 {
@@ -89,21 +91,22 @@ DoFAccessor<structdim,DH,level_dof_access>::DoFAccessor (const DoFAccessor<dim2,
 
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 template <bool level_dof_access2>
 inline
-DoFAccessor<structdim,DH,level_dof_access>::DoFAccessor (const DoFAccessor<structdim, DH, level_dof_access2> &other)
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::DoFAccessor
+(const DoFAccessor<structdim, DoFHandlerType, level_dof_access2> &other)
   : BaseClass(other),
-    dof_handler(const_cast<DH *>(other.dof_handler))
+    dof_handler(const_cast<DoFHandlerType *>(other.dof_handler))
 {
 }
 
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
 void
-DoFAccessor<structdim,DH,level_dof_access>::set_dof_handler (DH *dh)
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::set_dof_handler (DoFHandlerType *dh)
 {
   Assert (dh != 0, ExcInvalidObject());
   this->dof_handler = dh;
@@ -111,21 +114,21 @@ DoFAccessor<structdim,DH,level_dof_access>::set_dof_handler (DH *dh)
 
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
-const DH &
-DoFAccessor<structdim,DH,level_dof_access>::get_dof_handler () const
+const DoFHandlerType &
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::get_dof_handler () const
 {
   return *this->dof_handler;
 }
 
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
 void
-DoFAccessor<structdim,DH,level_dof_access>::copy_from (
-  const TriaAccessorBase<structdim, DH::dimension, DH::space_dimension> &da)
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::copy_from
+(const TriaAccessorBase<structdim, DoFHandlerType::dimension, DoFHandlerType::space_dimension> &da)
 {
   Assert (this->dof_handler != 0, ExcInvalidObject());
   BaseClass::copy_from(da);
@@ -133,11 +136,12 @@ DoFAccessor<structdim,DH,level_dof_access>::copy_from (
 
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 template <bool level_dof_access2>
 inline
 void
-DoFAccessor<structdim,DH,level_dof_access>::copy_from (const DoFAccessor<structdim,DH,level_dof_access2> &a)
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::copy_from
+(const DoFAccessor<structdim,DoFHandlerType,level_dof_access2> &a)
 {
   BaseClass::copy_from (a);
   set_dof_handler (a.dof_handler);
@@ -145,11 +149,12 @@ DoFAccessor<structdim,DH,level_dof_access>::copy_from (const DoFAccessor<structd
 
 
 
-template <int structdim, class DH, bool level_dof_access>
-template <int dim2, class DH2, bool level_dof_access2>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int dim2, class DoFHandlerType2, bool level_dof_access2>
 inline
 bool
-DoFAccessor<structdim,DH,level_dof_access>::operator == (const DoFAccessor<dim2,DH2,level_dof_access2> &a) const
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::operator ==
+(const DoFAccessor<dim2,DoFHandlerType2,level_dof_access2> &a) const
 {
   Assert (structdim == dim2, ExcCantCompareIterators());
   Assert (this->dof_handler == a.dof_handler, ExcCantCompareIterators());
@@ -158,11 +163,12 @@ DoFAccessor<structdim,DH,level_dof_access>::operator == (const DoFAccessor<dim2,
 
 
 
-template <int structdim, class DH, bool level_dof_access>
-template <int dim2, class DH2, bool level_dof_access2>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int dim2, class DoFHandlerType2, bool level_dof_access2>
 inline
 bool
-DoFAccessor<structdim,DH,level_dof_access>::operator != (const DoFAccessor<dim2,DH2,level_dof_access2> &a) const
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::operator !=
+(const DoFAccessor<dim2,DoFHandlerType2,level_dof_access2> &a) const
 {
   Assert (structdim == dim2, ExcCantCompareIterators());
   Assert (this->dof_handler == a.dof_handler, ExcCantCompareIterators());
@@ -171,18 +177,18 @@ DoFAccessor<structdim,DH,level_dof_access>::operator != (const DoFAccessor<dim2,
 
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
-TriaIterator<DoFAccessor<structdim,DH,level_dof_access> >
-DoFAccessor<structdim,DH,level_dof_access>::child (const unsigned int i) const
+TriaIterator<DoFAccessor<structdim,DoFHandlerType,level_dof_access> >
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::child (const unsigned int i) const
 {
   Assert (static_cast<unsigned int>(this->level()) < this->dof_handler->levels.size(),
           ExcMessage ("DoFHandler not initialized"));
 
-  TriaIterator<TriaAccessor<structdim,DH::dimension,DH::space_dimension> >
-  t = TriaAccessor<structdim,DH::dimension,DH::space_dimension>::child(i);
+  TriaIterator<TriaAccessor<structdim,DoFHandlerType::dimension,DoFHandlerType::space_dimension> >
+  t = TriaAccessor<structdim,DoFHandlerType::dimension,DoFHandlerType::space_dimension>::child(i);
 
-  TriaIterator<DoFAccessor<structdim,DH,level_dof_access> > q (*t, this->dof_handler);
+  TriaIterator<DoFAccessor<structdim,DoFHandlerType,level_dof_access> > q (*t, this->dof_handler);
   return q;
 }
 
@@ -1393,9 +1399,9 @@ namespace internal
           }
       }
 
-      template<class DH, bool level_dof_access>
+      template<typename DoFHandlerType, bool level_dof_access>
       static
-      void set_mg_dof_indices (const dealii::DoFAccessor<1,DH,level_dof_access> &,
+      void set_mg_dof_indices (const dealii::DoFAccessor<1,DoFHandlerType,level_dof_access> &,
                                const int,
                                const std::vector<types::global_dof_index> &,
                                const unsigned int)
@@ -1405,14 +1411,15 @@ namespace internal
 
 
 
-      template<class DH, bool level_dof_access>
+      template<typename DoFHandlerType, bool level_dof_access>
       static
-      void set_mg_dof_indices (dealii::DoFAccessor<2, DH,level_dof_access> &accessor,
+      void set_mg_dof_indices (dealii::DoFAccessor<2, DoFHandlerType,level_dof_access> &accessor,
                                const int level,
                                const std::vector<types::global_dof_index> &dof_indices,
                                const unsigned int fe_index)
       {
-        const FiniteElement<DH::dimension, DH::space_dimension> &fe = accessor.get_dof_handler ().get_fe ()[fe_index];
+        const FiniteElement<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe
+          = accessor.get_dof_handler ().get_fe ()[fe_index];
         std::vector<types::global_dof_index>::const_iterator next = dof_indices.begin ();
 
         for (unsigned int vertex = 0; vertex < GeometryInfo<2>::vertices_per_cell; ++vertex)
@@ -1431,14 +1438,16 @@ namespace internal
 
 
 
-      template<class DH, bool level_dof_access>
+      template<typename DoFHandlerType, bool level_dof_access>
       static
-      void set_mg_dof_indices (const dealii::DoFAccessor<3, DH,level_dof_access> &accessor,
-                               const int level,
-                               const std::vector<types::global_dof_index> &dof_indices,
-                               const unsigned int fe_index)
+      void set_mg_dof_indices
+      (const dealii::DoFAccessor<3, DoFHandlerType,level_dof_access>      &accessor,
+       const int                                   level,
+       const std::vector<types::global_dof_index> &dof_indices,
+       const unsigned int                          fe_index)
       {
-        const FiniteElement<DH::dimension, DH::space_dimension> &fe = accessor.get_dof_handler ().get_fe ()[fe_index];
+        const FiniteElement<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe
+          = accessor.get_dof_handler ().get_fe ()[fe_index];
         std::vector<types::global_dof_index>::const_iterator next = dof_indices.begin ();
 
         for (unsigned int vertex = 0; vertex < GeometryInfo<3>::vertices_per_cell; ++vertex)
@@ -1465,11 +1474,11 @@ namespace internal
 
 
 
-template <int dim, class DH, bool level_dof_access>
+template <int dim, typename DoFHandlerType, bool level_dof_access>
 inline
 types::global_dof_index
-DoFAccessor<dim,DH,level_dof_access>::dof_index (const unsigned int i,
-                                                 const unsigned int fe_index) const
+DoFAccessor<dim,DoFHandlerType,level_dof_access>::dof_index (const unsigned int i,
+    const unsigned int fe_index) const
 {
   // access the respective DoF
   return dealii::internal::DoFAccessor::Implementation::get_dof_index (*this->dof_handler,
@@ -1481,22 +1490,22 @@ DoFAccessor<dim,DH,level_dof_access>::dof_index (const unsigned int i,
 }
 
 
-template<int structdim, class DH, bool level_dof_access>
+template<int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
 types::global_dof_index
-DoFAccessor<structdim, DH,level_dof_access>::mg_dof_index (const int level,
-                                                           const unsigned int i) const
+DoFAccessor<structdim, DoFHandlerType,level_dof_access>::mg_dof_index (const int level,
+    const unsigned int i) const
 {
   return this->dof_handler->template get_dof_index<structdim> (level, this->present_index, 0, i);
 }
 
 
-template <int dim, class DH, bool level_dof_access>
+template <int dim, typename DoFHandlerType, bool level_dof_access>
 inline
 void
-DoFAccessor<dim,DH,level_dof_access>::set_dof_index (const unsigned int i,
-                                                     const types::global_dof_index index,
-                                                     const unsigned int fe_index) const
+DoFAccessor<dim,DoFHandlerType,level_dof_access>::set_dof_index (const unsigned int i,
+    const types::global_dof_index index,
+    const unsigned int fe_index) const
 {
   // access the respective DoF
   dealii::internal::DoFAccessor::Implementation::set_dof_index (*this->dof_handler,
@@ -1510,10 +1519,10 @@ DoFAccessor<dim,DH,level_dof_access>::set_dof_index (const unsigned int i,
 
 
 
-template <int dim, class DH, bool level_dof_access>
+template <int dim, typename DoFHandlerType, bool level_dof_access>
 inline
 unsigned int
-DoFAccessor<dim,DH,level_dof_access>::n_active_fe_indices () const
+DoFAccessor<dim,DoFHandlerType,level_dof_access>::n_active_fe_indices () const
 {
   // access the respective DoF
   return
@@ -1526,10 +1535,10 @@ DoFAccessor<dim,DH,level_dof_access>::n_active_fe_indices () const
 
 
 
-template <int dim, class DH, bool level_dof_access>
+template <int dim, typename DoFHandlerType, bool level_dof_access>
 inline
 unsigned int
-DoFAccessor<dim,DH,level_dof_access>::nth_active_fe_index (const unsigned int n) const
+DoFAccessor<dim,DoFHandlerType,level_dof_access>::nth_active_fe_index (const unsigned int n) const
 {
   // access the respective DoF
   return
@@ -1543,10 +1552,10 @@ DoFAccessor<dim,DH,level_dof_access>::nth_active_fe_index (const unsigned int n)
 
 
 
-template <int dim, class DH, bool level_dof_access>
+template <int dim, typename DoFHandlerType, bool level_dof_access>
 inline
 bool
-DoFAccessor<dim,DH,level_dof_access>::fe_index_is_active (const unsigned int fe_index) const
+DoFAccessor<dim,DoFHandlerType,level_dof_access>::fe_index_is_active (const unsigned int fe_index) const
 {
   // access the respective DoF
   return
@@ -1560,12 +1569,13 @@ DoFAccessor<dim,DH,level_dof_access>::fe_index_is_active (const unsigned int fe_
 
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
 types::global_dof_index
-DoFAccessor<structdim, DH,level_dof_access>::vertex_dof_index (const unsigned int vertex,
-    const unsigned int i,
-    const unsigned int fe_index) const
+DoFAccessor<structdim, DoFHandlerType,level_dof_access>::vertex_dof_index
+(const unsigned int vertex,
+ const unsigned int i,
+ const unsigned int fe_index) const
 {
   return
     dealii::internal::DoFAccessor::Implementation::get_vertex_dof_index
@@ -1576,10 +1586,10 @@ DoFAccessor<structdim, DH,level_dof_access>::vertex_dof_index (const unsigned in
 }
 
 
-template<int structdim, class DH, bool level_dof_access>
+template<int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
 types::global_dof_index
-DoFAccessor<structdim, DH,level_dof_access>::mg_vertex_dof_index (const int level,
+DoFAccessor<structdim, DoFHandlerType,level_dof_access>::mg_vertex_dof_index (const int level,
     const unsigned int vertex,
     const unsigned int i,
     const unsigned int fe_index) const
@@ -1592,10 +1602,10 @@ DoFAccessor<structdim, DH,level_dof_access>::mg_vertex_dof_index (const int leve
 }
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
 void
-DoFAccessor<structdim, DH,level_dof_access>::set_vertex_dof_index (const unsigned int vertex,
+DoFAccessor<structdim, DoFHandlerType,level_dof_access>::set_vertex_dof_index (const unsigned int vertex,
     const unsigned int i,
     const types::global_dof_index index,
     const unsigned int fe_index) const
@@ -1609,14 +1619,15 @@ DoFAccessor<structdim, DH,level_dof_access>::set_vertex_dof_index (const unsigne
 }
 
 
-template<int structdim, class DH, bool level_dof_access>
+template<int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
 void
-DoFAccessor<structdim, DH,level_dof_access>::set_mg_vertex_dof_index (const int level,
-    const unsigned int vertex,
-    const unsigned int i,
-    const types::global_dof_index index,
-    const unsigned int fe_index) const
+DoFAccessor<structdim, DoFHandlerType,level_dof_access>::set_mg_vertex_dof_index
+(const int                     level,
+ const unsigned int            vertex,
+ const unsigned int            i,
+ const types::global_dof_index index,
+ const unsigned int            fe_index) const
 {
   (void)fe_index;
   Assert (this->dof_handler != 0, ExcInvalidObject ());
@@ -1626,12 +1637,13 @@ DoFAccessor<structdim, DH,level_dof_access>::set_mg_vertex_dof_index (const int
 }
 
 
-template<int structdim, class DH, bool level_dof_access>
+template<int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
 void
-DoFAccessor<structdim, DH,level_dof_access>::set_mg_dof_index (const int level,
-    const unsigned int i,
-    const types::global_dof_index index) const
+DoFAccessor<structdim, DoFHandlerType,level_dof_access>::set_mg_dof_index
+(const int                     level,
+ const unsigned int            i,
+ const types::global_dof_index index) const
 {
   this->dof_handler->template set_dof_index<structdim> (level, this->present_index, 0, i, index);
 }
@@ -1664,10 +1676,10 @@ namespace internal
 }
 
 
-template <int dim, class DH, bool level_dof_access>
+template <int dim, typename DoFHandlerType, bool level_dof_access>
 inline
-const FiniteElement<DH::dimension,DH::space_dimension> &
-DoFAccessor<dim,DH,level_dof_access>::get_fe (const unsigned int fe_index) const
+const FiniteElement<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &
+DoFAccessor<dim,DoFHandlerType,level_dof_access>::get_fe (const unsigned int fe_index) const
 {
   Assert (fe_index_is_active (fe_index) == true,
           ExcMessage ("This function can only be called for active fe indices"));
@@ -1681,10 +1693,10 @@ namespace internal
 {
   namespace DoFAccessor
   {
-    template <class DH, bool level_dof_access>
-    void get_dof_indices (const dealii::DoFAccessor<1,DH,level_dof_access>   &accessor,
-                          std::vector<types::global_dof_index> &dof_indices,
-                          const unsigned int         fe_index)
+    template <typename DoFHandlerType, bool level_dof_access>
+    void get_dof_indices (const dealii::DoFAccessor<1,DoFHandlerType,level_dof_access> &accessor,
+                          std::vector<types::global_dof_index>                         &dof_indices,
+                          const unsigned int                                            fe_index)
     {
       const unsigned int dofs_per_vertex = accessor.get_fe(fe_index).dofs_per_vertex,
                          dofs_per_line   = accessor.get_fe(fe_index).dofs_per_line;
@@ -1698,10 +1710,10 @@ namespace internal
 
 
 
-    template <class DH, bool level_dof_access>
-    void get_dof_indices (const dealii::DoFAccessor<2,DH,level_dof_access>   &accessor,
-                          std::vector<types::global_dof_index> &dof_indices,
-                          const unsigned int         fe_index)
+    template <typename DoFHandlerType, bool level_dof_access>
+    void get_dof_indices (const dealii::DoFAccessor<2,DoFHandlerType,level_dof_access> &accessor,
+                          std::vector<types::global_dof_index>                         &dof_indices,
+                          const unsigned int                                            fe_index)
     {
       const unsigned int dofs_per_vertex = accessor.get_fe(fe_index).dofs_per_vertex,
                          dofs_per_line   = accessor.get_fe(fe_index).dofs_per_line,
@@ -1733,10 +1745,10 @@ namespace internal
 
 
 
-    template <class DH, bool level_dof_access>
-    void get_dof_indices (const dealii::DoFAccessor<3,DH,level_dof_access>   &accessor,
-                          std::vector<types::global_dof_index> &dof_indices,
-                          const unsigned int         fe_index)
+    template <typename DoFHandlerType, bool level_dof_access>
+    void get_dof_indices (const dealii::DoFAccessor<3,DoFHandlerType,level_dof_access> &accessor,
+                          std::vector<types::global_dof_index>                         &dof_indices,
+                          const unsigned int                                            fe_index)
     {
       const unsigned int dofs_per_vertex = accessor.get_fe(fe_index).dofs_per_vertex,
                          dofs_per_line   = accessor.get_fe(fe_index).dofs_per_line,
@@ -1789,17 +1801,18 @@ namespace internal
 
 
 
-    template<class DH, bool level_dof_access>
-    void get_mg_dof_indices (const dealii::DoFAccessor<1, DH,level_dof_access> &accessor,
-                             const int level,
-                             std::vector<types::global_dof_index> &dof_indices,
-                             const unsigned int fe_index)
+    template<typename DoFHandlerType, bool level_dof_access>
+    void get_mg_dof_indices
+    (const dealii::DoFAccessor<1, DoFHandlerType,level_dof_access> &accessor,
+     const int                                                      level,
+     std::vector<types::global_dof_index>                          &dof_indices,
+     const unsigned int                                             fe_index)
     {
-      const DH &handler = accessor.get_dof_handler();
+      const DoFHandlerType &handler = accessor.get_dof_handler();
       Assert(handler.n_dofs(level) != numbers::invalid_dof_index,
              ExcNotInitialized());
 
-      const FiniteElement<DH::dimension, DH::space_dimension> &fe
+      const FiniteElement<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe
         = handler.get_fe ()[fe_index];
       std::vector<types::global_dof_index>::iterator next = dof_indices.begin ();
 
@@ -1815,17 +1828,18 @@ namespace internal
 
 
 
-    template<class DH, bool level_dof_access>
-    void get_mg_dof_indices (const dealii::DoFAccessor<2, DH,level_dof_access> &accessor,
+    template<typename DoFHandlerType, bool level_dof_access>
+    void get_mg_dof_indices (const dealii::DoFAccessor<2, DoFHandlerType,level_dof_access> &accessor,
                              const int level,
                              std::vector<types::global_dof_index> &dof_indices,
                              const unsigned int fe_index)
     {
-      const DH &handler = accessor.get_dof_handler();
+      const DoFHandlerType &handler = accessor.get_dof_handler();
       Assert(handler.n_dofs(level) != numbers::invalid_dof_index,
              ExcNotInitialized());
 
-      const FiniteElement<DH::dimension, DH::space_dimension> &fe = handler.get_fe ()[fe_index];
+      const FiniteElement<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe
+        = handler.get_fe ()[fe_index];
       std::vector<types::global_dof_index>::iterator next = dof_indices.begin ();
 
       for (unsigned int vertex = 0; vertex < GeometryInfo<2>::vertices_per_cell; ++vertex)
@@ -1844,17 +1858,19 @@ namespace internal
 
 
 
-    template<class DH, bool level_dof_access>
-    void get_mg_dof_indices (const dealii::DoFAccessor<3, DH,level_dof_access> &accessor,
-                             const int level,
-                             std::vector<types::global_dof_index> &dof_indices,
-                             const unsigned int fe_index)
+    template<typename DoFHandlerType, bool level_dof_access>
+    void get_mg_dof_indices
+    (const dealii::DoFAccessor<3, DoFHandlerType,level_dof_access> &accessor,
+     const int                                                      level,
+     std::vector<types::global_dof_index>                          &dof_indices,
+     const unsigned int                                             fe_index)
     {
-      const DH &handler = accessor.get_dof_handler();
+      const DoFHandlerType &handler = accessor.get_dof_handler();
       Assert(handler.n_dofs(level) != numbers::invalid_dof_index,
              ExcNotInitialized());
 
-      const FiniteElement<DH::dimension, DH::space_dimension> &fe = handler.get_fe ()[fe_index];
+      const FiniteElement<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe
+        = handler.get_fe ()[fe_index];
       std::vector<types::global_dof_index>::iterator next = dof_indices.begin ();
 
       for (unsigned int vertex = 0; vertex < GeometryInfo<3>::vertices_per_cell; ++vertex)
@@ -1880,11 +1896,12 @@ namespace internal
 }
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
 void
-DoFAccessor<structdim,DH,level_dof_access>::get_dof_indices (std::vector<types::global_dof_index> &dof_indices,
-    const unsigned int         fe_index) const
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::get_dof_indices
+(std::vector<types::global_dof_index> &dof_indices,
+ const unsigned int                    fe_index) const
 {
   Assert (this->dof_handler != 0, ExcNotInitialized());
   Assert (static_cast<unsigned int>(this->level()) < this->dof_handler->levels.size(),
@@ -1942,11 +1959,12 @@ DoFAccessor<structdim,DH,level_dof_access>::get_dof_indices (std::vector<types::
 
 
 
-template<int structdim, class DH, bool level_dof_access>
+template<int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
-void DoFAccessor<structdim, DH,level_dof_access>::get_mg_dof_indices (const int level,
-    std::vector<types::global_dof_index> &dof_indices,
-    const unsigned int fe_index) const
+void DoFAccessor<structdim, DoFHandlerType,level_dof_access>::get_mg_dof_indices
+(const int                             level,
+ std::vector<types::global_dof_index> &dof_indices,
+ const unsigned int                    fe_index) const
 {
   Assert (this->dof_handler != 0, ExcInvalidObject ());
 
@@ -1993,11 +2011,12 @@ void DoFAccessor<structdim, DH,level_dof_access>::get_mg_dof_indices (const int
 }
 
 
-template<int structdim, class DH, bool level_dof_access>
+template<int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
-void DoFAccessor<structdim, DH,level_dof_access>::set_mg_dof_indices (const int level,
-    const std::vector<types::global_dof_index> &dof_indices,
-    const unsigned int fe_index)
+void DoFAccessor<structdim, DoFHandlerType,level_dof_access>::set_mg_dof_indices
+(const int                                   level,
+ const std::vector<types::global_dof_index> &dof_indices,
+ const unsigned int                          fe_index)
 {
   Assert (this->dof_handler != 0, ExcInvalidObject ());
 
@@ -2048,12 +2067,12 @@ namespace internal
 {
   namespace DoFAccessor
   {
-    template <bool level_dof_access, class DH>
+    template <bool level_dof_access, typename DoFHandlerType>
     inline
-    typename dealii::internal::DoFHandler::Iterators<DH, level_dof_access>::quad_iterator
-    get_quad(const dealii::Triangulation<DH::dimension, DH::space_dimension> *,
+    typename dealii::internal::DoFHandler::Iterators<DoFHandlerType, level_dof_access>::quad_iterator
+    get_quad(const dealii::Triangulation<DoFHandlerType::dimension, DoFHandlerType::space_dimension> *,
              unsigned int /*index*/,
-             DH *)
+             DoFHandlerType *)
     {
     }
 
@@ -2105,10 +2124,10 @@ namespace internal
 }
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
-typename dealii::internal::DoFHandler::Iterators<DH,level_dof_access>::line_iterator
-DoFAccessor<structdim,DH,level_dof_access>::line (const unsigned int i) const
+typename dealii::internal::DoFHandler::Iterators<DoFHandlerType,level_dof_access>::line_iterator
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::line (const unsigned int i) const
 {
   // if we are asking for a particular line and this object refers to
   // a line, then the only valid index is i==0 and we should return
@@ -2118,7 +2137,7 @@ DoFAccessor<structdim,DH,level_dof_access>::line (const unsigned int i) const
       Assert (i==0, ExcMessage ("You can only ask for line zero if the "
                                 "current object is a line itself."));
       return
-        typename dealii::internal::DoFHandler::Iterators<DH,level_dof_access>::cell_iterator
+        typename dealii::internal::DoFHandler::Iterators<DoFHandlerType,level_dof_access>::cell_iterator
         (&this->get_triangulation(),
          this->level(),
          this->index(),
@@ -2127,10 +2146,10 @@ DoFAccessor<structdim,DH,level_dof_access>::line (const unsigned int i) const
 
   // otherwise we need to be in structdim>=2
   Assert (structdim > 1, ExcImpossibleInDim(structdim));
-  Assert (DH::dimension > 1, ExcImpossibleInDim(DH::dimension));
+  Assert (DoFHandlerType::dimension > 1, ExcImpossibleInDim(DoFHandlerType::dimension));
 
   // checking of 'i' happens in line_index(i)
-  return typename dealii::internal::DoFHandler::Iterators<DH,level_dof_access>::line_iterator
+  return typename dealii::internal::DoFHandler::Iterators<DoFHandlerType,level_dof_access>::line_iterator
          (this->tria,
           0,  // only sub-objects are allowed, which have no level
           this->line_index(i),
@@ -2138,10 +2157,10 @@ DoFAccessor<structdim,DH,level_dof_access>::line (const unsigned int i) const
 }
 
 
-template <int structdim, class DH, bool level_dof_access>
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
 inline
-typename dealii::internal::DoFHandler::Iterators<DH,level_dof_access>::quad_iterator
-DoFAccessor<structdim,DH,level_dof_access>::quad (const unsigned int i) const
+typename dealii::internal::DoFHandler::Iterators<DoFHandlerType,level_dof_access>::quad_iterator
+DoFAccessor<structdim,DoFHandlerType,level_dof_access>::quad (const unsigned int i) const
 {
   // if we are asking for a
   // particular quad and this object
@@ -2153,7 +2172,7 @@ DoFAccessor<structdim,DH,level_dof_access>::quad (const unsigned int i) const
       Assert (i==0, ExcMessage ("You can only ask for quad zero if the "
                                 "current object is a quad itself."));
       return
-        typename dealii::internal::DoFHandler::Iterators<DH>::cell_iterator
+        typename dealii::internal::DoFHandler::Iterators<DoFHandlerType>::cell_iterator
         (&this->get_triangulation(),
          this->level(),
          this->index(),
@@ -2162,10 +2181,10 @@ DoFAccessor<structdim,DH,level_dof_access>::quad (const unsigned int i) const
 
   // otherwise we need to be in structdim>=3
   Assert (structdim > 2, ExcImpossibleInDim(structdim));
-  Assert (DH::dimension > 2, ExcImpossibleInDim(DH::dimension));
+  Assert (DoFHandlerType::dimension > 2, ExcImpossibleInDim(DoFHandlerType::dimension));
 
   // checking of 'i' happens in quad_index(i)
-  return typename dealii::internal::DoFHandler::Iterators<DH,level_dof_access>::quad_iterator
+  return typename dealii::internal::DoFHandler::Iterators<DoFHandlerType,level_dof_access>::quad_iterator
          (this->tria,
           0,  // only sub-objects are allowed, which have no level
           this->quad_index(i),
@@ -2176,38 +2195,38 @@ DoFAccessor<structdim,DH,level_dof_access>::quad (const unsigned int i) const
 /*------------------------- Functions: DoFAccessor<0,1,spacedim> ---------------------------*/
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
 inline
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::DoFAccessor ()
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::DoFAccessor ()
 {
   Assert (false, ExcInvalidObject());
 }
 
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
 inline
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::
-DoFAccessor (const Triangulation<1,spacedim> *tria,
-             const typename TriaAccessor<0,1,spacedim>::VertexKind vertex_kind,
-             const unsigned int    vertex_index,
-             const DH<1,spacedim> *dof_handler)
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::
+DoFAccessor (const Triangulation<1,spacedim>                       *tria,
+             const typename TriaAccessor<0,1,spacedim>::VertexKind  vertex_kind,
+             const unsigned int                                     vertex_index,
+             const DoFHandlerType<1,spacedim>                      *dof_handler)
   :
   BaseClass (tria,
              vertex_kind,
              vertex_index),
-  dof_handler(const_cast<DH<1,spacedim>*>(dof_handler))
+  dof_handler(const_cast<DoFHandlerType<1,spacedim>*>(dof_handler))
 {}
 
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
 inline
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::
 DoFAccessor (const Triangulation<1,spacedim> *,
              const int                 ,
              const int                 ,
-             const DH<1,spacedim> *)
+             const DoFHandlerType<1,spacedim> *)
   :
   dof_handler(0)
 {
@@ -2217,29 +2236,31 @@ DoFAccessor (const Triangulation<1,spacedim> *,
 
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
 template <int structdim2, int dim2, int spacedim2>
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::DoFAccessor (const InvalidAccessor<structdim2,dim2,spacedim2> &)
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::DoFAccessor (const InvalidAccessor<structdim2,dim2,spacedim2> &)
 {
   Assert (false, ExcInvalidObject());
 }
 
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
-template <int dim2, class DH2, bool level_dof_access2>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
+template <int dim2, class DoFHandlerType2, bool level_dof_access2>
 inline
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::DoFAccessor (const DoFAccessor<dim2, DH2, level_dof_access2> &)
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::DoFAccessor
+(const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &)
 {
   Assert (false, ExcInvalidObject());
 }
 
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
 inline
 void
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::set_dof_handler (DH<1,spacedim> *dh)
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::set_dof_handler
+(DoFHandlerType<1,spacedim> *dh)
 {
   Assert (dh != 0, ExcInvalidObject());
   this->dof_handler = dh;
@@ -2247,22 +2268,22 @@ DoFAccessor<0,DH<1,spacedim>, level_dof_access>::set_dof_handler (DH<1,spacedim>
 
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
 inline
-const DH<1,spacedim> &
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::get_dof_handler () const
+const DoFHandlerType<1,spacedim> &
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::get_dof_handler () const
 {
   return *this->dof_handler;
 }
 
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
 inline
 void
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::get_dof_indices (
-  std::vector<types::global_dof_index> &dof_indices,
-  const unsigned int fe_index) const
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::get_dof_indices
+(std::vector<types::global_dof_index> &dof_indices,
+ const unsigned int                    fe_index) const
 {
   for (unsigned int i=0; i<dof_indices.size(); ++i)
     dof_indices[i]
@@ -2275,10 +2296,10 @@ DoFAccessor<0,DH<1,spacedim>, level_dof_access>::get_dof_indices (
 
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
 inline
 types::global_dof_index
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::
 vertex_dof_index (const unsigned int vertex,
                   const unsigned int i,
                   const unsigned int fe_index) const
@@ -2294,10 +2315,11 @@ vertex_dof_index (const unsigned int vertex,
 
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
 inline
 void
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::copy_from (const TriaAccessorBase<0,1,spacedim> &da)
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::copy_from
+(const TriaAccessorBase<0,1,spacedim> &da)
 {
   Assert (this->dof_handler != 0, ExcInvalidObject());
   BaseClass::copy_from(da);
@@ -2305,11 +2327,12 @@ DoFAccessor<0,DH<1,spacedim>, level_dof_access>::copy_from (const TriaAccessorBa
 
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
 template <bool level_dof_access2>
 inline
 void
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::copy_from (const DoFAccessor<0,DH<1,spacedim>, level_dof_access2> &a)
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::copy_from
+(const DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access2> &a)
 {
   BaseClass::copy_from (a);
   set_dof_handler (a.dof_handler);
@@ -2317,11 +2340,12 @@ DoFAccessor<0,DH<1,spacedim>, level_dof_access>::copy_from (const DoFAccessor<0,
 
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
-template <int dim2, class DH2, bool level_dof_access2>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
+template <int dim2, class DoFHandlerType2, bool level_dof_access2>
 inline
 bool
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::operator == (const DoFAccessor<dim2,DH2,level_dof_access2> &a) const
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::operator ==
+(const DoFAccessor<dim2,DoFHandlerType2,level_dof_access2> &a) const
 {
   Assert (dim2 == 0, ExcCantCompareIterators());
   Assert (this->dof_handler == a.dof_handler, ExcCantCompareIterators());
@@ -2330,11 +2354,12 @@ DoFAccessor<0,DH<1,spacedim>, level_dof_access>::operator == (const DoFAccessor<
 
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
-template <int dim2, class DH2, bool level_dof_access2>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
+template <int dim2, class DoFHandlerType2, bool level_dof_access2>
 inline
 bool
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::operator != (const DoFAccessor<dim2,DH2,level_dof_access2> &a) const
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::operator !=
+(const DoFAccessor<dim2,DoFHandlerType2,level_dof_access2> &a) const
 {
   Assert (dim2 == 0, ExcCantCompareIterators());
   Assert (this->dof_handler == a.dof_handler, ExcCantCompareIterators());
@@ -2343,12 +2368,12 @@ DoFAccessor<0,DH<1,spacedim>, level_dof_access>::operator != (const DoFAccessor<
 
 
 
-template <template <int, int> class DH, int spacedim, bool level_dof_access>
+template <template <int, int> class DoFHandlerType, int spacedim, bool level_dof_access>
 inline
-TriaIterator<DoFAccessor<0,DH<1,spacedim>, level_dof_access > >
-DoFAccessor<0,DH<1,spacedim>, level_dof_access>::child (const unsigned int i) const
+TriaIterator<DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access > >
+DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access>::child (const unsigned int i) const
 {
-  return TriaIterator<DoFAccessor<0,DH<1,spacedim>, level_dof_access > >();
+  return TriaIterator<DoFAccessor<0,DoFHandlerType<1,spacedim>, level_dof_access > >();
 }
 
 
@@ -3112,43 +3137,45 @@ namespace internal
 }
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 inline
-DoFCellAccessor<DH,level_dof_access>::DoFCellAccessor (
-  const Triangulation<DH::dimension,DH::space_dimension> *tria,
-  const int                 level,
-  const int                 index,
-  const AccessorData       *local_data)
+DoFCellAccessor<DoFHandlerType,level_dof_access>::DoFCellAccessor
+(const Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> *tria,
+ const int           level,
+ const int           index,
+ const AccessorData *local_data)
   :
-  DoFAccessor<DH::dimension,DH,level_dof_access> (tria,level,index, local_data)
+  DoFAccessor<DoFHandlerType::dimension,DoFHandlerType,level_dof_access> (tria,level,index, local_data)
 {}
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 template <int structdim2, int dim2, int spacedim2>
 inline
-DoFCellAccessor<DH,level_dof_access>::DoFCellAccessor (const InvalidAccessor<structdim2,dim2,spacedim2> &)
+DoFCellAccessor<DoFHandlerType,level_dof_access>::DoFCellAccessor
+(const InvalidAccessor<structdim2,dim2,spacedim2> &)
 {
   Assert (false, typename BaseClass::ExcInvalidObject());
 }
 
 
 
-template <class DH, bool level_dof_access>
-template <int dim2, class DH2, bool level_dof_access2>
+template <typename DoFHandlerType, bool level_dof_access>
+template <int dim2, class DoFHandlerType2, bool level_dof_access2>
 inline
-DoFCellAccessor<DH,level_dof_access>::DoFCellAccessor (const DoFAccessor<dim2,DH2,level_dof_access2> &other)
+DoFCellAccessor<DoFHandlerType,level_dof_access>::DoFCellAccessor
+(const DoFAccessor<dim2,DoFHandlerType2,level_dof_access2> &other)
   :
   BaseClass(other)
 {}
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 inline
-TriaIterator<DoFCellAccessor<DH,level_dof_access> >
-DoFCellAccessor<DH,level_dof_access>::neighbor (const unsigned int i) const
+TriaIterator<DoFCellAccessor<DoFHandlerType,level_dof_access> >
+DoFCellAccessor<DoFHandlerType,level_dof_access>::neighbor (const unsigned int i) const
 {
-  TriaIterator<DoFCellAccessor<DH,level_dof_access> >
+  TriaIterator<DoFCellAccessor<DoFHandlerType,level_dof_access> >
   q (this->tria,
      this->neighbor_level (i),
      this->neighbor_index (i),
@@ -3162,12 +3189,12 @@ DoFCellAccessor<DH,level_dof_access>::neighbor (const unsigned int i) const
 }
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 inline
-TriaIterator<DoFCellAccessor<DH,level_dof_access> >
-DoFCellAccessor<DH,level_dof_access>::child (const unsigned int i) const
+TriaIterator<DoFCellAccessor<DoFHandlerType,level_dof_access> >
+DoFCellAccessor<DoFHandlerType,level_dof_access>::child (const unsigned int i) const
 {
-  TriaIterator<DoFCellAccessor<DH,level_dof_access> >
+  TriaIterator<DoFCellAccessor<DoFHandlerType,level_dof_access> >
   q (this->tria,
      this->level()+1,
      this->child_index (i),
@@ -3181,12 +3208,12 @@ DoFCellAccessor<DH,level_dof_access>::child (const unsigned int i) const
 }
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 inline
-TriaIterator<DoFCellAccessor<DH,level_dof_access> >
-DoFCellAccessor<DH,level_dof_access>::parent () const
+TriaIterator<DoFCellAccessor<DoFHandlerType,level_dof_access> >
+DoFCellAccessor<DoFHandlerType,level_dof_access>::parent () const
 {
-  TriaIterator<DoFCellAccessor<DH,level_dof_access> >
+  TriaIterator<DoFCellAccessor<DoFHandlerType,level_dof_access> >
   q (this->tria,
      this->level() - 1,
      this->parent_index (),
@@ -3200,34 +3227,34 @@ namespace internal
 {
   namespace DoFCellAccessor
   {
-    template <class DH, bool level_dof_access>
+    template <typename DoFHandlerType, bool level_dof_access>
     inline
-    TriaIterator<dealii::DoFAccessor<DH::dimension-1,DH,level_dof_access> >
-    get_face (const dealii::DoFCellAccessor<DH,level_dof_access> &cell,
+    TriaIterator<dealii::DoFAccessor<DoFHandlerType::dimension-1,DoFHandlerType,level_dof_access> >
+    get_face (const dealii::DoFCellAccessor<DoFHandlerType,level_dof_access> &cell,
               const unsigned int i,
               const dealii::internal::int2type<1>)
     {
-      dealii::DoFAccessor<0, DH,level_dof_access>
+      dealii::DoFAccessor<0, DoFHandlerType,level_dof_access>
       a (&cell.get_triangulation(),
          ((i == 0) && cell.at_boundary(0)
           ?
-          dealii::TriaAccessor<0, 1, DH::space_dimension>::left_vertex
+          dealii::TriaAccessor<0, 1, DoFHandlerType::space_dimension>::left_vertex
           :
           ((i == 1) && cell.at_boundary(1)
            ?
-           dealii::TriaAccessor<0, 1, DH::space_dimension>::right_vertex
+           dealii::TriaAccessor<0, 1, DoFHandlerType::space_dimension>::right_vertex
            :
-           dealii::TriaAccessor<0, 1, DH::space_dimension>::interior_vertex)),
+           dealii::TriaAccessor<0, 1, DoFHandlerType::space_dimension>::interior_vertex)),
          cell.vertex_index(i),
          &cell.get_dof_handler());
-      return dealii::TriaIterator<dealii::DoFAccessor<0,DH,level_dof_access> > (a);
+      return dealii::TriaIterator<dealii::DoFAccessor<0,DoFHandlerType,level_dof_access> > (a);
     }
 
 
-    template <class DH, bool level_dof_access>
+    template <typename DoFHandlerType, bool level_dof_access>
     inline
-    TriaIterator<dealii::DoFAccessor<DH::dimension-1,DH,level_dof_access> >
-    get_face (const dealii::DoFCellAccessor<DH,level_dof_access> &cell,
+    TriaIterator<dealii::DoFAccessor<DoFHandlerType::dimension-1,DoFHandlerType,level_dof_access> >
+    get_face (const dealii::DoFCellAccessor<DoFHandlerType,level_dof_access> &cell,
               const unsigned int i,
               const dealii::internal::int2type<2>)
     {
@@ -3235,10 +3262,10 @@ namespace internal
     }
 
 
-    template <class DH, bool level_dof_access>
+    template <typename DoFHandlerType, bool level_dof_access>
     inline
-    TriaIterator<dealii::DoFAccessor<DH::dimension-1,DH,level_dof_access> >
-    get_face (const dealii::DoFCellAccessor<DH,level_dof_access> &cell,
+    TriaIterator<dealii::DoFAccessor<DoFHandlerType::dimension-1,DoFHandlerType,level_dof_access> >
+    get_face (const dealii::DoFCellAccessor<DoFHandlerType,level_dof_access> &cell,
               const unsigned int i,
               const dealii::internal::int2type<3>)
     {
@@ -3248,23 +3275,24 @@ namespace internal
 }
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 inline
-typename DoFCellAccessor<DH,level_dof_access>::face_iterator
-DoFCellAccessor<DH,level_dof_access>::face (const unsigned int i) const
+typename DoFCellAccessor<DoFHandlerType,level_dof_access>::face_iterator
+DoFCellAccessor<DoFHandlerType,level_dof_access>::face (const unsigned int i) const
 {
   Assert (i<GeometryInfo<dim>::faces_per_cell, ExcIndexRange (i, 0, GeometryInfo<dim>::faces_per_cell));
 
-  const unsigned int dim = DH::dimension;
+  const unsigned int dim = DoFHandlerType::dimension;
   return dealii::internal::DoFCellAccessor::get_face (*this, i, dealii::internal::int2type<dim>());
 }
 
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 inline
 void
-DoFCellAccessor<DH,level_dof_access>::get_dof_indices (std::vector<types::global_dof_index> &dof_indices) const
+DoFCellAccessor<DoFHandlerType,level_dof_access>::get_dof_indices
+(std::vector<types::global_dof_index> &dof_indices) const
 {
   Assert (this->active(), ExcMessage ("get_dof_indices() only works on active cells."));
   Assert (this->is_artificial() == false,
@@ -3280,27 +3308,30 @@ DoFCellAccessor<DH,level_dof_access>::get_dof_indices (std::vector<types::global
 
 
 
-template<class DH, bool level_dof_access>
+template<typename DoFHandlerType, bool level_dof_access>
 inline
-void DoFCellAccessor<DH,level_dof_access>::get_mg_dof_indices (std::vector<types::global_dof_index> &dof_indices) const
+void DoFCellAccessor<DoFHandlerType,level_dof_access>::get_mg_dof_indices
+(std::vector<types::global_dof_index> &dof_indices) const
 {
-  DoFAccessor<dim, DH,level_dof_access>::get_mg_dof_indices (this->level (), dof_indices);
+  DoFAccessor<dim, DoFHandlerType,level_dof_access>::get_mg_dof_indices (this->level (), dof_indices);
 }
 
 
 
-template<class DH, bool level_dof_access>
+template<typename DoFHandlerType, bool level_dof_access>
 inline
-void DoFCellAccessor<DH,level_dof_access>::set_mg_dof_indices (const std::vector<types::global_dof_index> &dof_indices)
+void DoFCellAccessor<DoFHandlerType,level_dof_access>::set_mg_dof_indices
+(const std::vector<types::global_dof_index> &dof_indices)
 {
-  DoFAccessor<dim, DH,level_dof_access>::set_mg_dof_indices (this->level (), dof_indices);
+  DoFAccessor<dim, DoFHandlerType,level_dof_access>::set_mg_dof_indices (this->level (), dof_indices);
 }
 
 
 
-template<class DH, bool level_dof_access>
+template<typename DoFHandlerType, bool level_dof_access>
 inline
-void DoFCellAccessor<DH,level_dof_access>::get_active_or_mg_dof_indices (std::vector<types::global_dof_index> &dof_indices) const
+void DoFCellAccessor<DoFHandlerType,level_dof_access>::get_active_or_mg_dof_indices
+(std::vector<types::global_dof_index> &dof_indices) const
 {
   if (level_dof_access)
     get_mg_dof_indices (dof_indices);
@@ -3310,25 +3341,27 @@ void DoFCellAccessor<DH,level_dof_access>::get_active_or_mg_dof_indices (std::ve
 
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 template <class InputVector, typename number>
 inline
 void
-DoFCellAccessor<DH,level_dof_access>::get_dof_values (const InputVector &values,
-                                                      Vector<number>    &local_values) const
+DoFCellAccessor<DoFHandlerType,level_dof_access>::get_dof_values
+(const InputVector &values,
+ Vector<number>    &local_values) const
 {
   get_dof_values (values, local_values.begin(), local_values.end());
 }
 
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 template <class InputVector, typename ForwardIterator>
 inline
 void
-DoFCellAccessor<DH,level_dof_access>::get_dof_values (const InputVector &values,
-                                                      ForwardIterator    local_values_begin,
-                                                      ForwardIterator    local_values_end) const
+DoFCellAccessor<DoFHandlerType,level_dof_access>::get_dof_values
+(const InputVector &values,
+ ForwardIterator    local_values_begin,
+ ForwardIterator    local_values_end) const
 {
   (void)local_values_end;
   Assert (this->is_artificial() == false,
@@ -3353,14 +3386,15 @@ DoFCellAccessor<DH,level_dof_access>::get_dof_values (const InputVector &values,
 
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 template <class InputVector, typename ForwardIterator>
 inline
 void
-DoFCellAccessor<DH,level_dof_access>::get_dof_values (const ConstraintMatrix &constraints,
-                                                      const InputVector      &values,
-                                                      ForwardIterator         local_values_begin,
-                                                      ForwardIterator         local_values_end) const
+DoFCellAccessor<DoFHandlerType,level_dof_access>::get_dof_values
+(const ConstraintMatrix &constraints,
+ const InputVector      &values,
+ ForwardIterator         local_values_begin,
+ ForwardIterator         local_values_end) const
 {
   Assert (this->is_artificial() == false,
           ExcMessage ("Can't ask for DoF indices on artificial cells."));
@@ -3384,12 +3418,13 @@ DoFCellAccessor<DH,level_dof_access>::get_dof_values (const ConstraintMatrix &co
 
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 template <class OutputVector, typename number>
 inline
 void
-DoFCellAccessor<DH,level_dof_access>::set_dof_values (const Vector<number> &local_values,
-                                                      OutputVector         &values) const
+DoFCellAccessor<DoFHandlerType,level_dof_access>::set_dof_values
+(const Vector<number> &local_values,
+ OutputVector         &values) const
 {
   Assert (this->is_artificial() == false,
           ExcMessage ("Can't ask for DoF indices on artificial cells."));
@@ -3413,12 +3448,12 @@ DoFCellAccessor<DH,level_dof_access>::set_dof_values (const Vector<number> &loca
 
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 inline
-const FiniteElement<DH::dimension,DH::space_dimension> &
-DoFCellAccessor<DH,level_dof_access>::get_fe () const
+const FiniteElement<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &
+DoFCellAccessor<DoFHandlerType,level_dof_access>::get_fe () const
 {
-  Assert ((dynamic_cast<const dealii::DoFHandler<DH::dimension,DH::space_dimension>*>
+  Assert ((dynamic_cast<const dealii::DoFHandler<DoFHandlerType::dimension,DoFHandlerType::space_dimension>*>
            (this->dof_handler) != 0)
           ||
           (this->has_children() == false),
@@ -3430,12 +3465,12 @@ DoFCellAccessor<DH,level_dof_access>::get_fe () const
 
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 inline
 unsigned int
-DoFCellAccessor<DH,level_dof_access>::active_fe_index () const
+DoFCellAccessor<DoFHandlerType,level_dof_access>::active_fe_index () const
 {
-  Assert ((dynamic_cast<const dealii::DoFHandler<DH::dimension,DH::space_dimension>*>
+  Assert ((dynamic_cast<const dealii::DoFHandler<DoFHandlerType::dimension,DoFHandlerType::space_dimension>*>
            (this->dof_handler) != 0)
           ||
           (this->has_children() == false),
@@ -3448,12 +3483,12 @@ DoFCellAccessor<DH,level_dof_access>::active_fe_index () const
 
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 inline
 void
-DoFCellAccessor<DH,level_dof_access>::set_active_fe_index (const unsigned int i)
+DoFCellAccessor<DoFHandlerType,level_dof_access>::set_active_fe_index (const unsigned int i)
 {
-  Assert ((dynamic_cast<const dealii::DoFHandler<DH::dimension,DH::space_dimension>*>
+  Assert ((dynamic_cast<const dealii::DoFHandler<DoFHandlerType::dimension,DoFHandlerType::space_dimension>*>
            (this->dof_handler) != 0)
           ||
           (this->has_children() == false),
@@ -3466,13 +3501,13 @@ DoFCellAccessor<DH,level_dof_access>::set_active_fe_index (const unsigned int i)
 
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 template <typename number, typename OutputVector>
 inline
 void
-DoFCellAccessor<DH,level_dof_access>::distribute_local_to_global (
-  const Vector<number> &local_source,
-  OutputVector         &global_destination) const
+DoFCellAccessor<DoFHandlerType,level_dof_access>::distribute_local_to_global
+(const Vector<number> &local_source,
+ OutputVector         &global_destination) const
 {
   dealii::internal::DoFCellAccessor::Implementation::
   distribute_local_to_global (*this, local_source.begin(),
@@ -3481,14 +3516,14 @@ DoFCellAccessor<DH,level_dof_access>::distribute_local_to_global (
 
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 template <typename ForwardIterator, typename OutputVector>
 inline
 void
-DoFCellAccessor<DH,level_dof_access>::distribute_local_to_global (
-  ForwardIterator  local_source_begin,
-  ForwardIterator  local_source_end,
-  OutputVector    &global_destination) const
+DoFCellAccessor<DoFHandlerType,level_dof_access>::distribute_local_to_global
+(ForwardIterator  local_source_begin,
+ ForwardIterator  local_source_end,
+ OutputVector    &global_destination) const
 {
   dealii::internal::DoFCellAccessor::Implementation::
   distribute_local_to_global (*this, local_source_begin,
@@ -3497,15 +3532,15 @@ DoFCellAccessor<DH,level_dof_access>::distribute_local_to_global (
 
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 template <typename ForwardIterator, typename OutputVector>
 inline
 void
-DoFCellAccessor<DH,level_dof_access>::distribute_local_to_global (
-  const ConstraintMatrix &constraints,
-  ForwardIterator         local_source_begin,
-  ForwardIterator         local_source_end,
-  OutputVector           &global_destination) const
+DoFCellAccessor<DoFHandlerType,level_dof_access>::distribute_local_to_global
+(const ConstraintMatrix &constraints,
+ ForwardIterator         local_source_begin,
+ ForwardIterator         local_source_end,
+ OutputVector           &global_destination) const
 {
   dealii::internal::DoFCellAccessor::Implementation::
   distribute_local_to_global (*this, constraints, local_source_begin,
@@ -3514,13 +3549,13 @@ DoFCellAccessor<DH,level_dof_access>::distribute_local_to_global (
 
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 template <typename number, typename OutputMatrix>
 inline
 void
-DoFCellAccessor<DH,level_dof_access>::distribute_local_to_global (
-  const FullMatrix<number> &local_source,
-  OutputMatrix             &global_destination) const
+DoFCellAccessor<DoFHandlerType,level_dof_access>::distribute_local_to_global
+(const FullMatrix<number> &local_source,
+ OutputMatrix             &global_destination) const
 {
   dealii::internal::DoFCellAccessor::Implementation::
   distribute_local_to_global (*this,local_source,global_destination);
@@ -3528,15 +3563,15 @@ DoFCellAccessor<DH,level_dof_access>::distribute_local_to_global (
 
 
 
-template <class DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 template <typename number, typename OutputMatrix, typename OutputVector>
 inline
 void
-DoFCellAccessor<DH,level_dof_access>::distribute_local_to_global (
-  const FullMatrix<number> &local_matrix,
-  const Vector<number>     &local_vector,
-  OutputMatrix             &global_matrix,
-  OutputVector             &global_vector) const
+DoFCellAccessor<DoFHandlerType,level_dof_access>::distribute_local_to_global
+(const FullMatrix<number> &local_matrix,
+ const Vector<number>     &local_vector,
+ OutputMatrix             &global_matrix,
+ OutputVector             &global_vector) const
 {
   dealii::internal::DoFCellAccessor::Implementation::
   distribute_local_to_global (*this,local_matrix,local_vector,
diff --git a/include/deal.II/dofs/dof_iterator_selector.h b/include/deal.II/dofs/dof_iterator_selector.h
index 9c47e4fb6a..f3a7ec3451 100644
--- a/include/deal.II/dofs/dof_iterator_selector.h
+++ b/include/deal.II/dofs/dof_iterator_selector.h
@@ -23,8 +23,8 @@ DEAL_II_NAMESPACE_OPEN
 
 template <int, int, int> class InvalidAccessor;
 
-template <int structdim, class DH, bool lda> class DoFAccessor;
-template <class DH, bool lda> class DoFCellAccessor;
+template <int structdim, typename DoFHandlerType, bool lda> class DoFAccessor;
+template <typename DoFHandlerType, bool lda> class DoFCellAccessor;
 
 template <int dim, int spacedim> class FiniteElement;
 template <typename Accessor> class TriaRawIterator;
@@ -38,7 +38,7 @@ namespace internal
 {
   namespace DoFHandler
   {
-    template <class DH, bool lda=false>
+    template <typename DoFHandlerType, bool lda=false>
     struct Iterators;
 
 
@@ -54,10 +54,10 @@ namespace internal
      * @author Wolfgang Bangerth, Oliver Kayser-Herold, Guido Kanschat, 1998,
      * 2003, 2008, 2010
      */
-    template <template <int, int> class DH, int spacedim, bool lda>
-    struct Iterators<DH<1, spacedim>, lda>
+    template <template <int, int> class DoFHandlerType, int spacedim, bool lda>
+    struct Iterators<DoFHandlerType<1, spacedim>, lda>
     {
-      typedef DH<1,spacedim> DoFHandler_type;
+      typedef DoFHandlerType<1,spacedim> DoFHandler_type;
       typedef dealii::DoFCellAccessor<DoFHandler_type, lda> CellAccessor;
       typedef dealii::DoFAccessor<0,DoFHandler_type, lda> FaceAccessor;
 
@@ -97,10 +97,10 @@ namespace internal
      * @author Wolfgang Bangerth, Oliver Kayser-Herold, Guido Kanschat, 1998,
      * 2003, 2008, 2010
      */
-    template <template <int, int> class DH, int spacedim, bool lda>
-    struct Iterators<DH<2, spacedim>, lda>
+    template <template <int, int> class DoFHandlerType, int spacedim, bool lda>
+    struct Iterators<DoFHandlerType<2, spacedim>, lda>
     {
-      typedef DH<2,spacedim> DoFHandler_type;
+      typedef DoFHandlerType<2,spacedim> DoFHandler_type;
       typedef dealii::DoFCellAccessor<DoFHandler_type, lda> CellAccessor;
       typedef dealii::DoFAccessor<1, DoFHandler_type, lda> FaceAccessor;
 
@@ -140,10 +140,10 @@ namespace internal
      * @author Wolfgang Bangerth, Oliver Kayser-Herold, Guido Kanschat, 1998,
      * 2003, 2008, 2010
      */
-    template <template <int, int> class DH, int spacedim, bool lda>
-    struct Iterators<DH<3, spacedim>, lda>
+    template <template <int, int> class DoFHandlerType, int spacedim, bool lda>
+    struct Iterators<DoFHandlerType<3, spacedim>, lda>
     {
-      typedef DH<3, spacedim> DoFHandler_type;
+      typedef DoFHandlerType<3, spacedim> DoFHandler_type;
       typedef dealii::DoFCellAccessor<DoFHandler_type, lda> CellAccessor;
       typedef dealii::DoFAccessor<2, DoFHandler_type, lda> FaceAccessor;
 
diff --git a/include/deal.II/dofs/dof_renumbering.h b/include/deal.II/dofs/dof_renumbering.h
index 2b940130d5..4511fbbe61 100644
--- a/include/deal.II/dofs/dof_renumbering.h
+++ b/include/deal.II/dofs/dof_renumbering.h
@@ -431,23 +431,23 @@ namespace DoFRenumbering
      * comparison of various algorithms in the documentation of the
      * DoFRenumbering namespace.
      */
-    template <class DH>
+    template <typename DoFHandlerType>
     void
-    Cuthill_McKee (DH                              &dof_handler,
-                   const bool                       reversed_numbering = false,
-                   const bool                       use_constraints    = false);
+    Cuthill_McKee (DoFHandlerType &dof_handler,
+                   const bool      reversed_numbering = false,
+                   const bool      use_constraints    = false);
 
     /**
      * Computes the renumbering vector needed by the Cuthill_McKee() function.
      * Does not perform the renumbering on the DoFHandler dofs but returns the
      * renumbering vector.
      */
-    template <class DH>
+    template <typename DoFHandlerType>
     void
     compute_Cuthill_McKee (std::vector<types::global_dof_index> &new_dof_indices,
-                           const DH &,
-                           const bool reversed_numbering = false,
-                           const bool use_constraints    = false);
+                           const DoFHandlerType &,
+                           const bool                            reversed_numbering = false,
+                           const bool                            use_constraints    = false);
 
     /**
      * Renumber the degrees of freedom based on the BOOST implementation of
@@ -461,22 +461,22 @@ namespace DoFRenumbering
      *
      * This algorithm is used in step-22.
      */
-    template <class DH>
+    template <typename DoFHandlerType>
     void
-    king_ordering (DH                              &dof_handler,
-                   const bool                       reversed_numbering = false,
-                   const bool                       use_constraints    = false);
+    king_ordering (DoFHandlerType &dof_handler,
+                   const bool      reversed_numbering = false,
+                   const bool      use_constraints    = false);
 
     /**
      * Compute the renumbering for the King algorithm but do not actually
      * renumber the degrees of freedom in the DoF handler argument.
      */
-    template <class DH>
+    template <typename DoFHandlerType>
     void
     compute_king_ordering (std::vector<types::global_dof_index> &new_dof_indices,
-                           const DH &,
-                           const bool reversed_numbering = false,
-                           const bool use_constraints    = false);
+                           const DoFHandlerType &,
+                           const bool                            reversed_numbering = false,
+                           const bool                            use_constraints    = false);
 
     /**
      * Renumber the degrees of freedom based on the BOOST implementation of
@@ -489,22 +489,22 @@ namespace DoFRenumbering
      * comparison of various algorithms in the documentation of the
      * DoFRenumbering namespace.
      */
-    template <class DH>
+    template <typename DoFHandlerType>
     void
-    minimum_degree (DH                              &dof_handler,
-                    const bool                       reversed_numbering = false,
-                    const bool                       use_constraints    = false);
+    minimum_degree (DoFHandlerType &dof_handler,
+                    const bool      reversed_numbering = false,
+                    const bool      use_constraints    = false);
 
     /**
      * Compute the renumbering for the minimum degree algorithm but do not
      * actually renumber the degrees of freedom in the DoF handler argument.
      */
-    template <class DH>
+    template <typename DoFHandlerType>
     void
     compute_minimum_degree (std::vector<types::global_dof_index> &new_dof_indices,
-                            const DH &,
-                            const bool reversed_numbering = false,
-                            const bool use_constraints    = false);
+                            const DoFHandlerType &,
+                            const bool                            reversed_numbering = false,
+                            const bool                            use_constraints    = false);
   }
 
   /**
@@ -540,25 +540,27 @@ namespace DoFRenumbering
    * different on every processor unless you pass an empty list as is the
    * default.)
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  Cuthill_McKee (DH                              &dof_handler,
-                 const bool                       reversed_numbering = false,
-                 const bool                       use_constraints    = false,
-                 const std::vector<types::global_dof_index> &starting_indices   = std::vector<types::global_dof_index>());
+  Cuthill_McKee (DoFHandlerType                             &dof_handler,
+                 const bool                                  reversed_numbering = false,
+                 const bool                                  use_constraints    = false,
+                 const std::vector<types::global_dof_index> &starting_indices
+                 = std::vector<types::global_dof_index>());
 
   /**
    * Computes the renumbering vector needed by the Cuthill_McKee() function.
    * Does not perform the renumbering on the DoFHandler dofs but returns the
    * renumbering vector.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  compute_Cuthill_McKee (std::vector<types::global_dof_index> &new_dof_indices,
-                         const DH &,
-                         const bool reversed_numbering = false,
-                         const bool use_constraints    = false,
-                         const std::vector<types::global_dof_index> &starting_indices   = std::vector<types::global_dof_index>());
+  compute_Cuthill_McKee (std::vector<types::global_dof_index>       &new_dof_indices,
+                         const DoFHandlerType &,
+                         const bool                                  reversed_numbering = false,
+                         const bool                                  use_constraints    = false,
+                         const std::vector<types::global_dof_index> &starting_indices
+                         = std::vector<types::global_dof_index>());
 
   /**
    * Renumber the degrees of freedom according to the Cuthill-McKee method,
@@ -573,12 +575,13 @@ namespace DoFRenumbering
    * See the general documentation of this class for details on the different
    * methods.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  Cuthill_McKee (DH &dof_handler,
-                 const unsigned int          level,
-                 const bool                  reversed_numbering = false,
-                 const std::vector<types::global_dof_index> &starting_indices   = std::vector<types::global_dof_index> ());
+  Cuthill_McKee (DoFHandlerType                             &dof_handler,
+                 const unsigned int                          level,
+                 const bool                                  reversed_numbering = false,
+                 const std::vector<types::global_dof_index> &starting_indices
+                 = std::vector<types::global_dof_index> ());
 
   /**
    * @name Component-wise numberings
@@ -633,11 +636,12 @@ namespace DoFRenumbering
    * multilevel discretization. The non-multigrid part of the the DoFHandler
    * is not touched.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  component_wise (DH &dof_handler,
-                  const unsigned int level,
-                  const std::vector<unsigned int> &target_component = std::vector<unsigned int>());
+  component_wise (DoFHandlerType                  &dof_handler,
+                  const unsigned int               level,
+                  const std::vector<unsigned int> &target_component
+                  = std::vector<unsigned int>());
 
   /**
    * Computes the renumbering vector needed by the component_wise() functions.
@@ -756,10 +760,10 @@ namespace DoFRenumbering
    *   cell iterator of that triangulation needs to be present in @p cell_order
    *   exactly once.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  cell_wise (DH &dof_handler,
-             const std::vector<typename DH::active_cell_iterator> &cell_order);
+  cell_wise (DoFHandlerType &dof_handler,
+             const std::vector<typename DoFHandlerType::active_cell_iterator> &cell_order);
 
   /**
    * Compute a renumbering of degrees of freedom by cell. The function takes a
@@ -793,34 +797,36 @@ namespace DoFRenumbering
    *   the condition <code>renumbering[inverse_renumbering[i]] == i</code>
    *   will hold.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  compute_cell_wise (std::vector<types::global_dof_index> &renumbering,
-                     std::vector<types::global_dof_index> &inverse_renumbering,
-                     const DH &dof_handler,
-                     const std::vector<typename DH::active_cell_iterator> &cell_order);
+  compute_cell_wise
+  (std::vector<types::global_dof_index>                             &renumbering,
+   std::vector<types::global_dof_index>                             &inverse_renumbering,
+   const DoFHandlerType                                             &dof_handler,
+   const std::vector<typename DoFHandlerType::active_cell_iterator> &cell_order);
 
   /**
    * Like the other cell_wise() function, but for one level
    * of a multilevel enumeration of degrees of freedom.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  cell_wise (DH &dof_handler,
-             const unsigned int level,
-             const std::vector<typename DH::level_cell_iterator> &cell_order);
+  cell_wise (DoFHandlerType                                                  &dof_handler,
+             const unsigned int                                               level,
+             const std::vector<typename DoFHandlerType::level_cell_iterator> &cell_order);
 
   /**
    * Like the other compute_cell_wise() function, but for one level
    * of a multilevel enumeration of degrees of freedom.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  compute_cell_wise (std::vector<types::global_dof_index> &renumbering,
-                     std::vector<types::global_dof_index> &inverse_renumbering,
-                     const DH   &dof_handler,
-                     const unsigned int         level,
-                     const std::vector<typename DH::level_cell_iterator> &cell_order);
+  compute_cell_wise
+  (std::vector<types::global_dof_index>                            &renumbering,
+   std::vector<types::global_dof_index>                            &inverse_renumbering,
+   const DoFHandlerType                                            &dof_handler,
+   const unsigned int                                               level,
+   const std::vector<typename DoFHandlerType::level_cell_iterator> &cell_order);
 
   /**
    * @}
@@ -856,50 +862,50 @@ namespace DoFRenumbering
    * downstream location (e.g. those parallel to the flow direction, or
    * several dofs within a FESystem) will be unaffected.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  downstream (DH               &dof_handler,
-              const Point<DH::space_dimension> &direction,
-              const bool        dof_wise_renumbering = false);
+  downstream (DoFHandlerType                               &dof_handler,
+              const Point<DoFHandlerType::space_dimension> &direction,
+              const bool                                    dof_wise_renumbering = false);
 
 
   /**
    * Cell-wise downstream numbering with respect to a constant flow direction
    * on one level. See the other function with the same name.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  downstream (DH &dof_handler,
-              const unsigned int level,
-              const Point<DH::space_dimension>  &direction,
-              const bool         dof_wise_renumbering = false);
+  downstream (DoFHandlerType                               &dof_handler,
+              const unsigned int                            level,
+              const Point<DoFHandlerType::space_dimension> &direction,
+              const bool                                    dof_wise_renumbering = false);
 
   /**
    * Computes the renumbering vector needed by the downstream() function. Does
    * not perform the renumbering on the DoFHandler dofs but returns the
    * renumbering vector.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  compute_downstream (std::vector<types::global_dof_index> &new_dof_indices,
-                      std::vector<types::global_dof_index> &reverse,
-                      const DH                  &dof_handler,
-                      const Point<DH::space_dimension>          &direction,
-                      const bool                 dof_wise_renumbering);
+  compute_downstream (std::vector<types::global_dof_index>         &new_dof_indices,
+                      std::vector<types::global_dof_index>         &reverse,
+                      const DoFHandlerType                         &dof_handler,
+                      const Point<DoFHandlerType::space_dimension> &direction,
+                      const bool                                    dof_wise_renumbering);
 
   /**
    * Computes the renumbering vector needed by the downstream() function. Does
    * not perform the renumbering on the DoFHandler dofs but returns the
    * renumbering vector.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  compute_downstream (std::vector<types::global_dof_index> &new_dof_indices,
-                      std::vector<types::global_dof_index> &reverse,
-                      const DH &dof_handler,
-                      const unsigned int         level,
-                      const Point<DH::space_dimension>          &direction,
-                      const bool                 dof_wise_renumbering);
+  compute_downstream (std::vector<types::global_dof_index>         &new_dof_indices,
+                      std::vector<types::global_dof_index>         &reverse,
+                      const DoFHandlerType                         &dof_handler,
+                      const unsigned int                            level,
+                      const Point<DoFHandlerType::space_dimension> &direction,
+                      const bool                                    dof_wise_renumbering);
 
   /**
    * Cell-wise clockwise numbering.
@@ -909,34 +915,34 @@ namespace DoFRenumbering
    * only works with Discontinuous Galerkin Finite Elements, i.e. all degrees
    * of freedom have to be associated with the interior of the cell.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  clockwise_dg (DH               &dof_handler,
-                const Point<DH::space_dimension> &center,
-                const bool        counter = false);
+  clockwise_dg (DoFHandlerType                               &dof_handler,
+                const Point<DoFHandlerType::space_dimension> &center,
+                const bool                                    counter = false);
 
   /**
    * Cell-wise clockwise numbering on one level. See the other function with
    * the same name.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  clockwise_dg (DH &dof_handler,
-                const unsigned int level,
-                const Point<DH::space_dimension> &center,
-                const bool counter = false);
+  clockwise_dg (DoFHandlerType                               &dof_handler,
+                const unsigned int                            level,
+                const Point<DoFHandlerType::space_dimension> &center,
+                const bool                                    counter = false);
 
   /**
    * Computes the renumbering vector needed by the clockwise_dg() functions.
    * Does not perform the renumbering on the DoFHandler dofs but returns the
    * renumbering vector.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  compute_clockwise_dg (std::vector<types::global_dof_index> &new_dof_indices,
-                        const DH                  &dof_handler,
-                        const Point<DH::space_dimension>          &center,
-                        const bool                 counter);
+  compute_clockwise_dg (std::vector<types::global_dof_index>         &new_dof_indices,
+                        const DoFHandlerType                         &dof_handler,
+                        const Point<DoFHandlerType::space_dimension> &center,
+                        const bool                                    counter);
 
   /**
    * @}
@@ -956,9 +962,9 @@ namespace DoFRenumbering
    * @pre The @p selected_dofs array must have as many elements as the @p
    * dof_handler has degrees of freedom.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  sort_selected_dofs_back (DH                      &dof_handler,
+  sort_selected_dofs_back (DoFHandlerType          &dof_handler,
                            const std::vector<bool> &selected_dofs);
 
   /**
@@ -971,9 +977,9 @@ namespace DoFRenumbering
    * @pre The @p selected_dofs array must have as many elements as the @p
    * dof_handler has degrees of freedom on the given level.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  sort_selected_dofs_back (DH                      &dof_handler,
+  sort_selected_dofs_back (DoFHandlerType          &dof_handler,
                            const std::vector<bool> &selected_dofs,
                            const unsigned int       level);
 
@@ -985,11 +991,11 @@ namespace DoFRenumbering
    * @pre The @p selected_dofs array must have as many elements as the @p
    * dof_handler has degrees of freedom.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   compute_sort_selected_dofs_back (std::vector<types::global_dof_index> &new_dof_indices,
-                                   const DH                  &dof_handler,
-                                   const std::vector<bool>   &selected_dofs);
+                                   const DoFHandlerType                 &dof_handler,
+                                   const std::vector<bool>              &selected_dofs);
 
   /**
    * This function computes the renumbering vector on each level needed by the
@@ -1000,12 +1006,12 @@ namespace DoFRenumbering
    * @pre The @p selected_dofs array must have as many elements as the @p
    * dof_handler has degrees of freedom on the given level.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   compute_sort_selected_dofs_back (std::vector<types::global_dof_index> &new_dof_indices,
-                                   const DH                  &dof_handler,
-                                   const std::vector<bool>   &selected_dofs,
-                                   const unsigned int         level);
+                                   const DoFHandlerType                 &dof_handler,
+                                   const std::vector<bool>              &selected_dofs,
+                                   const unsigned int                    level);
 
   /**
    * Renumber the degrees of freedom in a random way. The result of this
@@ -1018,9 +1024,9 @@ namespace DoFRenumbering
    * other threads running concurrently to this function also draw
    * random numbers).
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  random (DH &dof_handler);
+  random (DoFHandlerType &dof_handler);
 
   /**
    * Computes the renumbering vector needed by the random() function. See
@@ -1030,10 +1036,10 @@ namespace DoFRenumbering
    * perform the renumbering on the DoFHandler dofs but returns the
    * renumbering vector.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   compute_random (std::vector<types::global_dof_index> &new_dof_indices,
-                  const DH &dof_handler);
+                  const DoFHandlerType &dof_handler);
 
   /**
    * @}
@@ -1062,19 +1068,19 @@ namespace DoFRenumbering
    * belong to the same subdomain, then they will be in this order also after
    * reordering.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  subdomain_wise (DH &dof_handler);
+  subdomain_wise (DoFHandlerType &dof_handler);
 
   /**
    * Computes the renumbering vector needed by the subdomain_wise() function.
    * Does not perform the renumbering on the @p DoFHandler dofs but returns
    * the renumbering vector.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   compute_subdomain_wise (std::vector<types::global_dof_index> &new_dof_indices,
-                          const DH                  &dof_handler);
+                          const DoFHandlerType                 &dof_handler);
 
   /**
    * @}
@@ -1106,12 +1112,12 @@ namespace DoFRenumbering
 #ifndef DOXYGEN
 namespace DoFRenumbering
 {
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   inline
-  downstream (DH &dof,
-              const Point<DH::space_dimension> &direction,
-              const bool dof_wise_renumbering)
+  downstream (DoFHandlerType                               &dof,
+              const Point<DoFHandlerType::space_dimension> &direction,
+              const bool                                    dof_wise_renumbering)
   {
     std::vector<types::global_dof_index> renumbering(dof.n_dofs());
     std::vector<types::global_dof_index> reverse(dof.n_dofs());
diff --git a/include/deal.II/dofs/dof_tools.h b/include/deal.II/dofs/dof_tools.h
index 26997f95e1..fbd1650fdb 100644
--- a/include/deal.II/dofs/dof_tools.h
+++ b/include/deal.II/dofs/dof_tools.h
@@ -395,9 +395,9 @@ namespace DoFTools
    *
    * @ingroup constraints
    */
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
-  make_sparsity_pattern (const DH               &dof,
+  make_sparsity_pattern (const DoFHandlerType   &dof,
                          SP                     &sparsity_pattern,
                          const ConstraintMatrix &constraints = ConstraintMatrix(),
                          const bool              keep_constrained_dofs = true,
@@ -484,9 +484,9 @@ namespace DoFTools
    *
    * @ingroup constraints
    */
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
-  make_sparsity_pattern (const DH                 &dof,
+  make_sparsity_pattern (const DoFHandlerType     &dof,
                          const Table<2, Coupling> &coupling,
                          SP                       &sparsity_pattern,
                          const ConstraintMatrix   &constraints = ConstraintMatrix(),
@@ -513,10 +513,10 @@ namespace DoFTools
    * whereas the ones that correspond to columns come from the second
    * DoFHandler.
    */
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
-  make_sparsity_pattern (const DH        &dof_row,
-                         const DH        &dof_col,
+  make_sparsity_pattern (const DoFHandlerType        &dof_row,
+                         const DoFHandlerType        &dof_col,
                          SP              &sparsity);
 
   /**
@@ -529,9 +529,9 @@ namespace DoFTools
    * class that satisfies similar requirements. It is assumed that the size of
    * the sparsity pattern is already correct.
    */
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
-  make_boundary_sparsity_pattern (const DH                        &dof,
+  make_boundary_sparsity_pattern (const DoFHandlerType            &dof,
                                   const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
                                   SP                              &sparsity_pattern);
 
@@ -551,10 +551,10 @@ namespace DoFTools
    *
    * For the type of the sparsity pattern, the same holds as said above.
    */
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
-  make_boundary_sparsity_pattern (const DH &dof,
-                                  const typename FunctionMap<DH::space_dimension>::type &boundary_ids,
+  make_boundary_sparsity_pattern (const DoFHandlerType &dof,
+                                  const typename FunctionMap<DoFHandlerType::space_dimension>::type &boundary_ids,
                                   const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
                                   SP                 &sparsity);
 
@@ -566,9 +566,9 @@ namespace DoFTools
    * neighboring elements, the normal couplings and these extra matrix entries
    * are considered.
    */
-  template<class DH, class SP>
+  template<typename DoFHandlerType, class SP>
   void
-  make_flux_sparsity_pattern (const DH &dof_handler,
+  make_flux_sparsity_pattern (const DoFHandlerType &dof_handler,
                               SP       &sparsity_pattern);
 
   /**
@@ -578,9 +578,9 @@ namespace DoFTools
    *
    * @ingroup constraints
    */
-  template<class DH, class SP>
+  template<typename DoFHandlerType, class SP>
   void
-  make_flux_sparsity_pattern (const DH        &dof_handler,
+  make_flux_sparsity_pattern (const DoFHandlerType        &dof_handler,
                               SP              &sparsity_pattern,
                               const ConstraintMatrix   &constraints,
                               const bool                keep_constrained_dofs = true,
@@ -597,9 +597,9 @@ namespace DoFTools
    *
    * @todo Not implemented for hp::DoFHandler.
    */
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
-  make_flux_sparsity_pattern (const DH                &dof,
+  make_flux_sparsity_pattern (const DoFHandlerType    &dof,
                               SP                      &sparsity,
                               const Table<2,Coupling> &int_mask,
                               const Table<2,Coupling> &flux_mask);
@@ -650,10 +650,10 @@ namespace DoFTools
    *
    * @ingroup constraints
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  make_hanging_node_constraints (const DH         &dof_handler,
-                                 ConstraintMatrix &constraints);
+  make_hanging_node_constraints (const DoFHandlerType &dof_handler,
+                                 ConstraintMatrix     &constraints);
 
   /**
    * This function is used when different variables in a problem are
@@ -951,10 +951,10 @@ namespace DoFTools
    *
    * @author Daniel Arndt, Matthias Maier, 2013 - 2015
    */
-  template<typename DH>
+  template<typename DoFHandlerType>
   void
   make_periodicity_constraints
-  (const std::vector<GridTools::PeriodicFacePair<typename DH::cell_iterator> >
+  (const std::vector<GridTools::PeriodicFacePair<typename DoFHandlerType::cell_iterator> >
    &periodic_faces,
    dealii::ConstraintMatrix        &constraint_matrix,
    const ComponentMask             &component_mask = ComponentMask(),
@@ -992,13 +992,13 @@ namespace DoFTools
    *
    * @author Matthias Maier, 2012
    */
-  template<typename DH>
+  template<typename DoFHandlerType>
   void
   make_periodicity_constraints
-  (const DH                 &dof_handler,
-   const types::boundary_id b_id1,
-   const types::boundary_id b_id2,
-   const int                direction,
+  (const DoFHandlerType     &dof_handler,
+   const types::boundary_id  b_id1,
+   const types::boundary_id  b_id2,
+   const int                 direction,
    dealii::ConstraintMatrix &constraint_matrix,
    const ComponentMask      &component_mask = ComponentMask());
 
@@ -1028,12 +1028,12 @@ namespace DoFTools
    * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
    * for further information.
    */
-  template<typename DH>
+  template<typename DoFHandlerType>
   void
   make_periodicity_constraints
-  (const DH                 &dof_handler,
-   const types::boundary_id b_id,
-   const int                direction,
+  (const DoFHandlerType     &dof_handler,
+   const types::boundary_id  b_id,
+   const int                 direction,
    dealii::ConstraintMatrix &constraint_matrix,
    const ComponentMask      &component_mask = ComponentMask());
 
@@ -1065,9 +1065,9 @@ namespace DoFTools
    * functions that are non-zero in more than one vector component (in deal.II
    * speak: they are non-primitive).
    */
-  template <class DH, typename Number>
+  template <typename DoFHandlerType, typename Number>
   void
-  distribute_cell_to_dof_vector (const DH              &dof_handler,
+  distribute_cell_to_dof_vector (const DoFHandlerType  &dof_handler,
                                  const Vector<Number>  &cell_data,
                                  Vector<double>        &dof_data,
                                  const unsigned int     component = 0);
@@ -1158,23 +1158,23 @@ namespace DoFTools
    * Do the same thing as the corresponding extract_dofs() function for one
    * level of a multi-grid DoF numbering.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_level_dofs (const unsigned int       level,
-                      const DH &dof,
-                      const ComponentMask     &component_mask,
-                      std::vector<bool>       &selected_dofs);
+  extract_level_dofs (const unsigned int    level,
+                      const DoFHandlerType &dof,
+                      const ComponentMask  &component_mask,
+                      std::vector<bool>    &selected_dofs);
 
   /**
    * Do the same thing as the corresponding extract_dofs() function for one
    * level of a multi-grid DoF numbering.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_level_dofs (const unsigned int       level,
-                      const DH &dof,
-                      const BlockMask     &component_mask,
-                      std::vector<bool>       &selected_dofs);
+  extract_level_dofs (const unsigned int    level,
+                      const DoFHandlerType &dof,
+                      const BlockMask      &component_mask,
+                      std::vector<bool>    &selected_dofs);
 
   /**
    * Extract all degrees of freedom which are at the boundary and belong to
@@ -1226,9 +1226,9 @@ namespace DoFTools
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_boundary_dofs (const DH                   &dof_handler,
+  extract_boundary_dofs (const DoFHandlerType       &dof_handler,
                          const ComponentMask        &component_mask,
                          std::vector<bool>          &selected_dofs,
                          const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
@@ -1263,9 +1263,9 @@ namespace DoFTools
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_boundary_dofs (const DH                   &dof_handler,
+  extract_boundary_dofs (const DoFHandlerType       &dof_handler,
                          const ComponentMask        &component_mask,
                          IndexSet                   &selected_dofs,
                          const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
@@ -1286,9 +1286,9 @@ namespace DoFTools
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_dofs_with_support_on_boundary (const DH               &dof_handler,
+  extract_dofs_with_support_on_boundary (const DoFHandlerType   &dof_handler,
                                          const ComponentMask    &component_mask,
                                          std::vector<bool>      &selected_dofs,
                                          const std::set<types::boundary_id> &boundary_ids = std::set<types::boundary_id>());
@@ -1326,9 +1326,9 @@ namespace DoFTools
    * The main reason for this program is the use of the null space with the
    * AMG preconditioner.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_constant_modes (const DH                        &dof_handler,
+  extract_constant_modes (const DoFHandlerType            &dof_handler,
                           const ComponentMask             &component_mask,
                           std::vector<std::vector<bool> > &constant_modes);
 
@@ -1366,11 +1366,11 @@ namespace DoFTools
    * If you want to get a unique association of degree of freedom with
    * subdomains, use the @p get_subdomain_association function.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_subdomain_dofs (const DH           &dof_handler,
-                          const types::subdomain_id subdomain_id,
-                          std::vector<bool>  &selected_dofs);
+  extract_subdomain_dofs (const DoFHandlerType      &dof_handler,
+                          const types::subdomain_id  subdomain_id,
+                          std::vector<bool>         &selected_dofs);
 
 
   /**
@@ -1379,10 +1379,10 @@ namespace DoFTools
    * with all DoF indices. In either case, it equals what
    * DoFHandler::locally_owned_dofs() returns.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_locally_owned_dofs (const DH &dof_handler,
-                              IndexSet &dof_set);
+  extract_locally_owned_dofs (const DoFHandlerType &dof_handler,
+                              IndexSet             &dof_set);
 
 
   /**
@@ -1399,10 +1399,10 @@ namespace DoFTools
    * from the dof_indices_with_subdomain_association() function when called
    * with the locally owned subdomain id.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_locally_active_dofs (const DH &dof_handler,
-                               IndexSet &dof_set);
+  extract_locally_active_dofs (const DoFHandlerType &dof_handler,
+                               IndexSet             &dof_set);
 
   /**
    * Extract the set of global DoF indices that are active on the current
@@ -1413,10 +1413,10 @@ namespace DoFTools
    * not artificial (see
    * @ref GlossArtificialCell "the glossary").
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_locally_relevant_dofs (const DH &dof_handler,
-                                 IndexSet &dof_set);
+  extract_locally_relevant_dofs (const DoFHandlerType &dof_handler,
+                                 IndexSet             &dof_set);
 
   /**
    *
@@ -1432,9 +1432,9 @@ namespace DoFTools
    *
    * @author Denis Davydov, 2015
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   std::vector<IndexSet>
-  locally_owned_dofs_per_subdomain (const DH   &dof_handler);
+  locally_owned_dofs_per_subdomain (const DoFHandlerType &dof_handler);
 
   /**
    *
@@ -1450,20 +1450,20 @@ namespace DoFTools
    *
    * @author Jean-Paul Pelteret, 2015
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   std::vector<IndexSet>
-  locally_relevant_dofs_per_subdomain (const DH   &dof_handler);
+  locally_relevant_dofs_per_subdomain (const DoFHandlerType &dof_handler);
 
 
   /**
    * Same as extract_locally_relevant_dofs() but for multigrid DoFs
    * for the given @p level.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_locally_relevant_level_dofs (const DH &dof_handler,
-                                       const unsigned int level,
-                                       IndexSet &dof_set);
+  extract_locally_relevant_level_dofs (const DoFHandlerType &dof_handler,
+                                       const unsigned int    level,
+                                       IndexSet             &dof_set);
 
 
   /**
@@ -1495,9 +1495,9 @@ namespace DoFTools
    * subdomain are not the same the DoFHandler class identifies as those it
    * owns.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  get_subdomain_association (const DH                  &dof_handler,
+  get_subdomain_association (const DoFHandlerType             &dof_handler,
                              std::vector<types::subdomain_id> &subdomain);
 
   /**
@@ -1525,10 +1525,10 @@ namespace DoFTools
    * subdomain are not the same the DoFHandler class identifies as those it
    * owns.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   unsigned int
-  count_dofs_with_subdomain_association (const DH           &dof_handler,
-                                         const types::subdomain_id subdomain);
+  count_dofs_with_subdomain_association (const DoFHandlerType      &dof_handler,
+                                         const types::subdomain_id  subdomain);
 
   /**
    * Count how many degrees of freedom are uniquely associated with the given
@@ -1549,10 +1549,10 @@ namespace DoFTools
    * subdomain are not the same the DoFHandler class identifies as those it
    * owns.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  count_dofs_with_subdomain_association (const DH           &dof_handler,
-                                         const types::subdomain_id subdomain,
+  count_dofs_with_subdomain_association (const DoFHandlerType      &dof_handler,
+                                         const types::subdomain_id  subdomain,
                                          std::vector<unsigned int> &n_dofs_on_subdomain);
 
   /**
@@ -1575,9 +1575,9 @@ namespace DoFTools
    * subdomain are not the same the DoFHandler class identifies as those it
    * owns.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   IndexSet
-  dof_indices_with_subdomain_association (const DH           &dof_handler,
+  dof_indices_with_subdomain_association (const DoFHandlerType &dof_handler,
                                           const types::subdomain_id subdomain);
   // @}
   /**
@@ -1600,12 +1600,12 @@ namespace DoFTools
    * @note The ordering of rows (cells) follows the ordering of the standard
    * cell iterators.
    */
-  template <class DH, class Sparsity>
-  void make_cell_patches(Sparsity &block_list,
-                         const DH &dof_handler,
-                         const unsigned int level,
+  template <typename DoFHandlerType, class Sparsity>
+  void make_cell_patches(Sparsity                &block_list,
+                         const DoFHandlerType    &dof_handler,
+                         const unsigned int       level,
                          const std::vector<bool> &selected_dofs = std::vector<bool>(),
-                         types::global_dof_index offset = 0);
+                         types::global_dof_index  offset        = 0);
 
   /**
    * Create an incidence matrix that for every vertex on a given level of a
@@ -1645,14 +1645,14 @@ namespace DoFTools
    * @arg <tt>single_cell_patches</tt>: if not true, patches containing a
    * single cell are eliminated.
    */
-  template <class DH>
-  void make_vertex_patches(SparsityPattern &block_list,
-                           const DH &dof_handler,
-                           const unsigned int level,
-                           const bool interior_dofs_only,
-                           const bool boundary_patches = false,
-                           const bool level_boundary_patches = false,
-                           const bool single_cell_patches = false);
+  template <typename DoFHandlerType>
+  void make_vertex_patches(SparsityPattern      &block_list,
+                           const DoFHandlerType &dof_handler,
+                           const unsigned int    level,
+                           const bool            interior_dofs_only,
+                           const bool            boundary_patches       = false,
+                           const bool            level_boundary_patches = false,
+                           const bool            single_cell_patches    = false);
 
   /**
    * Create an incidence matrix that for every cell on a given level of a
@@ -1691,12 +1691,12 @@ namespace DoFTools
    * the domain, and thus need smoothing. This parameter has no effect if
    * <tt>interior_dofs_only</tt> is false.
    */
-  template <class DH>
-  void make_child_patches(SparsityPattern &block_list,
-                          const DH &dof_handler,
-                          const unsigned int level,
-                          const bool interior_dofs_only,
-                          const bool boundary_dofs = false);
+  template <typename DoFHandlerType>
+  void make_child_patches(SparsityPattern      &block_list,
+                          const DoFHandlerType &dof_handler,
+                          const unsigned int    level,
+                          const bool            interior_dofs_only,
+                          const bool            boundary_dofs = false);
 
   /**
    * Create a block list with only a single patch, which in turn contains all
@@ -1717,11 +1717,11 @@ namespace DoFTools
    * @arg <tt>interior_dofs_only</tt>: if true, exclude degrees of freedom on
    * the boundary of the domain.
    */
-  template <class DH>
-  void make_single_patch(SparsityPattern &block_list,
-                         const DH &dof_handler,
-                         const unsigned int level,
-                         const bool interior_dofs_only = false);
+  template <typename DoFHandlerType>
+  void make_single_patch(SparsityPattern      &block_list,
+                         const DoFHandlerType &dof_handler,
+                         const unsigned int    level,
+                         const bool            interior_dofs_only = false);
 
   /**
    * @}
@@ -1765,12 +1765,12 @@ namespace DoFTools
    * in @p target_component. If this is not the case, an assertion is thrown.
    * The indices not targeted by target_components are left untouched.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  count_dofs_per_component (const DH      &dof_handler,
+  count_dofs_per_component (const DoFHandlerType                 &dof_handler,
                             std::vector<types::global_dof_index> &dofs_per_component,
-                            const bool vector_valued_once = false,
-                            std::vector<unsigned int>  target_component
+                            const bool                            vector_valued_once = false,
+                            std::vector<unsigned int> target_component
                             = std::vector<unsigned int>());
 
   /**
@@ -1789,9 +1789,9 @@ namespace DoFTools
    * element used by the dof_handler argument has blocks, or alternatively as
    * many blocks as are enumerated in the target_blocks argument if given.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  count_dofs_per_block (const DH &dof,
+  count_dofs_per_block (const DoFHandlerType                 &dof,
                         std::vector<types::global_dof_index> &dofs_per_block,
                         const std::vector<unsigned int>  &target_block
                         = std::vector<unsigned int>());
@@ -1806,9 +1806,9 @@ namespace DoFTools
    * finite element. For a hp::DoFHandler, the values may be different,
    * though.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  get_active_fe_indices (const DH                  &dof_handler,
+  get_active_fe_indices (const DoFHandlerType      &dof_handler,
                          std::vector<unsigned int> &active_fe_indices);
 
   /**
@@ -1825,10 +1825,10 @@ namespace DoFTools
    * between global degrees of freedom and the local ones.
    *
    * @tparam Container A type that is either DoFHandler or hp::DoFHandler. In
-   * C++, the compiler can not determine the type of <code>DH</code> from the
+   * C++, the compiler can not determine the type of <code>DoFHandlerType</code> from the
    * function call. You need to specify it as an explicit template argument
    * following the function name.
-   * @param patch A collection of cells within an object of type DH
+   * @param patch A collection of cells within an object of type DoFHandlerType
    * @return The number of degrees of freedom associated with the cells of
    * this patch.
    *
@@ -1842,9 +1842,9 @@ namespace DoFTools
    *
    * @author Arezou Ghesmati, Wolfgang Bangerth, 2014
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   unsigned int
-  count_dofs_on_patch (const std::vector<typename DH::active_cell_iterator> &patch);
+  count_dofs_on_patch (const std::vector<typename DoFHandlerType::active_cell_iterator> &patch);
 
   /**
    * Return the set of degrees of freedom that live on a set of cells (i.e., a
@@ -1877,10 +1877,10 @@ namespace DoFTools
    * system that results retains the block structure of the global system.
    *
    * @tparam Container A type that is either DoFHandler or hp::DoFHandler. In
-   * C++, the compiler can not determine the type of <code>DH</code> from the
+   * C++, the compiler can not determine the type of <code>DoFHandlerType</code> from the
    * function call. You need to specify it as an explicit template argument
    * following the function name.
-   * @param patch A collection of cells within an object of type DH
+   * @param patch A collection of cells within an object of type DoFHandlerType
    * @return A list of those global degrees of freedom located on the patch,
    * as defined above.
    *
@@ -1894,9 +1894,9 @@ namespace DoFTools
    *
    * @author Arezou Ghesmati, Wolfgang Bangerth, 2014
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   std::vector<types::global_dof_index>
-  get_dofs_on_patch (const std::vector<typename DH::active_cell_iterator> &patch);
+  get_dofs_on_patch (const std::vector<typename DoFHandlerType::active_cell_iterator> &patch);
 
   /**
    * @}
@@ -1915,10 +1915,10 @@ namespace DoFTools
    *
    * Prior content of @p mapping is deleted.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  map_dof_to_boundary_indices (const DH                   &dof_handler,
-                               std::vector<types::global_dof_index>  &mapping);
+  map_dof_to_boundary_indices (const DoFHandlerType                 &dof_handler,
+                               std::vector<types::global_dof_index> &mapping);
 
   /**
    * Same as the previous function, except that only those parts of the
@@ -1930,11 +1930,11 @@ namespace DoFTools
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  map_dof_to_boundary_indices (const DH                      &dof_handler,
-                               const std::set<types::boundary_id> &boundary_ids,
-                               std::vector<types::global_dof_index>     &mapping);
+  map_dof_to_boundary_indices (const DoFHandlerType                 &dof_handler,
+                               const std::set<types::boundary_id>   &boundary_ids,
+                               std::vector<types::global_dof_index> &mapping);
 
   /**
    * Return a list of support points (see this
@@ -2027,11 +2027,12 @@ namespace DoFTools
    * use here actually supports the notion of support points of all its
    * components.
    */
-  template <class DH, class Comp>
+  template <typename DoFHandlerType, class Comp>
   void
-  map_support_points_to_dofs (const Mapping<DH::dimension, DH::space_dimension> &mapping,
-                              const DH                                          &dof_handler,
-                              std::map<Point<DH::space_dimension>, types::global_dof_index, Comp> &point_to_index_map);
+  map_support_points_to_dofs
+  (const Mapping<DoFHandlerType::dimension, DoFHandlerType::space_dimension>       &mapping,
+   const DoFHandlerType                                                            &dof_handler,
+   std::map<Point<DoFHandlerType::space_dimension>, types::global_dof_index, Comp> &point_to_index_map);
 
   /**
    * Map a coupling table from the user friendly organization by components to
@@ -2088,12 +2089,12 @@ namespace DoFTools
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  template <int dim, int spacedim, template <int, int> class DH>
+  template <int dim, int spacedim, template <int, int> class DoFHandlerType>
   void
-  make_zero_boundary_constraints (const DH<dim,spacedim> &dof,
-                                  const types::boundary_id boundary_id,
-                                  ConstraintMatrix       &zero_boundary_constraints,
-                                  const ComponentMask    &component_mask = ComponentMask());
+  make_zero_boundary_constraints (const DoFHandlerType<dim,spacedim> &dof,
+                                  const types::boundary_id            boundary_id,
+                                  ConstraintMatrix                   &zero_boundary_constraints,
+                                  const ComponentMask                &component_mask = ComponentMask());
 
   /**
    * Do the same as the previous function, except do it for all parts of the
@@ -2105,11 +2106,11 @@ namespace DoFTools
    *
    * @ingroup constraints
    */
-  template <int dim, int spacedim, template <int, int> class DH>
+  template <int dim, int spacedim, template <int, int> class DoFHandlerType>
   void
-  make_zero_boundary_constraints (const DH<dim,spacedim> &dof,
-                                  ConstraintMatrix       &zero_boundary_constraints,
-                                  const ComponentMask    &component_mask = ComponentMask());
+  make_zero_boundary_constraints (const DoFHandlerType<dim,spacedim> &dof,
+                                  ConstraintMatrix                   &zero_boundary_constraints,
+                                  const ComponentMask                &component_mask = ComponentMask());
 
 
   /**
@@ -2317,17 +2318,18 @@ namespace DoFTools
   }
 
 
-  template <class DH, class Comp>
+  template <typename DoFHandlerType, class Comp>
   void
-  map_support_points_to_dofs (
-    const Mapping<DH::dimension,DH::space_dimension>         &mapping,
-    const DH                                                 &dof_handler,
-    std::map<Point<DH::space_dimension>, types::global_dof_index, Comp> &point_to_index_map)
+  map_support_points_to_dofs
+  (
+    const Mapping<DoFHandlerType::dimension,DoFHandlerType::space_dimension>        &mapping,
+    const DoFHandlerType                                                            &dof_handler,
+    std::map<Point<DoFHandlerType::space_dimension>, types::global_dof_index, Comp> &point_to_index_map)
   {
     // let the checking of arguments be
     // done by the function first
     // called
-    std::vector<Point<DH::space_dimension> > support_points (dof_handler.n_dofs());
+    std::vector<Point<DoFHandlerType::space_dimension> > support_points (dof_handler.n_dofs());
     map_dofs_to_support_points (mapping, dof_handler, support_points);
     // now copy over the results of the
     // previous function into the
diff --git a/include/deal.II/fe/fe_tools.h b/include/deal.II/fe/fe_tools.h
index 203fbd5770..b91fd60dd5 100644
--- a/include/deal.II/fe/fe_tools.h
+++ b/include/deal.II/fe/fe_tools.h
@@ -562,14 +562,14 @@ namespace FETools
    * @p distribute function of your hanging node constraints object.
    */
   template <int dim, int spacedim,
-            template <int,int> class DH1,
-            template <int,int> class DH2,
+            template <int, int> class DoFHandlerType1,
+            template <int, int> class DoFHandlerType2,
             class InVector, class OutVector>
   void
-  interpolate (const DH1<dim,spacedim> &dof1,
-               const InVector          &u1,
-               const DH2<dim,spacedim> &dof2,
-               OutVector               &u2);
+  interpolate (const DoFHandlerType1<dim,spacedim> &dof1,
+               const InVector                      &u1,
+               const DoFHandlerType2<dim,spacedim> &dof2,
+               OutVector                           &u2);
 
   /**
    * Gives the interpolation of a the @p dof1-function @p u1 to a @p
@@ -588,14 +588,14 @@ namespace FETools
    * at the discontinuities.
    */
   template <int dim, int spacedim,
-            template <int, int> class DH1,
-            template <int, int> class DH2,
+            template <int, int> class DoFHandlerType1,
+            template <int, int> class DoFHandlerType2,
             class InVector, class OutVector>
-  void interpolate (const DH1<dim,spacedim>  &dof1,
-                    const InVector           &u1,
-                    const DH2<dim,spacedim>  &dof2,
-                    const ConstraintMatrix   &constraints,
-                    OutVector                &u2);
+  void interpolate (const DoFHandlerType1<dim,spacedim> &dof1,
+                    const InVector                      &u1,
+                    const DoFHandlerType2<dim,spacedim> &dof2,
+                    const ConstraintMatrix              &constraints,
+                    OutVector                           &u2);
 
   /**
    * Gives the interpolation of the @p fe1-function @p u1 to a @p
@@ -621,12 +621,12 @@ namespace FETools
    * type @p hp::DoFHandler.
    */
   template <int dim,
-            template <int> class DH,
+            template <int> class DoFHandlerType,
             class InVector, class OutVector, int spacedim>
-  void back_interpolate (const DH<dim>            &dof1,
-                         const InVector           &u1,
+  void back_interpolate (const DoFHandlerType<dim>         &dof1,
+                         const InVector                    &u1,
                          const FiniteElement<dim,spacedim> &fe2,
-                         OutVector                &u1_interpolated);
+                         OutVector                         &u1_interpolated);
 
   /**
    * Gives the interpolation of the @p dof1-function @p u1 to a @p
diff --git a/include/deal.II/fe/fe_values.h b/include/deal.II/fe/fe_values.h
index 6aa1583170..02fcf60520 100644
--- a/include/deal.II/fe/fe_values.h
+++ b/include/deal.II/fe/fe_values.h
@@ -2810,8 +2810,8 @@ public:
    * associated with this object. It is assumed that the finite element used
    * by the given cell is also the one used by this FEValues object.
    */
-  template <template <int,int> class DH, bool level_dof_access>
-  void reinit (const TriaIterator<DoFCellAccessor<DH<dim,spacedim>,level_dof_access> > &cell);
+  template <template <int, int> class DoFHandlerType, bool level_dof_access>
+  void reinit (const TriaIterator<DoFCellAccessor<DoFHandlerType<dim,spacedim>,level_dof_access> > &cell);
 
   /**
    * Reinitialize the gradients, Jacobi determinants, etc for the given cell
@@ -3019,8 +3019,8 @@ public:
    * Reinitialize the gradients, Jacobi determinants, etc for the face with
    * number @p face_no of @p cell and the given finite element.
    */
-  template <template <int,int> class DH, bool level_dof_access>
-  void reinit (const TriaIterator<DoFCellAccessor<DH<dim,spacedim>,level_dof_access> > &cell,
+  template <template <int, int> class DoFHandlerType, bool level_dof_access>
+  void reinit (const TriaIterator<DoFCellAccessor<DoFHandlerType<dim,spacedim>,level_dof_access> > &cell,
                const unsigned int face_no);
 
   /**
@@ -3131,10 +3131,10 @@ public:
    * associated with this object. It is assumed that the finite element used
    * by the given cell is also the one used by this FESubfaceValues object.
    */
-  template <template <int,int> class DH, bool level_dof_access>
-  void reinit (const TriaIterator<DoFCellAccessor<DH<dim,spacedim>,level_dof_access> > &cell,
-               const unsigned int                    face_no,
-               const unsigned int                    subface_no);
+  template <template <int, int> class DoFHandlerType, bool level_dof_access>
+  void reinit (const TriaIterator<DoFCellAccessor<DoFHandlerType<dim,spacedim>,level_dof_access> > &cell,
+               const unsigned int face_no,
+               const unsigned int subface_no);
 
   /**
    * Reinitialize the gradients, Jacobi determinants, etc for the given
diff --git a/include/deal.II/fe/mapping_fe_field.h b/include/deal.II/fe/mapping_fe_field.h
index 1cda170a60..6703832b78 100644
--- a/include/deal.II/fe/mapping_fe_field.h
+++ b/include/deal.II/fe/mapping_fe_field.h
@@ -70,7 +70,7 @@ DEAL_II_NAMESPACE_OPEN
  */
 template <int dim, int spacedim=dim,
           typename VectorType=Vector<double>,
-          class DH=DoFHandler<dim,spacedim> >
+          typename DoFHandlerType=DoFHandler<dim,spacedim> >
 class MappingFEField : public Mapping<dim,spacedim>
 {
 public:
@@ -106,14 +106,14 @@ public:
    *
    * If an incompatible mask is passed, an exception is thrown.
    */
-  MappingFEField (const DH            &euler_dof_handler,
-                  const VectorType    &euler_vector,
-                  const ComponentMask mask=ComponentMask());
+  MappingFEField (const DoFHandlerType &euler_dof_handler,
+                  const VectorType     &euler_vector,
+                  const ComponentMask   mask = ComponentMask());
 
   /**
    * Copy constructor.
    */
-  MappingFEField (const MappingFEField<dim,spacedim,VectorType,DH> &mapping);
+  MappingFEField (const MappingFEField<dim,spacedim,VectorType,DoFHandlerType> &mapping);
 
   /**
    * Return a pointer to a copy of the present object. The caller of this copy
@@ -489,7 +489,7 @@ private:
   /**
    * Reference to the vector of shifts.
    */
-  SmartPointer<const VectorType, MappingFEField<dim,spacedim,VectorType,DH> > euler_vector;
+  SmartPointer<const VectorType, MappingFEField<dim,spacedim,VectorType,DoFHandlerType> > euler_vector;
 
   /**
    * A FiniteElement object which is only needed in 3D, since it knows how to
@@ -498,13 +498,13 @@ private:
    * prevent construction in 1D and 2D, but since memory and time requirements
    * are not particularly high this seems unnecessary at the moment.
    */
-  SmartPointer<const FiniteElement<dim,spacedim>, MappingFEField<dim,spacedim,VectorType,DH> > fe;
+  SmartPointer<const FiniteElement<dim,spacedim>, MappingFEField<dim,spacedim,VectorType,DoFHandlerType> > fe;
 
 
   /**
    * Pointer to the DoFHandler to which the mapping vector is associated.
    */
-  SmartPointer<const DH,MappingFEField<dim,spacedim,VectorType,DH> > euler_dof_handler;
+  SmartPointer<const DoFHandlerType,MappingFEField<dim,spacedim,VectorType,DoFHandlerType> > euler_dof_handler;
 
 private:
   /**
diff --git a/include/deal.II/hp/fe_values.h b/include/deal.II/hp/fe_values.h
index 936499d23f..5ad08b876b 100644
--- a/include/deal.II/hp/fe_values.h
+++ b/include/deal.II/hp/fe_values.h
@@ -309,12 +309,12 @@ namespace hp
      * mapping is used unless a different value for this argument is
      * specified.
      */
-    template <class DH, bool lda>
+    template <typename DoFHandlerType, bool lda>
     void
-    reinit (const TriaIterator<DoFCellAccessor<DH,lda> > cell,
-            const unsigned int q_index = numbers::invalid_unsigned_int,
+    reinit (const TriaIterator<DoFCellAccessor<DoFHandlerType,lda> > cell,
+            const unsigned int q_index       = numbers::invalid_unsigned_int,
             const unsigned int mapping_index = numbers::invalid_unsigned_int,
-            const unsigned int fe_index = numbers::invalid_unsigned_int);
+            const unsigned int fe_index      = numbers::invalid_unsigned_int);
 
     /**
      * Like the previous function, but for non-hp iterators. The reason this
@@ -332,9 +332,9 @@ namespace hp
      */
     void
     reinit (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
-            const unsigned int q_index = numbers::invalid_unsigned_int,
+            const unsigned int q_index       = numbers::invalid_unsigned_int,
             const unsigned int mapping_index = numbers::invalid_unsigned_int,
-            const unsigned int fe_index = numbers::invalid_unsigned_int);
+            const unsigned int fe_index      = numbers::invalid_unsigned_int);
 
 
   };
@@ -445,13 +445,13 @@ namespace hp
      * mapping is used unless a different value for this argument is
      * specified.
      */
-    template <class DH, bool lda>
+    template <typename DoFHandlerType, bool lda>
     void
-    reinit (const TriaIterator<DoFCellAccessor<DH,lda> > cell,
+    reinit (const TriaIterator<DoFCellAccessor<DoFHandlerType,lda> > cell,
             const unsigned int face_no,
-            const unsigned int q_index = numbers::invalid_unsigned_int,
+            const unsigned int q_index       = numbers::invalid_unsigned_int,
             const unsigned int mapping_index = numbers::invalid_unsigned_int,
-            const unsigned int fe_index = numbers::invalid_unsigned_int);
+            const unsigned int fe_index      = numbers::invalid_unsigned_int);
 
     /**
      * Like the previous function, but for non-hp iterators. The reason this
@@ -470,9 +470,9 @@ namespace hp
     void
     reinit (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
             const unsigned int face_no,
-            const unsigned int q_index = numbers::invalid_unsigned_int,
+            const unsigned int q_index       = numbers::invalid_unsigned_int,
             const unsigned int mapping_index = numbers::invalid_unsigned_int,
-            const unsigned int fe_index = numbers::invalid_unsigned_int);
+            const unsigned int fe_index      = numbers::invalid_unsigned_int);
   };
 
 
@@ -554,14 +554,14 @@ namespace hp
      * mapping is used unless a different value for this argument is
      * specified.
      */
-    template <class DH, bool lda>
+    template <typename DoFHandlerType, bool lda>
     void
-    reinit (const TriaIterator<DoFCellAccessor<DH,lda> > cell,
+    reinit (const TriaIterator<DoFCellAccessor<DoFHandlerType,lda> > cell,
             const unsigned int face_no,
             const unsigned int subface_no,
-            const unsigned int q_index = numbers::invalid_unsigned_int,
+            const unsigned int q_index       = numbers::invalid_unsigned_int,
             const unsigned int mapping_index = numbers::invalid_unsigned_int,
-            const unsigned int fe_index = numbers::invalid_unsigned_int);
+            const unsigned int fe_index      = numbers::invalid_unsigned_int);
 
     /**
      * Like the previous function, but for non-hp iterators. The reason this
@@ -581,9 +581,9 @@ namespace hp
     reinit (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
             const unsigned int face_no,
             const unsigned int subface_no,
-            const unsigned int q_index = numbers::invalid_unsigned_int,
+            const unsigned int q_index       = numbers::invalid_unsigned_int,
             const unsigned int mapping_index = numbers::invalid_unsigned_int,
-            const unsigned int fe_index = numbers::invalid_unsigned_int);
+            const unsigned int fe_index      = numbers::invalid_unsigned_int);
   };
 
 }
diff --git a/include/deal.II/matrix_free/fe_evaluation.h b/include/deal.II/matrix_free/fe_evaluation.h
index fa52f5e670..f63dc03edb 100644
--- a/include/deal.II/matrix_free/fe_evaluation.h
+++ b/include/deal.II/matrix_free/fe_evaluation.h
@@ -109,8 +109,8 @@ public:
    * also read from vectors (but less efficient than with data coming from
    * MatrixFree).
    */
-  template <class DH, bool level_dof_access>
-  void reinit (const TriaIterator<DoFCellAccessor<DH,level_dof_access> > &cell);
+  template <typename DoFHandlerType, bool level_dof_access>
+  void reinit (const TriaIterator<DoFCellAccessor<DoFHandlerType,level_dof_access> > &cell);
 
   /**
    * Initialize the data to the current cell using a TriaIterator object as
@@ -1990,11 +1990,11 @@ FEEvaluationBase<dim,n_components_,Number>::reinit (const unsigned int cell_in)
 
 
 template <int dim, int n_components_, typename Number>
-template <typename DH, bool level_dof_access>
+template <typename DoFHandlerType, bool level_dof_access>
 inline
 void
 FEEvaluationBase<dim,n_components_,Number>
-::reinit (const TriaIterator<DoFCellAccessor<DH,level_dof_access> > &cell)
+::reinit (const TriaIterator<DoFCellAccessor<DoFHandlerType,level_dof_access> > &cell)
 {
   Assert(matrix_info == 0,
          ExcMessage("Cannot use initialization from cell iterator if "
diff --git a/include/deal.II/matrix_free/matrix_free.h b/include/deal.II/matrix_free/matrix_free.h
index 4ef90dd6f6..0d070be5ef 100644
--- a/include/deal.II/matrix_free/matrix_free.h
+++ b/include/deal.II/matrix_free/matrix_free.h
@@ -292,9 +292,9 @@ public:
    * used, which gets the partitioning information builtin into the
    * DoFHandler.
    */
-  template <typename DH, typename QuadratureType>
+  template <typename DoFHandlerType, typename QuadratureType>
   void reinit (const Mapping<dim>     &mapping,
-               const DH               &dof_handler,
+               const DoFHandlerType   &dof_handler,
                const ConstraintMatrix &constraint,
                const IndexSet         &locally_owned_dofs,
                const QuadratureType   &quad,
@@ -304,9 +304,9 @@ public:
    * Initializes the data structures. Same as above, but with index set stored
    * in the DoFHandler for describing the locally owned degrees of freedom.
    */
-  template <typename DH, typename QuadratureType>
+  template <typename DoFHandlerType, typename QuadratureType>
   void reinit (const Mapping<dim>     &mapping,
-               const DH               &dof_handler,
+               const DoFHandlerType   &dof_handler,
                const ConstraintMatrix &constraint,
                const QuadratureType   &quad,
                const AdditionalData    additional_data = AdditionalData());
@@ -314,8 +314,8 @@ public:
   /**
    * Initializes the data structures. Same as above, but using a $Q_1$ mapping.
    */
-  template <typename DH, typename QuadratureType>
-  void reinit (const DH               &dof_handler,
+  template <typename DoFHandlerType, typename QuadratureType>
+  void reinit (const DoFHandlerType   &dof_handler,
                const ConstraintMatrix &constraint,
                const QuadratureType   &quad,
                const AdditionalData    additional_data = AdditionalData());
@@ -346,9 +346,9 @@ public:
    * used, which gets the partitioning information from the DoFHandler. This
    * is the most general initialization function.
    */
-  template <typename DH, typename QuadratureType>
+  template <typename DoFHandlerType, typename QuadratureType>
   void reinit (const Mapping<dim>                          &mapping,
-               const std::vector<const DH *>               &dof_handler,
+               const std::vector<const DoFHandlerType *>   &dof_handler,
                const std::vector<const ConstraintMatrix *> &constraint,
                const std::vector<IndexSet>                 &locally_owned_set,
                const std::vector<QuadratureType>           &quad,
@@ -359,9 +359,9 @@ public:
    * description of the locally owned range of degrees of freedom is taken
    * from the DoFHandler.
    */
-  template <typename DH, typename QuadratureType>
+  template <typename DoFHandlerType, typename QuadratureType>
   void reinit (const Mapping<dim>                          &mapping,
-               const std::vector<const DH *>               &dof_handler,
+               const std::vector<const DoFHandlerType *>   &dof_handler,
                const std::vector<const ConstraintMatrix *> &constraint,
                const std::vector<QuadratureType>           &quad,
                const AdditionalData                        additional_data = AdditionalData());
@@ -369,8 +369,8 @@ public:
   /**
    * Initializes the data structures. Same as above, but  using a $Q_1$ mapping.
    */
-  template <typename DH, typename QuadratureType>
-  void reinit (const std::vector<const DH *>               &dof_handler,
+  template <typename DoFHandlerType, typename QuadratureType>
+  void reinit (const std::vector<const DoFHandlerType *>   &dof_handler,
                const std::vector<const ConstraintMatrix *> &constraint,
                const std::vector<QuadratureType>           &quad,
                const AdditionalData                        additional_data = AdditionalData());
@@ -382,9 +382,9 @@ public:
    * as might be necessary when several components in a vector-valued problem
    * are integrated together based on the same quadrature formula.
    */
-  template <typename DH, typename QuadratureType>
+  template <typename DoFHandlerType, typename QuadratureType>
   void reinit (const Mapping<dim>                          &mapping,
-               const std::vector<const DH *>               &dof_handler,
+               const std::vector<const DoFHandlerType *>   &dof_handler,
                const std::vector<const ConstraintMatrix *> &constraint,
                const QuadratureType                        &quad,
                const AdditionalData                        additional_data = AdditionalData());
@@ -392,8 +392,8 @@ public:
   /**
    * Initializes the data structures. Same as above, but  using a $Q_1$ mapping.
    */
-  template <typename DH, typename QuadratureType>
-  void reinit (const std::vector<const DH *>               &dof_handler,
+  template <typename DoFHandlerType, typename QuadratureType>
+  void reinit (const std::vector<const DoFHandlerType *>   &dof_handler,
                const std::vector<const ConstraintMatrix *> &constraint,
                const QuadratureType                        &quad,
                const AdditionalData                        additional_data = AdditionalData());
@@ -1425,10 +1425,10 @@ namespace internal
 {
   namespace MatrixFree
   {
-    template <typename DH>
+    template <typename DoFHandlerType>
     inline
     std::vector<IndexSet>
-    extract_locally_owned_index_sets (const std::vector<const DH *> &dofh,
+    extract_locally_owned_index_sets (const std::vector<const DoFHandlerType *> &dofh,
                                       const unsigned int level)
     {
       std::vector<IndexSet> locally_owned_set;
@@ -1462,14 +1462,14 @@ namespace internal
 
 
 template <int dim, typename Number>
-template <typename DH, typename QuadratureType>
+template <typename DoFHandlerType, typename QuadratureType>
 void MatrixFree<dim,Number>::
-reinit(const DH                                              &dof_handler,
+reinit(const DoFHandlerType                                  &dof_handler,
        const ConstraintMatrix                                &constraints_in,
        const QuadratureType                                  &quad,
        const typename MatrixFree<dim,Number>::AdditionalData additional_data)
 {
-  std::vector<const DH *>               dof_handlers;
+  std::vector<const DoFHandlerType *>   dof_handlers;
   std::vector<const ConstraintMatrix *> constraints;
   std::vector<QuadratureType>           quads;
 
@@ -1487,15 +1487,15 @@ reinit(const DH                                              &dof_handler,
 
 
 template <int dim, typename Number>
-template <typename DH, typename QuadratureType>
+template <typename DoFHandlerType, typename QuadratureType>
 void MatrixFree<dim,Number>::
 reinit(const Mapping<dim>                                    &mapping,
-       const DH                                              &dof_handler,
+       const DoFHandlerType                                  &dof_handler,
        const ConstraintMatrix                                &constraints_in,
        const QuadratureType                                  &quad,
        const typename MatrixFree<dim,Number>::AdditionalData additional_data)
 {
-  std::vector<const DH *>               dof_handlers;
+  std::vector<const DoFHandlerType *>   dof_handlers;
   std::vector<const ConstraintMatrix *> constraints;
   std::vector<QuadratureType>           quads;
 
@@ -1513,9 +1513,9 @@ reinit(const Mapping<dim>                                    &mapping,
 
 
 template <int dim, typename Number>
-template <typename DH, typename QuadratureType>
+template <typename DoFHandlerType, typename QuadratureType>
 void MatrixFree<dim,Number>::
-reinit(const std::vector<const DH *>               &dof_handler,
+reinit(const std::vector<const DoFHandlerType *>   &dof_handler,
        const std::vector<const ConstraintMatrix *> &constraint,
        const std::vector<QuadratureType>           &quad,
        const typename MatrixFree<dim,Number>::AdditionalData additional_data)
@@ -1531,9 +1531,9 @@ reinit(const std::vector<const DH *>               &dof_handler,
 
 
 template <int dim, typename Number>
-template <typename DH, typename QuadratureType>
+template <typename DoFHandlerType, typename QuadratureType>
 void MatrixFree<dim,Number>::
-reinit(const std::vector<const DH *>                         &dof_handler,
+reinit(const std::vector<const DoFHandlerType *>             &dof_handler,
        const std::vector<const ConstraintMatrix *>           &constraint,
        const QuadratureType                                  &quad,
        const typename MatrixFree<dim,Number>::AdditionalData additional_data)
@@ -1550,10 +1550,10 @@ reinit(const std::vector<const DH *>                         &dof_handler,
 
 
 template <int dim, typename Number>
-template <typename DH, typename QuadratureType>
+template <typename DoFHandlerType, typename QuadratureType>
 void MatrixFree<dim,Number>::
 reinit(const Mapping<dim>                                    &mapping,
-       const std::vector<const DH *>                         &dof_handler,
+       const std::vector<const DoFHandlerType *>             &dof_handler,
        const std::vector<const ConstraintMatrix *>           &constraint,
        const QuadratureType                                  &quad,
        const typename MatrixFree<dim,Number>::AdditionalData additional_data)
@@ -1570,10 +1570,10 @@ reinit(const Mapping<dim>                                    &mapping,
 
 
 template <int dim, typename Number>
-template <typename DH, typename QuadratureType>
+template <typename DoFHandlerType, typename QuadratureType>
 void MatrixFree<dim,Number>::
 reinit(const Mapping<dim>                                   &mapping,
-       const std::vector<const DH *>                        &dof_handler,
+       const std::vector<const DoFHandlerType *>            &dof_handler,
        const std::vector<const ConstraintMatrix *>          &constraint,
        const std::vector<QuadratureType>                    &quad,
        const typename MatrixFree<dim,Number>::AdditionalData additional_data)
@@ -1588,10 +1588,10 @@ reinit(const Mapping<dim>                                   &mapping,
 
 
 template <int dim, typename Number>
-template <typename DH, typename QuadratureType>
+template <typename DoFHandlerType, typename QuadratureType>
 void MatrixFree<dim,Number>::
 reinit(const Mapping<dim>                                    &mapping,
-       const std::vector<const DH *>                         &dof_handler,
+       const std::vector<const DoFHandlerType *>             &dof_handler,
        const std::vector<const ConstraintMatrix *>           &constraint,
        const std::vector<IndexSet>                           &locally_owned_set,
        const std::vector<QuadratureType>                     &quad,
diff --git a/include/deal.II/multigrid/mg_tools.h b/include/deal.II/multigrid/mg_tools.h
index 346ee4c430..233bee6de0 100644
--- a/include/deal.II/multigrid/mg_tools.h
+++ b/include/deal.II/multigrid/mg_tools.h
@@ -81,9 +81,9 @@ namespace MGTools
    * There is no need to consider hanging nodes here, since only one level is
    * considered.
    */
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
-  make_sparsity_pattern (const DH           &dof_handler,
+  make_sparsity_pattern (const DoFHandlerType           &dof_handler,
                          SP                 &sparsity,
                          const unsigned int level);
 
@@ -150,11 +150,11 @@ namespace MGTools
    * Result is a vector containing for each level a vector containing the
    * number of dofs for each block (access is <tt>result[level][block]</tt>).
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  count_dofs_per_block (const DH     &dof_handler,
+  count_dofs_per_block (const DoFHandlerType                               &dof_handler,
                         std::vector<std::vector<types::global_dof_index> > &dofs_per_block,
-                        std::vector<unsigned int>  target_block = std::vector<unsigned int>());
+                        std::vector<unsigned int> target_block = std::vector<unsigned int>());
 
   /**
    * Count the dofs component-wise on each level.
diff --git a/include/deal.II/multigrid/mg_transfer.h b/include/deal.II/multigrid/mg_transfer.h
index ae936df4b4..4527a7d26a 100644
--- a/include/deal.II/multigrid/mg_transfer.h
+++ b/include/deal.II/multigrid/mg_transfer.h
@@ -49,8 +49,8 @@ namespace internal
     typedef ::dealii::SparsityPattern Sparsity;
     typedef ::dealii::SparseMatrix<typename VectorType::value_type> Matrix;
 
-    template <class DSP, class DH>
-    static void reinit(Matrix &matrix, Sparsity &sparsity, int level, const DSP &dsp, const DH &)
+    template <class DSP, typename DoFHandlerType>
+    static void reinit(Matrix &matrix, Sparsity &sparsity, int level, const DSP &dsp, const DoFHandlerType &)
     {
       sparsity.copy_from (dsp);
       (void)level;
@@ -65,8 +65,8 @@ namespace internal
     typedef ::dealii::TrilinosWrappers::SparsityPattern Sparsity;
     typedef ::dealii::TrilinosWrappers::SparseMatrix Matrix;
 
-    template <class DSP, class DH>
-    static void reinit(Matrix &matrix, Sparsity &, int level, const DSP &dsp, DH &dh)
+    template <class DSP, typename DoFHandlerType>
+    static void reinit(Matrix &matrix, Sparsity &, int level, const DSP &dsp, DoFHandlerType &dh)
     {
       matrix.reinit(dh.locally_owned_mg_dofs(level+1),
                     dh.locally_owned_mg_dofs(level),
@@ -80,8 +80,8 @@ namespace internal
     typedef ::dealii::TrilinosWrappers::SparsityPattern Sparsity;
     typedef ::dealii::TrilinosWrappers::SparseMatrix Matrix;
 
-    template <class DSP, class DH>
-    static void reinit(Matrix &matrix, Sparsity &, int level, const DSP &dsp, DH &dh)
+    template <class DSP, typename DoFHandlerType>
+    static void reinit(Matrix &matrix, Sparsity &, int level, const DSP &dsp, DoFHandlerType &dh)
     {
       matrix.reinit(dh.locally_owned_mg_dofs(level+1),
                     dh.locally_owned_mg_dofs(level),
@@ -96,8 +96,8 @@ namespace internal
     typedef ::dealii::TrilinosWrappers::SparsityPattern Sparsity;
     typedef ::dealii::TrilinosWrappers::SparseMatrix Matrix;
 
-    template <class DSP, class DH>
-    static void reinit(Matrix &, Sparsity &, int /*level*/, const DSP &, DH &)
+    template <class DSP, typename DoFHandlerType>
+    static void reinit(Matrix &, Sparsity &, int /*level*/, const DSP &, DoFHandlerType &)
     {
     }
   };
diff --git a/include/deal.II/multigrid/sparse_matrix_collection.h b/include/deal.II/multigrid/sparse_matrix_collection.h
index 31fa1b2516..ffa91fa48f 100644
--- a/include/deal.II/multigrid/sparse_matrix_collection.h
+++ b/include/deal.II/multigrid/sparse_matrix_collection.h
@@ -42,8 +42,8 @@ namespace mg
   public:
     void resize(const unsigned int minlevel, const unsigned  int maxlevel);
 
-    template <class DH>
-    void reinit(const DH &dof_handler);
+    template <typename DoFHandlerType>
+    void reinit(const DoFHandlerType &dof_handler);
 
     void set_zero();
 
@@ -78,9 +78,9 @@ namespace mg
 
 
   template <typename number>
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  SparseMatrixCollection<number>::reinit(const DH &dof_handler)
+  SparseMatrixCollection<number>::reinit(const DoFHandlerType &dof_handler)
   {
     AssertIndexRange(sparsity.max_level(), dof_handler.get_tria().n_levels());
 
diff --git a/include/deal.II/numerics/data_out.h b/include/deal.II/numerics/data_out.h
index 23364561ad..b729a776eb 100644
--- a/include/deal.II/numerics/data_out.h
+++ b/include/deal.II/numerics/data_out.h
@@ -146,7 +146,7 @@ namespace internal
  *
  * @pre This class only makes sense if the first template argument,
  * <code>dim</code> equals the dimension of the DoFHandler type given as the
- * second template argument, i.e., if <code>dim == DH::dimension</code>. This
+ * second template argument, i.e., if <code>dim == DoFHandlerType::dimension</code>. This
  * redundancy is a historical relic from the time where the library had only a
  * single DoFHandler class and this class consequently only a single template
  * argument.
@@ -154,16 +154,18 @@ namespace internal
  * @ingroup output
  * @author Wolfgang Bangerth, 1999
  */
-template <int dim, class DH=DoFHandler<dim> >
-class DataOut : public DataOut_DoFData<DH, DH::dimension, DH::space_dimension>
+template <int dim, typename DoFHandlerType=DoFHandler<dim> >
+class DataOut : public DataOut_DoFData<DoFHandlerType, DoFHandlerType::dimension, DoFHandlerType::space_dimension>
 {
 public:
   /**
    * Typedef to the iterator type of the dof handler class under
    * consideration.
    */
-  typedef typename DataOut_DoFData<DH,DH::dimension,DH::space_dimension>::cell_iterator cell_iterator;
-  typedef typename DataOut_DoFData<DH,DH::dimension,DH::space_dimension>::active_cell_iterator active_cell_iterator;
+  typedef typename DataOut_DoFData<DoFHandlerType, DoFHandlerType::dimension, DoFHandlerType::space_dimension>::cell_iterator
+  cell_iterator;
+  typedef typename DataOut_DoFData<DoFHandlerType, DoFHandlerType::dimension, DoFHandlerType::space_dimension>::active_cell_iterator
+  active_cell_iterator;
 
   /**
    * Enumeration describing the region of the domain in which curved cells
@@ -243,7 +245,7 @@ public:
    * @todo The @p mapping argument should be replaced by a
    * hp::MappingCollection in case of a hp::DoFHandler.
    */
-  virtual void build_patches (const Mapping<DH::dimension,DH::space_dimension> &mapping,
+  virtual void build_patches (const Mapping<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &mapping,
                               const unsigned int n_subdivisions = 0,
                               const CurvedCellRegion curved_region = curved_boundary);
 
@@ -291,11 +293,12 @@ private:
    * The function does not take a CopyData object but rather allocates one
    * on its own stack for memory access efficiency reasons.
    */
-  void build_one_patch (const std::pair<cell_iterator, unsigned int>                         *cell_and_index,
-                        internal::DataOut::ParallelData<DH::dimension, DH::space_dimension>  &scratch_data,
-                        const unsigned int                                                    n_subdivisions,
-                        const CurvedCellRegion                                                curved_cell_region,
-                        std::vector<DataOutBase::Patch<DH::dimension, DH::space_dimension> > &patches);
+  void build_one_patch
+  (const std::pair<cell_iterator, unsigned int>                 *cell_and_index,
+   internal::DataOut::ParallelData<DoFHandlerType::dimension, DoFHandlerType::space_dimension>  &scratch_data,
+   const unsigned int                                            n_subdivisions,
+   const CurvedCellRegion                                        curved_cell_region,
+   std::vector<DataOutBase::Patch<DoFHandlerType::dimension, DoFHandlerType::space_dimension> > &patches);
 };
 
 
diff --git a/include/deal.II/numerics/data_out_dof_data.h b/include/deal.II/numerics/data_out_dof_data.h
index 0db667e817..1c0e7e6bdc 100644
--- a/include/deal.II/numerics/data_out_dof_data.h
+++ b/include/deal.II/numerics/data_out_dof_data.h
@@ -161,7 +161,7 @@ namespace internal
      *
      * @author Wolfgang Bangerth, 2004
      */
-    template <class DH>
+    template <typename DoFHandlerType>
     class DataEntryBase
     {
     public:
@@ -170,7 +170,7 @@ namespace internal
        * the vector and their interpretation as scalar or vector data. This
        * constructor assumes that no postprocessor is going to be used.
        */
-      DataEntryBase (const DH                       *dofs,
+      DataEntryBase (const DoFHandlerType           *dofs,
                      const std::vector<std::string> &names,
                      const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation);
 
@@ -179,8 +179,8 @@ namespace internal
        * case, the names and vector declarations are going to be acquired from
        * the postprocessor.
        */
-      DataEntryBase (const DH                       *dofs,
-                     const DataPostprocessor<DH::space_dimension> *data_postprocessor);
+      DataEntryBase (const DoFHandlerType *dofs,
+                     const DataPostprocessor<DoFHandlerType::space_dimension> *data_postprocessor);
 
       /**
        * Destructor made virtual.
@@ -201,8 +201,9 @@ namespace internal
        */
       virtual
       void
-      get_function_values (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-                           std::vector<double>             &patch_values) const = 0;
+      get_function_values
+      (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+       std::vector<double> &patch_values) const = 0;
 
       /**
        * Given a FEValuesBase object, extract the values on the present cell
@@ -211,8 +212,9 @@ namespace internal
        */
       virtual
       void
-      get_function_values (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-                           std::vector<dealii::Vector<double> >    &patch_values_system) const = 0;
+      get_function_values
+      (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+       std::vector<dealii::Vector<double> > &patch_values_system) const = 0;
 
       /**
        * Given a FEValuesBase object, extract the gradients on the present
@@ -220,8 +222,9 @@ namespace internal
        */
       virtual
       void
-      get_function_gradients (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-                              std::vector<Tensor<1,DH::space_dimension> >       &patch_gradients) const = 0;
+      get_function_gradients
+      (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+       std::vector<Tensor<1,DoFHandlerType::space_dimension> > &patch_gradients) const = 0;
 
       /**
        * Given a FEValuesBase object, extract the gradients on the present
@@ -230,8 +233,9 @@ namespace internal
        */
       virtual
       void
-      get_function_gradients (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-                              std::vector<std::vector<Tensor<1,DH::space_dimension> > > &patch_gradients_system) const = 0;
+      get_function_gradients
+      (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+       std::vector<std::vector<Tensor<1,DoFHandlerType::space_dimension> > > &patch_gradients_system) const = 0;
 
       /**
        * Given a FEValuesBase object, extract the second derivatives on the
@@ -239,8 +243,9 @@ namespace internal
        */
       virtual
       void
-      get_function_hessians (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-                             std::vector<Tensor<2,DH::space_dimension> >       &patch_hessians) const = 0;
+      get_function_hessians
+      (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+       std::vector<Tensor<2,DoFHandlerType::space_dimension> > &patch_hessians) const = 0;
 
       /**
        * Given a FEValuesBase object, extract the second derivatives on the
@@ -249,8 +254,9 @@ namespace internal
        */
       virtual
       void
-      get_function_hessians (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-                             std::vector<std::vector< Tensor<2,DH::space_dimension> > > &patch_hessians_system) const = 0;
+      get_function_hessians
+      (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+       std::vector<std::vector< Tensor<2,DoFHandlerType::space_dimension> > > &patch_hessians_system) const = 0;
 
       /**
        * Clear all references to the vectors.
@@ -266,7 +272,7 @@ namespace internal
       /**
        * Pointer to the DoFHandler object that the vector is based on.
        */
-      SmartPointer<const DH> dof_handler;
+      SmartPointer<const DoFHandlerType> dof_handler;
 
       /**
        * Names of the components of this data vector.
@@ -285,7 +291,7 @@ namespace internal
        * Pointer to a DataPostprocessing object which shall be applied to this
        * data vector.
        */
-      SmartPointer<const dealii::DataPostprocessor<DH::space_dimension> > postprocessor;
+      SmartPointer<const dealii::DataPostprocessor<DoFHandlerType::space_dimension> > postprocessor;
 
       /**
        * Number of output variables this dataset provides (either number of
@@ -326,8 +332,8 @@ namespace internal
 
       ParallelDataBase (const ParallelDataBase &data);
 
-      template <typename DH>
-      void reinit_all_fe_values(std::vector<std_cxx11::shared_ptr<DataEntryBase<DH> > > &dof_data,
+      template <typename DoFHandlerType>
+      void reinit_all_fe_values(std::vector<std_cxx11::shared_ptr<DataEntryBase<DoFHandlerType> > > &dof_data,
                                 const typename dealii::Triangulation<dim,spacedim>::cell_iterator &cell,
                                 const unsigned int face = numbers::invalid_unsigned_int);
 
@@ -501,7 +507,7 @@ namespace internal
  * @ingroup output
  * @author Wolfgang Bangerth, 1999
  */
-template <class DH, int patch_dim, int patch_space_dim=patch_dim>
+template <typename DoFHandlerType, int patch_dim, int patch_space_dim=patch_dim>
 class DataOut_DoFData : public DataOutInterface<patch_dim,patch_space_dim>
 {
 public:
@@ -510,8 +516,8 @@ public:
    * Typedef to the iterator type of the dof handler class under
    * consideration.
    */
-  typedef typename Triangulation<DH::dimension,DH::space_dimension>::cell_iterator cell_iterator;
-  typedef typename Triangulation<DH::dimension,DH::space_dimension>::active_cell_iterator active_cell_iterator;
+  typedef typename Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::cell_iterator cell_iterator;
+  typedef typename Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::active_cell_iterator active_cell_iterator;
 
 public:
 
@@ -559,7 +565,7 @@ public:
    * This call is optional: If you add data vectors with specified DoFHandler
    * object, then that contains all information needed to generate the output.
    */
-  void attach_dof_handler (const DH &);
+  void attach_dof_handler (const DoFHandlerType &);
 
   /**
    * Designate a triangulation to be used to extract geometry data and the
@@ -570,8 +576,8 @@ public:
    * This call is useful when you only output cell vectors and no DoFHandler
    * at all, in which case it provides the geometry.
    */
-  void attach_triangulation (const Triangulation<DH::dimension,
-                             DH::space_dimension> &);
+  void attach_triangulation (const Triangulation<DoFHandlerType::dimension,
+                             DoFHandlerType::space_dimension> &);
 
   /**
    * Add a data vector together with its name.
@@ -683,7 +689,7 @@ public:
    * methods above is skipped.
    */
   template <class VectorType>
-  void add_data_vector (const DH                       &dof_handler,
+  void add_data_vector (const DoFHandlerType           &dof_handler,
                         const VectorType               &data,
                         const std::vector<std::string> &names,
                         const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation
@@ -695,7 +701,7 @@ public:
    * @p dof_handler given and a single data name.
    */
   template <class VectorType>
-  void add_data_vector (const DH          &dof_handler,
+  void add_data_vector (const DoFHandlerType          &dof_handler,
                         const VectorType  &data,
                         const std::string &name,
                         const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation
@@ -731,7 +737,7 @@ public:
    */
   template <class VectorType>
   void add_data_vector (const VectorType                             &data,
-                        const DataPostprocessor<DH::space_dimension> &data_postprocessor);
+                        const DataPostprocessor<DoFHandlerType::space_dimension> &data_postprocessor);
 
   /**
    * Same function as above, but with a DoFHandler object that does not need
@@ -740,9 +746,9 @@ public:
    * vector, not other solution vectors or DoFHandlers.
    */
   template <class VectorType>
-  void add_data_vector (const DH                                     &dof_handler,
+  void add_data_vector (const DoFHandlerType                         &dof_handler,
                         const VectorType                             &data,
-                        const DataPostprocessor<DH::space_dimension> &data_postprocessor);
+                        const DataPostprocessor<DoFHandlerType::space_dimension> &data_postprocessor);
 
   /**
    * Release the pointers to the data vectors. This allows output of a new set
@@ -787,8 +793,8 @@ public:
    * This function will fail if either this or the other object did not yet
    * set up any patches.
    */
-  template <class DH2>
-  void merge_patches (const DataOut_DoFData<DH2,patch_dim,patch_space_dim> &source,
+  template <typename DoFHandlerType2>
+  void merge_patches (const DataOut_DoFData<DoFHandlerType2,patch_dim,patch_space_dim> &source,
                       const Point<patch_space_dim> &shift = Point<patch_space_dim>());
 
   /**
@@ -814,22 +820,22 @@ protected:
   /**
    * Pointer to the triangulation object.
    */
-  SmartPointer<const Triangulation<DH::dimension,DH::space_dimension> > triangulation;
+  SmartPointer<const Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> > triangulation;
 
   /**
    * Pointer to the optional handler object.
    */
-  SmartPointer<const DH> dofs;
+  SmartPointer<const DoFHandlerType> dofs;
 
   /**
    * List of data elements with vectors of values for each degree of freedom.
    */
-  std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> > >  dof_data;
+  std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > >  dof_data;
 
   /**
    * List of data elements with vectors of values for each cell.
    */
-  std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> > >  cell_data;
+  std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > >  cell_data;
 
   /**
    * This is a list of patches that is created each time build_patches() is
@@ -856,7 +862,7 @@ protected:
    * Extracts the finite elements stored in the dof_data object, including a
    * dummy object of FE_DGQ<dim>(0) in case only the triangulation is used.
    */
-  std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<DH::dimension,DH::space_dimension> > >
+  std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<DoFHandlerType::dimension,DoFHandlerType::space_dimension> > >
   get_finite_elements() const;
 
   /**
@@ -880,11 +886,11 @@ protected:
 // -------------------- template and inline functions ------------------------
 
 
-template <class DH, int patch_dim, int patch_space_dim>
-template <class DH2>
+template <typename DoFHandlerType, int patch_dim, int patch_space_dim>
+template <typename DoFHandlerType2>
 void
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::
-merge_patches (const DataOut_DoFData<DH2,patch_dim,patch_space_dim> &source,
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::
+merge_patches (const DataOut_DoFData<DoFHandlerType2,patch_dim,patch_space_dim> &source,
                const Point<patch_space_dim> &shift)
 {
   const std::vector<Patch> source_patches = source.get_patches ();
diff --git a/include/deal.II/numerics/data_out_faces.h b/include/deal.II/numerics/data_out_faces.h
index 4cf2ad4a85..165bb103e8 100644
--- a/include/deal.II/numerics/data_out_faces.h
+++ b/include/deal.II/numerics/data_out_faces.h
@@ -99,7 +99,7 @@ namespace internal
  *
  * @pre This class only makes sense if the first template argument,
  * <code>dim</code> equals the dimension of the DoFHandler type given as the
- * second template argument, i.e., if <code>dim == DH::dimension</code>. This
+ * second template argument, i.e., if <code>dim == DoFHandlerType::dimension</code>. This
  * redundancy is a historical relic from the time where the library had only a
  * single DoFHandler class and this class consequently only a single template
  * argument.
@@ -110,28 +110,28 @@ namespace internal
  * @ingroup output
  * @author Wolfgang Bangerth, Guido Kanschat, 2000, 2011
  */
-template <int dim, class DH=DoFHandler<dim> >
-class DataOutFaces : public DataOut_DoFData<DH,DH::dimension-1,
-  DH::dimension>
+template <int dim, typename DoFHandlerType=DoFHandler<dim> >
+class DataOutFaces : public DataOut_DoFData<DoFHandlerType,DoFHandlerType::dimension-1,
+  DoFHandlerType::dimension>
 {
 public:
   /**
    * An abbreviation for the dimension of the DoFHandler object we work with.
    * Faces are then <code>dimension-1</code> dimensional objects.
    */
-  static const unsigned int dimension = DH::dimension;
+  static const unsigned int dimension = DoFHandlerType::dimension;
 
   /**
    * An abbreviation for the spatial dimension within which the triangulation
    * and DoFHandler are embedded in.
    */
-  static const unsigned int space_dimension = DH::space_dimension;
+  static const unsigned int space_dimension = DoFHandlerType::space_dimension;
 
   /**
    * Typedef to the iterator type of the dof handler class under
    * consideration.
    */
-  typedef typename DataOut_DoFData<DH,dimension-1,
+  typedef typename DataOut_DoFData<DoFHandlerType,dimension-1,
           dimension>::cell_iterator cell_iterator;
 
   /**
diff --git a/include/deal.II/numerics/data_out_rotation.h b/include/deal.II/numerics/data_out_rotation.h
index edf6a500d9..8b818f9901 100644
--- a/include/deal.II/numerics/data_out_rotation.h
+++ b/include/deal.II/numerics/data_out_rotation.h
@@ -107,7 +107,7 @@ namespace internal
  *
  * @pre This class only makes sense if the first template argument,
  * <code>dim</code> equals the dimension of the DoFHandler type given as the
- * second template argument, i.e., if <code>dim == DH::dimension</code>. This
+ * second template argument, i.e., if <code>dim == DoFHandlerType::dimension</code>. This
  * redundancy is a historical relic from the time where the library had only a
  * single DoFHandler class and this class consequently only a single template
  * argument.
@@ -115,27 +115,27 @@ namespace internal
  * @ingroup output
  * @author Wolfgang Bangerth, 2000
  */
-template <int dim, class DH=DoFHandler<dim> >
-class DataOutRotation : public DataOut_DoFData<DH,DH::dimension+1>
+template <int dim, typename DoFHandlerType=DoFHandler<dim> >
+class DataOutRotation : public DataOut_DoFData<DoFHandlerType,DoFHandlerType::dimension+1>
 {
 public:
   /**
    * An abbreviation for the dimension of the DoFHandler object we work with.
    * Faces are then <code>dimension-1</code> dimensional objects.
    */
-  static const unsigned int dimension = DH::dimension;
+  static const unsigned int dimension = DoFHandlerType::dimension;
 
   /**
    * An abbreviation for the spatial dimension within which the triangulation
    * and DoFHandler are embedded in.
    */
-  static const unsigned int space_dimension = DH::space_dimension;
+  static const unsigned int space_dimension = DoFHandlerType::space_dimension;
 
   /**
    * Typedef to the iterator type of the dof handler class under
    * consideration.
    */
-  typedef typename DataOut_DoFData<DH,dimension+1>::cell_iterator cell_iterator;
+  typedef typename DataOut_DoFData<DoFHandlerType,dimension+1>::cell_iterator cell_iterator;
 
   /**
    * This is the central function of this class since it builds the list of
diff --git a/include/deal.II/numerics/data_out_stack.h b/include/deal.II/numerics/data_out_stack.h
index d244fb59b0..4a1e071d06 100644
--- a/include/deal.II/numerics/data_out_stack.h
+++ b/include/deal.II/numerics/data_out_stack.h
@@ -105,7 +105,7 @@ template <int dim, int spacedim> class DoFHandler;
  * @ingroup output
  * @author Wolfgang Bangerth, 1999
  */
-template <int dim, int spacedim=dim, class DH = DoFHandler<dim,spacedim> >
+template <int dim, int spacedim=dim, typename DoFHandlerType = DoFHandler<dim,spacedim> >
 class DataOutStack : public DataOutInterface<dim+1>
 {
 public:
@@ -136,7 +136,7 @@ public:
    * This has to happen before adding data vectors for the present parameter
    * value.
    */
-  void attach_dof_handler (const DH &dof_handler);
+  void attach_dof_handler (const DoFHandlerType &dof_handler);
 
   /**
    * Declare a data vector. The @p vector_type argument determines whether the
@@ -289,7 +289,7 @@ private:
    * DoF handler to be used for the data corresponding to the present
    * parameter value.
    */
-  SmartPointer<const DH,DataOutStack<dim,spacedim,DH> > dof_handler;
+  SmartPointer<const DoFHandlerType,DataOutStack<dim,spacedim,DoFHandlerType> > dof_handler;
 
   /**
    * List of patches of all past and present parameter value data sets.
diff --git a/include/deal.II/numerics/derivative_approximation.h b/include/deal.II/numerics/derivative_approximation.h
index d3c55ec25e..5f232acd13 100644
--- a/include/deal.II/numerics/derivative_approximation.h
+++ b/include/deal.II/numerics/derivative_approximation.h
@@ -76,9 +76,9 @@ namespace hp
  * @code
  * --------------------------------------------------------
  * An error occurred in line <749> of file <source/numerics/derivative_approximation.cc> in function
- *     void DerivativeApproximation::approximate(const Mapping<dim,spacedim>&, const DH<dim,spacedim>&, const InputVector&, unsigned int, const
+ *     void DerivativeApproximation::approximate(const Mapping<dim,spacedim>&, const DoFHandlerType<dim,spacedim>&, const InputVector&, unsigned int, const
  *  std::pair<unsigned int, unsigned int>&, Vector<float>&) [with DerivativeDescription = DerivativeApproximation::Gradient<3>, int
- * dim = 3, DH = DoFHandler, InputVector = Vector<double>]
+ * dim = 3, DoFHandlerType = DoFHandler, InputVector = Vector<double>]
  * The violated condition was:
  *     determinant(Y) != 0
  * The name and call sequence of the exception was:
@@ -178,24 +178,24 @@ namespace DerivativeApproximation
    * In a parallel computation the @p solution vector needs to contain the
    * locally relevant unknowns.
    */
-  template <int dim, template <int, int> class DH, class InputVector, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, class InputVector, int spacedim>
   void
-  approximate_gradient (const Mapping<dim,spacedim>    &mapping,
-                        const DH<dim,spacedim>         &dof,
-                        const InputVector     &solution,
-                        Vector<float>         &derivative_norm,
-                        const unsigned int     component = 0);
+  approximate_gradient (const Mapping<dim,spacedim>        &mapping,
+                        const DoFHandlerType<dim,spacedim> &dof,
+                        const InputVector                  &solution,
+                        Vector<float>                      &derivative_norm,
+                        const unsigned int                  component = 0);
 
   /**
    * Calls the @p interpolate function, see above, with
    * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
    */
-  template <int dim, template <int, int> class DH, class InputVector, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, class InputVector, int spacedim>
   void
-  approximate_gradient (const DH<dim,spacedim>         &dof,
-                        const InputVector     &solution,
-                        Vector<float>         &derivative_norm,
-                        const unsigned int     component = 0);
+  approximate_gradient (const DoFHandlerType<dim,spacedim> &dof,
+                        const InputVector                  &solution,
+                        Vector<float>                      &derivative_norm,
+                        const unsigned int                  component = 0);
 
   /**
    * This function is the analogue to the one above, computing finite
@@ -214,24 +214,24 @@ namespace DerivativeApproximation
    * In a parallel computation the @p solution vector needs to contain the
    * locally relevant unknowns.
    */
-  template <int dim, template <int, int> class DH, class InputVector, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, class InputVector, int spacedim>
   void
-  approximate_second_derivative (const Mapping<dim,spacedim>    &mapping,
-                                 const DH<dim,spacedim>         &dof,
-                                 const InputVector     &solution,
-                                 Vector<float>         &derivative_norm,
-                                 const unsigned int     component = 0);
+  approximate_second_derivative (const Mapping<dim,spacedim>        &mapping,
+                                 const DoFHandlerType<dim,spacedim> &dof,
+                                 const InputVector                  &solution,
+                                 Vector<float>                      &derivative_norm,
+                                 const unsigned int                  component = 0);
 
   /**
    * Calls the @p interpolate function, see above, with
    * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
    */
-  template <int dim, template <int, int> class DH, class InputVector, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, class InputVector, int spacedim>
   void
-  approximate_second_derivative (const DH<dim,spacedim>         &dof,
-                                 const InputVector     &solution,
-                                 Vector<float>         &derivative_norm,
-                                 const unsigned int     component = 0);
+  approximate_second_derivative (const DoFHandlerType<dim,spacedim> &dof,
+                                 const InputVector                  &solution,
+                                 Vector<float>                      &derivative_norm,
+                                 const unsigned int                  component = 0);
 
   /**
    * This function calculates the <tt>order</tt>-th order approximate
@@ -246,33 +246,35 @@ namespace DerivativeApproximation
    * In a parallel computation the @p solution vector needs to contain the
    * locally relevant unknowns.
    */
-  template <class DH, int dim, int spacedim, class InputVector, int order>
+  template <typename DoFHandlerType, int dim, int spacedim, class InputVector, int order>
   void
-  approximate_derivative_tensor(const Mapping<dim, spacedim> &mapping,
-                                const DH                      &dof,
-                                const InputVector                            &solution,
+  approximate_derivative_tensor
+  (const Mapping<dim, spacedim>                        &mapping,
+   const DoFHandlerType                                &dof,
+   const InputVector                                   &solution,
 #ifndef _MSC_VER
-                                const typename DH::active_cell_iterator &cell,
+   const typename DoFHandlerType::active_cell_iterator &cell,
 #else
-                                const TriaActiveIterator < dealii::DoFCellAccessor < DH, false > > &cell,
+   const TriaActiveIterator <dealii::DoFCellAccessor<DoFHandlerType, false> > &cell,
 #endif
-                                Tensor<order, dim>  &derivative,
-                                const unsigned int                            component = 0);
+   Tensor<order, dim>                                  &derivative,
+   const unsigned int                                   component = 0);
 
   /**
    * Same as above, with <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
    */
-  template <class DH, int dim, int spacedim, class InputVector, int order>
+  template <typename DoFHandlerType, int dim, int spacedim, class InputVector, int order>
   void
-  approximate_derivative_tensor(const DH                    &dof,
-                                const InputVector                            &solution,
+  approximate_derivative_tensor
+  (const DoFHandlerType                                &dof,
+   const InputVector                                   &solution,
 #ifndef _MSC_VER
-                                const typename DH::active_cell_iterator &cell,
+   const typename DoFHandlerType::active_cell_iterator &cell,
 #else
-                                const TriaActiveIterator < dealii::DoFCellAccessor < DH, false > > &cell,
+   const TriaActiveIterator<dealii::DoFCellAccessor<DoFHandlerType, false> > &cell,
 #endif
-                                Tensor<order, dim>                  &derivative,
-                                const unsigned int                            component = 0);
+   Tensor<order, dim>                                  &derivative,
+   const unsigned int                                   component = 0);
 
   /**
    * Return the norm of the derivative.
diff --git a/include/deal.II/numerics/error_estimator.h b/include/deal.II/numerics/error_estimator.h
index b14bb33c73..a6172ae768 100644
--- a/include/deal.II/numerics/error_estimator.h
+++ b/include/deal.II/numerics/error_estimator.h
@@ -325,36 +325,38 @@ public:
    * cell in the mesh as reported by
    * parallel::distributed::Triangulation::n_locally_owned_active_cells().
    */
-  template <typename InputVector, class DH>
-  static void estimate (const Mapping<dim, spacedim>      &mapping,
-                        const DH                &dof,
-                        const Quadrature<dim-1> &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const InputVector       &solution,
-                        Vector<float>           &error,
-                        const ComponentMask &component_mask = ComponentMask(),
-                        const Function<spacedim>     *coefficients   = 0,
-                        const unsigned int       n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id       material_id = numbers::invalid_material_id,
-                        const Strategy strategy = cell_diameter_over_24);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const Mapping<dim, spacedim>               &mapping,
+   const DoFHandlerType                       &dof,
+   const Quadrature<dim-1>                    &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const InputVector                          &solution,
+   Vector<float>                              &error,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id,
+   const Strategy                              strategy       = cell_diameter_over_24);
 
   /**
    * Calls the @p estimate function, see above, with
    * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
    */
-  template <typename InputVector, class DH>
-  static void estimate (const DH                &dof,
-                        const Quadrature<dim-1> &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const InputVector       &solution,
-                        Vector<float>           &error,
-                        const ComponentMask &component_mask = ComponentMask(),
-                        const Function<spacedim>     *coefficients   = 0,
-                        const unsigned int       n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id       material_id = numbers::invalid_material_id,
-                        const Strategy strategy = cell_diameter_over_24);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const DoFHandlerType                       &dof,
+   const Quadrature<dim-1>                    &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const InputVector                          &solution,
+   Vector<float>                              &error,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id,
+   const Strategy                              strategy       = cell_diameter_over_24);
 
   /**
    * Same function as above, but accepts more than one solution vector and
@@ -369,110 +371,116 @@ public:
    * construct of vector of references, so we had to use a vector of
    * pointers.)
    */
-  template <typename InputVector, class DH>
-  static void estimate (const Mapping<dim, spacedim>          &mapping,
-                        const DH                    &dof,
-                        const Quadrature<dim-1>     &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const std::vector<const InputVector *> &solutions,
-                        std::vector<Vector<float>*> &errors,
-                        const ComponentMask     &component_mask = ComponentMask(),
-                        const Function<spacedim>         *coefficients   = 0,
-                        const unsigned int           n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id           material_id = numbers::invalid_material_id,
-                        const Strategy strategy = cell_diameter_over_24);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const Mapping<dim, spacedim>               &mapping,
+   const DoFHandlerType                       &dof,
+   const Quadrature<dim-1>                    &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const std::vector<const InputVector *>     &solutions,
+   std::vector<Vector<float>*>                &errors,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id,
+   const Strategy                              strategy       = cell_diameter_over_24);
 
   /**
    * Calls the @p estimate function, see above, with
    * <tt>mapping=MappingQGeneric@<dim@>(1)</tt>.
    */
-  template <typename InputVector, class DH>
-  static void estimate (const DH                    &dof,
-                        const Quadrature<dim-1>     &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const std::vector<const InputVector *> &solutions,
-                        std::vector<Vector<float>*> &errors,
-                        const ComponentMask     &component_mask = ComponentMask(),
-                        const Function<spacedim>         *coefficients   = 0,
-                        const unsigned int           n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id          material_id = numbers::invalid_material_id,
-                        const Strategy strategy = cell_diameter_over_24);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const DoFHandlerType                       &dof,
+   const Quadrature<dim-1>                    &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const std::vector<const InputVector *>     &solutions,
+   std::vector<Vector<float>*>                &errors,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id,
+   const Strategy                              strategy       = cell_diameter_over_24);
 
 
   /**
    * Equivalent to the set of functions above, except that this one takes a
    * quadrature collection for hp finite element dof handlers.
    */
-  template <typename InputVector, class DH>
-  static void estimate (const Mapping<dim, spacedim>      &mapping,
-                        const DH                &dof,
-                        const hp::QCollection<dim-1> &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const InputVector       &solution,
-                        Vector<float>           &error,
-                        const ComponentMask &component_mask = ComponentMask(),
-                        const Function<spacedim>     *coefficients   = 0,
-                        const unsigned int       n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id       material_id = numbers::invalid_material_id,
-                        const Strategy strategy = cell_diameter_over_24);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const Mapping<dim, spacedim>               &mapping,
+   const DoFHandlerType                       &dof,
+   const hp::QCollection<dim-1>               &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const InputVector                          &solution,
+   Vector<float>                              &error,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id,
+   const Strategy                              strategy       = cell_diameter_over_24);
 
 
   /**
    * Equivalent to the set of functions above, except that this one takes a
    * quadrature collection for hp finite element dof handlers.
    */
-  template <typename InputVector, class DH>
-  static void estimate (const DH                &dof,
-                        const hp::QCollection<dim-1> &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const InputVector       &solution,
-                        Vector<float>           &error,
-                        const ComponentMask &component_mask = ComponentMask(),
-                        const Function<spacedim>     *coefficients   = 0,
-                        const unsigned int       n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id       material_id = numbers::invalid_material_id,
-                        const Strategy strategy = cell_diameter_over_24);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const DoFHandlerType                       &dof,
+   const hp::QCollection<dim-1>               &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const InputVector                          &solution,
+   Vector<float>                              &error,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id,
+   const Strategy                              strategy       = cell_diameter_over_24);
 
 
   /**
    * Equivalent to the set of functions above, except that this one takes a
    * quadrature collection for hp finite element dof handlers.
    */
-  template <typename InputVector, class DH>
-  static void estimate (const Mapping<dim, spacedim>          &mapping,
-                        const DH                    &dof,
-                        const hp::QCollection<dim-1> &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const std::vector<const InputVector *> &solutions,
-                        std::vector<Vector<float>*> &errors,
-                        const ComponentMask     &component_mask = ComponentMask(),
-                        const Function<spacedim>         *coefficients   = 0,
-                        const unsigned int           n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id           material_id = numbers::invalid_material_id,
-                        const Strategy strategy = cell_diameter_over_24);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const Mapping<dim, spacedim>               &mapping,
+   const DoFHandlerType                       &dof,
+   const hp::QCollection<dim-1>               &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const std::vector<const InputVector *>     &solutions,
+   std::vector<Vector<float>*>                &errors,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id,
+   const Strategy                              strategy       = cell_diameter_over_24);
 
 
   /**
    * Equivalent to the set of functions above, except that this one takes a
    * quadrature collection for hp finite element dof handlers.
    */
-  template <typename InputVector, class DH>
-  static void estimate (const DH                    &dof,
-                        const hp::QCollection<dim-1> &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const std::vector<const InputVector *> &solutions,
-                        std::vector<Vector<float>*> &errors,
-                        const ComponentMask     &component_mask = ComponentMask(),
-                        const Function<spacedim>    *coefficients   = 0,
-                        const unsigned int           n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id           material_id = numbers::invalid_material_id,
-                        const Strategy strategy = cell_diameter_over_24);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const DoFHandlerType                       &dof,
+   const hp::QCollection<dim-1>               &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const std::vector<const InputVector *>     &solutions,
+   std::vector<Vector<float>*>                &errors,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id,
+   const Strategy                              strategy       = cell_diameter_over_24);
 
   /**
    * Exception
@@ -563,34 +571,36 @@ public:
    * respective parameter for compatibility with the function signature in the
    * general case.
    */
-  template <typename InputVector, class DH>
-  static void estimate (const Mapping<1,spacedim>  &mapping,
-                        const DH   &dof,
-                        const Quadrature<0> &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const InputVector       &solution,
-                        Vector<float>           &error,
-                        const ComponentMask &component_mask = ComponentMask(),
-                        const Function<spacedim>     *coefficients   = 0,
-                        const unsigned int       n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id       material_id = numbers::invalid_material_id);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const Mapping<1,spacedim>                  &mapping,
+   const DoFHandlerType                       &dof,
+   const Quadrature<0>                        &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const InputVector                          &solution,
+   Vector<float>                              &error,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id);
 
   /**
    * Calls the @p estimate function, see above, with
    * <tt>mapping=MappingQGeneric1<1>()</tt>.
    */
-  template <typename InputVector, class DH>
-  static void estimate (const DH   &dof,
-                        const Quadrature<0> &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const InputVector       &solution,
-                        Vector<float>           &error,
-                        const ComponentMask &component_mask = ComponentMask(),
-                        const Function<spacedim>     *coefficients   = 0,
-                        const unsigned int       n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id       material_id = numbers::invalid_material_id);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const DoFHandlerType                       &dof,
+   const Quadrature<0>                        &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const InputVector                          &solution,
+   Vector<float>                              &error,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id);
 
   /**
    * Same function as above, but accepts more than one solution vectors and
@@ -605,104 +615,110 @@ public:
    * construct of vector of references, so we had to use a vector of
    * pointers.)
    */
-  template <typename InputVector, class DH>
-  static void estimate (const Mapping<1,spacedim>          &mapping,
-                        const DH       &dof,
-                        const Quadrature<0>     &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const std::vector<const InputVector *> &solutions,
-                        std::vector<Vector<float>*> &errors,
-                        const ComponentMask     &component_mask = ComponentMask(),
-                        const Function<spacedim>         *coefficients   = 0,
-                        const unsigned int           n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id           material_id = numbers::invalid_material_id);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const Mapping<1,spacedim>                  &mapping,
+   const DoFHandlerType                       &dof,
+   const Quadrature<0>                        &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const std::vector<const InputVector *>     &solutions,
+   std::vector<Vector<float>*>                &errors,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id);
 
   /**
    * Calls the @p estimate function, see above, with
    * <tt>mapping=MappingQGeneric1<1>()</tt>.
    */
-  template <typename InputVector, class DH>
-  static void estimate (const DH       &dof,
-                        const Quadrature<0>     &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const std::vector<const InputVector *> &solutions,
-                        std::vector<Vector<float>*> &errors,
-                        const ComponentMask     &component_mask = ComponentMask(),
-                        const Function<spacedim>         *coefficients   = 0,
-                        const unsigned int           n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id           material_id = numbers::invalid_material_id);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const DoFHandlerType                       &dof,
+   const Quadrature<0>                        &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const std::vector<const InputVector *>     &solutions,
+   std::vector<Vector<float>*>                &errors,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id);
 
 
   /**
    * Equivalent to the set of functions above, except that this one takes a
    * quadrature collection for hp finite element dof handlers.
    */
-  template <typename InputVector, class DH>
-  static void estimate (const Mapping<1,spacedim>      &mapping,
-                        const DH                &dof,
-                        const hp::QCollection<0> &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const InputVector       &solution,
-                        Vector<float>           &error,
-                        const ComponentMask &component_mask = ComponentMask(),
-                        const Function<spacedim>     *coefficients   = 0,
-                        const unsigned int       n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id       material_id = numbers::invalid_material_id);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const Mapping<1,spacedim>                  &mapping,
+   const DoFHandlerType                       &dof,
+   const hp::QCollection<0>                   &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const InputVector                          &solution,
+   Vector<float>                              &error,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id);
 
 
   /**
    * Equivalent to the set of functions above, except that this one takes a
    * quadrature collection for hp finite element dof handlers.
    */
-  template <typename InputVector, class DH>
-  static void estimate (const DH                &dof,
-                        const hp::QCollection<0> &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const InputVector       &solution,
-                        Vector<float>           &error,
-                        const ComponentMask &component_mask = ComponentMask(),
-                        const Function<spacedim>     *coefficients   = 0,
-                        const unsigned int       n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id       material_id = numbers::invalid_material_id);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const DoFHandlerType                       &dof,
+   const hp::QCollection<0>                   &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const InputVector                          &solution,
+   Vector<float>                              &error,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id);
 
 
   /**
    * Equivalent to the set of functions above, except that this one takes a
    * quadrature collection for hp finite element dof handlers.
    */
-  template <typename InputVector, class DH>
-  static void estimate (const Mapping<1,spacedim>          &mapping,
-                        const DH                    &dof,
-                        const hp::QCollection<0> &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const std::vector<const InputVector *> &solutions,
-                        std::vector<Vector<float>*> &errors,
-                        const ComponentMask     &component_mask = ComponentMask(),
-                        const Function<spacedim>         *coefficients   = 0,
-                        const unsigned int           n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id           material_id = numbers::invalid_material_id);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const Mapping<1,spacedim>                  &mapping,
+   const DoFHandlerType                       &dof,
+   const hp::QCollection<0>                   &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const std::vector<const InputVector *>     &solutions,
+   std::vector<Vector<float>*>                &errors,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id);
 
 
   /**
    * Equivalent to the set of functions above, except that this one takes a
    * quadrature collection for hp finite element dof handlers.
    */
-  template <typename InputVector, class DH>
-  static void estimate (const DH                    &dof,
-                        const hp::QCollection<0> &quadrature,
-                        const typename FunctionMap<spacedim>::type &neumann_bc,
-                        const std::vector<const InputVector *> &solutions,
-                        std::vector<Vector<float>*> &errors,
-                        const ComponentMask     &component_mask = ComponentMask(),
-                        const Function<spacedim>         *coefficients   = 0,
-                        const unsigned int           n_threads = numbers::invalid_unsigned_int,
-                        const types::subdomain_id subdomain_id = numbers::invalid_subdomain_id,
-                        const types::material_id           material_id = numbers::invalid_material_id);
+  template <typename InputVector, typename DoFHandlerType>
+  static void estimate
+  (const DoFHandlerType                       &dof,
+   const hp::QCollection<0>                   &quadrature,
+   const typename FunctionMap<spacedim>::type &neumann_bc,
+   const std::vector<const InputVector *>     &solutions,
+   std::vector<Vector<float>*>                &errors,
+   const ComponentMask                        &component_mask = ComponentMask(),
+   const Function<spacedim>                   *coefficients   = 0,
+   const unsigned int                          n_threads      = numbers::invalid_unsigned_int,
+   const types::subdomain_id                   subdomain_id   = numbers::invalid_subdomain_id,
+   const types::material_id                    material_id    = numbers::invalid_material_id);
 
   /**
    * Exception
diff --git a/include/deal.II/numerics/error_estimator.templates.h b/include/deal.II/numerics/error_estimator.templates.h
index 81eed8918c..f619826bcc 100644
--- a/include/deal.II/numerics/error_estimator.templates.h
+++ b/include/deal.II/numerics/error_estimator.templates.h
@@ -97,11 +97,11 @@ namespace internal
      * resizing to a smaller size doesn't imply memory allocation, this is
      * fast.
      */
-    template <class DH,typename number>
+    template <typename DoFHandlerType,typename number>
     struct ParallelData
     {
-      static const unsigned int dim      = DH::dimension;
-      static const unsigned int spacedim = DH::space_dimension;
+      static const unsigned int dim      = DoFHandlerType::dimension;
+      static const unsigned int spacedim = DoFHandlerType::space_dimension;
 
       /**
        * The finite element to be used.
@@ -205,19 +205,20 @@ namespace internal
     };
 
 
-    template <class DH,typename number>
+    template <typename DoFHandlerType,typename number>
     template <class FE>
-    ParallelData<DH,number>::
-    ParallelData (const FE                                           &fe,
-                  const dealii::hp::QCollection<dim-1>     &face_quadratures,
-                  const dealii::hp::MappingCollection<dim, spacedim> &mapping,
-                  const bool     need_quadrature_points,
-                  const unsigned int n_solution_vectors,
-                  const types::subdomain_id subdomain_id,
-                  const types::material_id material_id,
-                  const typename FunctionMap<spacedim>::type *neumann_bc,
-                  const ComponentMask                component_mask,
-                  const Function<spacedim>         *coefficients)
+    ParallelData<DoFHandlerType,number>::
+    ParallelData
+    (const FE                                           &fe,
+     const dealii::hp::QCollection<dim-1>               &face_quadratures,
+     const dealii::hp::MappingCollection<dim, spacedim> &mapping,
+     const bool                                          need_quadrature_points,
+     const unsigned int                                  n_solution_vectors,
+     const types::subdomain_id                           subdomain_id,
+     const types::material_id                            material_id,
+     const typename FunctionMap<spacedim>::type         *neumann_bc,
+     const ComponentMask                                 component_mask,
+     const Function<spacedim>                           *coefficients)
       :
       finite_element (fe),
       face_quadratures (face_quadratures),
@@ -264,9 +265,9 @@ namespace internal
 
 
 
-    template <class DH, typename number>
+    template <typename DoFHandlerType, typename number>
     void
-    ParallelData<DH,number>::resize (const unsigned int active_fe_index)
+    ParallelData<DoFHandlerType,number>::resize (const unsigned int active_fe_index)
     {
       const unsigned int n_q_points   = face_quadratures[active_fe_index].size();
       const unsigned int n_components = finite_element.n_components();
@@ -301,14 +302,15 @@ namespace internal
      * object into a global such map. This is the copier stage of a WorkStream
      * pipeline.
      */
-    template <class DH>
+    template <typename DoFHandlerType>
     void
-    copy_local_to_global (const std::map<typename DH::face_iterator,std::vector<double> > &local_face_integrals,
-                          std::map<typename DH::face_iterator,std::vector<double> > &face_integrals)
+    copy_local_to_global
+    (const std::map<typename DoFHandlerType::face_iterator,std::vector<double> > &local_face_integrals,
+     std::map<typename DoFHandlerType::face_iterator,std::vector<double> > &face_integrals)
     {
 
       // now copy locally computed elements into the global map
-      for (typename std::map<typename DH::face_iterator,std::vector<double> >::const_iterator
+      for (typename std::map<typename DoFHandlerType::face_iterator,std::vector<double> >::const_iterator
            p=local_face_integrals.begin();
            p!=local_face_integrals.end();
            ++p)
@@ -333,11 +335,12 @@ namespace internal
      * Actually do the computation based on the evaluated gradients in
      * ParallelData.
      */
-    template <class DH, typename number>
+    template <typename DoFHandlerType, typename number>
     std::vector<double>
-    integrate_over_face (ParallelData<DH,number>                 &parallel_data,
-                         const typename DH::face_iterator        &face,
-                         dealii::hp::FEFaceValues<DH::dimension, DH::space_dimension> &fe_face_values_cell)
+    integrate_over_face
+    (ParallelData<DoFHandlerType,number>                 &parallel_data,
+     const typename DoFHandlerType::face_iterator        &face,
+     dealii::hp::FEFaceValues<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe_face_values_cell)
     {
       const unsigned int n_q_points         = parallel_data.psi[0].size(),
                          n_components       = parallel_data.finite_element.n_components(),
@@ -469,19 +472,19 @@ namespace internal
      * A factor to scale the integral for the face at the boundary.
      * Used for Neumann BC.
      */
-    template <class DH>
-    double boundary_face_factor(const typename DH::active_cell_iterator &cell,
+    template <typename DoFHandlerType>
+    double boundary_face_factor(const typename DoFHandlerType::active_cell_iterator &cell,
                                 const unsigned int                       face_no,
-                                const dealii::hp::FEFaceValues<DH::dimension, DH::space_dimension> &fe_face_values_cell,
-                                const typename KellyErrorEstimator<DH::dimension,DH::space_dimension>::Strategy strategy)
+                                const dealii::hp::FEFaceValues<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe_face_values_cell,
+                                const typename KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::Strategy strategy)
     {
       switch (strategy)
         {
-        case KellyErrorEstimator<DH::dimension,DH::space_dimension>::cell_diameter_over_24 :
+        case KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::cell_diameter_over_24 :
         {
           return 1.0;
         }
-        case KellyErrorEstimator<DH::dimension,DH::space_dimension>::face_diameter_over_twice_max_degree :
+        case KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::face_diameter_over_twice_max_degree :
         {
           const double cell_degree = fe_face_values_cell.get_fe_collection()[cell->active_fe_index()].degree;
           return cell->face(face_no)->diameter() / cell_degree;
@@ -498,20 +501,20 @@ namespace internal
     /**
      *  A factor to scale the integral for the regular face.
      */
-    template <class DH>
-    double regular_face_factor(const typename DH::active_cell_iterator &cell,
+    template <typename DoFHandlerType>
+    double regular_face_factor(const typename DoFHandlerType::active_cell_iterator &cell,
                                const unsigned int                       face_no,
-                               const dealii::hp::FEFaceValues<DH::dimension, DH::space_dimension> &fe_face_values_cell,
-                               const dealii::hp::FEFaceValues<DH::dimension, DH::space_dimension> &fe_face_values_neighbor,
-                               const typename KellyErrorEstimator<DH::dimension,DH::space_dimension>::Strategy strategy)
+                               const dealii::hp::FEFaceValues<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe_face_values_cell,
+                               const dealii::hp::FEFaceValues<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe_face_values_neighbor,
+                               const typename KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::Strategy strategy)
     {
       switch (strategy)
         {
-        case KellyErrorEstimator<DH::dimension,DH::space_dimension>::cell_diameter_over_24 :
+        case KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::cell_diameter_over_24 :
         {
           return 1.0;
         }
-        case KellyErrorEstimator<DH::dimension,DH::space_dimension>::face_diameter_over_twice_max_degree :
+        case KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::face_diameter_over_twice_max_degree :
         {
           const double cell_degree     = fe_face_values_cell.get_fe_collection()[cell->active_fe_index()].degree;
           const double neighbor_degree = fe_face_values_neighbor.get_fe_collection()[cell->neighbor(face_no)->active_fe_index()].degree;
@@ -528,22 +531,22 @@ namespace internal
     /**
      * A factor to scale the integral for the irregular face.
      */
-    template <class DH>
-    double irregular_face_factor(const typename DH::active_cell_iterator &cell,
-                                 const typename DH::active_cell_iterator &neighbor_child,
+    template <typename DoFHandlerType>
+    double irregular_face_factor(const typename DoFHandlerType::active_cell_iterator &cell,
+                                 const typename DoFHandlerType::active_cell_iterator &neighbor_child,
                                  const unsigned int                       face_no,
                                  const unsigned int                       subface_no,
-                                 const dealii::hp::FEFaceValues<DH::dimension, DH::space_dimension> &fe_face_values,
-                                 dealii::hp::FESubfaceValues<DH::dimension, DH::space_dimension>    &fe_subface_values,
-                                 const typename KellyErrorEstimator<DH::dimension,DH::space_dimension>::Strategy strategy)
+                                 const dealii::hp::FEFaceValues<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe_face_values,
+                                 dealii::hp::FESubfaceValues<DoFHandlerType::dimension, DoFHandlerType::space_dimension>    &fe_subface_values,
+                                 const typename KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::Strategy strategy)
     {
       switch (strategy)
         {
-        case KellyErrorEstimator<DH::dimension,DH::space_dimension>::cell_diameter_over_24 :
+        case KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::cell_diameter_over_24 :
         {
           return 1.0;
         }
-        case KellyErrorEstimator<DH::dimension,DH::space_dimension>::face_diameter_over_twice_max_degree :
+        case KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::face_diameter_over_twice_max_degree :
         {
           const double cell_degree = fe_face_values.get_fe_collection()[cell->active_fe_index()].degree;
           const double neighbor_child_degree = fe_subface_values.get_fe_collection()[neighbor_child->active_fe_index()].degree;
@@ -561,19 +564,19 @@ namespace internal
      * A factor used when summing up all the contribution
      * from different faces of each cell.
      */
-    template <class DH>
-    double cell_factor(const typename DH::active_cell_iterator &cell,
+    template <typename DoFHandlerType>
+    double cell_factor(const typename DoFHandlerType::active_cell_iterator &cell,
                        const unsigned int                       /*face_no*/,
-                       const DH                                &/*dof_handler*/,
-                       const typename KellyErrorEstimator<DH::dimension,DH::space_dimension>::Strategy strategy)
+                       const DoFHandlerType                    &/*dof_handler*/,
+                       const typename KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::Strategy strategy)
     {
       switch (strategy)
         {
-        case KellyErrorEstimator<DH::dimension,DH::space_dimension>::cell_diameter_over_24 :
+        case KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::cell_diameter_over_24 :
         {
           return cell->diameter()/24;
         }
-        case KellyErrorEstimator<DH::dimension,DH::space_dimension>::face_diameter_over_twice_max_degree :
+        case KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::face_diameter_over_twice_max_degree :
         {
           return 1.0;
         }
@@ -593,21 +596,21 @@ namespace internal
      * boundary), or the other side's refinement level is the same as that of
      * this side, then handle the integration of these both cases together.
      */
-    template <typename InputVector, class DH>
+    template <typename InputVector, typename DoFHandlerType>
     void
     integrate_over_regular_face (const std::vector<const InputVector *>   &solutions,
-                                 ParallelData<DH, typename InputVector::value_type> &parallel_data,
-                                 std::map<typename DH::face_iterator,std::vector<double> > &local_face_integrals,
-                                 const typename DH::active_cell_iterator &cell,
+                                 ParallelData<DoFHandlerType, typename InputVector::value_type> &parallel_data,
+                                 std::map<typename DoFHandlerType::face_iterator,std::vector<double> > &local_face_integrals,
+                                 const typename DoFHandlerType::active_cell_iterator &cell,
                                  const unsigned int                       face_no,
-                                 dealii::hp::FEFaceValues<DH::dimension, DH::space_dimension> &fe_face_values_cell,
-                                 dealii::hp::FEFaceValues<DH::dimension, DH::space_dimension> &fe_face_values_neighbor,
-                                 const typename KellyErrorEstimator<DH::dimension,DH::space_dimension>::Strategy strategy)
+                                 dealii::hp::FEFaceValues<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe_face_values_cell,
+                                 dealii::hp::FEFaceValues<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe_face_values_neighbor,
+                                 const typename KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::Strategy strategy)
     {
-      const unsigned int dim = DH::dimension;
+      const unsigned int dim = DoFHandlerType::dimension;
       (void)dim;
 
-      const typename DH::face_iterator face = cell->face(face_no);
+      const typename DoFHandlerType::face_iterator face = cell->face(face_no);
       const unsigned int n_solution_vectors = solutions.size();
 
 
@@ -630,7 +633,7 @@ namespace internal
           Assert (cell->neighbor(face_no).state() == IteratorState::valid,
                   ExcInternalError());
 
-          const typename DH::active_cell_iterator neighbor = cell->neighbor(face_no);
+          const typename DoFHandlerType::active_cell_iterator neighbor = cell->neighbor(face_no);
 
           // find which number the current face has relative to the
           // neighboring cell
@@ -645,9 +648,9 @@ namespace internal
           fe_face_values_neighbor.reinit (neighbor, neighbor_neighbor,
                                           cell->active_fe_index());
 
-          factor = regular_face_factor<DH>(cell,face_no,
-                                           fe_face_values_cell,fe_face_values_neighbor,
-                                           strategy);
+          factor = regular_face_factor<DoFHandlerType>(cell,face_no,
+                                                       fe_face_values_cell,fe_face_values_neighbor,
+                                                       strategy);
 
           // get gradients on neighbor cell
           for (unsigned int n=0; n<n_solution_vectors; ++n)
@@ -659,9 +662,9 @@ namespace internal
         }
       else
         {
-          factor = boundary_face_factor<DH>(cell,face_no,
-                                            fe_face_values_cell,
-                                            strategy);
+          factor = boundary_face_factor<DoFHandlerType>(cell,face_no,
+                                                        fe_face_values_cell,
+                                                        strategy);
         }
 
       // now go to the generic function that does all the other things
@@ -684,24 +687,24 @@ namespace internal
      * integration is a bit more
      * complex.
      */
-    template <typename InputVector, class DH>
+    template <typename InputVector, typename DoFHandlerType>
     void
     integrate_over_irregular_face (const std::vector<const InputVector *>   &solutions,
-                                   ParallelData<DH, typename InputVector::value_type> &parallel_data,
-                                   std::map<typename DH::face_iterator,std::vector<double> > &local_face_integrals,
-                                   const typename DH::active_cell_iterator    &cell,
+                                   ParallelData<DoFHandlerType, typename InputVector::value_type> &parallel_data,
+                                   std::map<typename DoFHandlerType::face_iterator,std::vector<double> > &local_face_integrals,
+                                   const typename DoFHandlerType::active_cell_iterator    &cell,
                                    const unsigned int                          face_no,
-                                   dealii::hp::FEFaceValues<DH::dimension,DH::space_dimension>    &fe_face_values,
-                                   dealii::hp::FESubfaceValues<DH::dimension, DH::space_dimension> &fe_subface_values,
-                                   const typename KellyErrorEstimator<DH::dimension,DH::space_dimension>::Strategy strategy)
+                                   dealii::hp::FEFaceValues<DoFHandlerType::dimension,DoFHandlerType::space_dimension>    &fe_face_values,
+                                   dealii::hp::FESubfaceValues<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe_subface_values,
+                                   const typename KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::Strategy strategy)
     {
-      const unsigned int dim = DH::dimension;
+      const unsigned int dim = DoFHandlerType::dimension;
       (void)dim;
 
-      const typename DH::cell_iterator neighbor = cell->neighbor(face_no);
+      const typename DoFHandlerType::cell_iterator neighbor = cell->neighbor(face_no);
       (void)neighbor;
       const unsigned int n_solution_vectors = solutions.size();
-      const typename DH::face_iterator
+      const typename DoFHandlerType::face_iterator
       face=cell->face(face_no);
 
       Assert (neighbor.state() == IteratorState::valid, ExcInternalError());
@@ -725,7 +728,7 @@ namespace internal
       for (unsigned int subface_no=0; subface_no<face->n_children(); ++subface_no)
         {
           // get an iterator pointing to the cell behind the present subface
-          const typename DH::active_cell_iterator neighbor_child
+          const typename DoFHandlerType::active_cell_iterator neighbor_child
             = cell->neighbor_child_on_subface (face_no, subface_no);
           Assert (!neighbor_child->has_children(),
                   ExcInternalError());
@@ -739,13 +742,13 @@ namespace internal
           fe_face_values.reinit (neighbor_child, neighbor_neighbor,
                                  cell->active_fe_index());
 
-          const double factor = irregular_face_factor<DH>(cell,
-                                                          neighbor_child,
-                                                          face_no,
-                                                          subface_no,
-                                                          fe_face_values,
-                                                          fe_subface_values,
-                                                          strategy);
+          const double factor = irregular_face_factor<DoFHandlerType>(cell,
+                                                                      neighbor_child,
+                                                                      face_no,
+                                                                      subface_no,
+                                                                      fe_face_values,
+                                                                      fe_subface_values,
+                                                                      strategy);
 
           // store the gradient of the solution in psi
           for (unsigned int n=0; n<n_solution_vectors; ++n)
@@ -789,15 +792,15 @@ namespace internal
      * This function is only needed in two or three dimensions.  The error
      * estimator in one dimension is implemented separately.
      */
-    template <typename InputVector, class DH>
+    template <typename InputVector, typename DoFHandlerType>
     void
-    estimate_one_cell (const typename DH::active_cell_iterator &cell,
-                       ParallelData<DH, typename InputVector::value_type> &parallel_data,
-                       std::map<typename DH::face_iterator,std::vector<double> > &local_face_integrals,
+    estimate_one_cell (const typename DoFHandlerType::active_cell_iterator &cell,
+                       ParallelData<DoFHandlerType, typename InputVector::value_type> &parallel_data,
+                       std::map<typename DoFHandlerType::face_iterator,std::vector<double> > &local_face_integrals,
                        const std::vector<const InputVector *> &solutions,
-                       const typename KellyErrorEstimator<DH::dimension,DH::space_dimension>::Strategy strategy)
+                       const typename KellyErrorEstimator<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::Strategy strategy)
     {
-      const unsigned int dim = DH::dimension;
+      const unsigned int dim = DoFHandlerType::dimension;
       const unsigned int n_solution_vectors = solutions.size();
 
       const types::subdomain_id subdomain_id = parallel_data.subdomain_id;
@@ -810,7 +813,7 @@ namespace internal
       for (unsigned int face_no=0;
            face_no<GeometryInfo<dim>::faces_per_cell; ++face_no)
         {
-          const typename DH::face_iterator
+          const typename DoFHandlerType::face_iterator
           face=cell->face(face_no);
 
           // make sure we do work only once: this face may either be regular
@@ -941,21 +944,21 @@ namespace internal
 // the following function is still independent of dimension, but it
 // calls dimension dependent functions
 template <int dim, int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void
 KellyErrorEstimator<dim, spacedim>::
-estimate (const Mapping<dim, spacedim>      &mapping,
-          const DH                &dof_handler,
-          const Quadrature<dim-1> &quadrature,
+estimate (const Mapping<dim, spacedim>               &mapping,
+          const DoFHandlerType                       &dof_handler,
+          const Quadrature<dim-1>                    &quadrature,
           const typename FunctionMap<spacedim>::type &neumann_bc,
-          const InputVector       &solution,
-          Vector<float>           &error,
-          const ComponentMask &component_mask,
-          const Function<spacedim>     *coefficients,
-          const unsigned int       n_threads,
-          const types::subdomain_id subdomain_id,
-          const types::material_id       material_id,
-          const Strategy strategy)
+          const InputVector                          &solution,
+          Vector<float>                              &error,
+          const ComponentMask                        &component_mask,
+          const Function<spacedim>                   *coefficients,
+          const unsigned int                          n_threads,
+          const types::subdomain_id                   subdomain_id,
+          const types::material_id                    material_id,
+          const Strategy                              strategy)
 {
   // just pass on to the other function
   const std::vector<const InputVector *> solutions (1, &solution);
@@ -966,20 +969,20 @@ estimate (const Mapping<dim, spacedim>      &mapping,
 
 
 template <int dim, int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void
 KellyErrorEstimator<dim,spacedim>::
-estimate (const DH                &dof_handler,
-          const Quadrature<dim-1> &quadrature,
+estimate (const DoFHandlerType                       &dof_handler,
+          const Quadrature<dim-1>                    &quadrature,
           const typename FunctionMap<spacedim>::type &neumann_bc,
-          const InputVector       &solution,
-          Vector<float>           &error,
-          const ComponentMask &component_mask,
-          const Function<spacedim>     *coefficients,
-          const unsigned int       n_threads,
-          const types::subdomain_id subdomain_id,
-          const types::material_id       material_id,
-          const Strategy strategy)
+          const InputVector                          &solution,
+          Vector<float>                              &error,
+          const ComponentMask                        &component_mask,
+          const Function<spacedim>                   *coefficients,
+          const unsigned int                          n_threads,
+          const types::subdomain_id                   subdomain_id,
+          const types::material_id                    material_id,
+          const Strategy                              strategy)
 {
   estimate(StaticMappingQ1<dim,spacedim>::mapping, dof_handler, quadrature, neumann_bc, solution,
            error, component_mask, coefficients, n_threads,
@@ -988,21 +991,21 @@ estimate (const DH                &dof_handler,
 
 
 template <int dim, int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void
 KellyErrorEstimator<dim, spacedim>::
-estimate (const Mapping<dim, spacedim>      &mapping,
-          const DH                &dof_handler,
-          const hp::QCollection<dim-1> &quadrature,
+estimate (const Mapping<dim, spacedim>               &mapping,
+          const DoFHandlerType                       &dof_handler,
+          const hp::QCollection<dim-1>               &quadrature,
           const typename FunctionMap<spacedim>::type &neumann_bc,
-          const InputVector       &solution,
-          Vector<float>           &error,
-          const ComponentMask &component_mask,
-          const Function<spacedim>     *coefficients,
-          const unsigned int       n_threads,
-          const types::subdomain_id subdomain_id,
-          const types::material_id       material_id,
-          const Strategy strategy)
+          const InputVector                          &solution,
+          Vector<float>                              &error,
+          const ComponentMask                        &component_mask,
+          const Function<spacedim>                   *coefficients,
+          const unsigned int                          n_threads,
+          const types::subdomain_id                   subdomain_id,
+          const types::material_id                    material_id,
+          const Strategy                              strategy)
 {
   // just pass on to the other function
   const std::vector<const InputVector *> solutions (1, &solution);
@@ -1013,20 +1016,20 @@ estimate (const Mapping<dim, spacedim>      &mapping,
 
 
 template <int dim, int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void
 KellyErrorEstimator<dim, spacedim>::
-estimate (const DH                &dof_handler,
-          const hp::QCollection<dim-1> &quadrature,
+estimate (const DoFHandlerType                       &dof_handler,
+          const hp::QCollection<dim-1>               &quadrature,
           const typename FunctionMap<spacedim>::type &neumann_bc,
-          const InputVector       &solution,
-          Vector<float>           &error,
-          const ComponentMask &component_mask,
-          const Function<spacedim>     *coefficients,
-          const unsigned int       n_threads,
-          const types::subdomain_id subdomain_id,
-          const types::material_id       material_id,
-          const Strategy strategy)
+          const InputVector                          &solution,
+          Vector<float>                              &error,
+          const ComponentMask                        &component_mask,
+          const Function<spacedim>                   *coefficients,
+          const unsigned int                          n_threads,
+          const types::subdomain_id                   subdomain_id,
+          const types::material_id                    material_id,
+          const Strategy                              strategy)
 {
   estimate(StaticMappingQ1<dim, spacedim>::mapping, dof_handler, quadrature, neumann_bc, solution,
            error, component_mask, coefficients, n_threads,
@@ -1037,21 +1040,21 @@ estimate (const DH                &dof_handler,
 
 
 template <int dim, int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void
 KellyErrorEstimator<dim, spacedim>::
-estimate (const Mapping<dim, spacedim>                  &mapping,
-          const DH                            &dof_handler,
-          const hp::QCollection<dim-1>        &face_quadratures,
+estimate (const Mapping<dim, spacedim>               &mapping,
+          const DoFHandlerType                       &dof_handler,
+          const hp::QCollection<dim-1>               &face_quadratures,
           const typename FunctionMap<spacedim>::type &neumann_bc,
-          const std::vector<const InputVector *> &solutions,
-          std::vector<Vector<float>*>              &errors,
-          const ComponentMask                  &component_mask,
-          const Function<spacedim>                 *coefficients,
-          const unsigned int                   ,
-          const types::subdomain_id          subdomain_id_,
-          const types::material_id                   material_id,
-          const Strategy strategy)
+          const std::vector<const InputVector *>     &solutions,
+          std::vector<Vector<float>*>                &errors,
+          const ComponentMask                        &component_mask,
+          const Function<spacedim>                   *coefficients,
+          const unsigned int,
+          const types::subdomain_id                   subdomain_id_,
+          const types::material_id                    material_id,
+          const Strategy                              strategy)
 {
 #ifdef DEAL_II_WITH_P4EST
   if (dynamic_cast<const parallel::distributed::Triangulation<dim,spacedim>*>
@@ -1117,12 +1120,12 @@ estimate (const Mapping<dim, spacedim>                  &mapping,
   // the integrated jump of the gradient for each face.  At the end of the
   // function, we again loop over the cells and collect the contributions of
   // the different faces of the cell.
-  std::map<typename DH::face_iterator,std::vector<double> > face_integrals;
+  std::map<typename DoFHandlerType::face_iterator,std::vector<double> > face_integrals;
 
   // all the data needed in the error estimator by each of the threads is
   // gathered in the following structures
   const hp::MappingCollection<dim,spacedim> mapping_collection(mapping);
-  const internal::ParallelData<DH,typename InputVector::value_type>
+  const internal::ParallelData<DoFHandlerType,typename InputVector::value_type>
   parallel_data (dof_handler.get_fe(),
                  face_quadratures,
                  mapping_collection,
@@ -1133,14 +1136,14 @@ estimate (const Mapping<dim, spacedim>                  &mapping,
                  &neumann_bc,
                  component_mask,
                  coefficients);
-  std::map<typename DH::face_iterator,std::vector<double> > sample_local_face_integrals;
+  std::map<typename DoFHandlerType::face_iterator,std::vector<double> > sample_local_face_integrals;
 
   // now let's work on all those cells:
   WorkStream::run (dof_handler.begin_active(),
-                   static_cast<typename DH::active_cell_iterator>(dof_handler.end()),
-                   std_cxx11::bind (&internal::estimate_one_cell<InputVector,DH>,
+                   static_cast<typename DoFHandlerType::active_cell_iterator>(dof_handler.end()),
+                   std_cxx11::bind (&internal::estimate_one_cell<InputVector,DoFHandlerType>,
                                     std_cxx11::_1, std_cxx11::_2, std_cxx11::_3, std_cxx11::ref(solutions),strategy),
-                   std_cxx11::bind (&internal::copy_local_to_global<DH>,
+                   std_cxx11::bind (&internal::copy_local_to_global<DoFHandlerType>,
                                     std_cxx11::_1, std_cxx11::ref(face_integrals)),
                    parallel_data,
                    sample_local_face_integrals);
@@ -1158,7 +1161,7 @@ estimate (const Mapping<dim, spacedim>                  &mapping,
   // now walk over all cells and collect information from the faces. only do
   // something if this is a cell we care for based on the subdomain id
   unsigned int present_cell=0;
-  for (typename DH::active_cell_iterator cell=dof_handler.begin_active();
+  for (typename DoFHandlerType::active_cell_iterator cell=dof_handler.begin_active();
        cell!=dof_handler.end();
        ++cell, ++present_cell)
     if ( ((subdomain_id == numbers::invalid_subdomain_id)
@@ -1176,10 +1179,10 @@ estimate (const Mapping<dim, spacedim>                  &mapping,
             Assert(face_integrals.find(cell->face(face_no))
                    != face_integrals.end(),
                    ExcInternalError());
-            const double factor = internal::cell_factor<DH>(cell,
-                                                            face_no,
-                                                            dof_handler,
-                                                            strategy);
+            const double factor = internal::cell_factor<DoFHandlerType>(cell,
+                                                                        face_no,
+                                                                        dof_handler,
+                                                                        strategy);
 
             for (unsigned int n=0; n<n_solution_vectors; ++n)
               {
@@ -1201,21 +1204,21 @@ estimate (const Mapping<dim, spacedim>                  &mapping,
 
 
 template <int dim, int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void
 KellyErrorEstimator<dim, spacedim>::
-estimate (const Mapping<dim, spacedim>                  &mapping,
-          const DH                            &dof_handler,
-          const Quadrature<dim-1>             &quadrature,
+estimate (const Mapping<dim, spacedim>               &mapping,
+          const DoFHandlerType                       &dof_handler,
+          const Quadrature<dim-1>                    &quadrature,
           const typename FunctionMap<spacedim>::type &neumann_bc,
-          const std::vector<const InputVector *> &solutions,
-          std::vector<Vector<float>*>              &errors,
-          const ComponentMask                  &component_mask,
-          const Function<spacedim>                 *coefficients,
-          const unsigned int                   n_threads,
-          const types::subdomain_id          subdomain_id,
-          const types::material_id                   material_id,
-          const Strategy strategy)
+          const std::vector<const InputVector *>     &solutions,
+          std::vector<Vector<float>*>                &errors,
+          const ComponentMask                        &component_mask,
+          const Function<spacedim>                   *coefficients,
+          const unsigned int                          n_threads,
+          const types::subdomain_id                   subdomain_id,
+          const types::material_id                    material_id,
+          const Strategy                              strategy)
 {
   // forward to the function with the QCollection
   estimate (mapping, dof_handler,
@@ -1227,18 +1230,19 @@ estimate (const Mapping<dim, spacedim>                  &mapping,
 
 
 template <int dim, int spacedim>
-template <typename InputVector, class DH>
-void KellyErrorEstimator<dim, spacedim>::estimate (const DH                            &dof_handler,
-                                                   const Quadrature<dim-1>             &quadrature,
-                                                   const typename FunctionMap<spacedim>::type &neumann_bc,
-                                                   const std::vector<const InputVector *> &solutions,
-                                                   std::vector<Vector<float>*>              &errors,
-                                                   const ComponentMask                  &component_mask,
-                                                   const Function<spacedim>                 *coefficients,
-                                                   const unsigned int                   n_threads,
-                                                   const types::subdomain_id subdomain_id,
-                                                   const types::material_id       material_id,
-                                                   const Strategy strategy)
+template <typename InputVector, typename DoFHandlerType>
+void KellyErrorEstimator<dim, spacedim>::estimate
+(const DoFHandlerType                       &dof_handler,
+ const Quadrature<dim-1>                    &quadrature,
+ const typename FunctionMap<spacedim>::type &neumann_bc,
+ const std::vector<const InputVector *>     &solutions,
+ std::vector<Vector<float>*>                &errors,
+ const ComponentMask                        &component_mask,
+ const Function<spacedim>                   *coefficients,
+ const unsigned int                          n_threads,
+ const types::subdomain_id                   subdomain_id,
+ const types::material_id                    material_id,
+ const Strategy                              strategy)
 {
   estimate(StaticMappingQ1<dim, spacedim>::mapping, dof_handler, quadrature, neumann_bc, solutions,
            errors, component_mask, coefficients, n_threads,
@@ -1248,18 +1252,19 @@ void KellyErrorEstimator<dim, spacedim>::estimate (const DH
 
 
 template <int dim, int spacedim>
-template <typename InputVector, class DH>
-void KellyErrorEstimator<dim, spacedim>::estimate (const DH                            &dof_handler,
-                                                   const hp::QCollection<dim-1>             &quadrature,
-                                                   const typename FunctionMap<spacedim>::type &neumann_bc,
-                                                   const std::vector<const InputVector *> &solutions,
-                                                   std::vector<Vector<float>*>              &errors,
-                                                   const ComponentMask                  &component_mask,
-                                                   const Function<spacedim>                 *coefficients,
-                                                   const unsigned int                   n_threads,
-                                                   const types::subdomain_id subdomain_id,
-                                                   const types::material_id       material_id,
-                                                   const Strategy strategy)
+template <typename InputVector, typename DoFHandlerType>
+void KellyErrorEstimator<dim, spacedim>::estimate
+(const DoFHandlerType                       &dof_handler,
+ const hp::QCollection<dim-1>               &quadrature,
+ const typename FunctionMap<spacedim>::type &neumann_bc,
+ const std::vector<const InputVector *>     &solutions,
+ std::vector<Vector<float>*>                &errors,
+ const ComponentMask                        &component_mask,
+ const Function<spacedim>                   *coefficients,
+ const unsigned int                          n_threads,
+ const types::subdomain_id                   subdomain_id,
+ const types::material_id                    material_id,
+ const Strategy                              strategy)
 {
   estimate(StaticMappingQ1<dim, spacedim>::mapping, dof_handler, quadrature, neumann_bc, solutions,
            errors, component_mask, coefficients, n_threads,
diff --git a/include/deal.II/numerics/fe_field_function.h b/include/deal.II/numerics/fe_field_function.h
index 658125c538..65e04efe3e 100644
--- a/include/deal.II/numerics/fe_field_function.h
+++ b/include/deal.II/numerics/fe_field_function.h
@@ -160,7 +160,7 @@ namespace Functions
    * @author Luca Heltai, 2006, Markus Buerg, 2012, Wolfgang Bangerth, 2013
    */
   template <int dim,
-            typename DH=DoFHandler<dim>,
+            typename DoFHandlerType=DoFHandler<dim>,
             typename VectorType=Vector<double> >
   class FEFieldFunction :  public Function<dim>
   {
@@ -173,16 +173,16 @@ namespace Functions
      * mapping is specified, that is what is used to find out where the points
      * lay. Otherwise the standard Q1 mapping is used.
      */
-    FEFieldFunction (const DH           &dh,
-                     const VectorType   &data_vector,
-                     const Mapping<dim> &mapping = StaticMappingQ1<dim>::mapping);
+    FEFieldFunction (const DoFHandlerType &dh,
+                     const VectorType     &data_vector,
+                     const Mapping<dim>   &mapping = StaticMappingQ1<dim>::mapping);
 
     /**
      * Set the current cell. If you know in advance where your points lie, you
      * can tell this object by calling this function. This will speed things
      * up a little.
      */
-    void set_active_cell (const typename DH::active_cell_iterator &newcell);
+    void set_active_cell (const typename DoFHandlerType::active_cell_iterator &newcell);
 
     /**
      * Get one vector value at the given point. It is inefficient to use
@@ -219,7 +219,7 @@ namespace Functions
      * See the section in the general documentation of this class for more
      * information.
      */
-    virtual double value (const Point< dim >     &p,
+    virtual double value (const Point< dim > &p,
                           const unsigned int  component = 0)    const;
 
     /**
@@ -408,10 +408,11 @@ namespace Functions
      * set of points.
      */
     unsigned int
-    compute_point_locations(const std::vector<Point<dim> > &points,
-                            std::vector<typename DH::active_cell_iterator > &cells,
-                            std::vector<std::vector<Point<dim> > > &qpoints,
-                            std::vector<std::vector<unsigned int> > &maps) const;
+    compute_point_locations
+    (const std::vector<Point<dim> >                              &points,
+     std::vector<typename DoFHandlerType::active_cell_iterator > &cells,
+     std::vector<std::vector<Point<dim> > >                      &qpoints,
+     std::vector<std::vector<unsigned int> >                     &maps) const;
 
     /**
      * @deprecated Use VectorTools::ExcPointNotAvailableHere instead.
@@ -423,13 +424,13 @@ namespace Functions
      * Typedef holding the local cell_hint.
      */
     typedef
-    Threads::ThreadLocalStorage <typename DH::active_cell_iterator >
+    Threads::ThreadLocalStorage <typename DoFHandlerType::active_cell_iterator >
     cell_hint_t;
 
     /**
      * Pointer to the dof handler.
      */
-    SmartPointer<const DH,FEFieldFunction<dim, DH, VectorType> > dh;
+    SmartPointer<const DoFHandlerType,FEFieldFunction<dim, DoFHandlerType, VectorType> > dh;
 
     /**
      * A reference to the actual data vector.
@@ -457,8 +458,8 @@ namespace Functions
      * uninitialized boost::optional object.
      */
     boost::optional<Point<dim> >
-    get_reference_coordinates (const typename DH::active_cell_iterator &cell,
-                               const Point<dim>                        &point) const;
+    get_reference_coordinates (const typename DoFHandlerType::active_cell_iterator &cell,
+                               const Point<dim>                                    &point) const;
   };
 }
 
diff --git a/include/deal.II/numerics/fe_field_function.templates.h b/include/deal.II/numerics/fe_field_function.templates.h
index adfe897ad9..df5bbd45d5 100644
--- a/include/deal.II/numerics/fe_field_function.templates.h
+++ b/include/deal.II/numerics/fe_field_function.templates.h
@@ -31,10 +31,11 @@ DEAL_II_NAMESPACE_OPEN
 namespace Functions
 {
 
-  template <int dim, typename DH, typename VectorType>
-  FEFieldFunction<dim, DH, VectorType>::FEFieldFunction (const DH           &mydh,
-                                                         const VectorType   &myv,
-                                                         const Mapping<dim> &mymapping)
+  template <int dim, typename DoFHandlerType, typename VectorType>
+  FEFieldFunction<dim, DoFHandlerType, VectorType>::FEFieldFunction
+  (const DoFHandlerType &mydh,
+   const VectorType     &myv,
+   const Mapping<dim>   &mymapping)
     :
     Function<dim>(mydh.get_fe().n_components()),
     dh(&mydh, "FEFieldFunction"),
@@ -47,23 +48,23 @@ namespace Functions
 
 
 
-  template <int dim, typename DH, typename VectorType>
+  template <int dim, typename DoFHandlerType, typename VectorType>
   void
-  FEFieldFunction<dim, DH, VectorType>::
-  set_active_cell(const typename DH::active_cell_iterator &newcell)
+  FEFieldFunction<dim, DoFHandlerType, VectorType>::
+  set_active_cell(const typename DoFHandlerType::active_cell_iterator &newcell)
   {
     cell_hint.get() = newcell;
   }
 
 
 
-  template <int dim, typename DH, typename VectorType>
-  void FEFieldFunction<dim, DH, VectorType>::vector_value (const Point<dim> &p,
-                                                           Vector<double>   &values) const
+  template <int dim, typename DoFHandlerType, typename VectorType>
+  void FEFieldFunction<dim, DoFHandlerType, VectorType>::vector_value (const Point<dim> &p,
+      Vector<double>   &values) const
   {
     Assert (values.size() == n_components,
             ExcDimensionMismatch(values.size(), n_components));
-    typename DH::active_cell_iterator cell = cell_hint.get();
+    typename DoFHandlerType::active_cell_iterator cell = cell_hint.get();
     if (cell == dh->end())
       cell = dh->begin_active();
 
@@ -71,7 +72,7 @@ namespace Functions
     qp = get_reference_coordinates (cell, p);
     if (!qp)
       {
-        const std::pair<typename dealii::internal::ActiveCellIterator<dim, dim, DH>::type, Point<dim> > my_pair
+        const std::pair<typename dealii::internal::ActiveCellIterator<dim, dim, DoFHandlerType>::type, Point<dim> > my_pair
           = GridTools::find_active_cell_around_point (mapping, *dh, p);
         AssertThrow (my_pair.first->is_locally_owned(),
                      VectorTools::ExcPointNotAvailableHere());
@@ -95,10 +96,10 @@ namespace Functions
 
 
 
-  template <int dim, typename DH, typename VectorType>
+  template <int dim, typename DoFHandlerType, typename VectorType>
   double
-  FEFieldFunction<dim, DH, VectorType>::value (const Point<dim>   &p,
-                                               const unsigned int comp) const
+  FEFieldFunction<dim, DoFHandlerType, VectorType>::value (const Point<dim>   &p,
+                                                           const unsigned int comp) const
   {
     Vector<double> values(n_components);
     vector_value(p, values);
@@ -107,15 +108,15 @@ namespace Functions
 
 
 
-  template <int dim, typename DH, typename VectorType>
+  template <int dim, typename DoFHandlerType, typename VectorType>
   void
-  FEFieldFunction<dim, DH, VectorType>::
+  FEFieldFunction<dim, DoFHandlerType, VectorType>::
   vector_gradient (const Point<dim>            &p,
                    std::vector<Tensor<1,dim> > &gradients) const
   {
     Assert (gradients.size() == n_components,
             ExcDimensionMismatch(gradients.size(), n_components));
-    typename DH::active_cell_iterator cell = cell_hint.get();
+    typename DoFHandlerType::active_cell_iterator cell = cell_hint.get();
     if (cell == dh->end())
       cell = dh->begin_active();
 
@@ -123,7 +124,7 @@ namespace Functions
     qp = get_reference_coordinates (cell, p);
     if (!qp)
       {
-        const std::pair<typename dealii::internal::ActiveCellIterator<dim, dim, DH>::type, Point<dim> > my_pair
+        const std::pair<typename dealii::internal::ActiveCellIterator<dim, dim, DoFHandlerType>::type, Point<dim> > my_pair
           = GridTools::find_active_cell_around_point (mapping, *dh, p);
         AssertThrow (my_pair.first->is_locally_owned(),
                      VectorTools::ExcPointNotAvailableHere());
@@ -151,9 +152,9 @@ namespace Functions
 
 
 
-  template <int dim, typename DH, typename VectorType>
+  template <int dim, typename DoFHandlerType, typename VectorType>
   Tensor<1,dim>
-  FEFieldFunction<dim, DH, VectorType>::
+  FEFieldFunction<dim, DoFHandlerType, VectorType>::
   gradient (const Point<dim>   &p,
             const unsigned int comp) const
   {
@@ -164,15 +165,15 @@ namespace Functions
 
 
 
-  template <int dim, typename DH, typename VectorType>
+  template <int dim, typename DoFHandlerType, typename VectorType>
   void
-  FEFieldFunction<dim, DH, VectorType>::
+  FEFieldFunction<dim, DoFHandlerType, VectorType>::
   vector_laplacian (const Point<dim> &p,
                     Vector<double>   &values) const
   {
     Assert (values.size() == n_components,
             ExcDimensionMismatch(values.size(), n_components));
-    typename DH::active_cell_iterator cell = cell_hint.get();
+    typename DoFHandlerType::active_cell_iterator cell = cell_hint.get();
     if (cell == dh->end())
       cell = dh->begin_active();
 
@@ -180,7 +181,7 @@ namespace Functions
     qp = get_reference_coordinates (cell, p);
     if (!qp)
       {
-        const std::pair<typename dealii::internal::ActiveCellIterator<dim, dim, DH>::type, Point<dim> > my_pair
+        const std::pair<typename dealii::internal::ActiveCellIterator<dim, dim, DoFHandlerType>::type, Point<dim> > my_pair
           = GridTools::find_active_cell_around_point (mapping, *dh, p);
         AssertThrow (my_pair.first->is_locally_owned(),
                      VectorTools::ExcPointNotAvailableHere());
@@ -204,9 +205,10 @@ namespace Functions
 
 
 
-  template <int dim, typename DH, typename VectorType>
-  double FEFieldFunction<dim, DH, VectorType>::laplacian
-  (const Point<dim>   &p, const unsigned int  comp) const
+  template <int dim, typename DoFHandlerType, typename VectorType>
+  double FEFieldFunction<dim, DoFHandlerType, VectorType>::laplacian
+  (const Point<dim>   &p,
+   const unsigned int  comp) const
   {
     Vector<double> lap(n_components);
     vector_laplacian(p, lap);
@@ -217,16 +219,16 @@ namespace Functions
   // Now the list versions
   // ==============================
 
-  template <int dim, typename DH, typename VectorType>
+  template <int dim, typename DoFHandlerType, typename VectorType>
   void
-  FEFieldFunction<dim, DH, VectorType>::
-  vector_value_list (const std::vector<Point< dim > >     &points,
-                     std::vector< Vector<double> > &values) const
+  FEFieldFunction<dim, DoFHandlerType, VectorType>::
+  vector_value_list (const std::vector<Point< dim > > &points,
+                     std::vector< Vector<double> >    &values) const
   {
     Assert(points.size() == values.size(),
            ExcDimensionMismatch(points.size(), values.size()));
 
-    std::vector<typename DH::active_cell_iterator > cells;
+    std::vector<typename DoFHandlerType::active_cell_iterator > cells;
     std::vector<std::vector<Point<dim> > > qpoints;
     std::vector<std::vector<unsigned int> > maps;
 
@@ -261,12 +263,12 @@ namespace Functions
 
 
 
-  template <int dim, typename DH, typename VectorType>
+  template <int dim, typename DoFHandlerType, typename VectorType>
   void
-  FEFieldFunction<dim, DH, VectorType>::
+  FEFieldFunction<dim, DoFHandlerType, VectorType>::
   value_list (const std::vector<Point< dim > > &points,
               std::vector< double >            &values,
-              const unsigned int               component) const
+              const unsigned int                component) const
   {
     Assert(points.size() == values.size(),
            ExcDimensionMismatch(points.size(), values.size()));
@@ -278,17 +280,16 @@ namespace Functions
 
 
 
-  template <int dim, typename DH, typename VectorType>
+  template <int dim, typename DoFHandlerType, typename VectorType>
   void
-  FEFieldFunction<dim, DH, VectorType>::
-  vector_gradient_list (const std::vector<Point< dim > >     &points,
-                        std::vector<
-                        std::vector< Tensor<1,dim> > > &values) const
+  FEFieldFunction<dim, DoFHandlerType, VectorType>::
+  vector_gradient_list (const std::vector<Point< dim > >           &points,
+                        std::vector<std::vector< Tensor<1,dim> > > &values) const
   {
     Assert(points.size() == values.size(),
            ExcDimensionMismatch(points.size(), values.size()));
 
-    std::vector<typename DH::active_cell_iterator > cells;
+    std::vector<typename DoFHandlerType::active_cell_iterator > cells;
     std::vector<std::vector<Point<dim> > > qpoints;
     std::vector<std::vector<unsigned int> > maps;
 
@@ -327,12 +328,12 @@ namespace Functions
       }
   }
 
-  template <int dim, typename DH, typename VectorType>
+  template <int dim, typename DoFHandlerType, typename VectorType>
   void
-  FEFieldFunction<dim, DH, VectorType>::
+  FEFieldFunction<dim, DoFHandlerType, VectorType>::
   gradient_list (const std::vector<Point< dim > > &points,
-                 std::vector< Tensor<1,dim> > &values,
-                 const unsigned int  component) const
+                 std::vector< Tensor<1,dim> >     &values,
+                 const unsigned int                component) const
   {
     Assert(points.size() == values.size(),
            ExcDimensionMismatch(points.size(), values.size()));
@@ -344,16 +345,16 @@ namespace Functions
   }
 
 
-  template <int dim, typename DH, typename VectorType>
+  template <int dim, typename DoFHandlerType, typename VectorType>
   void
-  FEFieldFunction<dim, DH, VectorType>::
-  vector_laplacian_list (const std::vector<Point< dim > >     &points,
-                         std::vector< Vector<double> > &values) const
+  FEFieldFunction<dim, DoFHandlerType, VectorType>::
+  vector_laplacian_list (const std::vector<Point< dim > > &points,
+                         std::vector< Vector<double> >    &values) const
   {
     Assert(points.size() == values.size(),
            ExcDimensionMismatch(points.size(), values.size()));
 
-    std::vector<typename DH::active_cell_iterator > cells;
+    std::vector<typename DoFHandlerType::active_cell_iterator> cells;
     std::vector<std::vector<Point<dim> > > qpoints;
     std::vector<std::vector<unsigned int> > maps;
 
@@ -386,12 +387,12 @@ namespace Functions
       }
   }
 
-  template <int dim, typename DH, typename VectorType>
+  template <int dim, typename DoFHandlerType, typename VectorType>
   void
-  FEFieldFunction<dim, DH, VectorType>::
-  laplacian_list (const std::vector<Point< dim > > &points,
-                  std::vector< double > &values,
-                  const unsigned int  component) const
+  FEFieldFunction<dim, DoFHandlerType, VectorType>::
+  laplacian_list (const std::vector<Point<dim> > &points,
+                  std::vector<double>            &values,
+                  const unsigned int              component) const
   {
     Assert(points.size() == values.size(),
            ExcDimensionMismatch(points.size(), values.size()));
@@ -403,12 +404,13 @@ namespace Functions
 
 
 
-  template <int dim, typename DH, typename VectorType>
-  unsigned int FEFieldFunction<dim, DH, VectorType>::
-  compute_point_locations(const std::vector<Point<dim> > &points,
-                          std::vector<typename DH::active_cell_iterator > &cells,
-                          std::vector<std::vector<Point<dim> > > &qpoints,
-                          std::vector<std::vector<unsigned int> > &maps) const
+  template <int dim, typename DoFHandlerType, typename VectorType>
+  unsigned int FEFieldFunction<dim, DoFHandlerType, VectorType>::
+  compute_point_locations
+  (const std::vector<Point<dim> >                              &points,
+   std::vector<typename DoFHandlerType::active_cell_iterator > &cells,
+   std::vector<std::vector<Point<dim> > >                      &qpoints,
+   std::vector<std::vector<unsigned int> >                     &maps) const
   {
     // How many points are here?
     const unsigned int np = points.size();
@@ -430,7 +432,7 @@ namespace Functions
     bool left_over = true;
 
     // Current quadrature point
-    typename DH::active_cell_iterator cell = cell_hint.get();
+    typename DoFHandlerType::active_cell_iterator cell = cell_hint.get();
     if (cell == dh->end())
       cell = dh->begin_active();
 
@@ -453,7 +455,7 @@ namespace Functions
       qp = get_reference_coordinates (cell, points[0]);
       if (!qp)
         {
-          const std::pair<typename dealii::internal::ActiveCellIterator<dim, dim, DH>::type, Point<dim> >
+          const std::pair<typename dealii::internal::ActiveCellIterator<dim, dim, DoFHandlerType>::type, Point<dim> >
           my_pair  = GridTools::find_active_cell_around_point
                      (mapping, *dh, points[0]);
           AssertThrow (my_pair.first->is_locally_owned(),
@@ -518,7 +520,7 @@ namespace Functions
         // the next cell
         if (left_over == true)
           {
-            const std::pair<typename dealii::internal::ActiveCellIterator<dim, dim, DH>::type, Point<dim> > my_pair
+            const std::pair<typename dealii::internal::ActiveCellIterator<dim, dim, DoFHandlerType>::type, Point<dim> > my_pair
               = GridTools::find_active_cell_around_point (mapping, *dh, points[first_outside]);
             AssertThrow (my_pair.first->is_locally_owned(),
                          VectorTools::ExcPointNotAvailableHere());
@@ -565,11 +567,11 @@ namespace Functions
   }
 
 
-  template <int dim, typename DH, typename VectorType>
+  template <int dim, typename DoFHandlerType, typename VectorType>
   boost::optional<Point<dim> >
-  FEFieldFunction<dim, DH, VectorType>::
-  get_reference_coordinates (const typename DH::active_cell_iterator &cell,
-                             const Point<dim>                        &point) const
+  FEFieldFunction<dim, DoFHandlerType, VectorType>::
+  get_reference_coordinates (const typename DoFHandlerType::active_cell_iterator &cell,
+                             const Point<dim>                                    &point) const
   {
     try
       {
diff --git a/include/deal.II/numerics/solution_transfer.h b/include/deal.II/numerics/solution_transfer.h
index 738c09e3a9..524e164148 100644
--- a/include/deal.II/numerics/solution_transfer.h
+++ b/include/deal.II/numerics/solution_transfer.h
@@ -288,7 +288,8 @@ DEAL_II_NAMESPACE_OPEN
  * @author Ralf Hartmann, 1999, Oliver Kayser-Herold and Wolfgang Bangerth,
  * 2006, Wolfgang Bangerth 2014
  */
-template<int dim, typename VectorType=Vector<double>, class DH=DoFHandler<dim> >
+template<int dim, typename VectorType=Vector<double>,
+         typename DoFHandlerType=DoFHandler<dim> >
 class SolutionTransfer
 {
 public:
@@ -296,7 +297,7 @@ public:
   /**
    * Constructor, takes the current DoFHandler as argument.
    */
-  SolutionTransfer(const DH &dof);
+  SolutionTransfer(const DoFHandlerType &dof);
 
   /**
    * Destructor
@@ -418,7 +419,7 @@ private:
   /**
    * Pointer to the degree of freedom handler to work with.
    */
-  SmartPointer<const DH,SolutionTransfer<dim,VectorType,DH> > dof_handler;
+  SmartPointer<const DoFHandlerType, SolutionTransfer<dim,VectorType, DoFHandlerType> > dof_handler;
 
   /**
    * Stores the number of DoFs before the refinement and/or coarsening.
diff --git a/include/deal.II/numerics/vector_tools.h b/include/deal.II/numerics/vector_tools.h
index 6b94eb7af9..ad82cb2ec1 100644
--- a/include/deal.II/numerics/vector_tools.h
+++ b/include/deal.II/numerics/vector_tools.h
@@ -392,7 +392,7 @@ namespace VectorTools
    * with the hanging nodes from space @p dof afterwards, to make the result
    * continuous again.
    *
-   * The template argument <code>DH</code> may either be of type DoFHandler or
+   * The template argument <code>DoFHandlerType</code> may either be of type DoFHandler or
    * hp::DoFHandler.
    *
    * See the general documentation of this namespace for further information.
@@ -400,20 +400,20 @@ namespace VectorTools
    * @todo The @p mapping argument should be replaced by a
    * hp::MappingCollection in case of a hp::DoFHandler.
    */
-  template <typename VectorType, int dim, int spacedim, template <int,int> class DH>
-  void interpolate (const Mapping<dim,spacedim>     &mapping,
-                    const DH<dim,spacedim>          &dof,
-                    const Function<spacedim,double> &function,
-                    VectorType                      &vec);
+  template <typename VectorType, int dim, int spacedim, template <int, int> class DoFHandlerType>
+  void interpolate (const Mapping<dim,spacedim>        &mapping,
+                    const DoFHandlerType<dim,spacedim> &dof,
+                    const Function<spacedim,double>    &function,
+                    VectorType                         &vec);
 
   /**
    * Calls the @p interpolate() function above with
    * <tt>mapping=MappingQGeneric1@<dim>@()</tt>.
    */
-  template <typename VectorType, class DH>
-  void interpolate (const DH                                   &dof,
-                    const Function<DH::space_dimension,double> &function,
-                    VectorType                                 &vec);
+  template <typename VectorType, typename DoFHandlerType>
+  void interpolate (const DoFHandlerType                                   &dof,
+                    const Function<DoFHandlerType::space_dimension,double> &function,
+                    VectorType                                             &vec);
 
   /**
    * Interpolate different finite element spaces. The interpolation of vector
@@ -432,11 +432,11 @@ namespace VectorTools
    * instantiated by hand.
    */
   template <int dim, class InVector, class OutVector, int spacedim>
-  void interpolate (const DoFHandler<dim,spacedim>    &dof_1,
-                    const DoFHandler<dim,spacedim>    &dof_2,
-                    const FullMatrix<double> &transfer,
-                    const InVector           &data_1,
-                    OutVector                &data_2);
+  void interpolate (const DoFHandler<dim,spacedim> &dof_1,
+                    const DoFHandler<dim,spacedim> &dof_2,
+                    const FullMatrix<double>       &transfer,
+                    const InVector                 &data_1,
+                    OutVector                      &data_2);
 
   /**
    * This function is a kind of generalization or modification of the very
@@ -484,14 +484,14 @@ namespace VectorTools
    *
    * @author Valentin Zingan, 2013
    */
-  template<typename VectorType, typename DH>
+  template <typename VectorType, typename DoFHandlerType>
   void
   interpolate_based_on_material_id
-  (const Mapping<DH::dimension, DH::space_dimension> &mapping,
-   const DH                                          &dof_handler,
-   const std::map< types::material_id, const Function<DH::space_dimension,double>* > &function_map,
-   VectorType                                        &dst,
-   const ComponentMask                               &component_mask = ComponentMask());
+  (const Mapping<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &mapping,
+   const DoFHandlerType                                                  &dof_handler,
+   const std::map<types::material_id, const Function<DoFHandlerType::space_dimension, double> *> &function_map,
+   VectorType                                                            &dst,
+   const ComponentMask                                                   &component_mask = ComponentMask());
 
   /**
    * Gives the interpolation of a @p dof1-function @p u1 to a @p dof2-function
@@ -518,13 +518,13 @@ namespace VectorTools
    * flag).
    */
   template <int dim, int spacedim,
-            template <int,int> class DH,
+            template <int, int> class DoFHandlerType,
             typename VectorType>
   void
-  interpolate_to_different_mesh (const DH<dim, spacedim> &dof1,
-                                 const VectorType        &u1,
-                                 const DH<dim, spacedim> &dof2,
-                                 VectorType              &u2);
+  interpolate_to_different_mesh (const DoFHandlerType<dim, spacedim> &dof1,
+                                 const VectorType                    &u1,
+                                 const DoFHandlerType<dim, spacedim> &dof2,
+                                 VectorType                          &u2);
 
   /**
    * Gives the interpolation of a @p dof1-function @p u1 to a @p dof2-function
@@ -540,14 +540,14 @@ namespace VectorTools
    * does not necessarily respect continuity requirements at hanging nodes.
    */
   template <int dim, int spacedim,
-            template <int,int> class DH,
+            template <int, int> class DoFHandlerType,
             typename VectorType>
   void
-  interpolate_to_different_mesh (const DH<dim, spacedim> &dof1,
-                                 const VectorType        &u1,
-                                 const DH<dim, spacedim> &dof2,
-                                 const ConstraintMatrix  &constraints,
-                                 VectorType              &u2);
+  interpolate_to_different_mesh (const DoFHandlerType<dim, spacedim> &dof1,
+                                 const VectorType                    &u1,
+                                 const DoFHandlerType<dim, spacedim> &dof2,
+                                 const ConstraintMatrix              &constraints,
+                                 VectorType                          &u2);
 
 
   /**
@@ -558,13 +558,14 @@ namespace VectorTools
    * pointing from a source DoFHandler to a destination DoFHandler.
    */
   template <int dim, int spacedim,
-            template <int,int> class DH,
+            template <int, int> class DoFHandlerType,
             typename VectorType>
   void
-  interpolate_to_different_mesh (const InterGridMap<DH<dim, spacedim> > &intergridmap,
-                                 const VectorType                       &u1,
-                                 const ConstraintMatrix                 &constraints,
-                                 VectorType                             &u2);
+  interpolate_to_different_mesh
+  (const InterGridMap<DoFHandlerType<dim, spacedim> > &intergridmap,
+   const VectorType                                   &u1,
+   const ConstraintMatrix                             &constraints,
+   VectorType                                         &u2);
 
   /**
    * Compute the projection of @p function to the finite element space.
@@ -697,13 +698,14 @@ namespace VectorTools
    *
    * See the general documentation of this namespace for more information.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  interpolate_boundary_values (const Mapping<DH::dimension,DH::space_dimension>            &mapping,
-                               const DH                 &dof,
-                               const typename FunctionMap<DH::space_dimension>::type &function_map,
-                               std::map<types::global_dof_index,double> &boundary_values,
-                               const ComponentMask       &component_mask = ComponentMask());
+  interpolate_boundary_values
+  (const Mapping<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &mapping,
+   const DoFHandlerType                                                     &dof,
+   const typename FunctionMap<DoFHandlerType::space_dimension>::type        &function_map,
+   std::map<types::global_dof_index,double>                                 &boundary_values,
+   const ComponentMask                                                      &component_mask = ComponentMask());
 
   /**
    * Like the previous function, but take a mapping collection to go with the
@@ -711,11 +713,12 @@ namespace VectorTools
    */
   template <int dim, int spacedim>
   void
-  interpolate_boundary_values (const hp::MappingCollection<dim,spacedim>            &mapping,
-                               const hp::DoFHandler<dim,spacedim>                 &dof,
-                               const typename FunctionMap<spacedim>::type &function_map,
-                               std::map<types::global_dof_index,double> &boundary_values,
-                               const ComponentMask       &component_mask = ComponentMask());
+  interpolate_boundary_values
+  (const hp::MappingCollection<dim,spacedim>  &mapping,
+   const hp::DoFHandler<dim,spacedim>         &dof,
+   const typename FunctionMap<spacedim>::type &function_map,
+   std::map<types::global_dof_index,double>   &boundary_values,
+   const ComponentMask                        &component_mask = ComponentMask());
 
   /**
    * Same function as above, but taking only one pair of boundary indicator
@@ -726,14 +729,15 @@ namespace VectorTools
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  interpolate_boundary_values (const Mapping<DH::dimension,DH::space_dimension>            &mapping,
-                               const DH                 &dof,
-                               const types::boundary_id            boundary_component,
-                               const Function<DH::space_dimension,double>           &boundary_function,
-                               std::map<types::global_dof_index,double> &boundary_values,
-                               const ComponentMask       &component_mask = ComponentMask());
+  interpolate_boundary_values
+  (const Mapping<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &mapping,
+   const DoFHandlerType                                                     &dof,
+   const types::boundary_id                                                  boundary_component,
+   const Function<DoFHandlerType::space_dimension,double>                   &boundary_function,
+   std::map<types::global_dof_index,double>                                 &boundary_values,
+   const ComponentMask                                                      &component_mask = ComponentMask());
 
   /**
    * Calls the other interpolate_boundary_values() function, see above, with
@@ -744,13 +748,14 @@ namespace VectorTools
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  interpolate_boundary_values (const DH        &dof,
-                               const types::boundary_id            boundary_component,
-                               const Function<DH::space_dimension,double>           &boundary_function,
-                               std::map<types::global_dof_index,double> &boundary_values,
-                               const ComponentMask       &component_mask = ComponentMask());
+  interpolate_boundary_values
+  (const DoFHandlerType                                   &dof,
+   const types::boundary_id                                boundary_component,
+   const Function<DoFHandlerType::space_dimension,double> &boundary_function,
+   std::map<types::global_dof_index,double>               &boundary_values,
+   const ComponentMask                                    &component_mask = ComponentMask());
 
 
   /**
@@ -759,12 +764,13 @@ namespace VectorTools
    * previous function, in particular about the use of the component mask and
    * the requires size of the function object.
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  interpolate_boundary_values (const DH                &dof,
-                               const typename FunctionMap<DH::space_dimension>::type &function_map,
-                               std::map<types::global_dof_index,double>         &boundary_values,
-                               const ComponentMask               &component_mask = ComponentMask());
+  interpolate_boundary_values
+  (const DoFHandlerType                                              &dof,
+   const typename FunctionMap<DoFHandlerType::space_dimension>::type &function_map,
+   std::map<types::global_dof_index,double>                          &boundary_values,
+   const ComponentMask                                               &component_mask = ComponentMask());
 
 
   /**
@@ -828,13 +834,14 @@ namespace VectorTools
    *
    * @ingroup constraints
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  interpolate_boundary_values (const Mapping<DH::dimension,DH::space_dimension>            &mapping,
-                               const DH                 &dof,
-                               const typename FunctionMap<DH::space_dimension>::type &function_map,
-                               ConstraintMatrix              &constraints,
-                               const ComponentMask       &component_mask = ComponentMask());
+  interpolate_boundary_values
+  (const Mapping<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &mapping,
+   const DoFHandlerType                                                     &dof,
+   const typename FunctionMap<DoFHandlerType::space_dimension>::type        &function_map,
+   ConstraintMatrix                                                         &constraints,
+   const ComponentMask                                                      &component_mask = ComponentMask());
 
   /**
    * Same function as above, but taking only one pair of boundary indicator
@@ -847,14 +854,15 @@ namespace VectorTools
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  interpolate_boundary_values (const Mapping<DH::dimension,DH::space_dimension> &mapping,
-                               const DH                            &dof,
-                               const types::boundary_id                  boundary_component,
-                               const Function<DH::space_dimension,double> &boundary_function,
-                               ConstraintMatrix                    &constraints,
-                               const ComponentMask             &component_mask = ComponentMask());
+  interpolate_boundary_values
+  (const Mapping<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &mapping,
+   const DoFHandlerType                                                     &dof,
+   const types::boundary_id                                                  boundary_component,
+   const Function<DoFHandlerType::space_dimension,double>                   &boundary_function,
+   ConstraintMatrix                                                         &constraints,
+   const ComponentMask                                                      &component_mask = ComponentMask());
 
   /**
    * Calls the other interpolate_boundary_values() function, see above, with
@@ -867,13 +875,14 @@ namespace VectorTools
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  interpolate_boundary_values (const DH                            &dof,
-                               const types::boundary_id                  boundary_component,
-                               const Function<DH::space_dimension,double> &boundary_function,
-                               ConstraintMatrix                    &constraints,
-                               const ComponentMask             &component_mask = ComponentMask());
+  interpolate_boundary_values
+  (const DoFHandlerType                                   &dof,
+   const types::boundary_id                                boundary_component,
+   const Function<DoFHandlerType::space_dimension,double> &boundary_function,
+   ConstraintMatrix                                       &constraints,
+   const ComponentMask                                    &component_mask = ComponentMask());
 
 
   /**
@@ -884,12 +893,13 @@ namespace VectorTools
    *
    * @ingroup constraints
    */
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  interpolate_boundary_values (const DH                &dof,
-                               const typename FunctionMap<DH::space_dimension>::type &function_map,
-                               ConstraintMatrix        &constraints,
-                               const ComponentMask &component_mask = ComponentMask());
+  interpolate_boundary_values
+  (const DoFHandlerType                                              &dof,
+   const typename FunctionMap<DoFHandlerType::space_dimension>::type &function_map,
+   ConstraintMatrix                                                  &constraints,
+   const ComponentMask                                               &component_mask = ComponentMask());
 
 
   /**
@@ -1514,14 +1524,15 @@ namespace VectorTools
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  template <int dim, template <int, int> class DH, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, int spacedim>
   void
-  compute_nonzero_normal_flux_constraints (const DH<dim,spacedim>         &dof_handler,
-                                           const unsigned int     first_vector_component,
-                                           const std::set<types::boundary_id> &boundary_ids,
-                                           typename FunctionMap<spacedim>::type &function_map,
-                                           ConstraintMatrix      &constraints,
-                                           const Mapping<dim, spacedim>    &mapping = StaticMappingQ1<dim>::mapping);
+  compute_nonzero_normal_flux_constraints
+  (const DoFHandlerType<dim,spacedim>   &dof_handler,
+   const unsigned int                    first_vector_component,
+   const std::set<types::boundary_id>   &boundary_ids,
+   typename FunctionMap<spacedim>::type &function_map,
+   ConstraintMatrix                     &constraints,
+   const Mapping<dim, spacedim>         &mapping = StaticMappingQ1<dim>::mapping);
 
   /**
    * Same as above for homogeneous normal-flux constraints.
@@ -1531,13 +1542,14 @@ namespace VectorTools
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  template <int dim, template <int, int> class DH, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, int spacedim>
   void
-  compute_no_normal_flux_constraints (const DH<dim,spacedim>         &dof_handler,
-                                      const unsigned int     first_vector_component,
-                                      const std::set<types::boundary_id> &boundary_ids,
-                                      ConstraintMatrix      &constraints,
-                                      const Mapping<dim, spacedim>    &mapping = StaticMappingQ1<dim>::mapping);
+  compute_no_normal_flux_constraints
+  (const DoFHandlerType<dim,spacedim> &dof_handler,
+   const unsigned int                  first_vector_component,
+   const std::set<types::boundary_id> &boundary_ids,
+   ConstraintMatrix                   &constraints,
+   const Mapping<dim, spacedim>       &mapping = StaticMappingQ1<dim>::mapping);
 
   /**
    * Compute the constraints that correspond to boundary conditions of the
@@ -1553,14 +1565,15 @@ namespace VectorTools
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  template <int dim, template <int, int> class DH, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, int spacedim>
   void
-  compute_nonzero_tangential_flux_constraints (const DH<dim,spacedim>         &dof_handler,
-                                               const unsigned int     first_vector_component,
-                                               const std::set<types::boundary_id> &boundary_ids,
-                                               typename FunctionMap<spacedim>::type &function_map,
-                                               ConstraintMatrix      &constraints,
-                                               const Mapping<dim, spacedim>    &mapping = StaticMappingQ1<dim>::mapping);
+  compute_nonzero_tangential_flux_constraints
+  (const DoFHandlerType<dim,spacedim>   &dof_handler,
+   const unsigned int                    first_vector_component,
+   const std::set<types::boundary_id>   &boundary_ids,
+   typename FunctionMap<spacedim>::type &function_map,
+   ConstraintMatrix                     &constraints,
+   const Mapping<dim, spacedim>         &mapping = StaticMappingQ1<dim>::mapping);
 
   /**
    * Same as above for homogeneous tangential-flux constraints.
@@ -1570,13 +1583,14 @@ namespace VectorTools
    * @see
    * @ref GlossBoundaryIndicator "Glossary entry on boundary indicators"
    */
-  template <int dim, template <int, int> class DH, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, int spacedim>
   void
-  compute_normal_flux_constraints (const DH<dim,spacedim>         &dof_handler,
-                                   const unsigned int     first_vector_component,
-                                   const std::set<types::boundary_id> &boundary_ids,
-                                   ConstraintMatrix      &constraints,
-                                   const Mapping<dim, spacedim>    &mapping = StaticMappingQ1<dim>::mapping);
+  compute_normal_flux_constraints
+  (const DoFHandlerType<dim,spacedim> &dof_handler,
+   const unsigned int                  first_vector_component,
+   const std::set<types::boundary_id> &boundary_ids,
+   ConstraintMatrix                   &constraints,
+   const Mapping<dim, spacedim>       &mapping = StaticMappingQ1<dim>::mapping);
 
 
   //@}
@@ -2369,10 +2383,10 @@ namespace VectorTools
    *
    * @author Luca Heltai, 2015
    */
-  template<class DH, typename VectorType>
-  void get_position_vector(const DH &dh,
-                           VectorType &vector,
-                           const ComponentMask &mask=ComponentMask());
+  template<typename DoFHandlerType, typename VectorType>
+  void get_position_vector(const DoFHandlerType &dh,
+                           VectorType           &vector,
+                           const ComponentMask  &mask = ComponentMask());
 
   //@}
 
diff --git a/include/deal.II/numerics/vector_tools.templates.h b/include/deal.II/numerics/vector_tools.templates.h
index 03fde39e59..5f2408ea92 100644
--- a/include/deal.II/numerics/vector_tools.templates.h
+++ b/include/deal.II/numerics/vector_tools.templates.h
@@ -73,11 +73,12 @@ DEAL_II_NAMESPACE_OPEN
 namespace VectorTools
 {
 
-  template <typename VectorType, int dim, int spacedim, template <int,int> class DH>
-  void interpolate (const Mapping<dim,spacedim> &mapping,
-                    const DH<dim,spacedim>      &dof,
-                    const Function<spacedim>    &function,
-                    VectorType                  &vec)
+  template <typename VectorType, int dim, int spacedim,
+            template <int, int> class DoFHandlerType>
+  void interpolate (const Mapping<dim,spacedim>        &mapping,
+                    const DoFHandlerType<dim,spacedim> &dof,
+                    const Function<spacedim>           &function,
+                    VectorType                         &vec)
   {
     Assert (vec.size() == dof.n_dofs(),
             ExcDimensionMismatch (vec.size(), dof.n_dofs()));
@@ -89,8 +90,9 @@ namespace VectorTools
     const unsigned int          n_components = fe.n_components();
     const bool                  fe_is_system = (n_components != 1);
 
-    typename DH<dim,spacedim>::active_cell_iterator cell = dof.begin_active(),
-                                                    endc = dof.end();
+    typename DoFHandlerType<dim,spacedim>::active_cell_iterator
+    cell = dof.begin_active(),
+    endc = dof.end();
 
     // For FESystems many of the
     // unit_support_points will appear
@@ -269,13 +271,16 @@ namespace VectorTools
   }
 
 
-  template <typename VectorType, class DH>
-  void interpolate (const DH                            &dof,
-                    const Function<DH::space_dimension> &function,
-                    VectorType                          &vec)
+  template <typename VectorType, typename DoFHandlerType>
+  void interpolate (const DoFHandlerType                            &dof,
+                    const Function<DoFHandlerType::space_dimension> &function,
+                    VectorType                                      &vec)
   {
-    interpolate(StaticMappingQ1<DH::dimension, DH::space_dimension>::mapping,
-                dof, function, vec);
+    interpolate(StaticMappingQ1<DoFHandlerType::dimension,
+                DoFHandlerType::space_dimension>::mapping,
+                dof,
+                function,
+                vec);
   }
 
 
@@ -332,15 +337,16 @@ namespace VectorTools
   }
 
 
-  template<typename VectorType, typename DH>
+  template<typename VectorType, typename DoFHandlerType>
   void
-  interpolate_based_on_material_id(const Mapping<DH::dimension, DH::space_dimension>                          &mapping,
-                                   const DH                                                                   &dof,
-                                   const std::map< types::material_id, const Function<DH::space_dimension>* > &function_map,
-                                   VectorType                                                                 &dst,
-                                   const ComponentMask                                                        &component_mask)
+  interpolate_based_on_material_id
+  (const Mapping<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &mapping,
+   const DoFHandlerType                                                      &dof,
+   const std::map<types::material_id, const Function<DoFHandlerType::space_dimension> *> &function_map,
+   VectorType                                                                &dst,
+   const ComponentMask                                                       &component_mask)
   {
-    const unsigned int dim = DH::dimension;
+    const unsigned int dim = DoFHandlerType::dimension;
 
     Assert( component_mask.represents_n_components(dof.get_fe().n_components()),
             ExcMessage("The number of components in the mask has to be either "
@@ -354,21 +360,23 @@ namespace VectorTools
             ExcMessage("You cannot specify the invalid material indicator "
                        "in your function map."));
 
-    for ( typename std::map< types::material_id, const Function<DH::space_dimension>* >::const_iterator
-          iter  = function_map.begin();
-          iter != function_map.end();
-          ++iter )
+    for (typename std::map<types::material_id, const Function<DoFHandlerType::space_dimension>* >
+         ::const_iterator
+         iter  = function_map.begin();
+         iter != function_map.end();
+         ++iter )
       {
         Assert( dof.get_fe().n_components() == iter->second->n_components,
                 ExcDimensionMismatch(dof.get_fe().n_components(), iter->second->n_components) );
       }
 
-    const hp::FECollection<DH::dimension, DH::space_dimension> fe(dof.get_fe());
+    const hp::FECollection<DoFHandlerType::dimension, DoFHandlerType::space_dimension>
+    fe(dof.get_fe());
     const unsigned int n_components =  fe.n_components();
     const bool         fe_is_system = (n_components != 1);
 
-    typename DH::active_cell_iterator cell = dof.begin_active(),
-                                      endc = dof.end();
+    typename DoFHandlerType::active_cell_iterator cell = dof.begin_active(),
+                                                  endc = dof.end();
 
     std::vector< std::vector< Point<dim> > > unit_support_points(fe.size());
     for (unsigned int fe_index = 0; fe_index < fe.size(); ++fe_index)
@@ -412,8 +420,8 @@ namespace VectorTools
 
     const unsigned int max_rep_points = *std::max_element(n_rep_points.begin(),
                                                           n_rep_points.end());
-    std::vector< types::global_dof_index>     dofs_on_cell(fe.max_dofs_per_cell());
-    std::vector< Point<DH::space_dimension> > rep_points(max_rep_points);
+    std::vector< types::global_dof_index> dofs_on_cell(fe.max_dofs_per_cell());
+    std::vector< Point<DoFHandlerType::space_dimension> > rep_points(max_rep_points);
 
     std::vector< std::vector<double> >           function_values_scalar(fe.size());
     std::vector< std::vector< Vector<double> > > function_values_system(fe.size());
@@ -422,11 +430,11 @@ namespace VectorTools
     for (unsigned int fe_index = 0; fe_index < fe.size(); ++fe_index)
       support_quadrature.push_back( Quadrature<dim>(unit_support_points[fe_index]) );
 
-    hp::MappingCollection<dim, DH::space_dimension> mapping_collection(mapping);
-    hp::FEValues<dim, DH::space_dimension> fe_values(mapping_collection,
-                                                     fe,
-                                                     support_quadrature,
-                                                     update_quadrature_points);
+    hp::MappingCollection<dim, DoFHandlerType::space_dimension> mapping_collection(mapping);
+    hp::FEValues<dim, DoFHandlerType::space_dimension> fe_values(mapping_collection,
+        fe,
+        support_quadrature,
+        update_quadrature_points);
 
     for ( ; cell != endc; ++cell)
       if ( cell->is_locally_owned() )
@@ -436,7 +444,8 @@ namespace VectorTools
 
             fe_values.reinit(cell);
 
-            const std::vector< Point<DH::space_dimension> > &support_points = fe_values.get_present_fe_values().get_quadrature_points();
+            const std::vector< Point<DoFHandlerType::space_dimension> > &support_points
+              = fe_values.get_present_fe_values().get_quadrature_points();
 
             rep_points.resize( dofs_of_rep_points[fe_index].size() );
             for (unsigned int i = 0; i < dofs_of_rep_points[fe_index].size(); ++i)
@@ -488,12 +497,12 @@ namespace VectorTools
      * mapping here because the function we evaluate for the DoFs is zero in
      * the mapped locations as well as in the original, unmapped locations
      */
-    template <class DH>
+    template <typename DoFHandlerType>
     void
-    interpolate_zero_boundary_values (const DH                                 &dof_handler,
+    interpolate_zero_boundary_values (const DoFHandlerType                     &dof_handler,
                                       std::map<types::global_dof_index,double> &boundary_values)
     {
-      const unsigned int dim      = DH::dimension;
+      const unsigned int dim = DoFHandlerType::dimension;
 
       // loop over all boundary faces
       // to get all dof indices of
@@ -516,7 +525,7 @@ namespace VectorTools
       // that is actually wholly on
       // the boundary, not only by
       // one line or one vertex
-      typename DH::active_cell_iterator
+      typename DoFHandlerType::active_cell_iterator
       cell = dof_handler.begin_active(),
       endc = dof_handler.end();
       std::vector<types::global_dof_index> face_dof_indices;
@@ -541,18 +550,18 @@ namespace VectorTools
 
 
 
-  template <int dim, int spacedim, template <int,int> class DH, typename VectorType>
+  template <int dim, int spacedim, template <int, int> class DoFHandlerType, typename VectorType>
   void
-  interpolate_to_different_mesh (const DH<dim, spacedim> &dof1,
-                                 const VectorType        &u1,
-                                 const DH<dim, spacedim> &dof2,
-                                 VectorType              &u2)
+  interpolate_to_different_mesh (const DoFHandlerType<dim, spacedim> &dof1,
+                                 const VectorType                    &u1,
+                                 const DoFHandlerType<dim, spacedim> &dof2,
+                                 VectorType                          &u2)
   {
     Assert(GridTools::have_same_coarse_mesh(dof1, dof2),
            ExcMessage ("The two containers must represent triangulations that "
                        "have the same coarse meshes"));
 
-    InterGridMap<DH<dim, spacedim> > intergridmap;
+    InterGridMap<DoFHandlerType<dim, spacedim> > intergridmap;
     intergridmap.make_mapping(dof1, dof2);
 
     ConstraintMatrix dummy;
@@ -563,19 +572,19 @@ namespace VectorTools
 
 
 
-  template <int dim, int spacedim, template <int,int> class DH, typename VectorType>
+  template <int dim, int spacedim, template <int, int> class DoFHandlerType, typename VectorType>
   void
-  interpolate_to_different_mesh (const DH<dim, spacedim> &dof1,
-                                 const VectorType        &u1,
-                                 const DH<dim, spacedim> &dof2,
-                                 const ConstraintMatrix  &constraints,
-                                 VectorType              &u2)
+  interpolate_to_different_mesh (const DoFHandlerType<dim, spacedim> &dof1,
+                                 const VectorType                    &u1,
+                                 const DoFHandlerType<dim, spacedim> &dof2,
+                                 const ConstraintMatrix              &constraints,
+                                 VectorType                          &u2)
   {
     Assert(GridTools::have_same_coarse_mesh(dof1, dof2),
            ExcMessage ("The two containers must represent triangulations that "
                        "have the same coarse meshes"));
 
-    InterGridMap<DH<dim, spacedim> > intergridmap;
+    InterGridMap<DoFHandlerType<dim, spacedim> > intergridmap;
     intergridmap.make_mapping(dof1, dof2);
 
     interpolate_to_different_mesh(intergridmap, u1, constraints, u2);
@@ -601,15 +610,16 @@ namespace VectorTools
   }
 
 
-  template <int dim, int spacedim, template <int,int> class DH, typename VectorType>
+  template <int dim, int spacedim, template <int, int> class DoFHandlerType, typename VectorType>
   void
-  interpolate_to_different_mesh (const InterGridMap<DH<dim, spacedim> > &intergridmap,
-                                 const VectorType                       &u1,
-                                 const ConstraintMatrix                 &constraints,
-                                 VectorType                             &u2)
+  interpolate_to_different_mesh
+  (const InterGridMap<DoFHandlerType<dim, spacedim> > &intergridmap,
+   const VectorType       &u1,
+   const ConstraintMatrix &constraints,
+   VectorType             &u2)
   {
-    const DH<dim, spacedim> &dof1 = intergridmap.get_source_grid();
-    const DH<dim, spacedim> &dof2 = intergridmap.get_destination_grid();
+    const DoFHandlerType<dim, spacedim> &dof1 = intergridmap.get_source_grid();
+    const DoFHandlerType<dim, spacedim> &dof2 = intergridmap.get_destination_grid();
     (void)dof2;
 
     Assert(u1.size()==dof1.n_dofs(),
@@ -628,12 +638,12 @@ namespace VectorTools
     // Therefor, loop over all cells
     // (active and inactive) of the source
     // grid ..
-    typename DH<dim,spacedim>::cell_iterator       cell1 = dof1.begin();
-    const typename DH<dim,spacedim>::cell_iterator endc1 = dof1.end();
+    typename DoFHandlerType<dim,spacedim>::cell_iterator       cell1 = dof1.begin();
+    const typename DoFHandlerType<dim,spacedim>::cell_iterator endc1 = dof1.end();
 
     for (; cell1 != endc1; ++cell1)
       {
-        const typename DH<dim,spacedim>::cell_iterator cell2 = intergridmap[cell1];
+        const typename DoFHandlerType<dim,spacedim>::cell_iterator cell2 = intergridmap[cell1];
 
         // .. and skip if source and destination
         // cells are not on the same level ..
@@ -676,15 +686,16 @@ namespace VectorTools
     /**
      * Compute the boundary values to be used in the project() functions.
      */
-    template <int dim, int spacedim, template <int,int> class DH,
+    template <int dim, int spacedim, template <int, int> class DoFHandlerType,
               template <int,int> class M_or_MC, template <int> class Q_or_QC>
-    void project_compute_b_v (const M_or_MC<dim, spacedim>   &mapping,
-                              const DH<dim,spacedim> &dof,
-                              const Function<spacedim> &function,
-                              const bool                enforce_zero_boundary,
-                              const Q_or_QC<dim-1>  &q_boundary,
-                              const bool                project_to_boundary_first,
-                              std::map<types::global_dof_index,double> &boundary_values)
+    void project_compute_b_v
+    (const M_or_MC<dim, spacedim>             &mapping,
+     const DoFHandlerType<dim,spacedim>       &dof,
+     const Function<spacedim>                 &function,
+     const bool                                enforce_zero_boundary,
+     const Q_or_QC<dim-1>                     &q_boundary,
+     const bool                                project_to_boundary_first,
+     std::map<types::global_dof_index,double> &boundary_values)
     {
       if (enforce_zero_boundary == true)
         // no need to project boundary
@@ -741,17 +752,18 @@ namespace VectorTools
     /**
      * Generic implementation of the project() function
      */
-    template <int dim, int spacedim, typename VectorType, template <int,int> class DH,
+    template <int dim, int spacedim, typename VectorType,
+              template <int, int> class DoFHandlerType,
               template <int,int> class M_or_MC, template <int> class Q_or_QC>
-    void do_project (const M_or_MC<dim, spacedim> &mapping,
-                     const DH<dim,spacedim>       &dof,
-                     const ConstraintMatrix       &constraints,
-                     const Q_or_QC<dim>           &quadrature,
-                     const Function<spacedim>     &function,
-                     VectorType                   &vec_result,
-                     const bool                   enforce_zero_boundary,
-                     const Q_or_QC<dim-1>         &q_boundary,
-                     const bool                   project_to_boundary_first)
+    void do_project (const M_or_MC<dim, spacedim>       &mapping,
+                     const DoFHandlerType<dim,spacedim> &dof,
+                     const ConstraintMatrix             &constraints,
+                     const Q_or_QC<dim>                 &quadrature,
+                     const Function<spacedim>           &function,
+                     VectorType                         &vec_result,
+                     const bool                          enforce_zero_boundary,
+                     const Q_or_QC<dim-1>               &q_boundary,
+                     const bool                          project_to_boundary_first)
     {
       Assert (dof.get_fe().n_components() == function.n_components,
               ExcDimensionMismatch(dof.get_fe().n_components(),
@@ -1650,17 +1662,18 @@ namespace VectorTools
     // faces are points and it is far
     // easier to simply work on
     // individual vertices
-    template <class DH, template <int,int> class M_or_MC>
+    template <typename DoFHandlerType, template <int,int> class M_or_MC>
     static inline
-    void do_interpolate_boundary_values (const M_or_MC<DH::dimension, DH::space_dimension> &,
-                                         const DH                 &dof,
-                                         const typename FunctionMap<DH::space_dimension>::type &function_map,
-                                         std::map<types::global_dof_index,double> &boundary_values,
-                                         const ComponentMask       &component_mask,
-                                         const dealii::internal::int2type<1>)
+    void do_interpolate_boundary_values
+    (const M_or_MC<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &,
+     const DoFHandlerType                                              &dof,
+     const typename FunctionMap<DoFHandlerType::space_dimension>::type &function_map,
+     std::map<types::global_dof_index,double>                          &boundary_values,
+     const ComponentMask                                               &component_mask,
+     const dealii::internal::int2type<1>)
     {
-      const unsigned int dim = DH::dimension;
-      const unsigned int spacedim=DH::space_dimension;
+      const unsigned int dim = DoFHandlerType::dimension;
+      const unsigned int spacedim = DoFHandlerType::space_dimension;
 
       Assert (component_mask.represents_n_components(dof.get_fe().n_components()),
               ExcMessage ("The number of components in the mask has to be either "
@@ -1673,7 +1686,7 @@ namespace VectorTools
       if (function_map.size() == 0)
         return;
 
-      for (typename DH::active_cell_iterator cell = dof.begin_active();
+      for (typename DoFHandlerType::active_cell_iterator cell = dof.begin_active();
            cell != dof.end(); ++cell)
         for (unsigned int direction=0;
              direction<GeometryInfo<dim>::faces_per_cell; ++direction)
@@ -1681,7 +1694,7 @@ namespace VectorTools
               &&
               (function_map.find(cell->face(direction)->boundary_id()) != function_map.end()))
             {
-              const Function<DH::space_dimension> &boundary_function
+              const Function<DoFHandlerType::space_dimension> &boundary_function
                 = *function_map.find(cell->face(direction)->boundary_id())->second;
 
               // get the FE corresponding to this
@@ -1732,18 +1745,19 @@ namespace VectorTools
     // dim_, it is clearly less specialized than the 1d function above and
     // whenever possible (i.e., if dim==1), the function template above
     // will be used
-    template <class DH, template <int,int> class M_or_MC, int dim_>
+    template <typename DoFHandlerType, template <int,int> class M_or_MC, int dim_>
     static inline
     void
-    do_interpolate_boundary_values (const M_or_MC<DH::dimension, DH::space_dimension> &mapping,
-                                    const DH                 &dof,
-                                    const typename FunctionMap<DH::space_dimension>::type &function_map,
-                                    std::map<types::global_dof_index,double> &boundary_values,
-                                    const ComponentMask       &component_mask,
-                                    const dealii::internal::int2type<dim_>)
+    do_interpolate_boundary_values
+    (const M_or_MC<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &mapping,
+     const DoFHandlerType                                                      &dof,
+     const typename FunctionMap<DoFHandlerType::space_dimension>::type         &function_map,
+     std::map<types::global_dof_index,double>                                  &boundary_values,
+     const ComponentMask                                                       &component_mask,
+     const dealii::internal::int2type<dim_>)
     {
-      const unsigned int dim = DH::dimension;
-      const unsigned int spacedim=DH::space_dimension;
+      const unsigned int dim = DoFHandlerType::dimension;
+      const unsigned int spacedim=DoFHandlerType::space_dimension;
 
       Assert (component_mask.represents_n_components(dof.get_fe().n_components()),
               ExcMessage ("The number of components in the mask has to be either "
@@ -1835,8 +1849,8 @@ namespace VectorTools
       dealii::hp::FEFaceValues<dim,spacedim> x_fe_values (mapping_collection, finite_elements, q_collection,
                                                           update_quadrature_points);
 
-      typename DH::active_cell_iterator cell = dof.begin_active(),
-                                        endc = dof.end();
+      typename DoFHandlerType::active_cell_iterator cell = dof.begin_active(),
+                                                    endc = dof.end();
       for (; cell!=endc; ++cell)
         if (!cell->is_artificial())
           for (unsigned int face_no = 0; face_no < GeometryInfo<dim>::faces_per_cell;
@@ -1864,7 +1878,7 @@ namespace VectorTools
                                           "elements"));
                 }
 
-              const typename DH::face_iterator face = cell->face(face_no);
+              const typename DoFHandlerType::face_iterator face = cell->face(face_no);
               const types::boundary_id boundary_component = face->boundary_id();
 
               // see if this face is part of the boundaries for which we are
@@ -1974,32 +1988,34 @@ namespace VectorTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
 
-  interpolate_boundary_values (const Mapping<DH::dimension, DH::space_dimension>            &mapping,
-                               const DH                 &dof,
-                               const typename FunctionMap<DH::space_dimension>::type &function_map,
-                               std::map<types::global_dof_index,double> &boundary_values,
-                               const ComponentMask       &component_mask_)
+  interpolate_boundary_values
+  (const Mapping<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &mapping,
+   const DoFHandlerType                                                      &dof,
+   const typename FunctionMap<DoFHandlerType::space_dimension>::type         &function_map,
+   std::map<types::global_dof_index,double>                                  &boundary_values,
+   const ComponentMask                                                       &component_mask_)
   {
     do_interpolate_boundary_values (mapping, dof, function_map, boundary_values,
                                     component_mask_,
-                                    dealii::internal::int2type<DH::dimension>());
+                                    dealii::internal::int2type<DoFHandlerType::dimension>());
   }
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  interpolate_boundary_values (const Mapping<DH::dimension, DH::space_dimension>            &mapping,
-                               const DH                 &dof,
-                               const types::boundary_id            boundary_component,
-                               const Function<DH::space_dimension>           &boundary_function,
-                               std::map<types::global_dof_index,double> &boundary_values,
-                               const ComponentMask       &component_mask)
+  interpolate_boundary_values
+  (const Mapping<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &mapping,
+   const DoFHandlerType                                                      &dof,
+   const types::boundary_id                                                   boundary_component,
+   const Function<DoFHandlerType::space_dimension>                           &boundary_function,
+   std::map<types::global_dof_index,double>                                  &boundary_values,
+   const ComponentMask                                                       &component_mask)
   {
-    typename FunctionMap<DH::space_dimension>::type function_map;
+    typename FunctionMap<DoFHandlerType::space_dimension>::type function_map;
     function_map[boundary_component] = &boundary_function;
     interpolate_boundary_values (mapping, dof, function_map, boundary_values,
                                  component_mask);
@@ -2008,11 +2024,12 @@ namespace VectorTools
 
   template <int dim, int spacedim>
   void
-  interpolate_boundary_values (const hp::MappingCollection<dim,spacedim>            &mapping,
-                               const hp::DoFHandler<dim,spacedim>                 &dof,
-                               const typename FunctionMap<spacedim>::type &function_map,
-                               std::map<types::global_dof_index,double> &boundary_values,
-                               const ComponentMask       &component_mask_)
+  interpolate_boundary_values
+  (const hp::MappingCollection<dim,spacedim>  &mapping,
+   const hp::DoFHandler<dim,spacedim>         &dof,
+   const typename FunctionMap<spacedim>::type &function_map,
+   std::map<types::global_dof_index,double>   &boundary_values,
+   const ComponentMask                        &component_mask_)
   {
     do_interpolate_boundary_values (mapping, dof, function_map, boundary_values,
                                     component_mask_,
@@ -2021,31 +2038,34 @@ namespace VectorTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  interpolate_boundary_values (const DH                 &dof,
-                               const types::boundary_id            boundary_component,
-                               const Function<DH::space_dimension>           &boundary_function,
-                               std::map<types::global_dof_index,double> &boundary_values,
-                               const ComponentMask       &component_mask)
+  interpolate_boundary_values
+  (const DoFHandlerType                            &dof,
+   const types::boundary_id                         boundary_component,
+   const Function<DoFHandlerType::space_dimension> &boundary_function,
+   std::map<types::global_dof_index,double>        &boundary_values,
+   const ComponentMask                             &component_mask)
   {
-    interpolate_boundary_values(StaticMappingQ1<DH::dimension,DH::space_dimension>::mapping,
+    interpolate_boundary_values(StaticMappingQ1<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::mapping,
                                 dof, boundary_component,
                                 boundary_function, boundary_values, component_mask);
   }
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  interpolate_boundary_values (const DH                 &dof,
-                               const typename FunctionMap<DH::space_dimension>::type &function_map,
-                               std::map<types::global_dof_index,double> &boundary_values,
-                               const ComponentMask       &component_mask)
+  interpolate_boundary_values
+  (const DoFHandlerType                                              &dof,
+   const typename FunctionMap<DoFHandlerType::space_dimension>::type &function_map,
+   std::map<types::global_dof_index,double>                          &boundary_values,
+   const ComponentMask                                               &component_mask)
   {
-    interpolate_boundary_values(StaticMappingQ1<DH::dimension,DH::space_dimension>::mapping,
-                                dof, function_map,
-                                boundary_values, component_mask);
+    interpolate_boundary_values
+    (StaticMappingQ1<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::mapping,
+     dof, function_map,
+     boundary_values, component_mask);
   }
 
 
@@ -2055,14 +2075,14 @@ namespace VectorTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   interpolate_boundary_values
-  (const Mapping<DH::dimension, DH::space_dimension>     &mapping,
-   const DH                                              &dof,
-   const typename FunctionMap<DH::space_dimension>::type &function_map,
-   ConstraintMatrix                                      &constraints,
-   const ComponentMask                               &component_mask_)
+  (const Mapping<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &mapping,
+   const DoFHandlerType                                                      &dof,
+   const typename FunctionMap<DoFHandlerType::space_dimension>::type         &function_map,
+   ConstraintMatrix                                                          &constraints,
+   const ComponentMask                                                       &component_mask_)
   {
     std::map<types::global_dof_index,double> boundary_values;
     interpolate_boundary_values (mapping, dof, function_map,
@@ -2084,17 +2104,17 @@ namespace VectorTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   interpolate_boundary_values
-  (const Mapping<DH::dimension, DH::space_dimension> &mapping,
-   const DH                                          &dof,
-   const types::boundary_id                                boundary_component,
-   const Function<DH::space_dimension>               &boundary_function,
-   ConstraintMatrix                                  &constraints,
-   const ComponentMask                           &component_mask)
+  (const Mapping<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &mapping,
+   const DoFHandlerType                                                      &dof,
+   const types::boundary_id                                                   boundary_component,
+   const Function<DoFHandlerType::space_dimension>                           &boundary_function,
+   ConstraintMatrix                                                          &constraints,
+   const ComponentMask                                                       &component_mask)
   {
-    typename FunctionMap<DH::space_dimension>::type function_map;
+    typename FunctionMap<DoFHandlerType::space_dimension>::type function_map;
     function_map[boundary_component] = &boundary_function;
     interpolate_boundary_values (mapping, dof, function_map, constraints,
                                  component_mask);
@@ -2102,33 +2122,35 @@ namespace VectorTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   interpolate_boundary_values
-  (const DH                            &dof,
-   const types::boundary_id                  boundary_component,
-   const Function<DH::space_dimension> &boundary_function,
-   ConstraintMatrix                    &constraints,
-   const ComponentMask             &component_mask)
+  (const DoFHandlerType                            &dof,
+   const types::boundary_id                         boundary_component,
+   const Function<DoFHandlerType::space_dimension> &boundary_function,
+   ConstraintMatrix                                &constraints,
+   const ComponentMask                             &component_mask)
   {
-    interpolate_boundary_values(StaticMappingQ1<DH::dimension,DH::space_dimension>::mapping,
-                                dof, boundary_component,
-                                boundary_function, constraints, component_mask);
+    interpolate_boundary_values
+    (StaticMappingQ1<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::mapping,
+     dof, boundary_component,
+     boundary_function, constraints, component_mask);
   }
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   interpolate_boundary_values
-  (const DH                                              &dof,
-   const typename FunctionMap<DH::space_dimension>::type &function_map,
-   ConstraintMatrix                                      &constraints,
-   const ComponentMask                               &component_mask)
+  (const DoFHandlerType                                              &dof,
+   const typename FunctionMap<DoFHandlerType::space_dimension>::type &function_map,
+   ConstraintMatrix                                                  &constraints,
+   const ComponentMask                                               &component_mask)
   {
-    interpolate_boundary_values(StaticMappingQ1<DH::dimension,DH::space_dimension>::mapping,
-                                dof, function_map,
-                                constraints, component_mask);
+    interpolate_boundary_values
+    (StaticMappingQ1<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::mapping,
+     dof, function_map,
+     constraints, component_mask);
   }
 
 
@@ -2139,15 +2161,15 @@ namespace VectorTools
 
   namespace
   {
-    template <int dim, int spacedim, template <int,int> class DH,
+    template <int dim, int spacedim, template <int, int> class DoFHandlerType,
               template <int,int> class M_or_MC, template <int> class Q_or_QC>
     void
-    do_project_boundary_values (const M_or_MC<dim, spacedim>   &mapping,
-                                const DH<dim, spacedim> &dof,
+    do_project_boundary_values (const M_or_MC<dim, spacedim>               &mapping,
+                                const DoFHandlerType<dim, spacedim>        &dof,
                                 const typename FunctionMap<spacedim>::type &boundary_functions,
-                                const Q_or_QC<dim-1>        &q,
-                                std::map<types::global_dof_index,double>  &boundary_values,
-                                std::vector<unsigned int>       component_mapping)
+                                const Q_or_QC<dim-1>                       &q,
+                                std::map<types::global_dof_index,double>   &boundary_values,
+                                std::vector<unsigned int>                   component_mapping)
     {
       // in 1d, projection onto the 0d end points == interpolation
       if (dim == 1)
@@ -2221,7 +2243,7 @@ namespace VectorTools
 #ifdef DEBUG
           // Assert that there are no hanging nodes at the boundary
           int level = -1;
-          for (typename DH<dim,spacedim>::active_cell_iterator cell = dof.begin_active();
+          for (typename DoFHandlerType<dim,spacedim>::active_cell_iterator cell = dof.begin_active();
                cell != dof.end(); ++cell)
             for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
               {
@@ -4418,14 +4440,15 @@ namespace VectorTools
         }
     }
 
-    template <int dim, class DH>
+    template <int dim, typename DoFHandlerType>
     void
-    compute_project_boundary_values_curl_conforming_l2 (const DH &dof_handler,
-                                                        const unsigned int first_vector_component,
-                                                        const Function<dim> &boundary_function,
-                                                        const types::boundary_id boundary_component,
-                                                        ConstraintMatrix &constraints,
-                                                        const hp::MappingCollection<dim, dim> &mapping_collection)
+    compute_project_boundary_values_curl_conforming_l2
+    (const DoFHandlerType                  &dof_handler,
+     const unsigned int                     first_vector_component,
+     const Function<dim>                   &boundary_function,
+     const types::boundary_id               boundary_component,
+     ConstraintMatrix                      &constraints,
+     const hp::MappingCollection<dim, dim> &mapping_collection)
     {
       // L2-projection based interpolation formed in one (in 2D) or two (in 3D) steps.
       //
@@ -4473,7 +4496,7 @@ namespace VectorTools
       std::vector<bool> dofs_processed;
       std::vector<double> dof_values;
       std::vector<types::global_dof_index> face_dof_indices;
-      typename DH::active_cell_iterator cell = dof_handler.begin_active ();
+      typename DoFHandlerType::active_cell_iterator cell = dof_handler.begin_active ();
 
       switch (dim)
         {
@@ -5188,13 +5211,13 @@ namespace VectorTools
 
 
 
-  template <int dim, template <int, int> class DH, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, int spacedim>
   void
-  compute_no_normal_flux_constraints (const DH<dim,spacedim>         &dof_handler,
-                                      const unsigned int     first_vector_component,
+  compute_no_normal_flux_constraints (const DoFHandlerType<dim,spacedim> &dof_handler,
+                                      const unsigned int                  first_vector_component,
                                       const std::set<types::boundary_id> &boundary_ids,
-                                      ConstraintMatrix      &constraints,
-                                      const Mapping<dim, spacedim>    &mapping)
+                                      ConstraintMatrix                   &constraints,
+                                      const Mapping<dim, spacedim>       &mapping)
   {
     ZeroFunction<dim>zero_function(dim);
     typename FunctionMap<spacedim>::type function_map;
@@ -5210,14 +5233,15 @@ namespace VectorTools
                                             mapping);
   }
 
-  template <int dim, template <int, int> class DH, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, int spacedim>
   void
-  compute_nonzero_normal_flux_constraints (const DH<dim,spacedim>         &dof_handler,
-                                           const unsigned int     first_vector_component,
-                                           const std::set<types::boundary_id> &boundary_ids,
-                                           typename FunctionMap<spacedim>::type &function_map,
-                                           ConstraintMatrix      &constraints,
-                                           const Mapping<dim, spacedim>    &mapping)
+  compute_nonzero_normal_flux_constraints
+  (const DoFHandlerType<dim,spacedim>   &dof_handler,
+   const unsigned int                    first_vector_component,
+   const std::set<types::boundary_id>   &boundary_ids,
+   typename FunctionMap<spacedim>::type &function_map,
+   ConstraintMatrix                     &constraints,
+   const Mapping<dim, spacedim>         &mapping)
   {
     Assert (dim > 1,
             ExcMessage ("This function is not useful in 1d because it amounts "
@@ -5268,7 +5292,7 @@ namespace VectorTools
     // normal vector was computed on
     typedef
     std::multimap<internal::VectorDoFTuple<dim>,
-        std::pair<Tensor<1,dim>, typename DH<dim,spacedim>::active_cell_iterator> >
+        std::pair<Tensor<1,dim>, typename DoFHandlerType<dim,spacedim>::active_cell_iterator> >
         DoFToNormalsMap;
     std::map<internal::VectorDoFTuple<dim>, Vector<double> >
     dof_vector_to_b_values;
@@ -5276,7 +5300,7 @@ namespace VectorTools
     DoFToNormalsMap dof_to_normals_map;
 
     // now loop over all cells and all faces
-    typename DH<dim,spacedim>::active_cell_iterator
+    typename DoFHandlerType<dim,spacedim>::active_cell_iterator
     cell = dof_handler.begin_active(),
     endc = dof_handler.end();
     std::set<types::boundary_id>::iterator b_id;
@@ -5288,7 +5312,7 @@ namespace VectorTools
               != boundary_ids.end())
             {
               const FiniteElement<dim> &fe = cell->get_fe ();
-              typename DH<dim,spacedim>::face_iterator face = cell->face(face_no);
+              typename DoFHandlerType<dim,spacedim>::face_iterator face = cell->face(face_no);
 
               // get the indices of the dofs on this cell...
               face_dofs.resize (fe.dofs_per_face);
@@ -5450,7 +5474,7 @@ namespace VectorTools
         // contributed to the current set of vector dofs, add up the normal
         // vectors. the values of the map are pairs of normal vectors and
         // number of cells that have contributed
-        typedef std::map<typename DH<dim,spacedim>::active_cell_iterator,
+        typedef std::map<typename DoFHandlerType<dim,spacedim>::active_cell_iterator,
                 std::pair<Tensor<1,dim>, unsigned int> >
                 CellToNormalsMap;
 
@@ -5617,7 +5641,7 @@ namespace VectorTools
             // std::list instead of a std::set (which would be more natural)
             // because std::set requires that the stored elements are
             // comparable with operator<
-            typedef std::map<typename DH<dim,spacedim>::active_cell_iterator,
+            typedef std::map<typename DoFHandlerType<dim,spacedim>::active_cell_iterator,
                     std::list<Tensor<1,dim> > >
                     CellContributions;
             CellContributions cell_contributions;
@@ -5774,13 +5798,13 @@ namespace VectorTools
 
 
 
-  template <int dim, template <int, int> class DH, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, int spacedim>
   void
-  compute_normal_flux_constraints (const DH<dim,spacedim> &dof_handler,
-                                   const unsigned int     first_vector_component,
+  compute_normal_flux_constraints (const DoFHandlerType<dim,spacedim> &dof_handler,
+                                   const unsigned int                  first_vector_component,
                                    const std::set<types::boundary_id> &boundary_ids,
-                                   ConstraintMatrix      &constraints,
-                                   const Mapping<dim, spacedim> &mapping)
+                                   ConstraintMatrix                   &constraints,
+                                   const Mapping<dim, spacedim>       &mapping)
   {
     ZeroFunction<dim>zero_function(dim);
     typename FunctionMap<spacedim>::type function_map;
@@ -5796,14 +5820,15 @@ namespace VectorTools
                                                 mapping);
   }
 
-  template <int dim, template <int, int> class DH, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, int spacedim>
   void
-  compute_nonzero_tangential_flux_constraints (const DH<dim,spacedim> &dof_handler,
-                                               const unsigned int     first_vector_component,
-                                               const std::set<types::boundary_id> &boundary_ids,
-                                               typename FunctionMap<spacedim>::type &function_map,
-                                               ConstraintMatrix      &constraints,
-                                               const Mapping<dim, spacedim> &mapping)
+  compute_nonzero_tangential_flux_constraints
+  (const DoFHandlerType<dim,spacedim>   &dof_handler,
+   const unsigned int                    first_vector_component,
+   const std::set<types::boundary_id>   &boundary_ids,
+   typename FunctionMap<spacedim>::type &function_map,
+   ConstraintMatrix                     &constraints,
+   const Mapping<dim, spacedim>         &mapping)
   {
     ConstraintMatrix no_normal_flux_constraints(constraints.get_local_lines());
     compute_nonzero_normal_flux_constraints (dof_handler,
@@ -5851,7 +5876,7 @@ namespace VectorTools
 
     std::set<types::boundary_id>::iterator b_id;
     std::vector<std_cxx11::array<types::global_dof_index,dim> > cell_vector_dofs;
-    for (typename DH<dim,spacedim>::active_cell_iterator cell =
+    for (typename DoFHandlerType<dim,spacedim>::active_cell_iterator cell =
            dof_handler.begin_active(); cell != dof_handler.end(); ++cell)
       if (!cell->is_artificial())
         for (unsigned int face_no=0; face_no < GeometryInfo<dim>::faces_per_cell;
@@ -5860,7 +5885,7 @@ namespace VectorTools
               != boundary_ids.end())
             {
               const FiniteElement<dim> &fe = cell->get_fe();
-              typename DH<dim,spacedim>::face_iterator face=cell->face(face_no);
+              typename DoFHandlerType<dim,spacedim>::face_iterator face=cell->face(face_no);
 
               // get the indices of the dofs on this cell...
               face_dofs.resize (fe.dofs_per_face);
@@ -6336,18 +6361,18 @@ namespace VectorTools
 
 
 
-    template <int dim, class InVector, class OutVector, class DH, int spacedim>
+    template <int dim, class InVector, class OutVector, typename DoFHandlerType, int spacedim>
     static
     void
     do_integrate_difference (const dealii::hp::MappingCollection<dim,spacedim> &mapping,
-                             const DH              &dof,
-                             const InVector        &fe_function,
-                             const Function<spacedim>   &exact_solution,
-                             OutVector             &difference,
-                             const dealii::hp::QCollection<dim> &q,
-                             const NormType &norm,
-                             const Function<spacedim>   *weight,
-                             const double           exponent_1)
+                             const DoFHandlerType                              &dof,
+                             const InVector                                    &fe_function,
+                             const Function<spacedim>                          &exact_solution,
+                             OutVector                                         &difference,
+                             const dealii::hp::QCollection<dim>                &q,
+                             const NormType                                    &norm,
+                             const Function<spacedim>                          *weight,
+                             const double                                       exponent_1)
     {
       typedef typename InVector::value_type Number;
       // we mark the "exponent" parameter to this function "const" since it is
@@ -6413,7 +6438,7 @@ namespace VectorTools
       IDScratchData<dim,spacedim, Number> data(mapping, fe_collection, q, update_flags);
 
       // loop over all cells
-      for (typename DH::active_cell_iterator cell = dof.begin_active();
+      for (typename DoFHandlerType::active_cell_iterator cell = dof.begin_active();
            cell != dof.end(); ++cell)
         if (cell->is_locally_owned())
           {
@@ -7082,15 +7107,15 @@ namespace VectorTools
   }
 
 
-  template<class DH, typename VectorType>
-  void get_position_vector(const DH            &dh,
-                           VectorType          &vector,
-                           const ComponentMask &mask)
+  template<typename DoFHandlerType, typename VectorType>
+  void get_position_vector(const DoFHandlerType &dh,
+                           VectorType           &vector,
+                           const ComponentMask  &mask)
   {
     AssertDimension(vector.size(), dh.n_dofs());
 
-    const unsigned int dim=DH::dimension;
-    const unsigned int spacedim=DH::space_dimension;
+    const unsigned int dim=DoFHandlerType::dimension;
+    const unsigned int spacedim=DoFHandlerType::space_dimension;
     const FiniteElement<dim, spacedim> &fe = dh.get_fe();
 
 
@@ -7113,7 +7138,7 @@ namespace VectorTools
 
     if ( fe.has_support_points() )
       {
-        typename DH::active_cell_iterator cell;
+        typename DoFHandlerType::active_cell_iterator cell;
         const Quadrature<dim> quad(fe.get_unit_support_points());
 
         MappingQ<dim,spacedim> map_q(fe.degree);
@@ -7166,7 +7191,7 @@ namespace VectorTools
         // carefully selecting the right components.
 
         FESystem<dim,spacedim> feq(FE_Q<dim,spacedim>(degree), spacedim);
-        DH dhq(dh.get_tria());
+        DoFHandlerType dhq(dh.get_tria());
         dhq.distribute_dofs(feq);
         Vector<double> eulerq(dhq.n_dofs());
         const ComponentMask maskq(spacedim, true);
diff --git a/source/distributed/solution_transfer.cc b/source/distributed/solution_transfer.cc
index 8829a486e9..89dcdbefe9 100644
--- a/source/distributed/solution_transfer.cc
+++ b/source/distributed/solution_transfer.cc
@@ -43,8 +43,8 @@ namespace parallel
   namespace distributed
   {
 
-    template<int dim, typename VectorType, class DH>
-    SolutionTransfer<dim, VectorType, DH>::SolutionTransfer (const DH &dof)
+    template<int dim, typename VectorType, typename DoFHandlerType>
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::SolutionTransfer (const DoFHandlerType &dof)
       :
       dof_handler(&dof, typeid(*this).name())
     {
@@ -55,15 +55,15 @@ namespace parallel
 
 
 
-    template<int dim, typename VectorType, class DH>
-    SolutionTransfer<dim, VectorType, DH>::~SolutionTransfer ()
+    template<int dim, typename VectorType, typename DoFHandlerType>
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::~SolutionTransfer ()
     {}
 
 
 
-    template<int dim, typename VectorType, class DH>
+    template<int dim, typename VectorType, typename DoFHandlerType>
     void
-    SolutionTransfer<dim, VectorType, DH>::
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::
     prepare_for_coarsening_and_refinement (const std::vector<const VectorType *> &all_in)
     {
       input_vectors = all_in;
@@ -72,9 +72,9 @@ namespace parallel
 
 
 
-    template<int dim, typename VectorType, class DH>
+    template<int dim, typename VectorType, typename DoFHandlerType>
     void
-    SolutionTransfer<dim, VectorType, DH>::register_data_attach (const std::size_t size)
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::register_data_attach (const std::size_t size)
     {
       Assert(size > 0, ExcMessage("Please transfer at least one vector!"));
 
@@ -87,7 +87,8 @@ namespace parallel
 
       offset
         = tria->register_data_attach(size,
-                                     std_cxx11::bind(&SolutionTransfer<dim, VectorType, DH>::pack_callback,
+                                     std_cxx11::bind(&SolutionTransfer<dim, VectorType,
+                                                     DoFHandlerType>::pack_callback,
                                                      this,
                                                      std_cxx11::_1,
                                                      std_cxx11::_2,
@@ -97,9 +98,9 @@ namespace parallel
 
 
 
-    template<int dim, typename VectorType, class DH>
+    template<int dim, typename VectorType, typename DoFHandlerType>
     void
-    SolutionTransfer<dim, VectorType, DH>::
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::
     prepare_for_coarsening_and_refinement (const VectorType &in)
     {
       std::vector<const VectorType *> all_in(1, &in);
@@ -108,9 +109,9 @@ namespace parallel
 
 
 
-    template<int dim, typename VectorType, class DH>
+    template<int dim, typename VectorType, typename DoFHandlerType>
     void
-    SolutionTransfer<dim, VectorType, DH>::prepare_serialization (const VectorType &in)
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::prepare_serialization (const VectorType &in)
     {
       std::vector<const VectorType *> all_in(1, &in);
       prepare_serialization(all_in);
@@ -118,9 +119,9 @@ namespace parallel
 
 
 
-    template<int dim, typename VectorType, class DH>
+    template<int dim, typename VectorType, typename DoFHandlerType>
     void
-    SolutionTransfer<dim, VectorType, DH>::prepare_serialization
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::prepare_serialization
     (const std::vector<const VectorType *> &all_in)
     {
       prepare_for_coarsening_and_refinement (all_in);
@@ -128,9 +129,9 @@ namespace parallel
 
 
 
-    template<int dim, typename VectorType, class DH>
+    template<int dim, typename VectorType, typename DoFHandlerType>
     void
-    SolutionTransfer<dim, VectorType, DH>::deserialize (VectorType &in)
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::deserialize (VectorType &in)
     {
       std::vector<VectorType *> all_in(1, &in);
       deserialize(all_in);
@@ -138,9 +139,9 @@ namespace parallel
 
 
 
-    template<int dim, typename VectorType, class DH>
+    template<int dim, typename VectorType, typename DoFHandlerType>
     void
-    SolutionTransfer<dim, VectorType, DH>::deserialize (std::vector<VectorType *> &all_in)
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::deserialize (std::vector<VectorType *> &all_in)
     {
       register_data_attach( get_data_size() * all_in.size() );
 
@@ -151,9 +152,9 @@ namespace parallel
     }
 
 
-    template<int dim, typename VectorType, class DH>
+    template<int dim, typename VectorType, typename DoFHandlerType>
     void
-    SolutionTransfer<dim, VectorType, DH>::interpolate (std::vector<VectorType *> &all_out)
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::interpolate (std::vector<VectorType *> &all_out)
     {
       Assert(input_vectors.size()==all_out.size(),
              ExcDimensionMismatch(input_vectors.size(), all_out.size()) );
@@ -166,7 +167,8 @@ namespace parallel
       Assert (tria != 0, ExcInternalError());
 
       tria->notify_ready_to_unpack(offset,
-                                   std_cxx11::bind(&SolutionTransfer<dim, VectorType, DH>::unpack_callback,
+                                   std_cxx11::bind(&SolutionTransfer<dim, VectorType,
+                                                   DoFHandlerType>::unpack_callback,
                                                    this,
                                                    std_cxx11::_1,
                                                    std_cxx11::_2,
@@ -184,9 +186,9 @@ namespace parallel
 
 
 
-    template<int dim, typename VectorType, class DH>
+    template<int dim, typename VectorType, typename DoFHandlerType>
     void
-    SolutionTransfer<dim, VectorType, DH>::interpolate (VectorType &out)
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::interpolate (VectorType &out)
     {
       std::vector<VectorType *> all_out(1, &out);
       interpolate(all_out);
@@ -194,24 +196,24 @@ namespace parallel
 
 
 
-    template<int dim, typename VectorType, class DH>
+    template<int dim, typename VectorType, typename DoFHandlerType>
     unsigned int
-    SolutionTransfer<dim, VectorType, DH>::get_data_size() const
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::get_data_size() const
     {
       return sizeof(double)* DoFTools::max_dofs_per_cell(*dof_handler);
     }
 
 
-    template<int dim, typename VectorType, class DH>
+    template<int dim, typename VectorType, typename DoFHandlerType>
     void
-    SolutionTransfer<dim, VectorType, DH>::
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::
     pack_callback(const typename Triangulation<dim,dim>::cell_iterator &cell_,
                   const typename Triangulation<dim,dim>::CellStatus /*status*/,
                   void *data)
     {
       typename VectorType::value_type *data_store = reinterpret_cast<typename VectorType::value_type *>(data);
 
-      typename DH::cell_iterator cell(*cell_, dof_handler);
+      typename DoFHandlerType::cell_iterator cell(*cell_, dof_handler);
 
       const unsigned int dofs_per_cell=cell->get_fe().dofs_per_cell;
       ::dealii::Vector<typename VectorType::value_type> dofvalues(dofs_per_cell);
@@ -227,15 +229,15 @@ namespace parallel
     }
 
 
-    template<int dim, typename VectorType, class DH>
+    template<int dim, typename VectorType, typename DoFHandlerType>
     void
-    SolutionTransfer<dim, VectorType, DH>::unpack_callback
+    SolutionTransfer<dim, VectorType, DoFHandlerType>::unpack_callback
     (const typename Triangulation<dim,dim>::cell_iterator &cell_,
      const typename Triangulation<dim,dim>::CellStatus    /*status*/,
      const void                                           *data,
      std::vector<VectorType *>                            &all_out)
     {
-      typename DH::cell_iterator
+      typename DoFHandlerType::cell_iterator
       cell(*cell_, dof_handler);
 
       const unsigned int dofs_per_cell=cell->get_fe().dofs_per_cell;
diff --git a/source/dofs/dof_accessor.cc b/source/dofs/dof_accessor.cc
index d8cee5b530..588654d0d9 100644
--- a/source/dofs/dof_accessor.cc
+++ b/source/dofs/dof_accessor.cc
@@ -28,11 +28,11 @@ DEAL_II_NAMESPACE_OPEN
 
 /*------------------------- Static variables: DoFAccessor -----------------------*/
 
-template <int structdim, class DH, bool level_dof_access>
-const unsigned int DoFAccessor<structdim,DH,level_dof_access>::dimension;
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
+const unsigned int DoFAccessor<structdim,DoFHandlerType,level_dof_access>::dimension;
 
-template <int structdim, class DH, bool level_dof_access>
-const unsigned int DoFAccessor<structdim,DH,level_dof_access>::space_dimension;
+template <int structdim, typename DoFHandlerType, bool level_dof_access>
+const unsigned int DoFAccessor<structdim,DoFHandlerType,level_dof_access>::space_dimension;
 
 
 
@@ -41,9 +41,9 @@ const unsigned int DoFAccessor<structdim,DH,level_dof_access>::space_dimension;
 
 
 
-template <class DH, bool lda>
+template <typename DoFHandlerType, bool lda>
 void
-DoFCellAccessor<DH,lda>::update_cell_dof_indices_cache () const
+DoFCellAccessor<DoFHandlerType,lda>::update_cell_dof_indices_cache () const
 {
   Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
           ExcMessage ("DoFHandler not initialized"));
@@ -56,9 +56,9 @@ DoFCellAccessor<DH,lda>::update_cell_dof_indices_cache () const
 
 
 
-template <class DH, bool lda>
+template <typename DoFHandlerType, bool lda>
 void
-DoFCellAccessor<DH,lda>::set_dof_indices (const std::vector<types::global_dof_index> &local_dof_indices)
+DoFCellAccessor<DoFHandlerType,lda>::set_dof_indices (const std::vector<types::global_dof_index> &local_dof_indices)
 {
   Assert (static_cast<unsigned int>(this->present_level) < this->dof_handler->levels.size(),
           ExcMessage ("DoFHandler not initialized"));
@@ -72,14 +72,14 @@ DoFCellAccessor<DH,lda>::set_dof_indices (const std::vector<types::global_dof_in
 
 
 
-template <class DH, bool lda>
-TriaIterator<DoFCellAccessor<DH,lda> >
-DoFCellAccessor<DH,lda>::neighbor_child_on_subface (const unsigned int face,
-                                                    const unsigned int subface) const
+template <typename DoFHandlerType, bool lda>
+TriaIterator<DoFCellAccessor<DoFHandlerType,lda> >
+DoFCellAccessor<DoFHandlerType,lda>::neighbor_child_on_subface (const unsigned int face,
+    const unsigned int subface) const
 {
   const TriaIterator<CellAccessor<dim,spacedim> > q
     = CellAccessor<dim,spacedim>::neighbor_child_on_subface (face, subface);
-  return TriaIterator<DoFCellAccessor<DH,lda> > (*q, this->dof_handler);
+  return TriaIterator<DoFCellAccessor<DoFHandlerType,lda> > (*q, this->dof_handler);
 }
 
 
diff --git a/source/dofs/dof_accessor_get.cc b/source/dofs/dof_accessor_get.cc
index 9d248a8681..b8a77812c8 100644
--- a/source/dofs/dof_accessor_get.cc
+++ b/source/dofs/dof_accessor_get.cc
@@ -37,10 +37,10 @@
 DEAL_II_NAMESPACE_OPEN
 
 
-template <class DH, bool lda>
+template <typename DoFHandlerType, bool lda>
 template <class InputVector, typename number>
 void
-DoFCellAccessor<DH,lda>::
+DoFCellAccessor<DoFHandlerType,lda>::
 get_interpolated_dof_values (const InputVector &values,
                              Vector<number>    &interpolated_values,
                              const unsigned int fe_index) const
@@ -50,7 +50,7 @@ get_interpolated_dof_values (const InputVector &values,
     // cell unless the finite element we need to interpolate to is different than
     // the one we have on the current cell
     {
-      if ((dynamic_cast<DoFHandler<DH::dimension,DH::space_dimension>*>
+      if ((dynamic_cast<DoFHandler<DoFHandlerType::dimension,DoFHandlerType::space_dimension>*>
            (this->dof_handler)
            != 0)
           ||
@@ -59,7 +59,7 @@ get_interpolated_dof_values (const InputVector &values,
           // or that you specify the correct one
           (fe_index == this->active_fe_index())
           ||
-          (fe_index == DH::default_fe_index))
+          (fe_index == DoFHandlerType::default_fe_index))
         this->get_dof_values (values, interpolated_values);
       else
         {
@@ -86,11 +86,11 @@ get_interpolated_dof_values (const InputVector &values,
       // mesh). consequently, we cannot interpolate from children's FE
       // space to this cell's (unknown) FE space unless an explicit
       // fe_index is given
-      Assert ((dynamic_cast<DoFHandler<DH::dimension,DH::space_dimension>*>
+      Assert ((dynamic_cast<DoFHandler<DoFHandlerType::dimension,DoFHandlerType::space_dimension>*>
                (this->dof_handler)
                != 0)
               ||
-              (fe_index != DH::default_fe_index),
+              (fe_index != DoFHandlerType::default_fe_index),
               ExcMessage ("You cannot call this function on non-active cells "
                           "of hp::DoFHandler objects unless you provide an explicit "
                           "finite element index because they do not have naturally "
diff --git a/source/dofs/dof_accessor_set.cc b/source/dofs/dof_accessor_set.cc
index 0260be236c..a97193cfe8 100644
--- a/source/dofs/dof_accessor_set.cc
+++ b/source/dofs/dof_accessor_set.cc
@@ -37,17 +37,17 @@
 DEAL_II_NAMESPACE_OPEN
 
 
-template <class DH, bool lda>
+template <typename DoFHandlerType, bool lda>
 template <class OutputVector, typename number>
 void
-DoFCellAccessor<DH,lda>::
+DoFCellAccessor<DoFHandlerType,lda>::
 set_dof_values_by_interpolation (const Vector<number> &local_values,
                                  OutputVector         &values,
                                  const unsigned int fe_index) const
 {
   if (!this->has_children() && !this->is_artificial ())
     {
-      if ((dynamic_cast<DoFHandler<DH::dimension,DH::space_dimension>*>
+      if ((dynamic_cast<DoFHandler<DoFHandlerType::dimension,DoFHandlerType::space_dimension>*>
            (this->dof_handler)
            != 0)
           ||
@@ -56,7 +56,7 @@ set_dof_values_by_interpolation (const Vector<number> &local_values,
           // or that you specify the correct one
           (fe_index == this->active_fe_index())
           ||
-          (fe_index == DH::default_fe_index))
+          (fe_index == DoFHandlerType::default_fe_index))
         // simply set the values on this cell
         this->set_dof_values (local_values, values);
       else
@@ -83,11 +83,11 @@ set_dof_values_by_interpolation (const Vector<number> &local_values,
   else
     // otherwise distribute them to the children
     {
-      Assert ((dynamic_cast<DoFHandler<DH::dimension,DH::space_dimension>*>
+      Assert ((dynamic_cast<DoFHandler<DoFHandlerType::dimension,DoFHandlerType::space_dimension>*>
                (this->dof_handler)
                != 0)
               ||
-              (fe_index != DH::default_fe_index),
+              (fe_index != DoFHandlerType::default_fe_index),
               ExcMessage ("You cannot call this function on non-active cells "
                           "of hp::DoFHandler objects unless you provide an explicit "
                           "finite element index because they do not have naturally "
diff --git a/source/dofs/dof_renumbering.cc b/source/dofs/dof_renumbering.cc
index 7aa568315d..8281d2e478 100644
--- a/source/dofs/dof_renumbering.cc
+++ b/source/dofs/dof_renumbering.cc
@@ -83,11 +83,12 @@ namespace DoFRenumbering
 
     namespace internal
     {
-      template <class DH>
-      void create_graph (const DH                                                       &dof_handler,
-                         const bool                                                      use_constraints,
-                         boosttypes::Graph                                                   &graph,
-                         boosttypes::property_map<boosttypes::Graph,boosttypes::vertex_degree_t>::type &graph_degree)
+      template <typename DoFHandlerType>
+      void create_graph
+      (const DoFHandlerType                                                          &dof_handler,
+       const bool                                                                     use_constraints,
+       boosttypes::Graph                                                             &graph,
+       boosttypes::property_map<boosttypes::Graph,boosttypes::vertex_degree_t>::type &graph_degree)
       {
         {
           // create intermediate sparsity pattern
@@ -116,14 +117,14 @@ namespace DoFRenumbering
     }
 
 
-    template <class DH>
+    template <typename DoFHandlerType>
     void
-    Cuthill_McKee (DH              &dof_handler,
+    Cuthill_McKee (DoFHandlerType  &dof_handler,
                    const bool       reversed_numbering,
                    const bool       use_constraints)
     {
       std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(),
-                                                       DH::invalid_dof_index);
+                                                       DoFHandlerType::invalid_dof_index);
       compute_Cuthill_McKee(renumbering, dof_handler, reversed_numbering,
                             use_constraints);
 
@@ -134,12 +135,12 @@ namespace DoFRenumbering
     }
 
 
-    template <class DH>
+    template <typename DoFHandlerType>
     void
     compute_Cuthill_McKee (std::vector<types::global_dof_index> &new_dof_indices,
-                           const DH        &dof_handler,
-                           const bool       reversed_numbering,
-                           const bool       use_constraints)
+                           const DoFHandlerType                 &dof_handler,
+                           const bool                            reversed_numbering,
+                           const bool                            use_constraints)
     {
       boosttypes::Graph
       graph(dof_handler.n_dofs());
@@ -167,20 +168,20 @@ namespace DoFRenumbering
         new_dof_indices[index_map[inv_perm[c]]] = c;
 
       Assert (std::find (new_dof_indices.begin(), new_dof_indices.end(),
-                         DH::invalid_dof_index) == new_dof_indices.end(),
+                         DoFHandlerType::invalid_dof_index) == new_dof_indices.end(),
               ExcInternalError());
     }
 
 
 
-    template <class DH>
+    template <typename DoFHandlerType>
     void
-    king_ordering (DH              &dof_handler,
+    king_ordering (DoFHandlerType  &dof_handler,
                    const bool       reversed_numbering,
                    const bool       use_constraints)
     {
       std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(),
-                                                       DH::invalid_dof_index);
+                                                       DoFHandlerType::invalid_dof_index);
       compute_king_ordering(renumbering, dof_handler, reversed_numbering,
                             use_constraints);
 
@@ -191,12 +192,12 @@ namespace DoFRenumbering
     }
 
 
-    template <class DH>
+    template <typename DoFHandlerType>
     void
     compute_king_ordering (std::vector<types::global_dof_index> &new_dof_indices,
-                           const DH        &dof_handler,
-                           const bool       reversed_numbering,
-                           const bool       use_constraints)
+                           const DoFHandlerType                 &dof_handler,
+                           const bool                            reversed_numbering,
+                           const bool                            use_constraints)
     {
       boosttypes::Graph
       graph(dof_handler.n_dofs());
@@ -220,20 +221,20 @@ namespace DoFRenumbering
         new_dof_indices[index_map[inv_perm[c]]] = c;
 
       Assert (std::find (new_dof_indices.begin(), new_dof_indices.end(),
-                         DH::invalid_dof_index) == new_dof_indices.end(),
+                         DoFHandlerType::invalid_dof_index) == new_dof_indices.end(),
               ExcInternalError());
     }
 
 
 
-    template <class DH>
+    template <typename DoFHandlerType>
     void
-    minimum_degree (DH              &dof_handler,
+    minimum_degree (DoFHandlerType  &dof_handler,
                     const bool       reversed_numbering,
                     const bool       use_constraints)
     {
       std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(),
-                                                       DH::invalid_dof_index);
+                                                       DoFHandlerType::invalid_dof_index);
       compute_minimum_degree(renumbering, dof_handler, reversed_numbering,
                              use_constraints);
 
@@ -244,12 +245,12 @@ namespace DoFRenumbering
     }
 
 
-    template <class DH>
+    template <typename DoFHandlerType>
     void
     compute_minimum_degree (std::vector<types::global_dof_index> &new_dof_indices,
-                            const DH        &dof_handler,
-                            const bool       reversed_numbering,
-                            const bool       use_constraints)
+                            const DoFHandlerType                 &dof_handler,
+                            const bool                            reversed_numbering,
+                            const bool                            use_constraints)
     {
       (void)use_constraints;
       Assert (use_constraints == false, ExcNotImplemented());
@@ -276,8 +277,8 @@ namespace DoFRenumbering
 
       std::vector<dealii::types::global_dof_index> dofs_on_this_cell;
 
-      typename DH::active_cell_iterator cell = dof_handler.begin_active(),
-                                        endc = dof_handler.end();
+      typename DoFHandlerType::active_cell_iterator cell = dof_handler.begin_active(),
+                                                    endc = dof_handler.end();
 
       for (; cell!=endc; ++cell)
         {
@@ -347,15 +348,15 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  Cuthill_McKee (DH              &dof_handler,
-                 const bool       reversed_numbering,
-                 const bool       use_constraints,
+  Cuthill_McKee (DoFHandlerType                             &dof_handler,
+                 const bool                                  reversed_numbering,
+                 const bool                                  use_constraints,
                  const std::vector<types::global_dof_index> &starting_indices)
   {
     std::vector<types::global_dof_index> renumbering(dof_handler.locally_owned_dofs().n_elements(),
-                                                     DH::invalid_dof_index);
+                                                     DoFHandlerType::invalid_dof_index);
     compute_Cuthill_McKee(renumbering, dof_handler, reversed_numbering,
                           use_constraints, starting_indices);
 
@@ -367,12 +368,12 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  compute_Cuthill_McKee (std::vector<types::global_dof_index> &new_indices,
-                         const DH                  &dof_handler,
-                         const bool                 reversed_numbering,
-                         const bool                 use_constraints,
+  compute_Cuthill_McKee (std::vector<types::global_dof_index>       &new_indices,
+                         const DoFHandlerType                       &dof_handler,
+                         const bool                                  reversed_numbering,
+                         const bool                                  use_constraints,
                          const std::vector<types::global_dof_index> &starting_indices)
   {
     // see if there is anything to do at all or whether we can skip the work on this processor
@@ -462,10 +463,10 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
-  void Cuthill_McKee (DH               &dof_handler,
-                      const unsigned int               level,
-                      const bool                       reversed_numbering,
+  template <typename DoFHandlerType>
+  void Cuthill_McKee (DoFHandlerType                             &dof_handler,
+                      const unsigned int                          level,
+                      const bool                                  reversed_numbering,
                       const std::vector<types::global_dof_index> &starting_indices)
   {
     Assert(dof_handler.n_dofs(level) != numbers::invalid_dof_index,
@@ -565,24 +566,24 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  component_wise (DH &dof_handler,
-                  const unsigned int level,
+  component_wise (DoFHandlerType                  &dof_handler,
+                  const unsigned int               level,
                   const std::vector<unsigned int> &component_order_arg)
   {
     Assert(dof_handler.n_dofs(level) != numbers::invalid_dof_index,
            ExcNotInitialized());
 
     std::vector<types::global_dof_index> renumbering (dof_handler.n_dofs(level),
-                                                      DH::invalid_dof_index);
+                                                      DoFHandlerType::invalid_dof_index);
 
-    typename DH::level_cell_iterator start =dof_handler.begin(level);
-    typename DH::level_cell_iterator end = dof_handler.end(level);
+    typename DoFHandlerType::level_cell_iterator start =dof_handler.begin(level);
+    typename DoFHandlerType::level_cell_iterator end = dof_handler.end(level);
 
     const types::global_dof_index result =
-      compute_component_wise<DH::dimension, DH::space_dimension,
-      typename DH::level_cell_iterator, typename DH::level_cell_iterator>
+      compute_component_wise<DoFHandlerType::dimension, DoFHandlerType::space_dimension,
+      typename DoFHandlerType::level_cell_iterator, typename DoFHandlerType::level_cell_iterator>
       (renumbering, start, end, component_order_arg, true);
 
     if (result == 0) return;
@@ -1247,13 +1248,13 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  sort_selected_dofs_back (DH                      &dof_handler,
+  sort_selected_dofs_back (DoFHandlerType          &dof_handler,
                            const std::vector<bool> &selected_dofs)
   {
     std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(),
-                                                     DH::invalid_dof_index);
+                                                     DoFHandlerType::invalid_dof_index);
     compute_sort_selected_dofs_back(renumbering, dof_handler, selected_dofs);
 
     dof_handler.renumber_dofs(renumbering);
@@ -1261,9 +1262,9 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  sort_selected_dofs_back (DH                      &dof_handler,
+  sort_selected_dofs_back (DoFHandlerType          &dof_handler,
                            const std::vector<bool> &selected_dofs,
                            const unsigned int       level)
   {
@@ -1271,7 +1272,7 @@ namespace DoFRenumbering
            ExcNotInitialized());
 
     std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(level),
-                                                     DH::invalid_dof_index);
+                                                     DoFHandlerType::invalid_dof_index);
     compute_sort_selected_dofs_back(renumbering, dof_handler, selected_dofs, level);
 
     dof_handler.renumber_dofs(level, renumbering);
@@ -1279,11 +1280,11 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   compute_sort_selected_dofs_back (std::vector<types::global_dof_index> &new_indices,
-                                   const DH                  &dof_handler,
-                                   const std::vector<bool>   &selected_dofs)
+                                   const DoFHandlerType                 &dof_handler,
+                                   const std::vector<bool>              &selected_dofs)
   {
     const types::global_dof_index n_dofs = dof_handler.n_dofs();
     Assert (selected_dofs.size() == n_dofs,
@@ -1317,12 +1318,12 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   compute_sort_selected_dofs_back (std::vector<types::global_dof_index> &new_indices,
-                                   const DH                  &dof_handler,
-                                   const std::vector<bool>   &selected_dofs,
-                                   const unsigned int         level)
+                                   const DoFHandlerType                 &dof_handler,
+                                   const std::vector<bool>              &selected_dofs,
+                                   const unsigned int                    level)
   {
     Assert(dof_handler.n_dofs(level) != numbers::invalid_dof_index,
            ExcNotInitialized());
@@ -1359,9 +1360,10 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  cell_wise (DH &dof, const std::vector<typename DH::active_cell_iterator> &cells)
+  cell_wise (DoFHandlerType &dof,
+             const std::vector<typename DoFHandlerType::active_cell_iterator> &cells)
   {
     std::vector<types::global_dof_index> renumbering(dof.n_dofs());
     std::vector<types::global_dof_index> reverse(dof.n_dofs());
@@ -1371,13 +1373,13 @@ namespace DoFRenumbering
   }
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  compute_cell_wise (
-    std::vector<types::global_dof_index> &new_indices,
-    std::vector<types::global_dof_index> &reverse,
-    const DH &dof,
-    const typename std::vector<typename DH::active_cell_iterator> &cells)
+  compute_cell_wise
+  (std::vector<types::global_dof_index>                                      &new_indices,
+   std::vector<types::global_dof_index>                                      &reverse,
+   const DoFHandlerType                                                      &dof,
+   const typename std::vector<typename DoFHandlerType::active_cell_iterator> &cells)
   {
     Assert(cells.size() == dof.get_tria().n_active_cells(),
            ExcDimensionMismatch(cells.size(),
@@ -1405,7 +1407,7 @@ namespace DoFRenumbering
 
     unsigned int global_index = 0;
 
-    typename std::vector<typename DH::active_cell_iterator>::const_iterator cell;
+    typename std::vector<typename DoFHandlerType::active_cell_iterator>::const_iterator cell;
 
     for (cell = cells.begin(); cell != cells.end(); ++cell)
       {
@@ -1441,11 +1443,11 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
-  void cell_wise (
-    DH &dof,
-    const unsigned int level,
-    const typename std::vector<typename DH::level_cell_iterator> &cells)
+  template <typename DoFHandlerType>
+  void cell_wise
+  (DoFHandlerType                                                           &dof,
+   const unsigned int                                                        level,
+   const typename std::vector<typename DoFHandlerType::level_cell_iterator> &cells)
   {
     Assert(dof.n_dofs(level) != numbers::invalid_dof_index,
            ExcNotInitialized());
@@ -1459,13 +1461,13 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
-  void compute_cell_wise (
-    std::vector<types::global_dof_index> &new_order,
-    std::vector<types::global_dof_index> &reverse,
-    const DH &dof,
-    const unsigned int level,
-    const typename std::vector<typename DH::level_cell_iterator> &cells)
+  template <typename DoFHandlerType>
+  void compute_cell_wise
+  (std::vector<types::global_dof_index>                                     &new_order,
+   std::vector<types::global_dof_index>                                     &reverse,
+   const DoFHandlerType                                                     &dof,
+   const unsigned int                                                        level,
+   const typename std::vector<typename DoFHandlerType::level_cell_iterator> &cells)
   {
     Assert(cells.size() == dof.get_tria().n_cells(level),
            ExcDimensionMismatch(cells.size(),
@@ -1483,7 +1485,7 @@ namespace DoFRenumbering
 
     unsigned int global_index = 0;
 
-    typename std::vector<typename DH::level_cell_iterator>::const_iterator cell;
+    typename std::vector<typename DoFHandlerType::level_cell_iterator>::const_iterator cell;
 
     for (cell = cells.begin(); cell != cells.end(); ++cell)
       {
@@ -1513,23 +1515,24 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  compute_downstream (
-    std::vector<types::global_dof_index> &new_indices,
-    std::vector<types::global_dof_index> &reverse,
-    const DH &dof,
-    const Point<DH::space_dimension> &direction,
-    const bool dof_wise_renumbering)
+  compute_downstream
+  (std::vector<types::global_dof_index>         &new_indices,
+   std::vector<types::global_dof_index>         &reverse,
+   const DoFHandlerType                         &dof,
+   const Point<DoFHandlerType::space_dimension> &direction,
+   const bool                                    dof_wise_renumbering)
   {
     if (dof_wise_renumbering == false)
       {
-        std::vector<typename DH::active_cell_iterator> ordered_cells;
+        std::vector<typename DoFHandlerType::active_cell_iterator> ordered_cells;
         ordered_cells.reserve(dof.get_tria().n_active_cells());
-        const CompareDownstream<typename DH::active_cell_iterator, DH::space_dimension> comparator(direction);
+        const CompareDownstream<typename DoFHandlerType::active_cell_iterator,
+              DoFHandlerType::space_dimension> comparator(direction);
 
-        typename DH::active_cell_iterator p = dof.begin_active();
-        typename DH::active_cell_iterator end = dof.end();
+        typename DoFHandlerType::active_cell_iterator p = dof.begin_active();
+        typename DoFHandlerType::active_cell_iterator end = dof.end();
 
         while (p!=end)
           {
@@ -1544,44 +1547,44 @@ namespace DoFRenumbering
       {
         // similar code as for
         // DoFTools::map_dofs_to_support_points, but
-        // need to do this for general DH classes and
+        // need to do this for general DoFHandlerType classes and
         // want to be able to sort the result
         // (otherwise, could use something like
         // DoFTools::map_support_points_to_dofs)
         const unsigned int n_dofs = dof.n_dofs();
-        std::vector<std::pair<Point<DH::space_dimension>,unsigned int> > support_point_list
+        std::vector<std::pair<Point<DoFHandlerType::space_dimension>,unsigned int> > support_point_list
         (n_dofs);
 
-        const hp::FECollection<DH::dimension> fe_collection (dof.get_fe ());
+        const hp::FECollection<DoFHandlerType::dimension> fe_collection (dof.get_fe ());
         Assert (fe_collection[0].has_support_points(),
-                typename FiniteElement<DH::dimension>::ExcFEHasNoSupportPoints());
-        hp::QCollection<DH::dimension> quadrature_collection;
+                typename FiniteElement<DoFHandlerType::dimension>::ExcFEHasNoSupportPoints());
+        hp::QCollection<DoFHandlerType::dimension> quadrature_collection;
         for (unsigned int comp=0; comp<fe_collection.size(); ++comp)
           {
             Assert (fe_collection[comp].has_support_points(),
-                    typename FiniteElement<DH::dimension>::ExcFEHasNoSupportPoints());
+                    typename FiniteElement<DoFHandlerType::dimension>::ExcFEHasNoSupportPoints());
             quadrature_collection.push_back
-            (Quadrature<DH::dimension> (fe_collection[comp].
-                                        get_unit_support_points()));
+            (Quadrature<DoFHandlerType::dimension> (fe_collection[comp].
+                                                    get_unit_support_points()));
           }
-        hp::FEValues<DH::dimension,DH::space_dimension>
+        hp::FEValues<DoFHandlerType::dimension,DoFHandlerType::space_dimension>
         hp_fe_values (fe_collection, quadrature_collection,
                       update_quadrature_points);
 
         std::vector<bool> already_touched (n_dofs, false);
 
         std::vector<types::global_dof_index> local_dof_indices;
-        typename DH::active_cell_iterator begin = dof.begin_active();
-        typename DH::active_cell_iterator end = dof.end();
+        typename DoFHandlerType::active_cell_iterator begin = dof.begin_active();
+        typename DoFHandlerType::active_cell_iterator end = dof.end();
         for ( ; begin != end; ++begin)
           {
             const unsigned int dofs_per_cell = begin->get_fe().dofs_per_cell;
             local_dof_indices.resize (dofs_per_cell);
             hp_fe_values.reinit (begin);
-            const FEValues<DH::dimension> &fe_values =
+            const FEValues<DoFHandlerType::dimension> &fe_values =
               hp_fe_values.get_present_fe_values ();
             begin->get_active_or_mg_dof_indices(local_dof_indices);
-            const std::vector<Point<DH::space_dimension> > &points
+            const std::vector<Point<DoFHandlerType::space_dimension> > &points
               = fe_values.get_quadrature_points ();
             for (unsigned int i=0; i<dofs_per_cell; ++i)
               if (!already_touched[local_dof_indices[i]])
@@ -1593,7 +1596,7 @@ namespace DoFRenumbering
                 }
           }
 
-        ComparePointwiseDownstream<DH::space_dimension> comparator (direction);
+        ComparePointwiseDownstream<DoFHandlerType::space_dimension> comparator (direction);
         std::sort (support_point_list.begin(), support_point_list.end(),
                    comparator);
         for (types::global_dof_index i=0; i<n_dofs; ++i)
@@ -1603,11 +1606,11 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
-  void downstream (DH &dof,
-                   const unsigned int level,
-                   const Point<DH::space_dimension>  &direction,
-                   const bool         dof_wise_renumbering)
+  template <typename DoFHandlerType>
+  void downstream (DoFHandlerType                               &dof,
+                   const unsigned int                            level,
+                   const Point<DoFHandlerType::space_dimension> &direction,
+                   const bool                                    dof_wise_renumbering)
   {
     std::vector<types::global_dof_index> renumbering(dof.n_dofs(level));
     std::vector<types::global_dof_index> reverse(dof.n_dofs(level));
@@ -1619,24 +1622,25 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  compute_downstream (
-    std::vector<types::global_dof_index> &new_indices,
-    std::vector<types::global_dof_index> &reverse,
-    const DH &dof,
-    const unsigned int level,
-    const Point<DH::space_dimension> &direction,
-    const bool dof_wise_renumbering)
+  compute_downstream
+  (std::vector<types::global_dof_index>         &new_indices,
+   std::vector<types::global_dof_index>         &reverse,
+   const DoFHandlerType                         &dof,
+   const unsigned int                            level,
+   const Point<DoFHandlerType::space_dimension> &direction,
+   const bool                                    dof_wise_renumbering)
   {
     if (dof_wise_renumbering == false)
       {
-        std::vector<typename DH::level_cell_iterator> ordered_cells;
+        std::vector<typename DoFHandlerType::level_cell_iterator> ordered_cells;
         ordered_cells.reserve (dof.get_tria().n_cells(level));
-        const CompareDownstream<typename DH::level_cell_iterator, DH::space_dimension> comparator(direction);
+        const CompareDownstream<typename DoFHandlerType::level_cell_iterator,
+              DoFHandlerType::space_dimension> comparator(direction);
 
-        typename DH::level_cell_iterator p = dof.begin(level);
-        typename DH::level_cell_iterator end = dof.end(level);
+        typename DoFHandlerType::level_cell_iterator p = dof.begin(level);
+        typename DoFHandlerType::level_cell_iterator end = dof.end(level);
 
         while (p!=end)
           {
@@ -1650,27 +1654,28 @@ namespace DoFRenumbering
     else
       {
         Assert (dof.get_fe().has_support_points(),
-                typename FiniteElement<DH::dimension>::ExcFEHasNoSupportPoints());
+                typename FiniteElement<DoFHandlerType::dimension>::ExcFEHasNoSupportPoints());
         const unsigned int n_dofs = dof.n_dofs(level);
-        std::vector<std::pair<Point<DH::space_dimension>,unsigned int> > support_point_list
+        std::vector<std::pair<Point<DoFHandlerType::space_dimension>,unsigned int> > support_point_list
         (n_dofs);
 
-        Quadrature<DH::dimension>   q_dummy(dof.get_fe().get_unit_support_points());
-        FEValues<DH::dimension,DH::space_dimension> fe_values (dof.get_fe(), q_dummy,
-                                                               update_quadrature_points);
+        Quadrature<DoFHandlerType::dimension>   q_dummy(dof.get_fe().get_unit_support_points());
+        FEValues<DoFHandlerType::dimension,DoFHandlerType::space_dimension> fe_values (dof.get_fe(), q_dummy,
+            update_quadrature_points);
 
         std::vector<bool> already_touched (dof.n_dofs(), false);
 
         const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
         std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
-        typename DH::level_cell_iterator begin = dof.begin(level);
-        typename DH::level_cell_iterator end = dof.end(level);
+        typename DoFHandlerType::level_cell_iterator begin = dof.begin(level);
+        typename DoFHandlerType::level_cell_iterator end = dof.end(level);
         for ( ; begin != end; ++begin)
           {
-            const typename Triangulation<DH::dimension,DH::space_dimension>::cell_iterator &begin_tria = begin;
+            const typename Triangulation<DoFHandlerType::dimension,
+                  DoFHandlerType::space_dimension>::cell_iterator &begin_tria = begin;
             begin->get_active_or_mg_dof_indices(local_dof_indices);
             fe_values.reinit (begin_tria);
-            const std::vector<Point<DH::space_dimension> > &points
+            const std::vector<Point<DoFHandlerType::space_dimension> > &points
               = fe_values.get_quadrature_points ();
             for (unsigned int i=0; i<dofs_per_cell; ++i)
               if (!already_touched[local_dof_indices[i]])
@@ -1682,7 +1687,7 @@ namespace DoFRenumbering
                 }
           }
 
-        ComparePointwiseDownstream<DH::space_dimension> comparator (direction);
+        ComparePointwiseDownstream<DoFHandlerType::space_dimension> comparator (direction);
         std::sort (support_point_list.begin(), support_point_list.end(),
                    comparator);
         for (types::global_dof_index i=0; i<n_dofs; ++i)
@@ -1765,11 +1770,11 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   clockwise_dg (
-    DH &dof,
-    const Point<DH::space_dimension> &center,
+    DoFHandlerType &dof,
+    const Point<DoFHandlerType::space_dimension> &center,
     const bool counter)
   {
     std::vector<types::global_dof_index> renumbering(dof.n_dofs());
@@ -1780,20 +1785,20 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  compute_clockwise_dg (
-    std::vector<types::global_dof_index> &new_indices,
-    const DH &dof,
-    const Point<DH::space_dimension> &center,
-    const bool counter)
+  compute_clockwise_dg
+  (std::vector<types::global_dof_index>         &new_indices,
+   const DoFHandlerType                         &dof,
+   const Point<DoFHandlerType::space_dimension> &center,
+   const bool                                    counter)
   {
-    std::vector<typename DH::active_cell_iterator> ordered_cells;
+    std::vector<typename DoFHandlerType::active_cell_iterator> ordered_cells;
     ordered_cells.reserve (dof.get_tria().n_active_cells());
-    internal::ClockCells<DH::space_dimension> comparator(center, counter);
+    internal::ClockCells<DoFHandlerType::space_dimension> comparator(center, counter);
 
-    typename DH::active_cell_iterator p = dof.begin_active();
-    typename DH::active_cell_iterator end = dof.end();
+    typename DoFHandlerType::active_cell_iterator p = dof.begin_active();
+    typename DoFHandlerType::active_cell_iterator end = dof.end();
 
     while (p!=end)
       {
@@ -1808,18 +1813,18 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
-  void clockwise_dg (DH &dof,
-                     const unsigned int level,
-                     const Point<DH::space_dimension> &center,
-                     const bool counter)
+  template <typename DoFHandlerType>
+  void clockwise_dg (DoFHandlerType                               &dof,
+                     const unsigned int                            level,
+                     const Point<DoFHandlerType::space_dimension> &center,
+                     const bool                                    counter)
   {
-    std::vector<typename DH::level_cell_iterator> ordered_cells;
+    std::vector<typename DoFHandlerType::level_cell_iterator> ordered_cells;
     ordered_cells.reserve(dof.get_tria().n_active_cells());
-    internal::ClockCells<DH::space_dimension> comparator(center, counter);
+    internal::ClockCells<DoFHandlerType::space_dimension> comparator(center, counter);
 
-    typename DH::level_cell_iterator p = dof.begin(level);
-    typename DH::level_cell_iterator end = dof.end(level);
+    typename DoFHandlerType::level_cell_iterator p = dof.begin(level);
+    typename DoFHandlerType::level_cell_iterator end = dof.end(level);
 
     while (p!=end)
       {
@@ -1833,12 +1838,12 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  random (DH &dof_handler)
+  random (DoFHandlerType &dof_handler)
   {
     std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(),
-                                                     DH::invalid_dof_index);
+                                                     DoFHandlerType::invalid_dof_index);
     compute_random(renumbering, dof_handler);
 
     dof_handler.renumber_dofs(renumbering);
@@ -1846,11 +1851,11 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   compute_random (
     std::vector<types::global_dof_index> &new_indices,
-    const DH                  &dof_handler)
+    const DoFHandlerType      &dof_handler)
   {
     const types::global_dof_index n_dofs = dof_handler.n_dofs();
     Assert(new_indices.size() == n_dofs,
@@ -1877,12 +1882,12 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  subdomain_wise (DH &dof_handler)
+  subdomain_wise (DoFHandlerType &dof_handler)
   {
     std::vector<types::global_dof_index> renumbering(dof_handler.n_dofs(),
-                                                     DH::invalid_dof_index);
+                                                     DoFHandlerType::invalid_dof_index);
     compute_subdomain_wise(renumbering, dof_handler);
 
     dof_handler.renumber_dofs(renumbering);
@@ -1890,10 +1895,10 @@ namespace DoFRenumbering
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
   compute_subdomain_wise (std::vector<types::global_dof_index> &new_dof_indices,
-                          const DH                  &dof_handler)
+                          const DoFHandlerType      &dof_handler)
   {
     const types::global_dof_index n_dofs = dof_handler.n_dofs();
     Assert (new_dof_indices.size() == n_dofs,
diff --git a/source/dofs/dof_tools.cc b/source/dofs/dof_tools.cc
index 205cd6baa4..e56f5b1322 100644
--- a/source/dofs/dof_tools.cc
+++ b/source/dofs/dof_tools.cc
@@ -136,13 +136,13 @@ namespace DoFTools
     //   shape function
     // - otherwise, the shape function is assigned the first component selected
     //   in the component_mask that corresponds to this shape function
-    template <class DH>
+    template <typename DoFHandlerType>
     void
-    get_component_association (const DH                   &dof,
+    get_component_association (const DoFHandlerType       &dof,
                                const ComponentMask        &component_mask,
                                std::vector<unsigned char> &dofs_by_component)
     {
-      const dealii::hp::FECollection<DH::dimension,DH::space_dimension>
+      const dealii::hp::FECollection<DoFHandlerType::dimension,DoFHandlerType::space_dimension>
       fe_collection (dof.get_fe());
       Assert (fe_collection.n_components() < 256, ExcNotImplemented());
       Assert (dofs_by_component.size() == dof.n_locally_owned_dofs(),
@@ -160,7 +160,7 @@ namespace DoFTools
       local_component_association (fe_collection.size());
       for (unsigned int f=0; f<fe_collection.size(); ++f)
         {
-          const FiniteElement<DH::dimension,DH::space_dimension> &fe =
+          const FiniteElement<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe =
             fe_collection[f];
           local_component_association[f]
             = get_local_component_association (fe, component_mask);
@@ -168,7 +168,7 @@ namespace DoFTools
 
       // then loop over all cells and do the work
       std::vector<types::global_dof_index> indices;
-      for (typename DH::active_cell_iterator c=dof.begin_active();
+      for (typename DoFHandlerType::active_cell_iterator c=dof.begin_active();
            c!=dof.end(); ++ c)
         if (c->is_locally_owned())
           {
@@ -191,13 +191,13 @@ namespace DoFTools
     // vector block. if the DoFHandler is based on a parallel distributed
     // triangulation then the output array is index by
     // dof.locally_owned_dofs().index_within_set(indices[i])
-    template <class DH>
+    template <typename DoFHandlerType>
     inline
     void
-    get_block_association (const DH                   &dof,
+    get_block_association (const DoFHandlerType       &dof,
                            std::vector<unsigned char> &dofs_by_block)
     {
-      const dealii::hp::FECollection<DH::dimension,DH::space_dimension>
+      const dealii::hp::FECollection<DoFHandlerType::dimension,DoFHandlerType::space_dimension>
       fe_collection (dof.get_fe());
       Assert (fe_collection.n_components() < 256, ExcNotImplemented());
       Assert (dofs_by_block.size() == dof.n_locally_owned_dofs(),
@@ -215,7 +215,7 @@ namespace DoFTools
       (fe_collection.size());
       for (unsigned int f=0; f<fe_collection.size(); ++f)
         {
-          const FiniteElement<DH::dimension,DH::space_dimension> &fe =
+          const FiniteElement<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe =
             fe_collection[f];
           local_block_association[f].resize(fe.dofs_per_cell,
                                             (unsigned char)(-1));
@@ -232,7 +232,7 @@ namespace DoFTools
 
       // then loop over all cells and do the work
       std::vector<types::global_dof_index> indices;
-      for (typename DH::active_cell_iterator c=dof.begin_active();
+      for (typename DoFHandlerType::active_cell_iterator c=dof.begin_active();
            c!=dof.end(); ++ c)
         if (c->is_locally_owned())
           {
@@ -250,15 +250,14 @@ namespace DoFTools
 
 
 
-  template <class DH, typename Number>
-  void distribute_cell_to_dof_vector (
-    const DH             &dof_handler,
-    const Vector<Number> &cell_data,
-    Vector<double>       &dof_data,
-    const unsigned int    component)
+  template <typename DoFHandlerType, typename Number>
+  void distribute_cell_to_dof_vector (const DoFHandlerType &dof_handler,
+                                      const Vector<Number> &cell_data,
+                                      Vector<double>       &dof_data,
+                                      const unsigned int    component)
   {
-    const unsigned int dim = DH::dimension;
-    const unsigned int spacedim = DH::space_dimension;
+    const unsigned int dim = DoFHandlerType::dimension;
+    const unsigned int spacedim = DoFHandlerType::space_dimension;
     const Triangulation<dim,spacedim> &tria = dof_handler.get_tria();
     (void)tria;
 
@@ -292,8 +291,8 @@ namespace DoFTools
     // count how often we have added a value in the sum for each dof
     std::vector<unsigned char> touch_count (dof_handler.n_dofs(), 0);
 
-    typename DH::active_cell_iterator cell = dof_handler.begin_active(),
-                                      endc = dof_handler.end();
+    typename DoFHandlerType::active_cell_iterator cell = dof_handler.begin_active(),
+                                                  endc = dof_handler.end();
     std::vector<types::global_dof_index> dof_indices;
     dof_indices.reserve (max_dofs_per_cell(dof_handler));
 
@@ -334,9 +333,9 @@ namespace DoFTools
 
   template <int dim, int spacedim>
   void
-  extract_dofs (const DoFHandler<dim,spacedim>   &dof,
-                const ComponentMask     &component_mask,
-                std::vector<bool>       &selected_dofs)
+  extract_dofs (const DoFHandler<dim,spacedim> &dof,
+                const ComponentMask            &component_mask,
+                std::vector<bool>              &selected_dofs)
   {
     const FiniteElement<dim,spacedim> &fe = dof.get_fe();
     (void)fe;
@@ -380,9 +379,9 @@ namespace DoFTools
 
   template <int dim, int spacedim>
   void
-  extract_dofs (const hp::DoFHandler<dim,spacedim>   &dof,
-                const ComponentMask     &component_mask,
-                std::vector<bool>       &selected_dofs)
+  extract_dofs (const hp::DoFHandler<dim,spacedim> &dof,
+                const ComponentMask                &component_mask,
+                std::vector<bool>                  &selected_dofs)
   {
     const FiniteElement<dim,spacedim> &fe = dof.begin_active()->get_fe();
     (void)fe;
@@ -449,14 +448,14 @@ namespace DoFTools
 
 
 
-  template<class DH>
+  template<typename DoFHandlerType>
   void
-  extract_level_dofs(const unsigned int       level,
-                     const DH &dof,
-                     const ComponentMask &component_mask,
-                     std::vector<bool>       &selected_dofs)
+  extract_level_dofs (const unsigned int    level,
+                      const DoFHandlerType &dof,
+                      const ComponentMask  &component_mask,
+                      std::vector<bool>    &selected_dofs)
   {
-    const FiniteElement<DH::dimension,DH::space_dimension> &fe = dof.get_fe();
+    const FiniteElement<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe = dof.get_fe();
 
     Assert(component_mask.represents_n_components(n_components(dof)),
            ExcMessage ("The given component mask is not sized correctly to represent the "
@@ -490,7 +489,7 @@ namespace DoFTools
 
     // then loop over all cells and do work
     std::vector<types::global_dof_index> indices(fe.dofs_per_cell);
-    typename DH::level_cell_iterator c;
+    typename DoFHandlerType::level_cell_iterator c;
     for (c = dof.begin(level) ; c != dof.end(level) ; ++ c)
       {
         c->get_mg_dof_indices(indices);
@@ -501,12 +500,12 @@ namespace DoFTools
 
 
 
-  template<class DH>
+  template<typename DoFHandlerType>
   void
-  extract_level_dofs(const unsigned int       level,
-                     const DH &dof,
-                     const BlockMask         &block_mask,
-                     std::vector<bool>       &selected_dofs)
+  extract_level_dofs (const unsigned int    level,
+                      const DoFHandlerType &dof,
+                      const BlockMask      &block_mask,
+                      std::vector<bool>    &selected_dofs)
   {
     // simply defer to the other extract_level_dofs() function
     extract_level_dofs (level, dof, dof.get_fe().component_mask(block_mask),
@@ -515,14 +514,14 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_boundary_dofs (const DH                      &dof_handler,
-                         const ComponentMask           &component_mask,
-                         std::vector<bool>             &selected_dofs,
+  extract_boundary_dofs (const DoFHandlerType               &dof_handler,
+                         const ComponentMask                &component_mask,
+                         std::vector<bool>                  &selected_dofs,
                          const std::set<types::boundary_id> &boundary_ids)
   {
-    Assert ((dynamic_cast<const parallel::distributed::Triangulation<DH::dimension,DH::space_dimension>*>
+    Assert ((dynamic_cast<const parallel::distributed::Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension>*>
              (&dof_handler.get_tria())
              == 0),
             ExcMessage ("This function can not be used with distributed triangulations."
@@ -541,18 +540,18 @@ namespace DoFTools
   }
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_boundary_dofs (const DH                      &dof_handler,
-                         const ComponentMask       &component_mask,
-                         IndexSet             &selected_dofs,
+  extract_boundary_dofs (const DoFHandlerType               &dof_handler,
+                         const ComponentMask                &component_mask,
+                         IndexSet                           &selected_dofs,
                          const std::set<types::boundary_id> &boundary_ids)
   {
     Assert (component_mask.represents_n_components(n_components(dof_handler)),
             ExcMessage ("Component mask has invalid size."));
     Assert (boundary_ids.find (numbers::internal_face_boundary_id) == boundary_ids.end(),
             ExcInvalidBoundaryIndicator());
-    const unsigned int dim=DH::dimension;
+    const unsigned int dim=DoFHandlerType::dimension;
 
     // first reset output argument
     selected_dofs.clear ();
@@ -579,20 +578,21 @@ namespace DoFTools
     // do not support boundaries of dimension dim-2, and so every isolated
     // boundary line is also part of a boundary face which we will be
     // visiting sooner or later
-    for (typename DH::active_cell_iterator cell=dof_handler.begin_active();
+    for (typename DoFHandlerType::active_cell_iterator cell=dof_handler.begin_active();
          cell!=dof_handler.end(); ++cell)
 
       // only work on cells that are either locally owned or at least ghost
       // cells
       if (cell->is_artificial() == false)
         for (unsigned int face=0;
-             face<GeometryInfo<DH::dimension>::faces_per_cell; ++face)
+             face<GeometryInfo<DoFHandlerType::dimension>::faces_per_cell; ++face)
           if (cell->at_boundary(face))
             if (! check_boundary_id ||
                 (boundary_ids.find (cell->face(face)->boundary_id())
                  != boundary_ids.end()))
               {
-                const FiniteElement<DH::dimension, DH::space_dimension> &fe = cell->get_fe();
+                const FiniteElement<DoFHandlerType::dimension, DoFHandlerType::space_dimension>
+                &fe = cell->get_fe();
 
                 const unsigned int dofs_per_face = fe.dofs_per_face;
                 face_dof_indices.resize (dofs_per_face);
@@ -648,11 +648,11 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_dofs_with_support_on_boundary (const DH                      &dof_handler,
-                                         const ComponentMask           &component_mask,
-                                         std::vector<bool>             &selected_dofs,
+  extract_dofs_with_support_on_boundary (const DoFHandlerType               &dof_handler,
+                                         const ComponentMask                &component_mask,
+                                         std::vector<bool>                  &selected_dofs,
                                          const std::set<types::boundary_id> &boundary_ids)
   {
     Assert (component_mask.represents_n_components (n_components(dof_handler)),
@@ -681,16 +681,17 @@ namespace DoFTools
     // do not support boundaries of dimension dim-2, and so every isolated
     // boundary line is also part of a boundary face which we will be
     // visiting sooner or later
-    for (typename DH::active_cell_iterator cell=dof_handler.begin_active();
+    for (typename DoFHandlerType::active_cell_iterator cell=dof_handler.begin_active();
          cell!=dof_handler.end(); ++cell)
       for (unsigned int face=0;
-           face<GeometryInfo<DH::dimension>::faces_per_cell; ++face)
+           face<GeometryInfo<DoFHandlerType::dimension>::faces_per_cell; ++face)
         if (cell->at_boundary(face))
           if (! check_boundary_id ||
               (boundary_ids.find (cell->face(face)->boundary_id())
                != boundary_ids.end()))
             {
-              const FiniteElement<DH::dimension, DH::space_dimension> &fe = cell->get_fe();
+              const FiniteElement<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &fe
+                = cell->get_fe();
 
               const unsigned int dofs_per_cell = fe.dofs_per_cell;
               cell_dof_indices.resize (dofs_per_cell);
@@ -857,11 +858,11 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_subdomain_dofs (const DH                   &dof_handler,
-                          const types::subdomain_id subdomain_id,
-                          std::vector<bool>          &selected_dofs)
+  extract_subdomain_dofs (const DoFHandlerType      &dof_handler,
+                          const types::subdomain_id  subdomain_id,
+                          std::vector<bool>         &selected_dofs)
   {
     Assert(selected_dofs.size() == dof_handler.n_dofs(),
            ExcDimensionMismatch(selected_dofs.size(), dof_handler.n_dofs()));
@@ -874,7 +875,7 @@ namespace DoFTools
 
     // this function is similar to the make_sparsity_pattern function, see
     // there for more information
-    typename DH::active_cell_iterator
+    typename DoFHandlerType::active_cell_iterator
     cell = dof_handler.begin_active(),
     endc = dof_handler.end();
     for (; cell!=endc; ++cell)
@@ -890,10 +891,10 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_locally_owned_dofs (const DH &dof_handler,
-                              IndexSet &dof_set)
+  extract_locally_owned_dofs (const DoFHandlerType &dof_handler,
+                              IndexSet             &dof_set)
   {
     // collect all the locally owned dofs
     dof_set = dof_handler.locally_owned_dofs();
@@ -902,10 +903,10 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_locally_active_dofs (const DH &dof_handler,
-                               IndexSet &dof_set)
+  extract_locally_active_dofs (const DoFHandlerType &dof_handler,
+                               IndexSet             &dof_set)
   {
     // collect all the locally owned dofs
     dof_set = dof_handler.locally_owned_dofs();
@@ -916,8 +917,8 @@ namespace DoFTools
     std::vector<types::global_dof_index> dof_indices;
     std::set<types::global_dof_index> global_dof_indices;
 
-    typename DH::active_cell_iterator cell = dof_handler.begin_active(),
-                                      endc = dof_handler.end();
+    typename DoFHandlerType::active_cell_iterator cell = dof_handler.begin_active(),
+                                                  endc = dof_handler.end();
     for (; cell!=endc; ++cell)
       if (cell->is_locally_owned())
         {
@@ -938,10 +939,10 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_locally_relevant_dofs (const DH &dof_handler,
-                                 IndexSet &dof_set)
+  extract_locally_relevant_dofs (const DoFHandlerType &dof_handler,
+                                 IndexSet             &dof_set)
   {
     // collect all the locally owned dofs
     dof_set = dof_handler.locally_owned_dofs();
@@ -955,8 +956,8 @@ namespace DoFTools
     // are contiguous. - Timo Heister
     std::vector<types::global_dof_index> dof_indices;
 
-    typename DH::active_cell_iterator cell = dof_handler.begin_active(),
-                                      endc = dof_handler.end();
+    typename DoFHandlerType::active_cell_iterator cell = dof_handler.begin_active(),
+                                                  endc = dof_handler.end();
     for (; cell!=endc; ++cell)
       if (cell->is_ghost())
         {
@@ -969,11 +970,11 @@ namespace DoFTools
   }
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_locally_relevant_level_dofs (const DH &dof_handler,
-                                       const unsigned int level,
-                                       IndexSet &dof_set)
+  extract_locally_relevant_level_dofs (const DoFHandlerType &dof_handler,
+                                       const unsigned int    level,
+                                       IndexSet             &dof_set)
   {
     // collect all the locally owned dofs
     dof_set = dof_handler.locally_owned_mg_dofs(level);
@@ -987,8 +988,8 @@ namespace DoFTools
     // are contiguous. - Timo Heister
     std::vector<types::global_dof_index> dof_indices;
 
-    typename DH::cell_iterator cell = dof_handler.begin(level),
-                               endc = dof_handler.end(level);
+    typename DoFHandlerType::cell_iterator cell = dof_handler.begin(level),
+                                           endc = dof_handler.end(level);
     for (; cell!=endc; ++cell)
       {
         const types::subdomain_id id = cell->level_subdomain_id();
@@ -1006,9 +1007,9 @@ namespace DoFTools
     dof_set.compress();
   }
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  extract_constant_modes (const DH                        &dof_handler,
+  extract_constant_modes (const DoFHandlerType            &dof_handler,
                           const ComponentMask             &component_mask,
                           std::vector<std::vector<bool> > &constant_modes)
   {
@@ -1039,7 +1040,7 @@ namespace DoFTools
     //
     // TODO: We might be able to extend this also for elements which do not
     // have the same constant modes, but that is messy...
-    const dealii::hp::FECollection<DH::dimension,DH::space_dimension>
+    const dealii::hp::FECollection<DoFHandlerType::dimension,DoFHandlerType::space_dimension>
     fe_collection (dof_handler.get_fe());
     std::vector<Table<2,bool> > element_constant_modes;
     std::vector<std::vector<std::pair<unsigned int, unsigned int> > >
@@ -1066,8 +1067,8 @@ namespace DoFTools
 
     // Loop over all owned cells and ask the element for the constant modes
 
-    typename DH::active_cell_iterator cell = dof_handler.begin_active(),
-                                      endc = dof_handler.end();
+    typename DoFHandlerType::active_cell_iterator cell = dof_handler.begin_active(),
+                                                  endc = dof_handler.end();
     std::vector<types::global_dof_index> dof_indices;
     for (; cell!=endc; ++cell)
       if (cell->is_locally_owned())
@@ -1093,28 +1094,28 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  get_active_fe_indices (const DH                  &dof_handler,
+  get_active_fe_indices (const DoFHandlerType      &dof_handler,
                          std::vector<unsigned int> &active_fe_indices)
   {
     AssertDimension (active_fe_indices.size(), dof_handler.get_tria().n_active_cells());
 
-    typename DH::active_cell_iterator
+    typename DoFHandlerType::active_cell_iterator
     cell = dof_handler.begin_active(),
     endc = dof_handler.end();
     for (; cell!=endc; ++cell)
       active_fe_indices[cell->active_cell_index()] = cell->active_fe_index();
   }
 
-  template <class DH>
+  template <typename DoFHandlerType>
   std::vector<IndexSet>
-  locally_owned_dofs_per_subdomain (const DH  &dof_handler)
+  locally_owned_dofs_per_subdomain (const DoFHandlerType  &dof_handler)
   {
     // If the Triangulation is distributed, the only thing we can usefully
     // ask is for its locally owned subdomain
     Assert ((dynamic_cast<const parallel::distributed::
-             Triangulation<DH::dimension,DH::space_dimension> *>
+             Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> *>
              (&dof_handler.get_tria()) == 0),
             ExcMessage ("For parallel::distributed::Triangulation objects and "
                         "associated DoF handler objects, asking for any information "
@@ -1166,14 +1167,14 @@ namespace DoFTools
     return index_sets;
   }
 
-  template <class DH>
+  template <typename DoFHandlerType>
   std::vector<IndexSet>
-  locally_relevant_dofs_per_subdomain (const DH  &dof_handler)
+  locally_relevant_dofs_per_subdomain (const DoFHandlerType  &dof_handler)
   {
     // If the Triangulation is distributed, the only thing we can usefully
     // ask is for its locally owned subdomain
     Assert ((dynamic_cast<const parallel::distributed::
-             Triangulation<DH::dimension,DH::space_dimension> *>
+             Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> *>
              (&dof_handler.get_tria()) == 0),
             ExcMessage ("For parallel::distributed::Triangulation objects and "
                         "associated DoF handler objects, asking for any information "
@@ -1195,19 +1196,19 @@ namespace DoFTools
          subdomain_id < n_subdomains; ++subdomain_id)
       {
         // Extract the layer of cells around this subdomain
-        std_cxx11::function<bool (const typename DH::active_cell_iterator &)> predicate
+        std_cxx11::function<bool (const typename DoFHandlerType::active_cell_iterator &)> predicate
           = IteratorFilters::SubdomainEqualTo(subdomain_id);
-        const std::vector<typename DH::active_cell_iterator>
+        const std::vector<typename DoFHandlerType::active_cell_iterator>
         active_halo_layer = GridTools::compute_active_cell_halo_layer (dof_handler,
                             predicate);
 
         // Extract DoFs associated with halo layer
         std::vector<types::global_dof_index> local_dof_indices;
         std::set<types::global_dof_index> subdomain_halo_global_dof_indices;
-        for (typename std::vector<typename DH::active_cell_iterator>::const_iterator
+        for (typename std::vector<typename DoFHandlerType::active_cell_iterator>::const_iterator
              it_cell = active_halo_layer.begin(); it_cell!=active_halo_layer.end(); ++it_cell)
           {
-            const typename DH::active_cell_iterator &cell = *it_cell;
+            const typename DoFHandlerType::active_cell_iterator &cell = *it_cell;
             Assert(cell->subdomain_id() != subdomain_id,
                    ExcMessage("The subdomain ID of the halo cell should not match that of the vector entry."));
 
@@ -1229,15 +1230,15 @@ namespace DoFTools
     return dof_set;
   }
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  get_subdomain_association (const DH                  &dof_handler,
+  get_subdomain_association (const DoFHandlerType &dof_handler,
                              std::vector<types::subdomain_id> &subdomain_association)
   {
     // if the Triangulation is distributed, the only thing we can usefully
     // ask is for its locally owned subdomain
     Assert ((dynamic_cast<const parallel::distributed::
-             Triangulation<DH::dimension,DH::space_dimension> *>
+             Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> *>
              (&dof_handler.get_tria()) == 0),
             ExcMessage ("For parallel::distributed::Triangulation objects and "
                         "associated DoF handler objects, asking for any subdomain other "
@@ -1256,8 +1257,9 @@ namespace DoFTools
     // artificial cells). Otherwise we are good to use subdomain_id as stored
     // in cell->subdomain_id().
     std::vector<types::subdomain_id> cell_owners (dof_handler.get_tria().n_active_cells());
-    if (const parallel::shared::Triangulation<DH::dimension, DH::space_dimension> *tr =
-          (dynamic_cast<const parallel::shared::Triangulation<DH::dimension, DH::space_dimension>*> (&dof_handler.get_tria ())))
+    if (const parallel::shared::Triangulation<DoFHandlerType::dimension, DoFHandlerType::space_dimension>
+        *tr = (dynamic_cast<const parallel::shared::Triangulation<DoFHandlerType::dimension,
+               DoFHandlerType::space_dimension>*> (&dof_handler.get_tria ())))
       {
         cell_owners = tr->get_true_subdomain_ids_of_cells();
         Assert (tr->get_true_subdomain_ids_of_cells().size() == tr->n_active_cells(),
@@ -1265,7 +1267,7 @@ namespace DoFTools
       }
     else
       {
-        for (typename DH::active_cell_iterator cell = dof_handler.begin_active();
+        for (typename DoFHandlerType::active_cell_iterator cell = dof_handler.begin_active();
              cell!= dof_handler.end(); cell++)
           if (cell->is_locally_owned())
             cell_owners[cell->active_cell_index()] = cell->subdomain_id();
@@ -1284,7 +1286,7 @@ namespace DoFTools
 
     // loop over all cells and record which subdomain a DoF belongs to.
     // toss a coin in case it is on an interface
-    typename DH::active_cell_iterator
+    typename DoFHandlerType::active_cell_iterator
     cell = dof_handler.begin_active(),
     endc = dof_handler.end();
     for (; cell!=endc; ++cell)
@@ -1319,10 +1321,10 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   unsigned int
-  count_dofs_with_subdomain_association (const DH           &dof_handler,
-                                         const types::subdomain_id subdomain)
+  count_dofs_with_subdomain_association (const DoFHandlerType      &dof_handler,
+                                         const types::subdomain_id  subdomain)
   {
     std::vector<types::subdomain_id> subdomain_association (dof_handler.n_dofs());
     get_subdomain_association (dof_handler, subdomain_association);
@@ -1334,10 +1336,10 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   IndexSet
-  dof_indices_with_subdomain_association (const DH           &dof_handler,
-                                          const types::subdomain_id subdomain)
+  dof_indices_with_subdomain_association (const DoFHandlerType      &dof_handler,
+                                          const types::subdomain_id  subdomain)
   {
 
     // If we have a distributed::Triangulation only allow locally_owned
@@ -1362,7 +1364,7 @@ namespace DoFTools
     // more expensive than a vector
     std::vector<types::global_dof_index> subdomain_indices;
 
-    typename DH::active_cell_iterator
+    typename DoFHandlerType::active_cell_iterator
     cell = dof_handler.begin_active(),
     endc = dof_handler.end();
     for (; cell!=endc; ++cell)
@@ -1392,10 +1394,10 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  count_dofs_with_subdomain_association (const DH           &dof_handler,
-                                         const types::subdomain_id subdomain,
+  count_dofs_with_subdomain_association (const DoFHandlerType      &dof_handler,
+                                         const types::subdomain_id  subdomain,
                                          std::vector<unsigned int> &n_dofs_on_subdomain)
   {
     Assert (n_dofs_on_subdomain.size() == dof_handler.get_fe().n_components(),
@@ -1408,7 +1410,8 @@ namespace DoFTools
 #ifdef DEBUG
     {
       bool found = false;
-      for (typename Triangulation<DH::dimension,DH::space_dimension>::active_cell_iterator
+      for (typename Triangulation<DoFHandlerType::dimension,
+           DoFHandlerType::space_dimension>::active_cell_iterator
            cell=dof_handler.get_tria().begin_active();
            cell!=dof_handler.get_tria().end(); ++cell)
         if (cell->subdomain_id() == subdomain)
@@ -1550,13 +1553,12 @@ namespace DoFTools
     }
   }
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  count_dofs_per_component (
-    const DH      &dof_handler,
-    std::vector<types::global_dof_index> &dofs_per_component,
-    bool only_once,
-    std::vector<unsigned int>  target_component)
+  count_dofs_per_component (const DoFHandlerType                 &dof_handler,
+                            std::vector<types::global_dof_index> &dofs_per_component,
+                            bool                                  only_once,
+                            std::vector<unsigned int>             target_component)
   {
     const unsigned int n_components = dof_handler.get_fe().n_components();
 
@@ -1619,8 +1621,8 @@ namespace DoFTools
 
     // reduce information from all CPUs
 #ifdef DEAL_II_WITH_MPI
-    const unsigned int dim = DH::dimension;
-    const unsigned int spacedim = DH::space_dimension;
+    const unsigned int dim = DoFHandlerType::dimension;
+    const unsigned int spacedim = DoFHandlerType::space_dimension;
 
     if (const parallel::Triangulation<dim,spacedim> *tria
         = (dynamic_cast<const parallel::Triangulation<dim,spacedim>*>
@@ -1637,21 +1639,21 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  count_dofs_per_block (const DH &dof_handler,
+  count_dofs_per_block (const DoFHandlerType                 &dof_handler,
                         std::vector<types::global_dof_index> &dofs_per_block,
-                        const std::vector<unsigned int>  &target_block_)
+                        const std::vector<unsigned int>      &target_block_)
   {
     std::vector<unsigned int>  target_block = target_block_;
 
-    const dealii::hp::FECollection<DH::dimension,DH::space_dimension>
+    const dealii::hp::FECollection<DoFHandlerType::dimension,DoFHandlerType::space_dimension>
     fe_collection (dof_handler.get_fe());
     Assert (fe_collection.size() < 256, ExcNotImplemented());
 
     for (unsigned int this_fe=0; this_fe<fe_collection.size(); ++this_fe)
       {
-        const FiniteElement<DH::dimension,DH::space_dimension> &fe = fe_collection[this_fe];
+        const FiniteElement<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe = fe_collection[this_fe];
         std::fill (dofs_per_block.begin(), dofs_per_block.end(),
                    types::global_dof_index(0));
 
@@ -1700,8 +1702,8 @@ namespace DoFTools
 #ifdef DEAL_II_WITH_MPI
         // if we are working on a parallel mesh, we now need to collect
         // this information from all processors
-        if (const parallel::Triangulation<DH::dimension,DH::space_dimension> *tria
-            = (dynamic_cast<const parallel::Triangulation<DH::dimension,DH::space_dimension>*>
+        if (const parallel::Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> *tria
+            = (dynamic_cast<const parallel::Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension>*>
                (&dof_handler.get_tria())))
           {
             std::vector<types::global_dof_index> local_dof_count = dofs_per_block;
@@ -1716,14 +1718,14 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  map_dof_to_boundary_indices (const DH                  &dof_handler,
+  map_dof_to_boundary_indices (const DoFHandlerType &dof_handler,
                                std::vector<types::global_dof_index> &mapping)
   {
     mapping.clear ();
     mapping.insert (mapping.end(), dof_handler.n_dofs(),
-                    DH::invalid_dof_index);
+                    DoFHandlerType::invalid_dof_index);
 
     std::vector<types::global_dof_index> dofs_on_face;
     dofs_on_face.reserve (max_dofs_per_face(dof_handler));
@@ -1735,10 +1737,10 @@ namespace DoFTools
     // do not support boundaries of dimension dim-2, and so every isolated
     // boundary line is also part of a boundary face which we will be
     // visiting sooner or later
-    typename DH::active_cell_iterator cell = dof_handler.begin_active(),
-                                      endc = dof_handler.end();
+    typename DoFHandlerType::active_cell_iterator cell = dof_handler.begin_active(),
+                                                  endc = dof_handler.end();
     for (; cell!=endc; ++cell)
-      for (unsigned int f=0; f<GeometryInfo<DH::dimension>::faces_per_cell; ++f)
+      for (unsigned int f=0; f<GeometryInfo<DoFHandlerType::dimension>::faces_per_cell; ++f)
         if (cell->at_boundary(f))
           {
             const unsigned int dofs_per_face = cell->get_fe().dofs_per_face;
@@ -1746,7 +1748,7 @@ namespace DoFTools
             cell->face(f)->get_dof_indices (dofs_on_face,
                                             cell->active_fe_index());
             for (unsigned int i=0; i<dofs_per_face; ++i)
-              if (mapping[dofs_on_face[i]] == DH::invalid_dof_index)
+              if (mapping[dofs_on_face[i]] == DoFHandlerType::invalid_dof_index)
                 mapping[dofs_on_face[i]] = next_boundary_index++;
           }
 
@@ -1755,18 +1757,18 @@ namespace DoFTools
 
 
 
-  template <class DH>
-  void map_dof_to_boundary_indices (
-    const DH                      &dof_handler,
-    const std::set<types::boundary_id> &boundary_ids,
-    std::vector<types::global_dof_index>     &mapping)
+  template <typename DoFHandlerType>
+  void map_dof_to_boundary_indices
+  (const DoFHandlerType                 &dof_handler,
+   const std::set<types::boundary_id>   &boundary_ids,
+   std::vector<types::global_dof_index> &mapping)
   {
     Assert (boundary_ids.find (numbers::internal_face_boundary_id) == boundary_ids.end(),
             ExcInvalidBoundaryIndicator());
 
     mapping.clear ();
     mapping.insert (mapping.end(), dof_handler.n_dofs(),
-                    DH::invalid_dof_index);
+                    DoFHandlerType::invalid_dof_index);
 
     // return if there is nothing to do
     if (boundary_ids.size() == 0)
@@ -1776,10 +1778,10 @@ namespace DoFTools
     dofs_on_face.reserve (max_dofs_per_face(dof_handler));
     types::global_dof_index next_boundary_index = 0;
 
-    typename DH::active_cell_iterator cell = dof_handler.begin_active(),
-                                      endc = dof_handler.end();
+    typename DoFHandlerType::active_cell_iterator cell = dof_handler.begin_active(),
+                                                  endc = dof_handler.end();
     for (; cell!=endc; ++cell)
-      for (unsigned int f=0; f<GeometryInfo<DH::dimension>::faces_per_cell; ++f)
+      for (unsigned int f=0; f<GeometryInfo<DoFHandlerType::dimension>::faces_per_cell; ++f)
         if (boundary_ids.find (cell->face(f)->boundary_id()) !=
             boundary_ids.end())
           {
@@ -1787,7 +1789,7 @@ namespace DoFTools
             dofs_on_face.resize (dofs_per_face);
             cell->face(f)->get_dof_indices (dofs_on_face, cell->active_fe_index());
             for (unsigned int i=0; i<dofs_per_face; ++i)
-              if (mapping[dofs_on_face[i]] == DH::invalid_dof_index)
+              if (mapping[dofs_on_face[i]] == DoFHandlerType::invalid_dof_index)
                 mapping[dofs_on_face[i]] = next_boundary_index++;
           }
 
@@ -1799,14 +1801,15 @@ namespace DoFTools
   {
     namespace
     {
-      template <class DH>
+      template <typename DoFHandlerType>
       void
-      map_dofs_to_support_points(const hp::MappingCollection<DH::dimension, DH::space_dimension> &mapping,
-                                 const DH &dof_handler,
-                                 std::map<types::global_dof_index,Point<DH::space_dimension> >  &support_points)
+      map_dofs_to_support_points
+      (const hp::MappingCollection<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &mapping,
+       const DoFHandlerType                                                      &dof_handler,
+       std::map<types::global_dof_index,Point<DoFHandlerType::space_dimension> > &support_points)
       {
-        const unsigned int dim = DH::dimension;
-        const unsigned int spacedim = DH::space_dimension;
+        const unsigned int dim = DoFHandlerType::dimension;
+        const unsigned int spacedim = DoFHandlerType::space_dimension;
 
         hp::FECollection<dim, spacedim> fe_collection(dof_handler.get_fe());
         hp::QCollection<dim> q_coll_dummy;
@@ -1830,7 +1833,7 @@ namespace DoFTools
         // values by the used constructor.
         hp::FEValues<dim, spacedim> hp_fe_values(mapping, fe_collection,
                                                  q_coll_dummy, update_quadrature_points);
-        typename DH::active_cell_iterator cell =
+        typename DoFHandlerType::active_cell_iterator cell =
           dof_handler.begin_active(), endc = dof_handler.end();
 
         std::vector<types::global_dof_index> local_dof_indices;
@@ -1853,14 +1856,15 @@ namespace DoFTools
       }
 
 
-      template <class DH>
+      template <typename DoFHandlerType>
       void
-      map_dofs_to_support_points(const hp::MappingCollection<DH::dimension, DH::space_dimension> &mapping,
-                                 const DH  &dof_handler,
-                                 std::vector<Point<DH::space_dimension> >  &support_points)
+      map_dofs_to_support_points
+      (const hp::MappingCollection<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &mapping,
+       const DoFHandlerType                                 &dof_handler,
+       std::vector<Point<DoFHandlerType::space_dimension> > &support_points)
       {
         // get the data in the form of the map as above
-        std::map<types::global_dof_index,Point<DH::space_dimension> >  x_support_points;
+        std::map<types::global_dof_index,Point<DoFHandlerType::space_dimension> >  x_support_points;
         map_dofs_to_support_points(mapping, dof_handler, x_support_points);
 
         // now convert from the map to the linear vector. make sure every
@@ -1877,9 +1881,9 @@ namespace DoFTools
 
   template <int dim, int spacedim>
   void
-  map_dofs_to_support_points (const Mapping<dim,spacedim>       &mapping,
-                              const DoFHandler<dim,spacedim>    &dof_handler,
-                              std::vector<Point<spacedim> > &support_points)
+  map_dofs_to_support_points (const Mapping<dim,spacedim>    &mapping,
+                              const DoFHandler<dim,spacedim> &dof_handler,
+                              std::vector<Point<spacedim> >  &support_points)
   {
     AssertDimension(support_points.size(), dof_handler.n_dofs());
     Assert ((dynamic_cast<const parallel::distributed::Triangulation<dim,spacedim>*>
@@ -1902,8 +1906,8 @@ namespace DoFTools
   template<int dim, int spacedim>
   void
   map_dofs_to_support_points(const hp::MappingCollection<dim, spacedim> &mapping,
-                             const hp::DoFHandler<dim, spacedim> &dof_handler,
-                             std::vector<Point<spacedim> > &support_points)
+                             const hp::DoFHandler<dim, spacedim>        &dof_handler,
+                             std::vector<Point<spacedim> >              &support_points)
   {
     AssertDimension(support_points.size(), dof_handler.n_dofs());
     Assert ((dynamic_cast<const parallel::distributed::Triangulation<dim,spacedim>*>
@@ -1923,8 +1927,8 @@ namespace DoFTools
 
   template <int dim, int spacedim>
   void
-  map_dofs_to_support_points (const Mapping<dim,spacedim>       &mapping,
-                              const DoFHandler<dim,spacedim>    &dof_handler,
+  map_dofs_to_support_points (const Mapping<dim,spacedim>    &mapping,
+                              const DoFHandler<dim,spacedim> &dof_handler,
                               std::map<types::global_dof_index, Point<spacedim> > &support_points)
   {
     support_points.clear();
@@ -1942,7 +1946,7 @@ namespace DoFTools
   template<int dim, int spacedim>
   void
   map_dofs_to_support_points(const hp::MappingCollection<dim, spacedim> &mapping,
-                             const hp::DoFHandler<dim, spacedim> &dof_handler,
+                             const hp::DoFHandler<dim, spacedim>        &dof_handler,
                              std::map<types::global_dof_index, Point<spacedim> > &support_points)
   {
     support_points.clear();
@@ -1957,10 +1961,10 @@ namespace DoFTools
 
   template<int dim, int spacedim>
   void
-  convert_couplings_to_blocks (
-    const DoFHandler<dim,spacedim> &dof_handler,
-    const Table<2, Coupling> &table,
-    std::vector<Table<2,Coupling> > &tables_by_block)
+  convert_couplings_to_blocks
+  (const DoFHandler<dim,spacedim>  &dof_handler,
+   const Table<2, Coupling>        &table,
+   std::vector<Table<2,Coupling> > &tables_by_block)
   {
     const FiniteElement<dim,spacedim> &fe = dof_handler.get_fe();
     const unsigned int nb = fe.n_blocks();
@@ -1983,10 +1987,9 @@ namespace DoFTools
 
   template<int dim, int spacedim>
   void
-  convert_couplings_to_blocks (
-    const hp::DoFHandler<dim,spacedim> &dof_handler,
-    const Table<2, Coupling> &table,
-    std::vector<Table<2,Coupling> > &tables_by_block)
+  convert_couplings_to_blocks (const hp::DoFHandler<dim,spacedim> &dof_handler,
+                               const Table<2, Coupling>           &table,
+                               std::vector<Table<2,Coupling> >    &tables_by_block)
   {
     const hp::FECollection<dim> &fe_collection = dof_handler.get_fe();
     tables_by_block.resize(fe_collection.size());
@@ -2012,16 +2015,15 @@ namespace DoFTools
 
 
 
-  template <class DH, class Sparsity>
-  void make_cell_patches(
-    Sparsity &block_list,
-    const DH &dof_handler,
-    const unsigned int level,
-    const std::vector<bool> &selected_dofs,
-    types::global_dof_index offset)
+  template <typename DoFHandlerType, class Sparsity>
+  void make_cell_patches(Sparsity                &block_list,
+                         const DoFHandlerType    &dof_handler,
+                         const unsigned int       level,
+                         const std::vector<bool> &selected_dofs,
+                         types::global_dof_index  offset)
   {
-    typename DH::level_cell_iterator cell;
-    typename DH::level_cell_iterator endc = dof_handler.end(level);
+    typename DoFHandlerType::level_cell_iterator cell;
+    typename DoFHandlerType::level_cell_iterator endc = dof_handler.end(level);
     std::vector<types::global_dof_index> indices;
 
     unsigned int i=0;
@@ -2047,17 +2049,16 @@ namespace DoFTools
   }
 
 
-  template <class DH>
-  void make_single_patch(
-    SparsityPattern &block_list,
-    const DH &dof_handler,
-    const unsigned int level,
-    const bool interior_only)
+  template <typename DoFHandlerType>
+  void make_single_patch(SparsityPattern      &block_list,
+                         const DoFHandlerType &dof_handler,
+                         const unsigned int    level,
+                         const bool            interior_only)
   {
-    const FiniteElement<DH::dimension> &fe = dof_handler.get_fe();
+    const FiniteElement<DoFHandlerType::dimension> &fe = dof_handler.get_fe();
     block_list.reinit(1, dof_handler.n_dofs(level), dof_handler.n_dofs(level));
-    typename DH::level_cell_iterator cell;
-    typename DH::level_cell_iterator endc = dof_handler.end(level);
+    typename DoFHandlerType::level_cell_iterator cell;
+    typename DoFHandlerType::level_cell_iterator endc = dof_handler.end(level);
 
     std::vector<types::global_dof_index> indices;
     std::vector<bool> exclude;
@@ -2074,7 +2075,7 @@ namespace DoFTools
             std::fill(exclude.begin(), exclude.end(), false);
             const unsigned int dpf = fe.dofs_per_face;
 
-            for (unsigned int face=0; face<GeometryInfo<DH::dimension>::faces_per_cell; ++face)
+            for (unsigned int face=0; face<GeometryInfo<DoFHandlerType::dimension>::faces_per_cell; ++face)
               if (cell->at_boundary(face) || cell->neighbor(face)->level() != cell->level())
                 for (unsigned int i=0; i<dpf; ++i)
                   exclude[fe.face_to_cell_index(i,face)] = true;
@@ -2091,19 +2092,18 @@ namespace DoFTools
   }
 
 
-  template <class DH>
-  void make_child_patches(
-    SparsityPattern &block_list,
-    const DH &dof_handler,
-    const unsigned int level,
-    const bool interior_dofs_only,
-    const bool boundary_dofs)
+  template <typename DoFHandlerType>
+  void make_child_patches (SparsityPattern      &block_list,
+                           const DoFHandlerType &dof_handler,
+                           const unsigned int    level,
+                           const bool            interior_dofs_only,
+                           const bool            boundary_dofs)
   {
     Assert(level > 0 && level < dof_handler.get_tria().n_levels(),
            ExcIndexRange(level, 1, dof_handler.get_tria().n_levels()));
 
-    typename DH::level_cell_iterator pcell = dof_handler.begin(level-1);
-    typename DH::level_cell_iterator endc = dof_handler.end(level-1);
+    typename DoFHandlerType::level_cell_iterator pcell = dof_handler.begin(level-1);
+    typename DoFHandlerType::level_cell_iterator endc = dof_handler.end(level-1);
 
     std::vector<types::global_dof_index> indices;
     std::vector<bool> exclude;
@@ -2115,10 +2115,10 @@ namespace DoFTools
 
         for (unsigned int child=0; child<pcell->n_children(); ++child)
           {
-            const typename DH::level_cell_iterator cell = pcell->child(child);
+            const typename DoFHandlerType::level_cell_iterator cell = pcell->child(child);
 
             // For hp, only this line here would have to be replaced.
-            const FiniteElement<DH::dimension> &fe = dof_handler.get_fe();
+            const FiniteElement<DoFHandlerType::dimension> &fe = dof_handler.get_fe();
             const unsigned int n_dofs = fe.dofs_per_cell;
             indices.resize(n_dofs);
             exclude.resize(n_dofs);
@@ -2131,9 +2131,9 @@ namespace DoFTools
                 // of the parent
                 const unsigned int dpf = fe.dofs_per_face;
 
-                for (unsigned int d=0; d<DH::dimension; ++d)
+                for (unsigned int d=0; d<DoFHandlerType::dimension; ++d)
                   {
-                    const unsigned int face = GeometryInfo<DH::dimension>::vertex_to_face[child][d];
+                    const unsigned int face = GeometryInfo<DoFHandlerType::dimension>::vertex_to_face[child][d];
                     for (unsigned int i=0; i<dpf; ++i)
                       exclude[fe.face_to_cell_index(i,face)] = true;
                   }
@@ -2141,7 +2141,7 @@ namespace DoFTools
                 // Now remove all degrees of freedom on the domain boundary
                 // from the exclusion list
                 if (boundary_dofs)
-                  for (unsigned int face=0; face< GeometryInfo<DH::dimension>::faces_per_cell; ++face)
+                  for (unsigned int face=0; face< GeometryInfo<DoFHandlerType::dimension>::faces_per_cell; ++face)
                     if (cell->at_boundary(face))
                       for (unsigned int i=0; i<dpf; ++i)
                         exclude[fe.face_to_cell_index(i,face)] = false;
@@ -2157,18 +2157,17 @@ namespace DoFTools
 
 
 
-  template <class DH>
-  void make_vertex_patches(
-    SparsityPattern &block_list,
-    const DH &dof_handler,
-    const unsigned int level,
-    const bool interior_only,
-    const bool boundary_patches,
-    const bool level_boundary_patches,
-    const bool single_cell_patches)
+  template <typename DoFHandlerType>
+  void make_vertex_patches (SparsityPattern       &block_list,
+                            const DoFHandlerType &dof_handler,
+                            const unsigned int    level,
+                            const bool            interior_only,
+                            const bool            boundary_patches,
+                            const bool            level_boundary_patches,
+                            const bool            single_cell_patches)
   {
-    typename DH::level_cell_iterator cell;
-    typename DH::level_cell_iterator endc = dof_handler.end(level);
+    typename DoFHandlerType::level_cell_iterator cell;
+    typename DoFHandlerType::level_cell_iterator endc = dof_handler.end(level);
 
     // Vector mapping from vertex index in the triangulation to consecutive
     // block indices on this level The number of cells at a vertex
@@ -2186,14 +2185,14 @@ namespace DoFTools
     // Identify all vertices active on this level and remember some data
     // about them
     for (cell=dof_handler.begin(level); cell != endc; ++cell)
-      for (unsigned int v=0; v<GeometryInfo<DH::dimension>::vertices_per_cell; ++v)
+      for (unsigned int v=0; v<GeometryInfo<DoFHandlerType::dimension>::vertices_per_cell; ++v)
         {
           const unsigned int vg = cell->vertex_index(v);
           vertex_dof_count[vg] += cell->get_fe().dofs_per_cell;
           ++vertex_cell_count[vg];
-          for (unsigned int d=0; d<DH::dimension; ++d)
+          for (unsigned int d=0; d<DoFHandlerType::dimension; ++d)
             {
-              const unsigned int face = GeometryInfo<DH::dimension>::vertex_to_face[v][d];
+              const unsigned int face = GeometryInfo<DoFHandlerType::dimension>::vertex_to_face[v][d];
               if (cell->at_boundary(face))
                 vertex_boundary[vg] = true;
               else if ((!level_boundary_patches)
@@ -2234,11 +2233,11 @@ namespace DoFTools
 
     for (cell=dof_handler.begin(level); cell != endc; ++cell)
       {
-        const FiniteElement<DH::dimension> &fe = cell->get_fe();
+        const FiniteElement<DoFHandlerType::dimension> &fe = cell->get_fe();
         indices.resize(fe.dofs_per_cell);
         cell->get_mg_dof_indices(indices);
 
-        for (unsigned int v=0; v<GeometryInfo<DH::dimension>::vertices_per_cell; ++v)
+        for (unsigned int v=0; v<GeometryInfo<DoFHandlerType::dimension>::vertices_per_cell; ++v)
           {
             const unsigned int vg = cell->vertex_index(v);
             const unsigned int block = vertex_mapping[vg];
@@ -2253,10 +2252,10 @@ namespace DoFTools
                 std::fill(exclude.begin(), exclude.end(), false);
                 const unsigned int dpf = fe.dofs_per_face;
 
-                for (unsigned int d=0; d<DH::dimension; ++d)
+                for (unsigned int d=0; d<DoFHandlerType::dimension; ++d)
                   {
-                    const unsigned int a_face = GeometryInfo<DH::dimension>::vertex_to_face[v][d];
-                    const unsigned int face = GeometryInfo<DH::dimension>::opposite_face[a_face];
+                    const unsigned int a_face = GeometryInfo<DoFHandlerType::dimension>::vertex_to_face[v][d];
+                    const unsigned int face = GeometryInfo<DoFHandlerType::dimension>::opposite_face[a_face];
                     for (unsigned int i=0; i<dpf; ++i)
                       exclude[fe.face_to_cell_index(i,face)] = true;
                   }
@@ -2275,9 +2274,9 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   unsigned int
-  count_dofs_on_patch (const std::vector<typename DH::active_cell_iterator> &patch)
+  count_dofs_on_patch (const std::vector<typename DoFHandlerType::active_cell_iterator> &patch)
   {
     std::set<types::global_dof_index> dofs_on_patch;
     std::vector<types::global_dof_index> local_dof_indices;
@@ -2287,7 +2286,7 @@ namespace DoFTools
     // all duplicates are ignored
     for (unsigned int i=0; i<patch.size(); ++i)
       {
-        const typename DH::active_cell_iterator cell = patch[i];
+        const typename DoFHandlerType::active_cell_iterator cell = patch[i];
         Assert (cell->is_artificial() == false,
                 ExcMessage("This function can not be called with cells that are "
                            "not either locally owned or ghost cells."));
@@ -2303,9 +2302,9 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   std::vector<types::global_dof_index>
-  get_dofs_on_patch (const std::vector<typename DH::active_cell_iterator> &patch)
+  get_dofs_on_patch (const std::vector<typename DoFHandlerType::active_cell_iterator> &patch)
   {
     std::set<types::global_dof_index> dofs_on_patch;
     std::vector<types::global_dof_index> local_dof_indices;
@@ -2315,7 +2314,7 @@ namespace DoFTools
     // all duplicates are ignored
     for (unsigned int i=0; i<patch.size(); ++i)
       {
-        const typename DH::active_cell_iterator cell = patch[i];
+        const typename DoFHandlerType::active_cell_iterator cell = patch[i];
         Assert (cell->is_artificial() == false,
                 ExcMessage("This function can not be called with cells that are "
                            "not either locally owned or ghost cells."));
@@ -2325,7 +2324,7 @@ namespace DoFTools
                               local_dof_indices.end());
       }
 
-    Assert (dofs_on_patch.size() == count_dofs_on_patch<DH>(patch),
+    Assert (dofs_on_patch.size() == count_dofs_on_patch<DoFHandlerType>(patch),
             ExcInternalError());
 
     // return a vector with the content of the set above. copying
diff --git a/source/dofs/dof_tools_constraints.cc b/source/dofs/dof_tools_constraints.cc
index f76dbee3fb..7936224ff9 100644
--- a/source/dofs/dof_tools_constraints.cc
+++ b/source/dofs/dof_tools_constraints.cc
@@ -460,9 +460,9 @@ namespace DoFTools
       }
 
 
-      template <class DH>
+      template <typename DoFHandlerType>
       unsigned int
-      n_finite_elements (const DH &)
+      n_finite_elements (const DoFHandlerType &)
       {
         return 1;
       }
@@ -667,15 +667,15 @@ namespace DoFTools
 
 
 
-    template <class DH>
+    template <typename DoFHandlerType>
     void
-    make_oldstyle_hanging_node_constraints (const DH         &dof_handler,
-                                            ConstraintMatrix &constraints,
+    make_oldstyle_hanging_node_constraints (const DoFHandlerType &dof_handler,
+                                            ConstraintMatrix     &constraints,
                                             dealii::internal::int2type<2>)
     {
       const unsigned int dim = 2;
 
-      const unsigned int spacedim = DH::space_dimension;
+      const unsigned int spacedim = DoFHandlerType::space_dimension;
 
       std::vector<types::global_dof_index> dofs_on_mother;
       std::vector<types::global_dof_index> dofs_on_children;
@@ -689,8 +689,8 @@ namespace DoFTools
       // note that even though we may visit a face twice if the neighboring
       // cells are equally refined, we can only visit each face with
       // hanging nodes once
-      typename DH::active_cell_iterator cell = dof_handler.begin_active(),
-                                        endc = dof_handler.end();
+      typename DoFHandlerType::active_cell_iterator cell = dof_handler.begin_active(),
+                                                    endc = dof_handler.end();
       for (; cell!=endc; ++cell)
         {
           // artificial cells can at best neighbor ghost cells, but we're not
@@ -744,7 +744,7 @@ namespace DoFTools
                        ExcDimensionMismatch(n_dofs_on_children,
                                             fe.constraints().m()));
 
-                const typename DH::line_iterator this_face = cell->face(face);
+                const typename DoFHandlerType::line_iterator this_face = cell->face(face);
 
                 // fill the dofs indices. Use same enumeration scheme as in
                 // @p{FiniteElement::constraints()}
@@ -805,10 +805,10 @@ namespace DoFTools
 
 
 
-    template <class DH>
+    template <typename DoFHandlerType>
     void
-    make_oldstyle_hanging_node_constraints (const DH         &dof_handler,
-                                            ConstraintMatrix &constraints,
+    make_oldstyle_hanging_node_constraints (const DoFHandlerType &dof_handler,
+                                            ConstraintMatrix     &constraints,
                                             dealii::internal::int2type<3>)
     {
       const unsigned int dim = 3;
@@ -825,8 +825,8 @@ namespace DoFTools
       // note that even though we may visit a face twice if the neighboring
       // cells are equally refined, we can only visit each face with
       // hanging nodes once
-      typename DH::active_cell_iterator cell = dof_handler.begin_active(),
-                                        endc = dof_handler.end();
+      typename DoFHandlerType::active_cell_iterator cell = dof_handler.begin_active(),
+                                                    endc = dof_handler.end();
       for (; cell!=endc; ++cell)
         {
           // artificial cells can at best neighbor ghost cells, but we're not
@@ -911,7 +911,7 @@ namespace DoFTools
                        ExcDimensionMismatch(n_dofs_on_children,
                                             fe.constraints().m()));
 
-                const typename DH::face_iterator this_face = cell->face(face);
+                const typename DoFHandlerType::face_iterator this_face = cell->face(face);
 
                 // fill the dofs indices. Use same enumeration scheme as in
                 // @p{FiniteElement::constraints()}
@@ -1045,19 +1045,19 @@ namespace DoFTools
     }
 
 
-    template <class DH>
+    template <typename DoFHandlerType>
     void
-    make_hp_hanging_node_constraints (const DH         &dof_handler,
-                                      ConstraintMatrix &constraints)
+    make_hp_hanging_node_constraints (const DoFHandlerType &dof_handler,
+                                      ConstraintMatrix     &constraints)
     {
       // note: this function is going to be hard to understand if you
       // haven't read the hp paper. however, we try to follow the notation
       // laid out there, so go read the paper before you try to understand
       // what is going on here
 
-      const unsigned int dim = DH::dimension;
+      const unsigned int dim = DoFHandlerType::dimension;
 
-      const unsigned int spacedim = DH::space_dimension;
+      const unsigned int spacedim = DoFHandlerType::space_dimension;
 
 
       // a matrix to be used for constraints below. declared here and
@@ -1103,8 +1103,8 @@ namespace DoFTools
       // note that even though we may visit a face twice if the neighboring
       // cells are equally refined, we can only visit each face with
       // hanging nodes once
-      typename DH::active_cell_iterator cell = dof_handler.begin_active(),
-                                        endc = dof_handler.end();
+      typename DoFHandlerType::active_cell_iterator cell = dof_handler.begin_active(),
+                                                    endc = dof_handler.end();
       for (; cell!=endc; ++cell)
         {
           // artificial cells can at best neighbor ghost cells, but we're not
@@ -1157,7 +1157,7 @@ namespace DoFTools
                 std::set<unsigned int> fe_ind_face_subface;
                 fe_ind_face_subface.insert(cell->active_fe_index());
 
-                if (DoFHandlerSupportsDifferentFEs<DH>::value == true)
+                if (DoFHandlerSupportsDifferentFEs<DoFHandlerType>::value == true)
                   for (unsigned int c=0; c<cell->face(face)->number_of_children(); ++c)
                     if (!cell->neighbor_child_on_subface (face, c)->is_artificial())
                       {
@@ -1193,7 +1193,7 @@ namespace DoFTools
                         if (cell->neighbor_child_on_subface (face, c)->is_artificial())
                           continue;
 
-                        const typename DH::active_face_iterator
+                        const typename DoFHandlerType::active_face_iterator
                         subface = cell->face(face)->child(c);
 
                         Assert (subface->n_active_fe_indices() == 1,
@@ -1277,7 +1277,7 @@ namespace DoFTools
                     //
                     // since this is something that can only happen for hp
                     // dof handlers, add a check here...
-                    Assert (DoFHandlerSupportsDifferentFEs<DH>::value == true,
+                    Assert (DoFHandlerSupportsDifferentFEs<DoFHandlerType>::value == true,
                             ExcInternalError());
 
                     const dealii::hp::FECollection<dim,spacedim> &fe_collection =
@@ -1473,7 +1473,7 @@ namespace DoFTools
                 // Only if there is a neighbor with a different
                 // active_fe_index and the same h-level, some action has to
                 // be taken.
-                if ((DoFHandlerSupportsDifferentFEs<DH>::value == true)
+                if ((DoFHandlerSupportsDifferentFEs<DoFHandlerType>::value == true)
                     &&
                     !cell->face(face)->at_boundary ()
                     &&
@@ -1483,7 +1483,7 @@ namespace DoFTools
                     (!cell->face(face)->has_children() &&
                      !cell->neighbor_is_coarser(face) ))
                   {
-                    const typename DH::level_cell_iterator neighbor = cell->neighbor (face);
+                    const typename DoFHandlerType::level_cell_iterator neighbor = cell->neighbor (face);
 
                     // see which side of the face we have to constrain
                     switch (cell->get_fe().compare_for_face_domination (neighbor->get_fe ()))
@@ -1725,10 +1725,10 @@ namespace DoFTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  make_hanging_node_constraints (const DH &dof_handler,
-                                 ConstraintMatrix &constraints)
+  make_hanging_node_constraints (const DoFHandlerType &dof_handler,
+                                 ConstraintMatrix     &constraints)
   {
     // Decide whether to use the new or old make_hanging_node_constraints
     // function. If all the FiniteElement or all elements in a FECollection
@@ -1742,7 +1742,7 @@ namespace DoFTools
       internal::
       make_oldstyle_hanging_node_constraints (dof_handler,
                                               constraints,
-                                              dealii::internal::int2type<DH::dimension>());
+                                              dealii::internal::int2type<DoFHandlerType::dimension>());
   }
 
 
@@ -2382,16 +2382,16 @@ namespace DoFTools
 
 
 
-  template<typename DH>
+  template<typename DoFHandlerType>
   void
   make_periodicity_constraints
-  (const std::vector<GridTools::PeriodicFacePair<typename DH::cell_iterator> >
+  (const std::vector<GridTools::PeriodicFacePair<typename DoFHandlerType::cell_iterator> >
    &periodic_faces,
    dealii::ConstraintMatrix        &constraint_matrix,
    const ComponentMask             &component_mask,
    const std::vector<unsigned int> &first_vector_components)
   {
-    typedef std::vector<GridTools::PeriodicFacePair<typename DH::cell_iterator> >
+    typedef std::vector<GridTools::PeriodicFacePair<typename DoFHandlerType::cell_iterator> >
     FaceVector;
     typename FaceVector::const_iterator it, end_periodic;
     it = periodic_faces.begin();
@@ -2400,7 +2400,7 @@ namespace DoFTools
     // Loop over all periodic faces...
     for (; it!=end_periodic; ++it)
       {
-        typedef typename DH::face_iterator FaceIterator;
+        typedef typename DoFHandlerType::face_iterator FaceIterator;
         const FaceIterator face_1 = it->cell[0]->face(it->face_idx[0]);
         const FaceIterator face_2 = it->cell[1]->face(it->face_idx[1]);
 
@@ -2428,16 +2428,16 @@ namespace DoFTools
   // High level interface variants:
 
 
-  template<typename DH>
+  template<typename DoFHandlerType>
   void
-  make_periodicity_constraints (const DH                        &dof_handler,
-                                const types::boundary_id        b_id1,
-                                const types::boundary_id        b_id2,
-                                const int                       direction,
-                                dealii::ConstraintMatrix        &constraint_matrix,
-                                const ComponentMask             &component_mask)
+  make_periodicity_constraints (const DoFHandlerType     &dof_handler,
+                                const types::boundary_id  b_id1,
+                                const types::boundary_id  b_id2,
+                                const int                 direction,
+                                dealii::ConstraintMatrix &constraint_matrix,
+                                const ComponentMask      &component_mask)
   {
-    static const int space_dim = DH::space_dimension;
+    static const int space_dim = DoFHandlerType::space_dimension;
     (void)space_dim;
     Assert (0<=direction && direction<space_dim,
             ExcIndexRange (direction, 0, space_dim));
@@ -2447,28 +2447,28 @@ namespace DoFTools
                         "different to denote different boundaries."));
 
     std::vector<GridTools::PeriodicFacePair
-    <typename DH::cell_iterator> > matched_faces;
+    <typename DoFHandlerType::cell_iterator> > matched_faces;
 
     // Collect matching periodic cells on the coarsest level:
     GridTools::collect_periodic_faces(dof_handler, b_id1, b_id2, direction,
                                       matched_faces);
 
-    make_periodicity_constraints<DH>
+    make_periodicity_constraints<DoFHandlerType>
     (matched_faces, constraint_matrix, component_mask);
   }
 
 
 
-  template<typename DH>
+  template<typename DoFHandlerType>
   void
-  make_periodicity_constraints (const DH                        &dof_handler,
+  make_periodicity_constraints (const DoFHandlerType            &dof_handler,
                                 const types::boundary_id         b_id,
                                 const int                        direction,
                                 dealii::ConstraintMatrix        &constraint_matrix,
                                 const ComponentMask             &component_mask)
   {
-    static const int dim = DH::dimension;
-    static const int space_dim = DH::space_dimension;
+    static const int dim = DoFHandlerType::dimension;
+    static const int space_dim = DoFHandlerType::space_dimension;
     (void)dim;
     (void)space_dim;
 
@@ -2479,13 +2479,13 @@ namespace DoFTools
            ExcNotImplemented());
 
     std::vector<GridTools::PeriodicFacePair
-    <typename DH::cell_iterator> > matched_faces;
+    <typename DoFHandlerType::cell_iterator> > matched_faces;
 
     // Collect matching periodic cells on the coarsest level:
     GridTools::collect_periodic_faces(dof_handler, b_id, direction,
                                       matched_faces);
 
-    make_periodicity_constraints<DH>
+    make_periodicity_constraints<DoFHandlerType>
     (matched_faces, constraint_matrix, component_mask);
   }
 
@@ -3240,12 +3240,12 @@ namespace DoFTools
 
 
 
-  template <int dim, int spacedim, template <int,int> class DH>
+  template <int dim, int spacedim, template <int, int> class DoFHandlerType>
   void
-  make_zero_boundary_constraints (const DH<dim, spacedim> &dof,
-                                  const types::boundary_id boundary_id,
-                                  ConstraintMatrix        &zero_boundary_constraints,
-                                  const ComponentMask     &component_mask)
+  make_zero_boundary_constraints (const DoFHandlerType<dim, spacedim> &dof,
+                                  const types::boundary_id             boundary_id,
+                                  ConstraintMatrix                    &zero_boundary_constraints,
+                                  const ComponentMask                 &component_mask)
   {
     Assert (component_mask.represents_n_components(dof.get_fe().n_components()),
             ExcMessage ("The number of components in the mask has to be either "
@@ -3264,7 +3264,7 @@ namespace DoFTools
     std::vector<types::global_dof_index> cell_dofs;
     cell_dofs.reserve (max_dofs_per_cell(dof));
 
-    typename DH<dim,spacedim>::active_cell_iterator
+    typename DoFHandlerType<dim,spacedim>::active_cell_iterator
     cell = dof.begin_active(),
     endc = dof.end();
     for (; cell!=endc; ++cell)
@@ -3281,7 +3281,7 @@ namespace DoFTools
           for (unsigned int face_no = 0; face_no < GeometryInfo<dim>::faces_per_cell;
                ++face_no)
             {
-              const typename DH<dim,spacedim>::face_iterator face = cell->face(face_no);
+              const typename DoFHandlerType<dim,spacedim>::face_iterator face = cell->face(face_no);
 
               // if face is on the boundary and satisfies the correct
               // boundary id property
@@ -3326,11 +3326,11 @@ namespace DoFTools
 
 
 
-  template <int dim, int spacedim, template <int,int> class DH>
+  template <int dim, int spacedim, template <int, int> class DoFHandlerType>
   void
-  make_zero_boundary_constraints (const DH<dim, spacedim> &dof,
-                                  ConstraintMatrix        &zero_boundary_constraints,
-                                  const ComponentMask     &component_mask)
+  make_zero_boundary_constraints (const DoFHandlerType<dim, spacedim> &dof,
+                                  ConstraintMatrix                    &zero_boundary_constraints,
+                                  const ComponentMask                 &component_mask)
   {
     make_zero_boundary_constraints(dof, numbers::invalid_boundary_id,
                                    zero_boundary_constraints, component_mask);
diff --git a/source/dofs/dof_tools_sparsity.cc b/source/dofs/dof_tools_sparsity.cc
index d5de0b6878..5954bfeba4 100644
--- a/source/dofs/dof_tools_sparsity.cc
+++ b/source/dofs/dof_tools_sparsity.cc
@@ -50,9 +50,9 @@ DEAL_II_NAMESPACE_OPEN
 namespace DoFTools
 {
 
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
-  make_sparsity_pattern (const DH                  &dof,
+  make_sparsity_pattern (const DoFHandlerType      &dof,
                          SP                        &sparsity,
                          const ConstraintMatrix    &constraints,
                          const bool                 keep_constrained_dofs,
@@ -81,8 +81,8 @@ namespace DoFTools
 
     std::vector<types::global_dof_index> dofs_on_this_cell;
     dofs_on_this_cell.reserve (max_dofs_per_cell(dof));
-    typename DH::active_cell_iterator cell = dof.begin_active(),
-                                      endc = dof.end();
+    typename DoFHandlerType::active_cell_iterator cell = dof.begin_active(),
+                                                  endc = dof.end();
 
     // In case we work with a distributed sparsity pattern of Trilinos
     // type, we only have to do the work if the current cell is owned by
@@ -109,9 +109,9 @@ namespace DoFTools
 
 
 
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
-  make_sparsity_pattern (const DH                  &dof,
+  make_sparsity_pattern (const DoFHandlerType      &dof,
                          const Table<2,Coupling>   &couplings,
                          SP                        &sparsity,
                          const ConstraintMatrix    &constraints,
@@ -143,7 +143,7 @@ namespace DoFTools
                   "associated DoF handler objects, asking for any subdomain other "
                   "than the locally owned one does not make sense."));
 
-    const hp::FECollection<DH::dimension,DH::space_dimension> fe_collection (dof.get_fe());
+    const hp::FECollection<DoFHandlerType::dimension,DoFHandlerType::space_dimension> fe_collection (dof.get_fe());
 
     // first, for each finite element, build a mask for each dof, not like
     // the one given which represents components. make sure we do the right
@@ -192,8 +192,8 @@ namespace DoFTools
 
 
     std::vector<types::global_dof_index> dofs_on_this_cell(fe_collection.max_dofs_per_cell());
-    typename DH::active_cell_iterator cell = dof.begin_active(),
-                                      endc = dof.end();
+    typename DoFHandlerType::active_cell_iterator cell = dof.begin_active(),
+                                                  endc = dof.end();
 
     // In case we work with a distributed sparsity pattern of Trilinos
     // type, we only have to do the work if the current cell is owned by
@@ -224,10 +224,10 @@ namespace DoFTools
 
 
 
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
-  make_sparsity_pattern (const DH &dof_row,
-                         const DH &dof_col,
+  make_sparsity_pattern (const DoFHandlerType &dof_row,
+                         const DoFHandlerType &dof_col,
                          SP       &sparsity)
   {
     const types::global_dof_index n_dofs_row = dof_row.n_dofs();
@@ -242,20 +242,20 @@ namespace DoFTools
 
 //TODO: Looks like wasteful memory management here
 
-    const std::list<std::pair<typename DH::cell_iterator,
-          typename DH::cell_iterator> >
+    const std::list<std::pair<typename DoFHandlerType::cell_iterator,
+          typename DoFHandlerType::cell_iterator> >
           cell_list
           = GridTools::get_finest_common_cells (dof_row, dof_col);
 
 
-    typename std::list<std::pair<typename DH::cell_iterator,
-             typename DH::cell_iterator> >::const_iterator
+    typename std::list<std::pair<typename DoFHandlerType::cell_iterator,
+             typename DoFHandlerType::cell_iterator> >::const_iterator
              cell_iter = cell_list.begin();
 
     for (; cell_iter!=cell_list.end(); ++cell_iter)
       {
-        const typename DH::cell_iterator cell_row = cell_iter->first;
-        const typename DH::cell_iterator cell_col = cell_iter->second;
+        const typename DoFHandlerType::cell_iterator cell_row = cell_iter->first;
+        const typename DoFHandlerType::cell_iterator cell_col = cell_iter->second;
 
         if (!cell_row->has_children() && !cell_col->has_children())
           {
@@ -276,11 +276,11 @@ namespace DoFTools
           }
         else if (cell_row->has_children())
           {
-            const std::vector<typename DH::active_cell_iterator >
-            child_cells = GridTools::get_active_child_cells<DH> (cell_row);
+            const std::vector<typename DoFHandlerType::active_cell_iterator >
+            child_cells = GridTools::get_active_child_cells<DoFHandlerType> (cell_row);
             for (unsigned int i=0; i<child_cells.size(); i++)
               {
-                const typename DH::cell_iterator
+                const typename DoFHandlerType::cell_iterator
                 cell_row_child = child_cells[i];
                 const unsigned int dofs_per_cell_row =
                   cell_row_child->get_fe().dofs_per_cell;
@@ -300,11 +300,11 @@ namespace DoFTools
           }
         else
           {
-            std::vector<typename DH::active_cell_iterator>
-            child_cells = GridTools::get_active_child_cells<DH> (cell_col);
+            std::vector<typename DoFHandlerType::active_cell_iterator>
+            child_cells = GridTools::get_active_child_cells<DoFHandlerType> (cell_col);
             for (unsigned int i=0; i<child_cells.size(); i++)
               {
-                const typename DH::active_cell_iterator
+                const typename DoFHandlerType::active_cell_iterator
                 cell_col_child = child_cells[i];
                 const unsigned int dofs_per_cell_row =
                   cell_row->get_fe().dofs_per_cell;
@@ -327,24 +327,24 @@ namespace DoFTools
 
 
 
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
   make_boundary_sparsity_pattern
-  (const DH                                   &dof,
+  (const DoFHandlerType                       &dof,
    const std::vector<types::global_dof_index> &dof_to_boundary_mapping,
    SP                                         &sparsity)
   {
-    if (DH::dimension == 1)
+    if (DoFHandlerType::dimension == 1)
       {
         // there are only 2 boundary indicators in 1d, so it is no
         // performance problem to call the other function
-        typename DH::FunctionMap boundary_ids;
+        typename DoFHandlerType::FunctionMap boundary_ids;
         boundary_ids[0] = 0;
         boundary_ids[1] = 0;
-        make_boundary_sparsity_pattern<DH, SP> (dof,
-                                                boundary_ids,
-                                                dof_to_boundary_mapping,
-                                                sparsity);
+        make_boundary_sparsity_pattern<DoFHandlerType, SP> (dof,
+                                                            boundary_ids,
+                                                            dof_to_boundary_mapping,
+                                                            sparsity);
         return;
       }
 
@@ -360,7 +360,7 @@ namespace DoFTools
         types::global_dof_index max_element = 0;
         for (std::vector<types::global_dof_index>::const_iterator i=dof_to_boundary_mapping.begin();
              i!=dof_to_boundary_mapping.end(); ++i)
-          if ((*i != DH::invalid_dof_index) &&
+          if ((*i != DoFHandlerType::invalid_dof_index) &&
               (*i > max_element))
             max_element = *i;
         AssertDimension (max_element, sparsity.n_rows()-1);
@@ -375,10 +375,10 @@ namespace DoFTools
     // @p{cell->has_boundary_lines}), since we do not support boundaries of
     // dimension dim-2, and so every boundary line is also part of a
     // boundary face.
-    typename DH::active_cell_iterator cell = dof.begin_active(),
-                                      endc = dof.end();
+    typename DoFHandlerType::active_cell_iterator cell = dof.begin_active(),
+                                                  endc = dof.end();
     for (; cell!=endc; ++cell)
-      for (unsigned int f=0; f<GeometryInfo<DH::dimension>::faces_per_cell; ++f)
+      for (unsigned int f=0; f<GeometryInfo<DoFHandlerType::dimension>::faces_per_cell; ++f)
         if (cell->at_boundary(f))
           {
             const unsigned int dofs_per_face = cell->get_fe().dofs_per_face;
@@ -396,14 +396,14 @@ namespace DoFTools
 
 
 
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void make_boundary_sparsity_pattern
-  (const DH                                              &dof,
-   const typename FunctionMap<DH::space_dimension>::type &boundary_ids,
+  (const DoFHandlerType                                  &dof,
+   const typename FunctionMap<DoFHandlerType::space_dimension>::type &boundary_ids,
    const std::vector<types::global_dof_index>            &dof_to_boundary_mapping,
    SP                                                    &sparsity)
   {
-    if (DH::dimension == 1)
+    if (DoFHandlerType::dimension == 1)
       {
         // first check left, then right boundary point
         for (unsigned int direction=0; direction<2; ++direction)
@@ -415,7 +415,7 @@ namespace DoFTools
 
             // find active cell at that boundary: first go to left/right,
             // then to children
-            typename DH::level_cell_iterator cell = dof.begin(0);
+            typename DoFHandlerType::level_cell_iterator cell = dof.begin(0);
             while (!cell->at_boundary(direction))
               cell = cell->neighbor(direction);
             while (!cell->active())
@@ -442,7 +442,7 @@ namespace DoFTools
 
     AssertDimension (dof_to_boundary_mapping.size(), n_dofs);
     Assert (boundary_ids.find(numbers::internal_face_boundary_id) == boundary_ids.end(),
-            typename DH::ExcInvalidBoundaryIndicator());
+            typename DoFHandlerType::ExcInvalidBoundaryIndicator());
     Assert (sparsity.n_rows() == dof.n_boundary_dofs (boundary_ids),
             ExcDimensionMismatch (sparsity.n_rows(), dof.n_boundary_dofs (boundary_ids)));
     Assert (sparsity.n_cols() == dof.n_boundary_dofs (boundary_ids),
@@ -453,7 +453,7 @@ namespace DoFTools
         types::global_dof_index max_element = 0;
         for (std::vector<types::global_dof_index>::const_iterator i=dof_to_boundary_mapping.begin();
              i!=dof_to_boundary_mapping.end(); ++i)
-          if ((*i != DH::invalid_dof_index) &&
+          if ((*i != DoFHandlerType::invalid_dof_index) &&
               (*i > max_element))
             max_element = *i;
         AssertDimension (max_element, sparsity.n_rows()-1);
@@ -462,10 +462,10 @@ namespace DoFTools
 
     std::vector<types::global_dof_index> dofs_on_this_face;
     dofs_on_this_face.reserve (max_dofs_per_face(dof));
-    typename DH::active_cell_iterator cell = dof.begin_active(),
-                                      endc = dof.end();
+    typename DoFHandlerType::active_cell_iterator cell = dof.begin_active(),
+                                                  endc = dof.end();
     for (; cell!=endc; ++cell)
-      for (unsigned int f=0; f<GeometryInfo<DH::dimension>::faces_per_cell; ++f)
+      for (unsigned int f=0; f<GeometryInfo<DoFHandlerType::dimension>::faces_per_cell; ++f)
         if (boundary_ids.find(cell->face(f)->boundary_id()) !=
             boundary_ids.end())
           {
@@ -484,9 +484,9 @@ namespace DoFTools
 
 
 
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
-  make_flux_sparsity_pattern (const DH                  &dof,
+  make_flux_sparsity_pattern (const DoFHandlerType      &dof,
                               SP                        &sparsity,
                               const ConstraintMatrix    &constraints,
                               const bool                 keep_constrained_dofs,
@@ -518,8 +518,8 @@ namespace DoFTools
     std::vector<types::global_dof_index> dofs_on_other_cell;
     dofs_on_this_cell.reserve (max_dofs_per_cell(dof));
     dofs_on_other_cell.reserve (max_dofs_per_cell(dof));
-    typename DH::active_cell_iterator cell = dof.begin_active(),
-                                      endc = dof.end();
+    typename DoFHandlerType::active_cell_iterator cell = dof.begin_active(),
+                                                  endc = dof.end();
 
     // TODO: in an old implementation, we used user flags before to tag
     // faces that were already touched. this way, we could reduce the work
@@ -548,19 +548,19 @@ namespace DoFTools
                                                    keep_constrained_dofs);
 
           for (unsigned int face = 0;
-               face < GeometryInfo<DH::dimension>::faces_per_cell;
+               face < GeometryInfo<DoFHandlerType::dimension>::faces_per_cell;
                ++face)
             {
-              typename DH::face_iterator cell_face = cell->face(face);
+              typename DoFHandlerType::face_iterator cell_face = cell->face(face);
               if (! cell->at_boundary(face) )
                 {
-                  typename DH::level_cell_iterator neighbor = cell->neighbor(face);
+                  typename DoFHandlerType::level_cell_iterator neighbor = cell->neighbor(face);
 
                   // in 1d, we do not need to worry whether the neighbor
                   // might have children and then loop over those children.
                   // rather, we may as well go straight to to cell behind
                   // this particular cell's most terminal child
-                  if (DH::dimension==1)
+                  if (DoFHandlerType::dimension==1)
                     while (neighbor->has_children())
                       neighbor = neighbor->child(face==0 ? 1 : 0);
 
@@ -570,7 +570,7 @@ namespace DoFTools
                            sub_nr != cell_face->number_of_children();
                            ++sub_nr)
                         {
-                          const typename DH::level_cell_iterator
+                          const typename DoFHandlerType::level_cell_iterator
                           sub_neighbor
                             = cell->neighbor_child_on_subface (face, sub_nr);
 
@@ -634,9 +634,9 @@ namespace DoFTools
 
 
 
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
-  make_flux_sparsity_pattern (const DH &dof,
+  make_flux_sparsity_pattern (const DoFHandlerType &dof,
                               SP       &sparsity)
   {
     ConstraintMatrix constraints;
@@ -710,14 +710,14 @@ namespace DoFTools
 
       // implementation of the same function in namespace DoFTools for
       // non-hp DoFHandlers
-      template <class DH, class SP>
+      template <typename DoFHandlerType, class SP>
       void
-      make_flux_sparsity_pattern (const DH                &dof,
+      make_flux_sparsity_pattern (const DoFHandlerType    &dof,
                                   SP                      &sparsity,
                                   const Table<2,Coupling> &int_mask,
                                   const Table<2,Coupling> &flux_mask)
       {
-        const FiniteElement<DH::dimension,DH::space_dimension> &fe = dof.get_fe();
+        const FiniteElement<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe = dof.get_fe();
 
         std::vector<types::global_dof_index> dofs_on_this_cell(fe.dofs_per_cell);
         std::vector<types::global_dof_index> dofs_on_other_cell(fe.dofs_per_cell);
@@ -727,13 +727,13 @@ namespace DoFTools
         flux_dof_mask = dof_couplings_from_component_couplings(fe, flux_mask);
 
         Table<2,bool> support_on_face(fe.dofs_per_cell,
-                                      GeometryInfo<DH::dimension>::faces_per_cell);
+                                      GeometryInfo<DoFHandlerType::dimension>::faces_per_cell);
         for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
-          for (unsigned int f=0; f<GeometryInfo<DH::dimension>::faces_per_cell; ++f)
+          for (unsigned int f=0; f<GeometryInfo<DoFHandlerType::dimension>::faces_per_cell; ++f)
             support_on_face(i,f) = fe.has_support_on_face(i,f);
 
-        typename DH::active_cell_iterator cell = dof.begin_active(),
-                                          endc = dof.end();
+        typename DoFHandlerType::active_cell_iterator cell = dof.begin_active(),
+                                                      endc = dof.end();
         for (; cell!=endc; ++cell)
           if (cell->is_locally_owned())
             {
@@ -747,10 +747,10 @@ namespace DoFTools
 
               // Loop over all interior neighbors
               for (unsigned int face = 0;
-                   face < GeometryInfo<DH::dimension>::faces_per_cell;
+                   face < GeometryInfo<DoFHandlerType::dimension>::faces_per_cell;
                    ++face)
                 {
-                  const typename DH::face_iterator
+                  const typename DoFHandlerType::face_iterator
                   cell_face = cell->face(face);
                   if (cell_face->user_flag_set ())
                     continue;
@@ -778,7 +778,7 @@ namespace DoFTools
                     }
                   else
                     {
-                      typename DH::level_cell_iterator
+                      typename DoFHandlerType::level_cell_iterator
                       neighbor = cell->neighbor(face);
                       // Refinement edges are taken care of by coarser
                       // cells
@@ -794,7 +794,7 @@ namespace DoFTools
                                sub_nr != cell_face->n_children();
                                ++sub_nr)
                             {
-                              const typename DH::level_cell_iterator
+                              const typename DoFHandlerType::level_cell_iterator
                               sub_neighbor
                                 = cell->neighbor_child_on_subface (face, sub_nr);
 
@@ -1131,9 +1131,9 @@ namespace DoFTools
 
 
 
-  template <class DH, class SP>
+  template <typename DoFHandlerType, class SP>
   void
-  make_flux_sparsity_pattern (const DH                &dof,
+  make_flux_sparsity_pattern (const DoFHandlerType    &dof,
                               SP                      &sparsity,
                               const Table<2,Coupling> &int_mask,
                               const Table<2,Coupling> &flux_mask)
@@ -1164,13 +1164,15 @@ namespace DoFTools
     // at the beginning of this function.
     std::vector<bool> user_flags;
     dof.get_tria().save_user_flags(user_flags);
-    const_cast<Triangulation<DH::dimension,DH::space_dimension> &>(dof.get_tria()).clear_user_flags ();
+    const_cast<Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &>
+    (dof.get_tria()).clear_user_flags ();
 
     internal::make_flux_sparsity_pattern (dof, sparsity,
                                           int_mask, flux_mask);
 
     // finally restore the user flags
-    const_cast<Triangulation<DH::dimension,DH::space_dimension> &>(dof.get_tria()).load_user_flags(user_flags);
+    const_cast<Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &>
+    (dof.get_tria()).load_user_flags(user_flags);
   }
 
 
diff --git a/source/fe/fe_tools_interpolate.cc b/source/fe/fe_tools_interpolate.cc
index 989e01aa9c..46826973c1 100644
--- a/source/fe/fe_tools_interpolate.cc
+++ b/source/fe/fe_tools_interpolate.cc
@@ -51,14 +51,14 @@ DEAL_II_NAMESPACE_OPEN
 namespace FETools
 {
   template <int dim, int spacedim,
-            template <int, int> class DH1,
-            template <int, int> class DH2,
+            template <int, int> class DoFHandlerType1,
+            template <int, int> class DoFHandlerType2,
             class InVector, class OutVector>
   void
-  interpolate(const DH1<dim, spacedim> &dof1,
-              const InVector           &u1,
-              const DH2<dim, spacedim> &dof2,
-              OutVector                &u2)
+  interpolate(const DoFHandlerType1<dim, spacedim> &dof1,
+              const InVector                       &u1,
+              const DoFHandlerType2<dim, spacedim> &dof2,
+              OutVector                            &u2)
   {
     ConstraintMatrix dummy;
     dummy.close();
@@ -68,15 +68,15 @@ namespace FETools
 
 
   template <int dim, int spacedim,
-            template <int, int> class DH1,
-            template <int, int> class DH2,
+            template <int, int> class DoFHandlerType1,
+            template <int, int> class DoFHandlerType2,
             class InVector, class OutVector>
   void
-  interpolate (const DH1<dim, spacedim> &dof1,
-               const InVector           &u1,
-               const DH2<dim, spacedim> &dof2,
-               const ConstraintMatrix   &constraints,
-               OutVector                &u2)
+  interpolate (const DoFHandlerType1<dim, spacedim> &dof1,
+               const InVector                       &u1,
+               const DoFHandlerType2<dim, spacedim> &dof2,
+               const ConstraintMatrix               &constraints,
+               OutVector                            &u2)
   {
     Assert(&dof1.get_tria()==&dof2.get_tria(), ExcTriangulationMismatch());
 
@@ -119,10 +119,10 @@ namespace FETools
         std_cxx11::shared_ptr<FullMatrix<double> > > >
         interpolation_matrices;
 
-    typename DH1<dim,spacedim>::active_cell_iterator cell1 = dof1.begin_active(),
-                                                     endc1 = dof1.end();
-    typename DH2<dim,spacedim>::active_cell_iterator cell2 = dof2.begin_active(),
-                                                     endc2 = dof2.end();
+    typename DoFHandlerType1<dim,spacedim>::active_cell_iterator cell1 = dof1.begin_active(),
+                                                                 endc1 = dof1.end();
+    typename DoFHandlerType2<dim,spacedim>::active_cell_iterator cell2 = dof2.begin_active(),
+                                                                 endc2 = dof2.end();
     (void)endc2;
 
     std::vector<types::global_dof_index> dofs;
@@ -315,13 +315,13 @@ namespace FETools
 
 
   template <int dim,
-            template <int> class DH,
+            template <int> class DoFHandlerType,
             class InVector, class OutVector, int spacedim>
   void
-  back_interpolate(const DH<dim>            &dof1,
-                   const InVector           &u1,
+  back_interpolate(const DoFHandlerType<dim>         &dof1,
+                   const InVector                    &u1,
                    const FiniteElement<dim,spacedim> &fe2,
-                   OutVector                &u1_interpolated)
+                   OutVector                         &u1_interpolated)
   {
     Assert(u1.size() == dof1.n_dofs(),
            ExcDimensionMismatch(u1.size(), dof1.n_dofs()));
@@ -353,8 +353,8 @@ namespace FETools
     const types::subdomain_id subdomain_id =
       dof1.get_tria().locally_owned_subdomain();
 
-    typename DH<dim>::active_cell_iterator cell = dof1.begin_active(),
-                                           endc = dof1.end();
+    typename DoFHandlerType<dim>::active_cell_iterator cell = dof1.begin_active(),
+                                                       endc = dof1.end();
 
     // map from possible fe objects in
     // dof1 to the back_interpolation
diff --git a/source/fe/fe_values.cc b/source/fe/fe_values.cc
index e800b2cdbf..5d68b94a06 100644
--- a/source/fe/fe_values.cc
+++ b/source/fe/fe_values.cc
@@ -3712,9 +3712,10 @@ void FEValues<dim,spacedim>::reinit (const typename Triangulation<dim,spacedim>:
 
 
 template <int dim, int spacedim>
-template <template <int,int> class DH, bool lda>
+template <template <int, int> class DoFHandlerType, bool lda>
 void
-FEValues<dim,spacedim>::reinit (const TriaIterator<DoFCellAccessor<DH<dim,spacedim>, lda> > &cell)
+FEValues<dim,spacedim>::reinit
+(const TriaIterator<DoFCellAccessor<DoFHandlerType<dim,spacedim>, lda> > &cell)
 {
   // assert that the finite elements
   // passed to the constructor and
@@ -3728,7 +3729,9 @@ FEValues<dim,spacedim>::reinit (const TriaIterator<DoFCellAccessor<DH<dim,spaced
   this->maybe_invalidate_previous_present_cell (cell);
   this->check_cell_similarity(cell);
 
-  reset_pointer_in_place_if_possible<typename FEValuesBase<dim,spacedim>::template CellIterator<TriaIterator<DoFCellAccessor<DH<dim,spacedim>, lda> > > >
+  reset_pointer_in_place_if_possible<typename FEValuesBase<dim,spacedim>::template
+  CellIterator<TriaIterator<DoFCellAccessor<DoFHandlerType<dim,spacedim>,
+                                            lda> > > >
   (this->present_cell, cell);
 
   // this was the part of the work
@@ -3899,10 +3902,11 @@ FEFaceValues<dim,spacedim>::initialize (const UpdateFlags update_flags)
 
 
 template <int dim, int spacedim>
-template <template <int,int> class DH, bool lda>
+template <template <int, int> class DoFHandlerType, bool lda>
 void
-FEFaceValues<dim,spacedim>::reinit (const TriaIterator<DoFCellAccessor<DH<dim,spacedim>, lda> > &cell,
-                                    const unsigned int face_no)
+FEFaceValues<dim,spacedim>::reinit
+(const TriaIterator<DoFCellAccessor<DoFHandlerType<dim,spacedim>, lda> > &cell,
+ const unsigned int face_no)
 {
   // assert that the finite elements
   // passed to the constructor and
@@ -3918,7 +3922,9 @@ FEFaceValues<dim,spacedim>::reinit (const TriaIterator<DoFCellAccessor<DH<dim,sp
           ExcIndexRange (face_no, 0, GeometryInfo<dim>::faces_per_cell));
 
   this->maybe_invalidate_previous_present_cell (cell);
-  reset_pointer_in_place_if_possible<typename FEValuesBase<dim,spacedim>::template CellIterator<TriaIterator<DoFCellAccessor<DH<dim,spacedim>, lda> > > >
+  reset_pointer_in_place_if_possible<typename FEValuesBase<dim,spacedim>::template
+  CellIterator<TriaIterator<DoFCellAccessor<DoFHandlerType<dim,spacedim>,
+                                            lda> > > >
   (this->present_cell, cell);
 
   // this was the part of the work
@@ -4055,10 +4061,11 @@ FESubfaceValues<dim,spacedim>::initialize (const UpdateFlags update_flags)
 
 
 template <int dim, int spacedim>
-template <template <int,int> class DH, bool lda>
-void FESubfaceValues<dim,spacedim>::reinit (const TriaIterator<DoFCellAccessor<DH<dim,spacedim>, lda> > &cell,
-                                            const unsigned int         face_no,
-                                            const unsigned int         subface_no)
+template <template <int, int> class DoFHandlerType, bool lda>
+void FESubfaceValues<dim,spacedim>::reinit
+(const TriaIterator<DoFCellAccessor<DoFHandlerType<dim,spacedim>, lda> > &cell,
+ const unsigned int face_no,
+ const unsigned int subface_no)
 {
   // assert that the finite elements
   // passed to the constructor and
@@ -4091,7 +4098,9 @@ void FESubfaceValues<dim,spacedim>::reinit (const TriaIterator<DoFCellAccessor<D
                       "instead in these cases."));
 
   this->maybe_invalidate_previous_present_cell (cell);
-  reset_pointer_in_place_if_possible<typename FEValuesBase<dim,spacedim>::template CellIterator<TriaIterator<DoFCellAccessor<DH<dim,spacedim>, lda> > > >
+  reset_pointer_in_place_if_possible<typename FEValuesBase<dim,spacedim>::template
+  CellIterator<TriaIterator<DoFCellAccessor<DoFHandlerType<dim,spacedim>,
+                                            lda> > > >
   (this->present_cell, cell);
 
   // this was the part of the work
diff --git a/source/fe/mapping_fe_field.cc b/source/fe/mapping_fe_field.cc
index 2cc3e5da28..80a377c08c 100644
--- a/source/fe/mapping_fe_field.cc
+++ b/source/fe/mapping_fe_field.cc
@@ -44,8 +44,8 @@
 DEAL_II_NAMESPACE_OPEN
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
-MappingFEField<dim,spacedim,VectorType,DH>::InternalData::InternalData
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::InternalData::InternalData
 (const FiniteElement<dim,spacedim> &fe,
  const ComponentMask                mask)
   :
@@ -57,9 +57,9 @@ MappingFEField<dim,spacedim,VectorType,DH>::InternalData::InternalData
 
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 std::size_t
-MappingFEField<dim,spacedim,VectorType,DH>::InternalData::memory_consumption () const
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::InternalData::memory_consumption () const
 {
   Assert (false, ExcNotImplemented());
   return 0;
@@ -67,9 +67,9 @@ MappingFEField<dim,spacedim,VectorType,DH>::InternalData::memory_consumption ()
 
 
 
-template<int dim, int spacedim, class DH, typename VectorType>
+template<int dim, int spacedim, typename DoFHandlerType, typename VectorType>
 double &
-MappingFEField<dim,spacedim,DH,VectorType>::InternalData::shape
+MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::shape
 (const unsigned int qpoint,
  const unsigned int shape_nr)
 {
@@ -80,9 +80,9 @@ MappingFEField<dim,spacedim,DH,VectorType>::InternalData::shape
 }
 
 
-template<int dim, int spacedim, class DH, typename VectorType>
+template<int dim, int spacedim, typename DoFHandlerType, typename VectorType>
 const Tensor<1,dim> &
-MappingFEField<dim,spacedim,DH,VectorType>::InternalData::derivative
+MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::derivative
 (const unsigned int qpoint,
  const unsigned int shape_nr) const
 {
@@ -94,9 +94,9 @@ MappingFEField<dim,spacedim,DH,VectorType>::InternalData::derivative
 
 
 
-template<int dim, int spacedim, class DH, typename VectorType>
+template<int dim, int spacedim, typename DoFHandlerType, typename VectorType>
 Tensor<1,dim> &
-MappingFEField<dim,spacedim,DH,VectorType>::InternalData::derivative
+MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::derivative
 (const unsigned int qpoint,
  const unsigned int shape_nr)
 {
@@ -107,9 +107,9 @@ MappingFEField<dim,spacedim,DH,VectorType>::InternalData::derivative
 }
 
 
-template <int dim, int spacedim, class DH, typename VectorType>
+template <int dim, int spacedim, typename DoFHandlerType, typename VectorType>
 const Tensor<2,dim> &
-MappingFEField<dim,spacedim,DH,VectorType>::InternalData::second_derivative
+MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::second_derivative
 (const unsigned int qpoint,
  const unsigned int shape_nr) const
 {
@@ -121,9 +121,9 @@ MappingFEField<dim,spacedim,DH,VectorType>::InternalData::second_derivative
 
 
 
-template <int dim, int spacedim, class DH, typename VectorType>
+template <int dim, int spacedim, typename DoFHandlerType, typename VectorType>
 Tensor<2,dim> &
-MappingFEField<dim,spacedim,DH,VectorType>::InternalData::second_derivative
+MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::second_derivative
 (const unsigned int qpoint,
  const unsigned int shape_nr)
 {
@@ -134,9 +134,9 @@ MappingFEField<dim,spacedim,DH,VectorType>::InternalData::second_derivative
 }
 
 
-template <int dim, int spacedim, class DH, typename VectorType>
+template <int dim, int spacedim, typename DoFHandlerType, typename VectorType>
 const Tensor<3,dim> &
-MappingFEField<dim,spacedim,DH,VectorType>::InternalData::third_derivative
+MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::third_derivative
 (const unsigned int qpoint,
  const unsigned int shape_nr) const
 {
@@ -148,9 +148,9 @@ MappingFEField<dim,spacedim,DH,VectorType>::InternalData::third_derivative
 
 
 
-template <int dim, int spacedim, class DH, typename VectorType>
+template <int dim, int spacedim, typename DoFHandlerType, typename VectorType>
 Tensor<3,dim> &
-MappingFEField<dim,spacedim,DH,VectorType>::InternalData::third_derivative
+MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::third_derivative
 (const unsigned int qpoint,
  const unsigned int shape_nr)
 {
@@ -161,9 +161,9 @@ MappingFEField<dim,spacedim,DH,VectorType>::InternalData::third_derivative
 }
 
 
-template <int dim, int spacedim, class DH, typename VectorType>
+template <int dim, int spacedim, typename DoFHandlerType, typename VectorType>
 const Tensor<4,dim> &
-MappingFEField<dim,spacedim,DH,VectorType>::InternalData::fourth_derivative
+MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::fourth_derivative
 (const unsigned int qpoint,
  const unsigned int shape_nr) const
 {
@@ -175,9 +175,9 @@ MappingFEField<dim,spacedim,DH,VectorType>::InternalData::fourth_derivative
 
 
 
-template <int dim, int spacedim, class DH, typename VectorType>
+template <int dim, int spacedim, typename DoFHandlerType, typename VectorType>
 Tensor<4,dim> &
-MappingFEField<dim,spacedim,DH,VectorType>::InternalData::fourth_derivative
+MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::fourth_derivative
 (const unsigned int qpoint,
  const unsigned int shape_nr)
 {
@@ -189,9 +189,9 @@ MappingFEField<dim,spacedim,DH,VectorType>::InternalData::fourth_derivative
 
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
-MappingFEField<dim,spacedim,VectorType,DH>::MappingFEField
-(const DH            &euler_dof_handler,
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::MappingFEField
+(const DoFHandlerType            &euler_dof_handler,
  const VectorType    &euler_vector,
  const ComponentMask  mask)
   :
@@ -212,9 +212,9 @@ MappingFEField<dim,spacedim,VectorType,DH>::MappingFEField
 }
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
-MappingFEField<dim,spacedim,VectorType,DH>::MappingFEField
-(const MappingFEField<dim,spacedim,VectorType,DH> &mapping)
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::MappingFEField
+(const MappingFEField<dim,spacedim,VectorType,DoFHandlerType> &mapping)
   :
   euler_vector(mapping.euler_vector),
   fe(mapping.fe),
@@ -225,10 +225,10 @@ MappingFEField<dim,spacedim,VectorType,DH>::MappingFEField
 
 
 
-template<int dim, int spacedim, class DH, typename VectorType>
+template<int dim, int spacedim, typename DoFHandlerType, typename VectorType>
 inline
 const double &
-MappingFEField<dim,spacedim,DH,VectorType>::InternalData::shape
+MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::InternalData::shape
 (const unsigned int qpoint,
  const unsigned int shape_nr) const
 {
@@ -240,18 +240,18 @@ MappingFEField<dim,spacedim,DH,VectorType>::InternalData::shape
 
 
 
-template <int dim, int spacedim, class DH, typename VectorType>
+template <int dim, int spacedim, typename DoFHandlerType, typename VectorType>
 bool
-MappingFEField<dim,spacedim,DH,VectorType>::preserves_vertex_locations () const
+MappingFEField<dim,spacedim,DoFHandlerType,VectorType>::preserves_vertex_locations () const
 {
   return false;
 }
 
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 void
-MappingFEField<dim,spacedim,VectorType,DH>::
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
 compute_shapes_virtual (const std::vector<Point<dim> >                       &unit_points,
                         typename MappingFEField<dim, spacedim>::InternalData &data) const
 {
@@ -282,9 +282,9 @@ compute_shapes_virtual (const std::vector<Point<dim> >                       &un
 }
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 UpdateFlags
-MappingFEField<dim,spacedim,VectorType,DH>::requires_update_flags (const UpdateFlags in) const
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::requires_update_flags (const UpdateFlags in) const
 {
   // add flags if the respective quantities are necessary to compute
   // what we need. note that some flags appear in both conditions and
@@ -341,9 +341,9 @@ MappingFEField<dim,spacedim,VectorType,DH>::requires_update_flags (const UpdateF
 
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 void
-MappingFEField<dim,spacedim,VectorType,DH>::compute_data
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::compute_data
 (const UpdateFlags      update_flags,
  const Quadrature<dim> &q,
  const unsigned int     n_original_q_points,
@@ -393,9 +393,9 @@ MappingFEField<dim,spacedim,VectorType,DH>::compute_data
 }
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 void
-MappingFEField<dim,spacedim,VectorType,DH>::compute_face_data
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::compute_face_data
 (const UpdateFlags      update_flags,
  const Quadrature<dim> &q,
  const unsigned int     n_original_q_points,
@@ -461,11 +461,11 @@ MappingFEField<dim,spacedim,VectorType,DH>::compute_face_data
 }
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 typename
-MappingFEField<dim,spacedim,VectorType,DH>::InternalData *
-MappingFEField<dim,spacedim,VectorType,DH>::get_data (const UpdateFlags      update_flags,
-                                                      const Quadrature<dim> &quadrature) const
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::InternalData *
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::get_data (const UpdateFlags      update_flags,
+    const Quadrature<dim> &quadrature) const
 {
   InternalData *data = new InternalData(*fe, fe_mask);
   this->compute_data (update_flags, quadrature,
@@ -475,9 +475,9 @@ MappingFEField<dim,spacedim,VectorType,DH>::get_data (const UpdateFlags      upd
 
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 typename Mapping<dim,spacedim>::InternalDataBase *
-MappingFEField<dim,spacedim,VectorType,DH>::get_face_data
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::get_face_data
 (const UpdateFlags        update_flags,
  const Quadrature<dim-1> &quadrature) const
 {
@@ -490,9 +490,9 @@ MappingFEField<dim,spacedim,VectorType,DH>::get_face_data
 }
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 typename Mapping<dim,spacedim>::InternalDataBase *
-MappingFEField<dim,spacedim,VectorType,DH>::get_subface_data
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::get_subface_data
 (const UpdateFlags        update_flags,
  const Quadrature<dim-1> &quadrature) const
 {
@@ -1273,9 +1273,9 @@ namespace internal
 
 // Note that the CellSimilarity flag is modifiable, since MappingFEField can need to
 // recalculate data even when cells are similar.
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 CellSimilarity::Similarity
-MappingFEField<dim,spacedim,VectorType,DH>::
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
 fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
                 const CellSimilarity::Similarity                           cell_similarity,
                 const Quadrature<dim>                                     &quadrature,
@@ -1445,9 +1445,9 @@ fill_fe_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
 
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 void
-MappingFEField<dim,spacedim,VectorType,DH>::
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
 fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
                      const unsigned int                                         face_no,
                      const Quadrature<dim-1>                                   &quadrature,
@@ -1477,9 +1477,9 @@ fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &
 }
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 void
-MappingFEField<dim,spacedim,VectorType,DH>::
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
 fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
                         const unsigned int                                         face_no,
                         const unsigned int                                         subface_no,
@@ -1513,7 +1513,7 @@ fill_fe_subface_values (const typename Triangulation<dim,spacedim>::cell_iterato
 
 namespace
 {
-  template<int dim, int spacedim, int rank, typename VectorType, class DH>
+  template<int dim, int spacedim, int rank, typename VectorType, typename DoFHandlerType>
   void
   transform_fields(const VectorSlice<const std::vector<Tensor<rank,dim> > > input,
                    const MappingType                                        mapping_type,
@@ -1521,10 +1521,10 @@ namespace
                    VectorSlice<std::vector<Tensor<rank,spacedim> > >        output)
   {
     AssertDimension (input.size(), output.size());
-    Assert ((dynamic_cast<const typename MappingFEField<dim,spacedim,VectorType,DH>::InternalData *>(&mapping_data) != 0),
+    Assert ((dynamic_cast<const typename MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::InternalData *>(&mapping_data) != 0),
             ExcInternalError());
-    const typename MappingFEField<dim,spacedim,VectorType,DH>::InternalData
-    &data = static_cast<const typename MappingFEField<dim,spacedim,VectorType,DH>::InternalData &>(mapping_data);
+    const typename MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::InternalData
+    &data = static_cast<const typename MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::InternalData &>(mapping_data);
 
     switch (mapping_type)
       {
@@ -1575,19 +1575,20 @@ namespace
   }
 
 
-  template<int dim, int spacedim, int rank, typename VectorType, class DH>
+  template<int dim, int spacedim, int rank, typename VectorType, typename DoFHandlerType>
   void
-  transform_differential_forms(const VectorSlice<const std::vector<DerivativeForm<rank, dim,spacedim> > >  input,
-                               const MappingType                                                           mapping_type,
-                               const typename Mapping<dim,spacedim>::InternalDataBase                     &mapping_data,
-                               VectorSlice<std::vector<Tensor<rank+1, spacedim> > >                        output)
+  transform_differential_forms
+  (const VectorSlice<const std::vector<DerivativeForm<rank, dim,spacedim> > >  input,
+   const MappingType                                                           mapping_type,
+   const typename Mapping<dim,spacedim>::InternalDataBase                     &mapping_data,
+   VectorSlice<std::vector<Tensor<rank+1, spacedim> > >                        output)
   {
 
     AssertDimension (input.size(), output.size());
-    Assert ((dynamic_cast<const typename MappingFEField<dim,spacedim,VectorType,DH>::InternalData *>(&mapping_data) != 0),
+    Assert ((dynamic_cast<const typename MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::InternalData *>(&mapping_data) != 0),
             ExcInternalError());
-    const typename MappingFEField<dim,spacedim,VectorType,DH>::InternalData
-    &data = static_cast<const typename MappingFEField<dim,spacedim,VectorType,DH>::InternalData &>(mapping_data);
+    const typename MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::InternalData
+    &data = static_cast<const typename MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::InternalData &>(mapping_data);
 
     switch (mapping_type)
       {
@@ -1610,9 +1611,9 @@ namespace
 
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 void
-MappingFEField<dim,spacedim,VectorType,DH>::
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
 transform (const VectorSlice<const std::vector<Tensor<1,dim> > >   input,
            const MappingType                                       mapping_type,
            const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
@@ -1620,14 +1621,14 @@ transform (const VectorSlice<const std::vector<Tensor<1,dim> > >   input,
 {
   AssertDimension (input.size(), output.size());
 
-  transform_fields<dim,spacedim,1,VectorType,DH>(input, mapping_type, mapping_data, output);
+  transform_fields<dim,spacedim,1,VectorType,DoFHandlerType>(input, mapping_type, mapping_data, output);
 }
 
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 void
-MappingFEField<dim,spacedim,VectorType,DH>::
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
 transform (const VectorSlice<const std::vector<DerivativeForm<1, dim ,spacedim>  > >  input,
            const MappingType                                                          mapping_type,
            const typename Mapping<dim,spacedim>::InternalDataBase                    &mapping_data,
@@ -1635,14 +1636,14 @@ transform (const VectorSlice<const std::vector<DerivativeForm<1, dim ,spacedim>
 {
   AssertDimension (input.size(), output.size());
 
-  transform_differential_forms<dim,spacedim,1,VectorType,DH>(input, mapping_type, mapping_data, output);
+  transform_differential_forms<dim,spacedim,1,VectorType,DoFHandlerType>(input, mapping_type, mapping_data, output);
 }
 
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 void
-MappingFEField<dim,spacedim,VectorType,DH>::
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
 transform (const VectorSlice<const std::vector<Tensor<2, dim> > >  input,
            const MappingType,
            const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
@@ -1658,9 +1659,9 @@ transform (const VectorSlice<const std::vector<Tensor<2, dim> > >  input,
 
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 void
-MappingFEField<dim,spacedim,VectorType,DH>::
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
 transform (const VectorSlice<const std::vector< DerivativeForm<2, dim, spacedim> > > input,
            const MappingType                                                         mapping_type,
            const typename Mapping<dim,spacedim>::InternalDataBase                   &mapping_data,
@@ -1708,9 +1709,9 @@ transform (const VectorSlice<const std::vector< DerivativeForm<2, dim, spacedim>
 
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 void
-MappingFEField<dim,spacedim,VectorType,DH>::
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
 transform (const VectorSlice<const std::vector< Tensor<3,dim> > >  input,
            const MappingType                                     /*mapping_type*/,
            const typename Mapping<dim,spacedim>::InternalDataBase &mapping_data,
@@ -1728,9 +1729,9 @@ transform (const VectorSlice<const std::vector< Tensor<3,dim> > >  input,
 
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 Point<spacedim>
-MappingFEField<dim,spacedim,VectorType,DH>::
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
 transform_unit_to_real_cell (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
                              const Point<dim>                                          &p) const
 {
@@ -1747,9 +1748,9 @@ transform_unit_to_real_cell (const typename Triangulation<dim,spacedim>::cell_it
 }
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 Point<spacedim>
-MappingFEField<dim,spacedim,VectorType,DH>::
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
 do_transform_unit_to_real_cell (const InternalData &data) const
 {
   Point<spacedim> p_real;
@@ -1766,9 +1767,9 @@ do_transform_unit_to_real_cell (const InternalData &data) const
 
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 Point<dim>
-MappingFEField<dim,spacedim,VectorType,DH>::
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
 transform_real_to_unit_cell (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
                              const Point<spacedim>                                     &p) const
 {
@@ -1809,9 +1810,9 @@ transform_real_to_unit_cell (const typename Triangulation<dim,spacedim>::cell_it
 }
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 Point<dim>
-MappingFEField<dim,spacedim,VectorType,DH>::
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::
 do_transform_real_to_unit_cell
 (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
  const Point<spacedim>                                     &p,
@@ -1917,39 +1918,39 @@ failure:
 }
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 unsigned int
-MappingFEField<dim,spacedim,VectorType,DH>::get_degree() const
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::get_degree() const
 {
   return fe->degree;
 }
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 ComponentMask
-MappingFEField<dim,spacedim,VectorType,DH>::get_component_mask() const
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::get_component_mask() const
 {
   return this->fe_mask;
 }
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 Mapping<dim,spacedim> *
-MappingFEField<dim,spacedim,VectorType,DH>::clone () const
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::clone () const
 {
-  return new MappingFEField<dim,spacedim,VectorType,DH>(*this);
+  return new MappingFEField<dim,spacedim,VectorType,DoFHandlerType>(*this);
 }
 
 
-template<int dim, int spacedim, typename VectorType, class DH>
+template<int dim, int spacedim, typename VectorType, typename DoFHandlerType>
 void
-MappingFEField<dim,spacedim,VectorType,DH>::update_internal_dofs
+MappingFEField<dim,spacedim,VectorType,DoFHandlerType>::update_internal_dofs
 (const typename Triangulation<dim,spacedim>::cell_iterator  &cell,
  const typename MappingFEField<dim, spacedim>::InternalData &data) const
 {
   Assert(euler_dof_handler != 0, ExcMessage("euler_dof_handler is empty"));
 
-  typename DH::cell_iterator dof_cell(*cell, euler_dof_handler);
+  typename DoFHandlerType::cell_iterator dof_cell(*cell, euler_dof_handler);
   Assert (dof_cell->active() == true, ExcInactiveCell());
 
   dof_cell->get_dof_indices(data.local_dof_indices);
diff --git a/source/hp/fe_values.cc b/source/hp/fe_values.cc
index d86382ad24..00e1c6cffa 100644
--- a/source/hp/fe_values.cc
+++ b/source/hp/fe_values.cc
@@ -139,9 +139,9 @@ namespace hp
 
 
   template <int dim, int spacedim>
-  template <class DH, bool lda>
+  template <typename DoFHandlerType, bool lda>
   void
-  FEValues<dim,spacedim>::reinit (const TriaIterator<DoFCellAccessor<DH,lda> > cell,
+  FEValues<dim,spacedim>::reinit (const TriaIterator<DoFCellAccessor<DoFHandlerType,lda> > cell,
                                   const unsigned int q_index,
                                   const unsigned int mapping_index,
                                   const unsigned int fe_index)
@@ -256,9 +256,9 @@ namespace hp
 
 
   template <int dim, int spacedim>
-  template <class DH, bool lda>
+  template <typename DoFHandlerType, bool lda>
   void
-  FEFaceValues<dim,spacedim>::reinit (const TriaIterator<DoFCellAccessor<DH,lda> > cell,
+  FEFaceValues<dim,spacedim>::reinit (const TriaIterator<DoFCellAccessor<DoFHandlerType,lda> > cell,
                                       const unsigned int face_no,
                                       const unsigned int q_index,
                                       const unsigned int mapping_index,
@@ -375,9 +375,9 @@ namespace hp
 
 
   template <int dim, int spacedim>
-  template <class DH, bool lda>
+  template <typename DoFHandlerType, bool lda>
   void
-  FESubfaceValues<dim,spacedim>::reinit (const TriaIterator<DoFCellAccessor<DH,lda> > cell,
+  FESubfaceValues<dim,spacedim>::reinit (const TriaIterator<DoFCellAccessor<DoFHandlerType,lda> > cell,
                                          const unsigned int face_no,
                                          const unsigned int subface_no,
                                          const unsigned int q_index,
diff --git a/source/multigrid/mg_tools.cc b/source/multigrid/mg_tools.cc
index 7e34e6f5dc..1add14de02 100644
--- a/source/multigrid/mg_tools.cc
+++ b/source/multigrid/mg_tools.cc
@@ -535,10 +535,10 @@ namespace MGTools
 
 
 
-  template <class DH, class SP>
-  void make_sparsity_pattern (const DH           &dof,
-                              SP                 &sparsity,
-                              const unsigned int  level)
+  template <typename DoFHandlerType, class SP>
+  void make_sparsity_pattern (const DoFHandlerType &dof,
+                              SP                   &sparsity,
+                              const unsigned int    level)
   {
     const types::global_dof_index n_dofs = dof.n_dofs(level);
     (void)n_dofs;
@@ -550,8 +550,8 @@ namespace MGTools
 
     const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
     std::vector<types::global_dof_index> dofs_on_this_cell(dofs_per_cell);
-    typename DH::cell_iterator cell = dof.begin(level),
-                               endc = dof.end(level);
+    typename DoFHandlerType::cell_iterator cell = dof.begin(level),
+                                           endc = dof.end(level);
     for (; cell!=endc; ++cell)
       if (dof.get_tria().locally_owned_subdomain()==numbers::invalid_subdomain_id
           || cell->level_subdomain_id()==dof.get_tria().locally_owned_subdomain())
@@ -1063,14 +1063,14 @@ namespace MGTools
 
 
 
-  template <class DH>
+  template <typename DoFHandlerType>
   void
-  count_dofs_per_block (
-    const DH     &dof_handler,
-    std::vector<std::vector<types::global_dof_index> > &dofs_per_block,
-    std::vector<unsigned int>  target_block)
+  count_dofs_per_block
+  (const DoFHandlerType                               &dof_handler,
+   std::vector<std::vector<types::global_dof_index> > &dofs_per_block,
+   std::vector<unsigned int>                           target_block)
   {
-    const FiniteElement<DH::dimension,DH::space_dimension> &fe = dof_handler.get_fe();
+    const FiniteElement<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe = dof_handler.get_fe();
     const unsigned int n_blocks = fe.n_blocks();
     const unsigned int n_levels = dof_handler.get_tria().n_global_levels();
 
@@ -1121,10 +1121,10 @@ namespace MGTools
         for (unsigned int i=0; i<n_blocks; ++i)
           {
             void (*fun_ptr) (const unsigned int level,
-                             const DH &,
+                             const DoFHandlerType &,
                              const BlockMask &,
                              std::vector<bool> &)
-              = &DoFTools::extract_level_dofs<DH>;
+              = &DoFTools::extract_level_dofs<DoFHandlerType>;
 
             std::vector<bool> tmp(n_blocks, false);
             tmp[i] = true;
diff --git a/source/numerics/data_out.cc b/source/numerics/data_out.cc
index 2d835327d9..5920e81d41 100644
--- a/source/numerics/data_out.cc
+++ b/source/numerics/data_out.cc
@@ -59,37 +59,38 @@ namespace internal
 
 
 
-template <int dim, class DH>
+template <int dim, typename DoFHandlerType>
 void
-DataOut<dim,DH>::
-build_one_patch (const std::pair<cell_iterator, unsigned int>                         *cell_and_index,
-                 internal::DataOut::ParallelData<DH::dimension, DH::space_dimension>  &scratch_data,
-                 const unsigned int                                                    n_subdivisions,
-                 const CurvedCellRegion                                                curved_cell_region,
-                 std::vector<DataOutBase::Patch<DH::dimension, DH::space_dimension> > &patches)
+DataOut<dim,DoFHandlerType>::
+build_one_patch
+(const std::pair<cell_iterator, unsigned int>                                                *cell_and_index,
+ internal::DataOut::ParallelData<DoFHandlerType::dimension, DoFHandlerType::space_dimension> &scratch_data,
+ const unsigned int                                                                           n_subdivisions,
+ const CurvedCellRegion                                                                       curved_cell_region,
+ std::vector<DataOutBase::Patch<DoFHandlerType::dimension, DoFHandlerType::space_dimension> > &patches)
 {
   // first create the output object that we will write into
-  ::dealii::DataOutBase::Patch<DH::dimension, DH::space_dimension> patch;
+  ::dealii::DataOutBase::Patch<DoFHandlerType::dimension, DoFHandlerType::space_dimension> patch;
   patch.n_subdivisions = n_subdivisions;
 
   // use ucd_to_deal map as patch vertices are in the old, unnatural
   // ordering. if the mapping does not preserve locations
   // (e.g. MappingQEulerian), we need to compute the offset of the vertex for
   // the graphical output. Otherwise, we can just use the vertex info.
-  for (unsigned int vertex=0; vertex<GeometryInfo<DH::dimension>::vertices_per_cell; ++vertex)
+  for (unsigned int vertex=0; vertex<GeometryInfo<DoFHandlerType::dimension>::vertices_per_cell; ++vertex)
     if (scratch_data.mapping_collection[0].preserves_vertex_locations())
       patch.vertices[vertex] = cell_and_index->first->vertex(vertex);
     else
       patch.vertices[vertex] = scratch_data.mapping_collection[0].transform_unit_to_real_cell
                                (cell_and_index->first,
-                                GeometryInfo<DH::dimension>::unit_cell_vertex (vertex));
+                                GeometryInfo<DoFHandlerType::dimension>::unit_cell_vertex (vertex));
 
   if (scratch_data.n_datasets > 0)
     {
-      // create DH::active_cell_iterator and initialize FEValues
+      // create DoFHandlerType::active_cell_iterator and initialize FEValues
       scratch_data.reinit_all_fe_values(this->dof_data, cell_and_index->first);
 
-      const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values
+      const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values
         = scratch_data.get_present_fe_values (0);
 
       const unsigned int n_q_points = fe_patch_values.n_quadrature_points;
@@ -107,20 +108,20 @@ build_one_patch (const std::pair<cell_iterator, unsigned int>
            &&
            (cell_and_index->first->at_boundary()
             ||
-            (DH::dimension != DH::space_dimension))))
+            (DoFHandlerType::dimension != DoFHandlerType::space_dimension))))
         {
-          Assert(patch.space_dim==DH::space_dimension, ExcInternalError());
-          const std::vector<Point<DH::space_dimension> > &q_points=fe_patch_values.get_quadrature_points();
+          Assert(patch.space_dim==DoFHandlerType::space_dimension, ExcInternalError());
+          const std::vector<Point<DoFHandlerType::space_dimension> > &q_points=fe_patch_values.get_quadrature_points();
           // resize the patch.data member in order to have enough memory for
           // the quadrature points as well
-          patch.data.reinit (scratch_data.n_datasets+DH::space_dimension, n_q_points);
+          patch.data.reinit (scratch_data.n_datasets+DoFHandlerType::space_dimension, n_q_points);
           // set the flag indicating that for this cell the points are
           // explicitly given
           patch.points_are_available=true;
           // copy points to patch.data
-          for (unsigned int i=0; i<DH::space_dimension; ++i)
+          for (unsigned int i=0; i<DoFHandlerType::space_dimension; ++i)
             for (unsigned int q=0; q<n_q_points; ++q)
-              patch.data(patch.data.size(0)-DH::space_dimension+i,q)=q_points[q][i];
+              patch.data(patch.data.size(0)-DoFHandlerType::space_dimension+i,q)=q_points[q][i];
         }
       else
         {
@@ -135,12 +136,12 @@ build_one_patch (const std::pair<cell_iterator, unsigned int>
       // first fill dof_data
       for (unsigned int dataset=0; dataset<this->dof_data.size(); ++dataset)
         {
-          const FEValuesBase<DH::dimension,DH::space_dimension> &this_fe_patch_values
+          const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &this_fe_patch_values
             = scratch_data.get_present_fe_values (dataset);
           const unsigned int n_components =
             this_fe_patch_values.get_fe().n_components();
 
-          const DataPostprocessor<DH::space_dimension> *postprocessor=this->dof_data[dataset]->postprocessor;
+          const DataPostprocessor<DoFHandlerType::space_dimension> *postprocessor=this->dof_data[dataset]->postprocessor;
 
           if (postprocessor != 0)
             {
@@ -165,7 +166,7 @@ build_one_patch (const std::pair<cell_iterator, unsigned int>
                     scratch_data.patch_evaluation_points = this_fe_patch_values.get_quadrature_points();
 
 
-                  std::vector<Point<DH::space_dimension> > dummy_normals;
+                  std::vector<Point<DoFHandlerType::space_dimension> > dummy_normals;
                   postprocessor->
                   compute_derived_quantities_scalar(scratch_data.patch_values,
                                                     scratch_data.patch_gradients,
@@ -193,7 +194,7 @@ build_one_patch (const std::pair<cell_iterator, unsigned int>
                   if (update_flags & update_quadrature_points)
                     scratch_data.patch_evaluation_points = this_fe_patch_values.get_quadrature_points();
 
-                  std::vector<Point<DH::space_dimension> > dummy_normals;
+                  std::vector<Point<DoFHandlerType::space_dimension> > dummy_normals;
 
                   postprocessor->
                   compute_derived_quantities_vector(scratch_data.patch_values_system,
@@ -255,7 +256,7 @@ build_one_patch (const std::pair<cell_iterator, unsigned int>
     }
 
 
-  for (unsigned int f=0; f<GeometryInfo<DH::dimension>::faces_per_cell; ++f)
+  for (unsigned int f=0; f<GeometryInfo<DoFHandlerType::dimension>::faces_per_cell; ++f)
     {
       // let's look up whether the neighbor behind that face is noted in the
       // table of cells which we treat. this can only happen if the neighbor
@@ -284,7 +285,7 @@ build_one_patch (const std::pair<cell_iterator, unsigned int>
           ||
           ((*scratch_data.cell_to_patch_index_map)[neighbor->level()][neighbor->index()]
            ==
-           dealii::DataOutBase::Patch<DH::dimension>::no_neighbor))
+           dealii::DataOutBase::Patch<DoFHandlerType::dimension>::no_neighbor))
         {
           patch.neighbors[f] = numbers::invalid_unsigned_int;
           continue;
@@ -310,22 +311,23 @@ build_one_patch (const std::pair<cell_iterator, unsigned int>
 
 
 
-template <int dim, class DH>
-void DataOut<dim,DH>::build_patches (const unsigned int n_subdivisions)
+template <int dim, typename DoFHandlerType>
+void DataOut<dim,DoFHandlerType>::build_patches (const unsigned int n_subdivisions)
 {
-  build_patches (StaticMappingQ1<DH::dimension,DH::space_dimension>::mapping,
+  build_patches (StaticMappingQ1<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::mapping,
                  n_subdivisions, no_curved_cells);
 }
 
 
 
-template <int dim, class DH>
-void DataOut<dim,DH>::build_patches (const Mapping<DH::dimension,DH::space_dimension> &mapping,
-                                     const unsigned int n_subdivisions_,
-                                     const CurvedCellRegion curved_region)
+template <int dim, typename DoFHandlerType>
+void DataOut<dim,DoFHandlerType>::build_patches
+(const Mapping<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &mapping,
+ const unsigned int                                                        n_subdivisions_,
+ const CurvedCellRegion                                                    curved_region)
 {
   // Check consistency of redundant template parameter
-  Assert (dim==DH::dimension, ExcDimensionMismatch(dim, DH::dimension));
+  Assert (dim==DoFHandlerType::dimension, ExcDimensionMismatch(dim, DoFHandlerType::dimension));
 
   Assert (this->triangulation != 0,
           Exceptions::DataOut::ExcNoTriangulationSelected());
@@ -362,7 +364,8 @@ void DataOut<dim,DH>::build_patches (const Mapping<DH::dimension,DH::space_dimen
                                 static_cast<unsigned int>(cell->index()));
 
       cell_to_patch_index_map[l].resize (max_index+1,
-                                         dealii::DataOutBase::Patch<DH::dimension,DH::space_dimension>::no_neighbor);
+                                         dealii::DataOutBase::Patch<DoFHandlerType::dimension,
+                                         DoFHandlerType::space_dimension>::no_neighbor);
     }
 
   // will be all_cells[patch_index] = pair(cell, active_index)
@@ -434,7 +437,7 @@ void DataOut<dim,DH>::build_patches (const Mapping<DH::dimension,DH::space_dimen
           ExcMessage("The update of normal vectors may not be requested for evaluation of "
                      "data on cells via DataPostprocessor."));
 
-  internal::DataOut::ParallelData<DH::dimension, DH::space_dimension>
+  internal::DataOut::ParallelData<DoFHandlerType::dimension, DoFHandlerType::space_dimension>
   thread_data (n_datasets, n_subdivisions,
                n_postprocessor_outputs,
                mapping,
@@ -446,7 +449,7 @@ void DataOut<dim,DH>::build_patches (const Mapping<DH::dimension,DH::space_dimen
   if (all_cells.size() > 0)
     WorkStream::run (&all_cells[0],
                      &all_cells[0]+all_cells.size(),
-                     std_cxx11::bind(&DataOut<dim,DH>::build_one_patch,
+                     std_cxx11::bind(&DataOut<dim,DoFHandlerType>::build_one_patch,
                                      this,
                                      std_cxx11::_1,
                                      std_cxx11::_2,
@@ -472,22 +475,23 @@ void DataOut<dim,DH>::build_patches (const Mapping<DH::dimension,DH::space_dimen
 
 
 
-template <int dim, class DH>
-typename DataOut<dim,DH>::cell_iterator
-DataOut<dim,DH>::first_cell ()
+template <int dim, typename DoFHandlerType>
+typename DataOut<dim,DoFHandlerType>::cell_iterator
+DataOut<dim,DoFHandlerType>::first_cell ()
 {
   return this->triangulation->begin_active ();
 }
 
 
 
-template <int dim, class DH>
-typename DataOut<dim,DH>::cell_iterator
-DataOut<dim,DH>::next_cell (const typename DataOut<dim,DH>::cell_iterator &cell)
+template <int dim, typename DoFHandlerType>
+typename DataOut<dim,DoFHandlerType>::cell_iterator
+DataOut<dim,DoFHandlerType>::next_cell
+(const typename DataOut<dim,DoFHandlerType>::cell_iterator &cell)
 {
   // convert the iterator to an active_iterator and advance this to the next
   // active cell
-  typename Triangulation<DH::dimension,DH::space_dimension>::
+  typename Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension>::
   active_cell_iterator active_cell = cell;
   ++active_cell;
   return active_cell;
@@ -495,11 +499,11 @@ DataOut<dim,DH>::next_cell (const typename DataOut<dim,DH>::cell_iterator &cell)
 
 
 
-template <int dim, class DH>
-typename DataOut<dim,DH>::cell_iterator
-DataOut<dim,DH>::first_locally_owned_cell ()
+template <int dim, typename DoFHandlerType>
+typename DataOut<dim,DoFHandlerType>::cell_iterator
+DataOut<dim,DoFHandlerType>::first_locally_owned_cell ()
 {
-  typename DataOut<dim,DH>::cell_iterator
+  typename DataOut<dim,DoFHandlerType>::cell_iterator
   cell = first_cell();
 
   // skip cells if the current one has no children (is active) and is a ghost
@@ -514,11 +518,12 @@ DataOut<dim,DH>::first_locally_owned_cell ()
 
 
 
-template <int dim, class DH>
-typename DataOut<dim,DH>::cell_iterator
-DataOut<dim,DH>::next_locally_owned_cell (const typename DataOut<dim,DH>::cell_iterator &old_cell)
+template <int dim, typename DoFHandlerType>
+typename DataOut<dim,DoFHandlerType>::cell_iterator
+DataOut<dim,DoFHandlerType>::next_locally_owned_cell
+(const typename DataOut<dim,DoFHandlerType>::cell_iterator &old_cell)
 {
-  typename DataOut<dim,DH>::cell_iterator
+  typename DataOut<dim,DoFHandlerType>::cell_iterator
   cell = next_cell(old_cell);
   while ((cell != this->triangulation->end()) &&
          (cell->has_children() == false) &&
diff --git a/source/numerics/data_out_dof_data.cc b/source/numerics/data_out_dof_data.cc
index dad80cdfa9..5691ede97a 100644
--- a/source/numerics/data_out_dof_data.cc
+++ b/source/numerics/data_out_dof_data.cc
@@ -206,12 +206,12 @@ namespace internal
 
 
     template <int dim, int spacedim>
-    template <typename DH>
+    template <typename DoFHandlerType>
     void
     ParallelDataBase<dim,spacedim>::
-    reinit_all_fe_values(std::vector<std_cxx11::shared_ptr<DataEntryBase<DH> > > &dof_data,
-                         const typename dealii::Triangulation<dim,spacedim>::cell_iterator &cell,
-                         const unsigned int face)
+    reinit_all_fe_values(std::vector<std_cxx11::shared_ptr<DataEntryBase<DoFHandlerType> > > &dof_data,
+                         const typename dealii::Triangulation<dim,spacedim>::cell_iterator   &cell,
+                         const unsigned int                                                   face)
     {
       for (unsigned int dataset=0; dataset<dof_data.size(); ++dataset)
         {
@@ -221,10 +221,10 @@ namespace internal
               duplicate = true;
           if (duplicate == false)
             {
-              typename DH::active_cell_iterator dh_cell(&cell->get_triangulation(),
-                                                        cell->level(),
-                                                        cell->index(),
-                                                        dof_data[dataset]->dof_handler);
+              typename DoFHandlerType::active_cell_iterator dh_cell(&cell->get_triangulation(),
+                                                                    cell->level(),
+                                                                    cell->index(),
+                                                                    dof_data[dataset]->dof_handler);
               if (x_fe_values.empty())
                 {
                   AssertIndexRange(face,
@@ -306,12 +306,13 @@ namespace internal
 {
   namespace DataOut
   {
-    template <class DH>
-    DataEntryBase<DH>::DataEntryBase (const DH                       *dofs,
-                                      const std::vector<std::string> &names_in,
-                                      const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation)
+    template <typename DoFHandlerType>
+    DataEntryBase<DoFHandlerType>::DataEntryBase
+    (const DoFHandlerType           *dofs,
+     const std::vector<std::string> &names_in,
+     const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation)
       :
-      dof_handler (dofs, typeid(dealii::DataOut_DoFData<DH,DH::dimension,DH::space_dimension>).name()),
+      dof_handler (dofs, typeid(dealii::DataOut_DoFData<DoFHandlerType,DoFHandlerType::dimension,DoFHandlerType::space_dimension>).name()),
       names(names_in),
       data_component_interpretation (data_component_interpretation),
       postprocessor(0, typeid(*this).name()),
@@ -334,11 +335,12 @@ namespace internal
 
 
 
-    template <class DH>
-    DataEntryBase<DH>::DataEntryBase (const DH *dofs,
-                                      const DataPostprocessor<DH::space_dimension> *data_postprocessor)
+    template <typename DoFHandlerType>
+    DataEntryBase<DoFHandlerType>::DataEntryBase
+    (const DoFHandlerType *dofs,
+     const DataPostprocessor<DoFHandlerType::space_dimension> *data_postprocessor)
       :
-      dof_handler (dofs, typeid(dealii::DataOut_DoFData<DH,DH::dimension,DH::space_dimension>).name()),
+      dof_handler (dofs, typeid(dealii::DataOut_DoFData<DoFHandlerType,DoFHandlerType::dimension,DoFHandlerType::space_dimension>).name()),
       names(data_postprocessor->get_names()),
       data_component_interpretation (data_postprocessor->get_data_component_interpretation()),
       postprocessor(data_postprocessor, typeid(*this).name()),
@@ -363,8 +365,8 @@ namespace internal
 
 
 
-    template <class DH>
-    DataEntryBase<DH>::~DataEntryBase ()
+    template <typename DoFHandlerType>
+    DataEntryBase<DoFHandlerType>::~DataEntryBase ()
     {}
 
 
@@ -375,8 +377,8 @@ namespace internal
      *
      * @author Wolfgang Bangerth, 2004
      */
-    template <class DH, typename VectorType>
-    class DataEntry : public DataEntryBase<DH>
+    template <typename DoFHandlerType, typename VectorType>
+    class DataEntry : public DataEntryBase<DoFHandlerType>
     {
     public:
       /**
@@ -384,19 +386,20 @@ namespace internal
        * the vector and their interpretation as scalar or vector data. This
        * constructor assumes that no postprocessor is going to be used.
        */
-      DataEntry (const DH                       *dofs,
-                 const VectorType               *data,
-                 const std::vector<std::string> &names,
-                 const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation);
+      DataEntry
+      (const DoFHandlerType           *dofs,
+       const VectorType               *data,
+       const std::vector<std::string> &names,
+       const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation);
 
       /**
        * Constructor when a data postprocessor is going to be used. In that
        * case, the names and vector declarations are going to be acquired from
        * the postprocessor.
        */
-      DataEntry (const DH                                     *dofs,
-                 const VectorType                             *data,
-                 const DataPostprocessor<DH::space_dimension> *data_postprocessor);
+      DataEntry (const DoFHandlerType                                     *dofs,
+                 const VectorType                                         *data,
+                 const DataPostprocessor<DoFHandlerType::space_dimension> *data_postprocessor);
 
       /**
        * Assuming that the stored vector is a cell vector, extract the given
@@ -412,8 +415,9 @@ namespace internal
        */
       virtual
       void
-      get_function_values (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-                           std::vector<double>             &patch_values) const;
+      get_function_values
+      (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+       std::vector<double> &patch_values) const;
 
       /**
        * Given a FEValuesBase object, extract the values on the present cell
@@ -422,8 +426,9 @@ namespace internal
        */
       virtual
       void
-      get_function_values (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-                           std::vector<dealii::Vector<double> >    &patch_values_system) const;
+      get_function_values
+      (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+       std::vector<dealii::Vector<double> > &patch_values_system) const;
 
       /**
        * Given a FEValuesBase object, extract the gradients on the present
@@ -431,8 +436,9 @@ namespace internal
        */
       virtual
       void
-      get_function_gradients (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-                              std::vector<Tensor<1,DH::space_dimension> >       &patch_gradients) const;
+      get_function_gradients
+      (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+       std::vector<Tensor<1,DoFHandlerType::space_dimension> > &patch_gradients) const;
 
       /**
        * Given a FEValuesBase object, extract the gradients on the present
@@ -441,8 +447,9 @@ namespace internal
        */
       virtual
       void
-      get_function_gradients (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-                              std::vector<std::vector<Tensor<1,DH::space_dimension> > > &patch_gradients_system) const;
+      get_function_gradients
+      (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+       std::vector<std::vector<Tensor<1,DoFHandlerType::space_dimension> > > &patch_gradients_system) const;
 
       /**
        * Given a FEValuesBase object, extract the second derivatives on the
@@ -450,8 +457,9 @@ namespace internal
        */
       virtual
       void
-      get_function_hessians (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-                             std::vector<Tensor<2,DH::space_dimension> >       &patch_hessians) const;
+      get_function_hessians
+      (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+       std::vector<Tensor<2,DoFHandlerType::space_dimension> > &patch_hessians) const;
 
       /**
        * Given a FEValuesBase object, extract the second derivatives on the
@@ -460,8 +468,9 @@ namespace internal
        */
       virtual
       void
-      get_function_hessians (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-                             std::vector<std::vector< Tensor<2,DH::space_dimension> > > &patch_hessians_system) const;
+      get_function_hessians
+      (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+       std::vector<std::vector< Tensor<2,DoFHandlerType::space_dimension> > > &patch_hessians_system) const;
 
       /**
        * Clear all references to the vectors.
@@ -484,26 +493,26 @@ namespace internal
 
 
 
-    template <class DH, typename VectorType>
-    DataEntry<DH,VectorType>::
-    DataEntry (const DH                               *dofs,
-               const VectorType                       *data,
-               const std::vector<std::string>         &names,
+    template <typename DoFHandlerType, typename VectorType>
+    DataEntry<DoFHandlerType,VectorType>::
+    DataEntry (const DoFHandlerType           *dofs,
+               const VectorType               *data,
+               const std::vector<std::string> &names,
                const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation)
       :
-      DataEntryBase<DH> (dofs, names, data_component_interpretation),
+      DataEntryBase<DoFHandlerType> (dofs, names, data_component_interpretation),
       vector (data)
     {}
 
 
 
-    template <class DH, typename VectorType>
-    DataEntry<DH,VectorType>::
-    DataEntry (const DH                                     *dofs,
-               const VectorType                             *data,
-               const DataPostprocessor<DH::space_dimension> *data_postprocessor)
+    template <typename DoFHandlerType, typename VectorType>
+    DataEntry<DoFHandlerType,VectorType>::
+    DataEntry (const DoFHandlerType                                     *dofs,
+               const VectorType                                         *data,
+               const DataPostprocessor<DoFHandlerType::space_dimension> *data_postprocessor)
       :
-      DataEntryBase<DH> (dofs, data_postprocessor),
+      DataEntryBase<DoFHandlerType> (dofs, data_postprocessor),
       vector (data)
     {}
 
@@ -529,9 +538,9 @@ namespace internal
 
 
 
-    template <class DH, typename VectorType>
+    template <typename DoFHandlerType, typename VectorType>
     double
-    DataEntry<DH,VectorType>::
+    DataEntry<DoFHandlerType,VectorType>::
     get_cell_data_value (const unsigned int cell_number) const
     {
       return get_vector_element(*vector, cell_number);
@@ -539,10 +548,10 @@ namespace internal
 
 
 
-    template <class DH, typename VectorType>
+    template <typename DoFHandlerType, typename VectorType>
     void
-    DataEntry<DH,VectorType>::get_function_values
-    (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
+    DataEntry<DoFHandlerType,VectorType>::get_function_values
+    (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
      std::vector<dealii::Vector<double> >                  &patch_values_system) const
     {
       // FIXME: FEValuesBase gives us data in types that match that of
@@ -582,10 +591,10 @@ namespace internal
 
 
 
-    template <class DH, typename VectorType>
+    template <typename DoFHandlerType, typename VectorType>
     void
-    DataEntry<DH,VectorType>::get_function_values
-    (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
+    DataEntry<DoFHandlerType,VectorType>::get_function_values
+    (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
      std::vector<double>                                   &patch_values) const
     {
       // FIXME: FEValuesBase gives us data in types that match that of
@@ -623,11 +632,11 @@ namespace internal
 
 
 
-    template <class DH, typename VectorType>
+    template <typename DoFHandlerType, typename VectorType>
     void
-    DataEntry<DH,VectorType>::get_function_gradients
-    (const FEValuesBase<DH::dimension,DH::space_dimension>     &fe_patch_values,
-     std::vector<std::vector<Tensor<1,DH::space_dimension> > > &patch_gradients_system) const
+    DataEntry<DoFHandlerType,VectorType>::get_function_gradients
+    (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension>     &fe_patch_values,
+     std::vector<std::vector<Tensor<1,DoFHandlerType::space_dimension> > > &patch_gradients_system) const
     {
       // FIXME: FEValuesBase gives us data in types that match that of
       // the solution vector. but this function needs to pass it back
@@ -648,12 +657,14 @@ namespace internal
                                                   // identity cast whenever the code is
                                                   // executed, but the cast is necessary
                                                   // to allow compilation even if we don't get here
-                                                  reinterpret_cast<std::vector<std::vector<Tensor<1,DH::space_dimension,typename VectorType::value_type> > >&>
+                                                  reinterpret_cast<std::vector<std::vector<Tensor<1,DoFHandlerType::space_dimension,typename VectorType::value_type> > >&>
                                                   (patch_gradients_system));
         }
       else
         {
-          std::vector<std::vector<Tensor<1,DH::space_dimension,typename VectorType::value_type> > > tmp(patch_gradients_system.size());
+          std::vector<std::vector<Tensor<1,DoFHandlerType::space_dimension,
+              typename VectorType::value_type> > >
+              tmp(patch_gradients_system.size());
           for (unsigned int i = 0; i < tmp.size(); i++)
             tmp[i].resize(patch_gradients_system[i].size());
 
@@ -667,11 +678,11 @@ namespace internal
 
 
 
-    template <class DH, typename VectorType>
+    template <typename DoFHandlerType, typename VectorType>
     void
-    DataEntry<DH,VectorType>::get_function_gradients
-    (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-     std::vector<Tensor<1,DH::space_dimension> >           &patch_gradients) const
+    DataEntry<DoFHandlerType,VectorType>::get_function_gradients
+    (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+     std::vector<Tensor<1,DoFHandlerType::space_dimension> >           &patch_gradients) const
     {
       // FIXME: FEValuesBase gives us data in types that match that of
       // the solution vector. but this function needs to pass it back
@@ -692,12 +703,12 @@ namespace internal
                                                   // identity cast whenever the code is
                                                   // executed, but the cast is necessary
                                                   // to allow compilation even if we don't get here
-                                                  reinterpret_cast<std::vector<Tensor<1,DH::space_dimension,typename VectorType::value_type> >&>
+                                                  reinterpret_cast<std::vector<Tensor<1,DoFHandlerType::space_dimension,typename VectorType::value_type> >&>
                                                   (patch_gradients));
         }
       else
         {
-          std::vector<Tensor<1,DH::space_dimension,typename VectorType::value_type> >  tmp;
+          std::vector<Tensor<1,DoFHandlerType::space_dimension,typename VectorType::value_type> >  tmp;
           tmp.resize(patch_gradients.size());
 
           fe_patch_values.get_function_gradients (*vector, tmp);
@@ -709,11 +720,11 @@ namespace internal
 
 
 
-    template <class DH, typename VectorType>
+    template <typename DoFHandlerType, typename VectorType>
     void
-    DataEntry<DH,VectorType>::get_function_hessians
-    (const FEValuesBase<DH::dimension,DH::space_dimension>     &fe_patch_values,
-     std::vector<std::vector<Tensor<2,DH::space_dimension> > > &patch_hessians_system) const
+    DataEntry<DoFHandlerType,VectorType>::get_function_hessians
+    (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+     std::vector<std::vector<Tensor<2,DoFHandlerType::space_dimension> > > &patch_hessians_system) const
     {
       // FIXME: FEValuesBase gives us data in types that match that of
       // the solution vector. but this function needs to pass it back
@@ -734,12 +745,14 @@ namespace internal
                                                  // identity cast whenever the code is
                                                  // executed, but the cast is necessary
                                                  // to allow compilation even if we don't get here
-                                                 reinterpret_cast<std::vector<std::vector<Tensor<2,DH::space_dimension,typename VectorType::value_type> > >&>
+                                                 reinterpret_cast<std::vector<std::vector<Tensor<2,DoFHandlerType::space_dimension,typename VectorType::value_type> > >&>
                                                  (patch_hessians_system));
         }
       else
         {
-          std::vector<std::vector<Tensor<2,DH::space_dimension,typename VectorType::value_type> > > tmp(patch_hessians_system.size());
+          std::vector<std::vector<Tensor<2,DoFHandlerType::space_dimension,
+              typename VectorType::value_type> > >
+              tmp(patch_hessians_system.size());
           for (unsigned int i = 0; i < tmp.size(); i++)
             tmp[i].resize(patch_hessians_system[i].size());
 
@@ -753,11 +766,11 @@ namespace internal
 
 
 
-    template <class DH, typename VectorType>
+    template <typename DoFHandlerType, typename VectorType>
     void
-    DataEntry<DH,VectorType>::get_function_hessians
-    (const FEValuesBase<DH::dimension,DH::space_dimension> &fe_patch_values,
-     std::vector<Tensor<2,DH::space_dimension> >           &patch_hessians) const
+    DataEntry<DoFHandlerType,VectorType>::get_function_hessians
+    (const FEValuesBase<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &fe_patch_values,
+     std::vector<Tensor<2,DoFHandlerType::space_dimension> >                       &patch_hessians) const
     {
       // FIXME: FEValuesBase gives us data in types that match that of
       // the solution vector. but this function needs to pass it back
@@ -778,12 +791,14 @@ namespace internal
                                                  // identity cast whenever the code is
                                                  // executed, but the cast is necessary
                                                  // to allow compilation even if we don't get here
-                                                 reinterpret_cast<std::vector<Tensor<2,DH::space_dimension,typename VectorType::value_type> >&>
+                                                 reinterpret_cast<std::vector<Tensor<2,DoFHandlerType
+                                                 ::space_dimension,typename VectorType::value_type> >&>
                                                  (patch_hessians));
         }
       else
         {
-          std::vector<Tensor<2,DH::space_dimension,typename VectorType::value_type> > tmp(patch_hessians.size());
+          std::vector<Tensor<2,DoFHandlerType::space_dimension,typename VectorType::value_type> >
+          tmp(patch_hessians.size());
 
           fe_patch_values.get_function_hessians (*vector, tmp);
 
@@ -794,9 +809,9 @@ namespace internal
 
 
 
-    template <class DH, typename VectorType>
+    template <typename DoFHandlerType, typename VectorType>
     std::size_t
-    DataEntry<DH,VectorType>::memory_consumption () const
+    DataEntry<DoFHandlerType,VectorType>::memory_consumption () const
     {
       return (sizeof (vector) +
               MemoryConsumption::memory_consumption (this->names));
@@ -804,9 +819,9 @@ namespace internal
 
 
 
-    template <class DH, typename VectorType>
+    template <typename DoFHandlerType, typename VectorType>
     void
-    DataEntry<DH,VectorType>::clear ()
+    DataEntry<DoFHandlerType,VectorType>::clear ()
     {
       vector = 0;
       this->dof_handler = 0;
@@ -816,9 +831,9 @@ namespace internal
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::DataOut_DoFData ()
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::DataOut_DoFData ()
   :
   triangulation(0,typeid(*this).name()),
   dofs(0,typeid(*this).name())
@@ -826,51 +841,55 @@ DataOut_DoFData<DH,patch_dim,patch_space_dim>::DataOut_DoFData ()
 
 
 
-template <class DH, int patch_dim, int patch_space_dim>
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::~DataOut_DoFData ()
+template <typename DoFHandlerType, int patch_dim, int patch_space_dim>
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::~DataOut_DoFData ()
 {
   clear ();
 }
 
 
 
-template <class DH, int patch_dim, int patch_space_dim>
+template <typename DoFHandlerType, int patch_dim, int patch_space_dim>
 void
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::
-attach_dof_handler (const DH &d)
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::
+attach_dof_handler (const DoFHandlerType &d)
 {
   Assert (dof_data.size() == 0,
           Exceptions::DataOut::ExcOldDataStillPresent());
   Assert (cell_data.size() == 0,
           Exceptions::DataOut::ExcOldDataStillPresent());
 
-  triangulation = SmartPointer<const Triangulation<DH::dimension,DH::space_dimension> >(&d.get_tria(), typeid(*this).name());
-  dofs = SmartPointer<const DH>(&d, typeid(*this).name());
+  triangulation = SmartPointer<const Triangulation<DoFHandlerType::dimension,
+  DoFHandlerType::space_dimension> >
+  (&d.get_tria(), typeid(*this).name());
+  dofs = SmartPointer<const DoFHandlerType>(&d, typeid(*this).name());
 }
 
 
 
-template <class DH, int patch_dim, int patch_space_dim>
+template <typename DoFHandlerType, int patch_dim, int patch_space_dim>
 void
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::
-attach_triangulation (const Triangulation<DH::dimension,DH::space_dimension> &tria)
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::
+attach_triangulation (const Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> &tria)
 {
   Assert (dof_data.size() == 0,
           Exceptions::DataOut::ExcOldDataStillPresent());
   Assert (cell_data.size() == 0,
           Exceptions::DataOut::ExcOldDataStillPresent());
 
-  triangulation = SmartPointer<const Triangulation<DH::dimension,DH::space_dimension> >(&tria, typeid(*this).name());
+  triangulation = SmartPointer<const Triangulation<DoFHandlerType::dimension,
+  DoFHandlerType::space_dimension> >
+  (&tria, typeid(*this).name());
 }
 
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
 template <typename VectorType>
 void
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::
 add_data_vector (const VectorType                         &vec,
                  const std::string                        &name,
                  const DataVectorType                      type,
@@ -905,11 +924,11 @@ add_data_vector (const VectorType                         &vec,
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
 template <typename VectorType>
 void
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::
 add_data_vector (const VectorType                         &vec,
                  const std::vector<std::string>           &names,
                  const DataVectorType                      type,
@@ -970,24 +989,24 @@ add_data_vector (const VectorType                         &vec,
       Assert (false, ExcInternalError());
     }
 
-  internal::DataOut::DataEntryBase<DH> *new_entry
-    = new internal::DataOut::DataEntry<DH,VectorType>(dofs, &vec, names,
-                                                      data_component_interpretation);
+  internal::DataOut::DataEntryBase<DoFHandlerType> *new_entry
+    = new internal::DataOut::DataEntry<DoFHandlerType,VectorType>(dofs, &vec, names,
+        data_component_interpretation);
   if (actual_type == type_dof_data)
-    dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
+    dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
   else
-    cell_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
+    cell_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
 }
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
 template <typename VectorType>
 void
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::
 add_data_vector (const VectorType                       &vec,
-                 const DataPostprocessor<DH::space_dimension> &data_postprocessor)
+                 const DataPostprocessor<DoFHandlerType::space_dimension> &data_postprocessor)
 {
   // this is a specialized version of the other function where we have a
   // postprocessor. if we do, we know that we have type_dof_data, which makes
@@ -1002,21 +1021,21 @@ add_data_vector (const VectorType                       &vec,
                                                      dofs->n_dofs(),
                                                      dofs->get_tria().n_active_cells()));
 
-  internal::DataOut::DataEntryBase<DH> *new_entry
-    = new internal::DataOut::DataEntry<DH,VectorType>(dofs, &vec, &data_postprocessor);
-  dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
+  internal::DataOut::DataEntryBase<DoFHandlerType> *new_entry
+    = new internal::DataOut::DataEntry<DoFHandlerType,VectorType>(dofs, &vec, &data_postprocessor);
+  dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
 }
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
 template <typename VectorType>
 void
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::
-add_data_vector (const DH                               &dof_handler,
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::
+add_data_vector (const DoFHandlerType                   &dof_handler,
                  const VectorType                       &vec,
-                 const DataPostprocessor<DH::space_dimension> &data_postprocessor)
+                 const DataPostprocessor<DoFHandlerType::space_dimension> &data_postprocessor)
 {
   // this is a specialized version of the other function where we have a
   // postprocessor. if we do, we know that we have type_dof_data, which makes
@@ -1025,22 +1044,23 @@ add_data_vector (const DH                               &dof_handler,
 
   AssertDimension (vec.size(), dof_handler.n_dofs());
 
-  internal::DataOut::DataEntryBase<DH> *new_entry
-    = new internal::DataOut::DataEntry<DH,VectorType>(&dof_handler, &vec, &data_postprocessor);
-  dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
+  internal::DataOut::DataEntryBase<DoFHandlerType> *new_entry
+    = new internal::DataOut::DataEntry<DoFHandlerType,VectorType>(&dof_handler, &vec, &data_postprocessor);
+  dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
 }
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
 template <typename VectorType>
 void
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::
-add_data_vector (const DH                       &dof_handler,
-                 const VectorType               &data,
-                 const std::string              &name,
-                 const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation)
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::
+add_data_vector
+(const DoFHandlerType           &dof_handler,
+ const VectorType               &data,
+ const std::string              &name,
+ const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation)
 {
   const unsigned int n_components = dof_handler.get_fe().n_components ();
 
@@ -1065,21 +1085,22 @@ add_data_vector (const DH                       &dof_handler,
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
 template <typename VectorType>
 void
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::
-add_data_vector (const DH                       &dof_handler,
-                 const VectorType               &data,
-                 const std::vector<std::string> &names,
-                 const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation_)
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::
+add_data_vector
+(const DoFHandlerType           &dof_handler,
+ const VectorType               &data,
+ const std::vector<std::string> &names,
+ const std::vector<DataComponentInterpretation::DataComponentInterpretation> &data_component_interpretation_)
 {
   // this is an extended version of the other functions where we pass a vector
   // together with its DoFHandler. if we do, we know that we have
   // type_dof_data, which makes things a bit simpler
   if (triangulation == 0)
-    triangulation = SmartPointer<const Triangulation<DH::dimension,DH::space_dimension> >(&dof_handler.get_tria(), typeid(*this).name());
+    triangulation = SmartPointer<const Triangulation<DoFHandlerType::dimension,DoFHandlerType::space_dimension> >(&dof_handler.get_tria(), typeid(*this).name());
 
   Assert (&dof_handler.get_tria() == triangulation,
           ExcMessage("The triangulation attached to the DoFHandler does not "
@@ -1097,17 +1118,17 @@ add_data_vector (const DH                       &dof_handler,
        std::vector<DataComponentInterpretation::DataComponentInterpretation>
        (names.size(), DataComponentInterpretation::component_is_scalar));
 
-  internal::DataOut::DataEntryBase<DH> *new_entry
-    = new internal::DataOut::DataEntry<DH,VectorType>(&dof_handler, &data, names,
-                                                      data_component_interpretation);
-  dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> >(new_entry));
+  internal::DataOut::DataEntryBase<DoFHandlerType> *new_entry
+    = new internal::DataOut::DataEntry<DoFHandlerType,VectorType>(&dof_handler, &data, names,
+        data_component_interpretation);
+  dof_data.push_back (std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> >(new_entry));
 }
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
-void DataOut_DoFData<DH,patch_dim,patch_space_dim>::clear_data_vectors ()
+void DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::clear_data_vectors ()
 {
   dof_data.erase (dof_data.begin(), dof_data.end());
   cell_data.erase (cell_data.begin(), cell_data.end());
@@ -1119,10 +1140,10 @@ void DataOut_DoFData<DH,patch_dim,patch_space_dim>::clear_data_vectors ()
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
 void
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::
 clear_input_data_references ()
 {
   for (unsigned int i=0; i<dof_data.size(); ++i)
@@ -1137,10 +1158,10 @@ clear_input_data_references ()
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
 void
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::clear ()
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::clear ()
 {
   dof_data.erase (dof_data.begin(), dof_data.end());
   cell_data.erase (cell_data.begin(), cell_data.end());
@@ -1155,17 +1176,17 @@ DataOut_DoFData<DH,patch_dim,patch_space_dim>::clear ()
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
 std::vector<std::string>
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::
 get_dataset_names () const
 {
   std::vector<std::string> names;
   // collect the names of dof
   // and cell data
   typedef
-  typename std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> > >::const_iterator
+  typename std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > >::const_iterator
   data_iterator;
 
   for (data_iterator  d=dof_data.begin();
@@ -1183,10 +1204,10 @@ get_dataset_names () const
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
 std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::get_vector_data_ranges () const
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::get_vector_data_ranges () const
 {
   std::vector<std_cxx11::tuple<unsigned int, unsigned int, std::string> >
   ranges;
@@ -1194,7 +1215,7 @@ DataOut_DoFData<DH,patch_dim,patch_space_dim>::get_vector_data_ranges () const
   // collect the ranges of dof
   // and cell data
   typedef
-  typename std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DH> > >::const_iterator
+  typename std::vector<std_cxx11::shared_ptr<internal::DataOut::DataEntryBase<DoFHandlerType> > >::const_iterator
   data_iterator;
 
   unsigned int output_component = 0;
@@ -1277,23 +1298,24 @@ DataOut_DoFData<DH,patch_dim,patch_space_dim>::get_vector_data_ranges () const
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
 const std::vector< dealii::DataOutBase::Patch<patch_dim, patch_space_dim> > &
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::get_patches () const
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::get_patches () const
 {
   return patches;
 }
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
-std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<DH::dimension,DH::space_dimension> > >
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::get_finite_elements() const
+std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<DoFHandlerType::dimension,
+    DoFHandlerType::space_dimension> > >
+    DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::get_finite_elements() const
 {
-  const unsigned int dhdim = DH::dimension;
-  const unsigned int dhspacedim = DH::space_dimension;
+  const unsigned int dhdim = DoFHandlerType::dimension;
+  const unsigned int dhspacedim = DoFHandlerType::space_dimension;
   std::vector<std_cxx11::shared_ptr<dealii::hp::FECollection<dhdim,dhspacedim> > >
   finite_elements(this->dof_data.size());
   for (unsigned int i=0; i<this->dof_data.size(); ++i)
@@ -1329,10 +1351,10 @@ DataOut_DoFData<DH,patch_dim,patch_space_dim>::get_finite_elements() const
 
 
 
-template <class DH,
+template <typename DoFHandlerType,
           int patch_dim, int patch_space_dim>
 std::size_t
-DataOut_DoFData<DH,patch_dim,patch_space_dim>::memory_consumption () const
+DataOut_DoFData<DoFHandlerType,patch_dim,patch_space_dim>::memory_consumption () const
 {
   return (DataOutInterface<patch_dim,patch_space_dim>::memory_consumption () +
           MemoryConsumption::memory_consumption (dofs) +
diff --git a/source/numerics/data_out_faces.cc b/source/numerics/data_out_faces.cc
index c67af1892b..170656c2d9 100644
--- a/source/numerics/data_out_faces.cc
+++ b/source/numerics/data_out_faces.cc
@@ -72,20 +72,20 @@ namespace internal
 
 
 
-template <int dim, class DH>
-DataOutFaces<dim,DH>::DataOutFaces(const bool so)
+template <int dim, typename DoFHandlerType>
+DataOutFaces<dim,DoFHandlerType>::DataOutFaces(const bool so)
   :
   surface_only(so)
 {
-  Assert (dim == DH::dimension,
+  Assert (dim == DoFHandlerType::dimension,
           ExcNotImplemented());
 }
 
 
 
-template <int dim, class DH>
+template <int dim, typename DoFHandlerType>
 void
-DataOutFaces<dim,DH>::
+DataOutFaces<dim,DoFHandlerType>::
 build_one_patch (const FaceDescriptor *cell_and_face,
                  internal::DataOutFaces::ParallelData<dimension, dimension> &data,
                  DataOutBase::Patch<dimension-1,space_dimension>  &patch)
@@ -269,17 +269,17 @@ build_one_patch (const FaceDescriptor *cell_and_face,
 
 
 
-template <int dim, class DH>
-void DataOutFaces<dim,DH>::build_patches (const unsigned int n_subdivisions_)
+template <int dim, typename DoFHandlerType>
+void DataOutFaces<dim,DoFHandlerType>::build_patches (const unsigned int n_subdivisions_)
 {
   build_patches (StaticMappingQ1<dimension>::mapping, n_subdivisions_);
 }
 
 
 
-template <int dim, class DH>
-void DataOutFaces<dim,DH>::build_patches (const Mapping<dimension> &mapping,
-                                          const unsigned int n_subdivisions_)
+template <int dim, typename DoFHandlerType>
+void DataOutFaces<dim,DoFHandlerType>::build_patches (const Mapping<dimension> &mapping,
+                                                      const unsigned int n_subdivisions_)
 {
   // Check consistency of redundant template parameter
   Assert (dim==dimension, ExcDimensionMismatch(dim, dimension));
@@ -340,7 +340,7 @@ void DataOutFaces<dim,DH>::build_patches (const Mapping<dimension> &mapping,
   // now build the patches in parallel
   WorkStream::run (&all_faces[0],
                    &all_faces[0]+all_faces.size(),
-                   std_cxx11::bind(&DataOutFaces<dim,DH>::build_one_patch,
+                   std_cxx11::bind(&DataOutFaces<dim,DoFHandlerType>::build_one_patch,
                                    this, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3),
                    std_cxx11::bind(&internal::DataOutFaces::
                                    append_patch_to_list<dim,space_dimension>,
@@ -351,9 +351,9 @@ void DataOutFaces<dim,DH>::build_patches (const Mapping<dimension> &mapping,
 
 
 
-template <int dim, class DH>
-typename DataOutFaces<dim,DH>::FaceDescriptor
-DataOutFaces<dim,DH>::first_face ()
+template <int dim, typename DoFHandlerType>
+typename DataOutFaces<dim,DoFHandlerType>::FaceDescriptor
+DataOutFaces<dim,DoFHandlerType>::first_face ()
 {
   // simply find first active cell
   // with a face on the boundary
@@ -372,9 +372,9 @@ DataOutFaces<dim,DH>::first_face ()
 
 
 
-template <int dim, class DH>
-typename DataOutFaces<dim,DH>::FaceDescriptor
-DataOutFaces<dim,DH>::next_face (const FaceDescriptor &old_face)
+template <int dim, typename DoFHandlerType>
+typename DataOutFaces<dim,DoFHandlerType>::FaceDescriptor
+DataOutFaces<dim,DoFHandlerType>::next_face (const FaceDescriptor &old_face)
 {
   FaceDescriptor face = old_face;
 
diff --git a/source/numerics/data_out_rotation.cc b/source/numerics/data_out_rotation.cc
index 701f8c058a..9b29b06807 100644
--- a/source/numerics/data_out_rotation.cc
+++ b/source/numerics/data_out_rotation.cc
@@ -90,9 +90,9 @@ namespace internal
 
 
 
-template <int dim, class DH>
+template <int dim, typename DoFHandlerType>
 void
-DataOutRotation<dim,DH>::
+DataOutRotation<dim,DoFHandlerType>::
 build_one_patch (const cell_iterator *cell,
                  internal::DataOutRotation::ParallelData<dimension, space_dimension> &data,
                  std::vector<DataOutBase::Patch<dimension+1,space_dimension+1> > &patches)
@@ -398,9 +398,9 @@ build_one_patch (const cell_iterator *cell,
 
 
 
-template <int dim, class DH>
-void DataOutRotation<dim,DH>::build_patches (const unsigned int n_patches_per_circle,
-                                             const unsigned int nnnn_subdivisions)
+template <int dim, typename DoFHandlerType>
+void DataOutRotation<dim,DoFHandlerType>::build_patches (const unsigned int n_patches_per_circle,
+                                                         const unsigned int nnnn_subdivisions)
 {
   // Check consistency of redundant
   // template parameter
@@ -472,7 +472,7 @@ void DataOutRotation<dim,DH>::build_patches (const unsigned int n_patches_per_ci
   // now build the patches in parallel
   WorkStream::run (&all_cells[0],
                    &all_cells[0]+all_cells.size(),
-                   std_cxx11::bind(&DataOutRotation<dim,DH>::build_one_patch,
+                   std_cxx11::bind(&DataOutRotation<dim,DoFHandlerType>::build_one_patch,
                                    this, std_cxx11::_1, std_cxx11::_2, std_cxx11::_3),
                    std_cxx11::bind(&internal::DataOutRotation
                                    ::append_patch_to_list<dim,space_dimension>,
@@ -483,17 +483,17 @@ void DataOutRotation<dim,DH>::build_patches (const unsigned int n_patches_per_ci
 
 
 
-template <int dim, class DH>
-typename DataOutRotation<dim,DH>::cell_iterator
-DataOutRotation<dim,DH>::first_cell ()
+template <int dim, typename DoFHandlerType>
+typename DataOutRotation<dim,DoFHandlerType>::cell_iterator
+DataOutRotation<dim,DoFHandlerType>::first_cell ()
 {
   return this->triangulation->begin_active ();
 }
 
 
-template <int dim, class DH>
-typename DataOutRotation<dim,DH>::cell_iterator
-DataOutRotation<dim,DH>::next_cell (const cell_iterator &cell)
+template <int dim, typename DoFHandlerType>
+typename DataOutRotation<dim,DoFHandlerType>::cell_iterator
+DataOutRotation<dim,DoFHandlerType>::next_cell (const cell_iterator &cell)
 {
   // convert the iterator to an
   // active_iterator and advance
diff --git a/source/numerics/data_out_stack.cc b/source/numerics/data_out_stack.cc
index 350c155d9c..de75811f47 100644
--- a/source/numerics/data_out_stack.cc
+++ b/source/numerics/data_out_stack.cc
@@ -31,9 +31,9 @@
 DEAL_II_NAMESPACE_OPEN
 
 
-template <int dim, int spacedim, class DH>
+template <int dim, int spacedim, typename DoFHandlerType>
 std::size_t
-DataOutStack<dim,spacedim,DH>::DataVector::memory_consumption () const
+DataOutStack<dim,spacedim,DoFHandlerType>::DataVector::memory_consumption () const
 {
   return (MemoryConsumption::memory_consumption (data) +
           MemoryConsumption::memory_consumption (names));
@@ -41,14 +41,14 @@ DataOutStack<dim,spacedim,DH>::DataVector::memory_consumption () const
 
 
 
-template <int dim, int spacedim, class DH>
-DataOutStack<dim,spacedim,DH>::~DataOutStack ()
+template <int dim, int spacedim, typename DoFHandlerType>
+DataOutStack<dim,spacedim,DoFHandlerType>::~DataOutStack ()
 {}
 
 
-template <int dim, int spacedim, class DH>
-void DataOutStack<dim,spacedim,DH>::new_parameter_value (const double p,
-                                                         const double dp)
+template <int dim, int spacedim, typename DoFHandlerType>
+void DataOutStack<dim,spacedim,DoFHandlerType>::new_parameter_value (const double p,
+    const double dp)
 {
   parameter      = p;
   parameter_step = dp;
@@ -69,20 +69,20 @@ void DataOutStack<dim,spacedim,DH>::new_parameter_value (const double p,
 }
 
 
-template <int dim, int spacedim, class DH>
-void DataOutStack<dim,spacedim,DH>::attach_dof_handler (const DH &dof)
+template <int dim, int spacedim, typename DoFHandlerType>
+void DataOutStack<dim,spacedim,DoFHandlerType>::attach_dof_handler (const DoFHandlerType &dof)
 {
   // Check consistency of redundant
   // template parameter
-  Assert (dim==DH::dimension, ExcDimensionMismatch(dim, DH::dimension));
+  Assert (dim==DoFHandlerType::dimension, ExcDimensionMismatch(dim, DoFHandlerType::dimension));
 
   dof_handler = &dof;
 }
 
 
-template <int dim, int spacedim, class DH>
-void DataOutStack<dim,spacedim,DH>::declare_data_vector (const std::string &name,
-                                                         const VectorType   vector_type)
+template <int dim, int spacedim, typename DoFHandlerType>
+void DataOutStack<dim,spacedim,DoFHandlerType>::declare_data_vector (const std::string &name,
+    const VectorType   vector_type)
 {
   std::vector<std::string> names;
   names.push_back (name);
@@ -90,9 +90,9 @@ void DataOutStack<dim,spacedim,DH>::declare_data_vector (const std::string &name
 }
 
 
-template <int dim, int spacedim, class DH>
-void DataOutStack<dim,spacedim,DH>::declare_data_vector (const std::vector<std::string> &names,
-                                                         const VectorType    vector_type)
+template <int dim, int spacedim, typename DoFHandlerType>
+void DataOutStack<dim,spacedim,DoFHandlerType>::declare_data_vector (const std::vector<std::string> &names,
+    const VectorType    vector_type)
 {
   // make sure this function is
   // not called after some parameter
@@ -130,10 +130,10 @@ void DataOutStack<dim,spacedim,DH>::declare_data_vector (const std::vector<std::
 }
 
 
-template <int dim, int spacedim, class DH>
+template <int dim, int spacedim, typename DoFHandlerType>
 template <typename number>
-void DataOutStack<dim,spacedim,DH>::add_data_vector (const Vector<number> &vec,
-                                                     const std::string    &name)
+void DataOutStack<dim,spacedim,DoFHandlerType>::add_data_vector (const Vector<number> &vec,
+    const std::string    &name)
 {
   const unsigned int n_components = dof_handler->get_fe().n_components ();
 
@@ -163,10 +163,10 @@ void DataOutStack<dim,spacedim,DH>::add_data_vector (const Vector<number> &vec,
 }
 
 
-template <int dim, int spacedim, class DH>
+template <int dim, int spacedim, typename DoFHandlerType>
 template <typename number>
-void DataOutStack<dim,spacedim,DH>::add_data_vector (const Vector<number> &vec,
-                                                     const std::vector<std::string> &names)
+void DataOutStack<dim,spacedim,DoFHandlerType>::add_data_vector (const Vector<number> &vec,
+    const std::vector<std::string> &names)
 {
   Assert (dof_handler != 0,
           Exceptions::DataOut::ExcNoDoFHandlerSelected ());
@@ -232,8 +232,8 @@ void DataOutStack<dim,spacedim,DH>::add_data_vector (const Vector<number> &vec,
 }
 
 
-template <int dim, int spacedim, class DH>
-void DataOutStack<dim,spacedim,DH>::build_patches (const unsigned int nnnn_subdivisions)
+template <int dim, int spacedim, typename DoFHandlerType>
+void DataOutStack<dim,spacedim,DoFHandlerType>::build_patches (const unsigned int nnnn_subdivisions)
 {
   // this is mostly copied from the
   // DataOut class
@@ -254,7 +254,7 @@ void DataOutStack<dim,spacedim,DH>::build_patches (const unsigned int nnnn_subdi
   // create patches of and make sure
   // there is enough memory for that
   unsigned int n_patches = 0;
-  for (typename DH::active_cell_iterator
+  for (typename DoFHandlerType::active_cell_iterator
        cell=dof_handler->begin_active();
        cell != dof_handler->end(); ++cell)
     ++n_patches;
@@ -302,7 +302,7 @@ void DataOutStack<dim,spacedim,DH>::build_patches (const unsigned int nnnn_subdi
   typename std::vector< dealii::DataOutBase::Patch<dim+1,dim+1> >::iterator
   patch = patches.begin() + (patches.size()-n_patches);
   unsigned int cell_number = 0;
-  for (typename DH::active_cell_iterator cell=dof_handler->begin_active();
+  for (typename DoFHandlerType::active_cell_iterator cell=dof_handler->begin_active();
        cell != dof_handler->end(); ++cell, ++patch, ++cell_number)
     {
       Assert (cell->is_locally_owned(),
@@ -415,8 +415,8 @@ void DataOutStack<dim,spacedim,DH>::build_patches (const unsigned int nnnn_subdi
 }
 
 
-template <int dim, int spacedim, class DH>
-void DataOutStack<dim,spacedim,DH>::finish_parameter_value ()
+template <int dim, int spacedim, typename DoFHandlerType>
+void DataOutStack<dim,spacedim,DoFHandlerType>::finish_parameter_value ()
 {
   // release lock on dof handler
   dof_handler = 0;
@@ -431,9 +431,9 @@ void DataOutStack<dim,spacedim,DH>::finish_parameter_value ()
 
 
 
-template <int dim, int spacedim, class DH>
+template <int dim, int spacedim, typename DoFHandlerType>
 std::size_t
-DataOutStack<dim,spacedim,DH>::memory_consumption () const
+DataOutStack<dim,spacedim,DoFHandlerType>::memory_consumption () const
 {
   return (DataOutInterface<dim+1>::memory_consumption () +
           MemoryConsumption::memory_consumption (parameter) +
@@ -446,17 +446,17 @@ DataOutStack<dim,spacedim,DH>::memory_consumption () const
 
 
 
-template <int dim, int spacedim, class DH>
+template <int dim, int spacedim, typename DoFHandlerType>
 const std::vector< dealii::DataOutBase::Patch<dim+1,dim+1> > &
-DataOutStack<dim,spacedim,DH>::get_patches () const
+DataOutStack<dim,spacedim,DoFHandlerType>::get_patches () const
 {
   return patches;
 }
 
 
 
-template <int dim, int spacedim, class DH>
-std::vector<std::string> DataOutStack<dim,spacedim,DH>::get_dataset_names () const
+template <int dim, int spacedim, typename DoFHandlerType>
+std::vector<std::string> DataOutStack<dim,spacedim,DoFHandlerType>::get_dataset_names () const
 {
   std::vector<std::string> names;
   for (typename std::vector<DataVector>::const_iterator dataset=dof_data.begin();
diff --git a/source/numerics/derivative_approximation.cc b/source/numerics/derivative_approximation.cc
index c954de82c7..187e92bc7f 100644
--- a/source/numerics/derivative_approximation.cc
+++ b/source/numerics/derivative_approximation.cc
@@ -756,13 +756,15 @@ namespace DerivativeApproximation
     * Compute the derivative approximation on one cell. This computes the full
     * derivative tensor.
     */
-    template <class DerivativeDescription, int dim, template <int, int> class DH, class InputVector, int spacedim>
+    template <class DerivativeDescription, int dim, template <int, int> class DoFHandlerType,
+              class InputVector, int spacedim>
     void
-    approximate_cell (const Mapping<dim,spacedim>                   &mapping,
-                      const DH<dim,spacedim>                        &dof_handler,
-                      const InputVector                             &solution,
-                      const unsigned int                             component,
-                      const TriaActiveIterator < dealii::DoFCellAccessor < DH < dim, spacedim >, false > >  &cell,
+    approximate_cell (const Mapping<dim,spacedim>        &mapping,
+                      const DoFHandlerType<dim,spacedim> &dof_handler,
+                      const InputVector                  &solution,
+                      const unsigned int                  component,
+                      const TriaActiveIterator<dealii::DoFCellAccessor<DoFHandlerType<dim, spacedim>,
+                      false> >  &cell,
                       typename DerivativeDescription::Derivative    &derivative)
     {
       QMidpoint<dim> midpoint_rule;
@@ -791,7 +793,8 @@ namespace DerivativeApproximation
       // active neighbors of a cell
       // reserve the maximal number of
       // active neighbors
-      std::vector<TriaActiveIterator < dealii::DoFCellAccessor < DH < dim, spacedim >, false > > > active_neighbors;
+      std::vector<TriaActiveIterator<dealii::DoFCellAccessor<DoFHandlerType<dim, spacedim>,
+          false> > > active_neighbors;
 
       active_neighbors.reserve (GeometryInfo<dim>::faces_per_cell *
                                 GeometryInfo<dim>::max_children_per_face);
@@ -829,16 +832,17 @@ namespace DerivativeApproximation
       // first collect all neighbor
       // cells in a vector, and then
       // collect the data from them
-      GridTools::get_active_neighbors<DH<dim,spacedim> >(cell, active_neighbors);
+      GridTools::get_active_neighbors<DoFHandlerType<dim,spacedim> >(cell, active_neighbors);
 
       // now loop over all active
       // neighbors and collect the
       // data we need
-      typename std::vector<TriaActiveIterator < dealii::DoFCellAccessor < DH < dim, spacedim >, false > > >::const_iterator
-      neighbor_ptr = active_neighbors.begin();
+      typename std::vector<TriaActiveIterator<dealii::DoFCellAccessor<DoFHandlerType<dim, spacedim>,
+               false> > >::const_iterator
+               neighbor_ptr = active_neighbors.begin();
       for (; neighbor_ptr!=active_neighbors.end(); ++neighbor_ptr)
         {
-          const TriaActiveIterator < dealii::DoFCellAccessor < DH < dim, spacedim >, false > >
+          const TriaActiveIterator < dealii::DoFCellAccessor < DoFHandlerType < dim, spacedim >, false > >
           neighbor = *neighbor_ptr;
 
           // reinit fe values object...
@@ -923,14 +927,14 @@ namespace DerivativeApproximation
      * on the cell.
      */
     template <class DerivativeDescription, int dim,
-              template <int, int> class DH, class InputVector, int spacedim>
+              template <int, int> class DoFHandlerType, class InputVector, int spacedim>
     void
-    approximate(
-      SynchronousIterators<std_cxx11::tuple<TriaActiveIterator < dealii::DoFCellAccessor < DH < dim, spacedim >, false > >, Vector<float>::iterator> > const &cell,
-      const Mapping<dim,spacedim>                  &mapping,
-      const DH<dim,spacedim>                       &dof_handler,
-      const InputVector                            &solution,
-      const unsigned int                            component)
+    approximate
+    (SynchronousIterators<std_cxx11::tuple<TriaActiveIterator < dealii::DoFCellAccessor < DoFHandlerType < dim, spacedim >, false > >, Vector<float>::iterator> > const &cell,
+     const Mapping<dim,spacedim>        &mapping,
+     const DoFHandlerType<dim,spacedim> &dof_handler,
+     const InputVector                  &solution,
+     const unsigned int                  component)
     {
       // if the cell is not locally owned, then there is nothing to do
       if (std_cxx11::get<0>(cell.iterators)->is_locally_owned() == false)
@@ -940,7 +944,7 @@ namespace DerivativeApproximation
           typename DerivativeDescription::Derivative derivative;
           // call the function doing the actual
           // work on this cell
-          approximate_cell<DerivativeDescription,dim,DH,InputVector, spacedim>
+          approximate_cell<DerivativeDescription,dim,DoFHandlerType,InputVector, spacedim>
           (mapping,dof_handler,solution,component,std_cxx11::get<0>(cell.iterators),derivative);
 
           // evaluate the norm and fill the vector
@@ -961,13 +965,13 @@ namespace DerivativeApproximation
      * we are to work on.
      */
     template <class DerivativeDescription, int dim,
-              template <int, int> class DH, class InputVector, int spacedim>
+              template <int, int> class DoFHandlerType, class InputVector, int spacedim>
     void
-    approximate_derivative (const Mapping<dim,spacedim>    &mapping,
-                            const DH<dim,spacedim>         &dof_handler,
-                            const InputVector     &solution,
-                            const unsigned int     component,
-                            Vector<float>         &derivative_norm)
+    approximate_derivative (const Mapping<dim,spacedim>        &mapping,
+                            const DoFHandlerType<dim,spacedim> &dof_handler,
+                            const InputVector                  &solution,
+                            const unsigned int                  component,
+                            Vector<float>                      &derivative_norm)
     {
       Assert (derivative_norm.size() == dof_handler.get_tria().n_active_cells(),
               ExcVectorLengthVsNActiveCells (derivative_norm.size(),
@@ -975,8 +979,9 @@ namespace DerivativeApproximation
       Assert (component < dof_handler.get_fe().n_components(),
               ExcIndexRange (component, 0, dof_handler.get_fe().n_components()));
 
-      typedef std_cxx11::tuple<TriaActiveIterator < dealii::DoFCellAccessor < DH < dim, spacedim >, false > >, Vector<float>::iterator>
-      Iterators;
+      typedef std_cxx11::tuple<TriaActiveIterator<dealii::DoFCellAccessor
+      <DoFHandlerType<dim, spacedim>, false> >,
+      Vector<float>::iterator> Iterators;
       SynchronousIterators<Iterators> begin(Iterators(dof_handler.begin_active(),
                                                       derivative_norm.begin())),
                                                                             end(Iterators(dof_handler.end(),
@@ -988,7 +993,8 @@ namespace DerivativeApproximation
                       end,
                       static_cast<std_cxx11::function<void (SynchronousIterators<Iterators> const &,
                                                             Assembler::Scratch const &, Assembler::CopyData &)> >
-                      (std_cxx11::bind(&approximate<DerivativeDescription,dim,DH,InputVector,spacedim>,
+                      (std_cxx11::bind(&approximate<DerivativeDescription,dim,DoFHandlerType,
+                                       InputVector,spacedim>,
                                        std_cxx11::_1,
                                        std_cxx11::cref(mapping),
                                        std_cxx11::cref(dof_handler),
@@ -1006,13 +1012,13 @@ namespace DerivativeApproximation
 
 namespace DerivativeApproximation
 {
-  template <int dim, template <int, int> class DH, class InputVector, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, class InputVector, int spacedim>
   void
-  approximate_gradient (const Mapping<dim,spacedim>    &mapping,
-                        const DH<dim,spacedim>         &dof_handler,
-                        const InputVector     &solution,
-                        Vector<float>         &derivative_norm,
-                        const unsigned int     component)
+  approximate_gradient (const Mapping<dim,spacedim>        &mapping,
+                        const DoFHandlerType<dim,spacedim> &dof_handler,
+                        const InputVector                  &solution,
+                        Vector<float>                      &derivative_norm,
+                        const unsigned int                  component)
   {
     internal::approximate_derivative<internal::Gradient<dim>,dim> (mapping,
         dof_handler,
@@ -1022,12 +1028,12 @@ namespace DerivativeApproximation
   }
 
 
-  template <int dim, template <int, int> class DH, class InputVector, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, class InputVector, int spacedim>
   void
-  approximate_gradient (const DH<dim,spacedim>         &dof_handler,
-                        const InputVector     &solution,
-                        Vector<float>         &derivative_norm,
-                        const unsigned int     component)
+  approximate_gradient (const DoFHandlerType<dim,spacedim> &dof_handler,
+                        const InputVector                  &solution,
+                        Vector<float>                      &derivative_norm,
+                        const unsigned int                  component)
   {
     internal::approximate_derivative<internal::Gradient<dim>,dim> (StaticMappingQ1<dim>::mapping,
         dof_handler,
@@ -1037,13 +1043,13 @@ namespace DerivativeApproximation
   }
 
 
-  template <int dim, template <int, int> class DH, class InputVector, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, class InputVector, int spacedim>
   void
-  approximate_second_derivative (const Mapping<dim,spacedim>    &mapping,
-                                 const DH<dim,spacedim>         &dof_handler,
-                                 const InputVector     &solution,
-                                 Vector<float>         &derivative_norm,
-                                 const unsigned int     component)
+  approximate_second_derivative (const Mapping<dim,spacedim>        &mapping,
+                                 const DoFHandlerType<dim,spacedim> &dof_handler,
+                                 const InputVector                  &solution,
+                                 Vector<float>                      &derivative_norm,
+                                 const unsigned int                  component)
   {
     internal::approximate_derivative<internal::SecondDerivative<dim>,dim> (mapping,
         dof_handler,
@@ -1053,12 +1059,12 @@ namespace DerivativeApproximation
   }
 
 
-  template <int dim, template <int, int> class DH, class InputVector, int spacedim>
+  template <int dim, template <int, int> class DoFHandlerType, class InputVector, int spacedim>
   void
-  approximate_second_derivative (const DH<dim,spacedim>         &dof_handler,
-                                 const InputVector     &solution,
-                                 Vector<float>         &derivative_norm,
-                                 const unsigned int     component)
+  approximate_second_derivative (const DoFHandlerType<dim,spacedim> &dof_handler,
+                                 const InputVector                  &solution,
+                                 Vector<float>                      &derivative_norm,
+                                 const unsigned int                  component)
   {
     internal::approximate_derivative<internal::SecondDerivative<dim>,dim> (StaticMappingQ1<dim>::mapping,
         dof_handler,
@@ -1068,20 +1074,21 @@ namespace DerivativeApproximation
   }
 
 
-  template <class DH, int dim, int spacedim, class InputVector, int order>
+  template <typename DoFHandlerType, int dim, int spacedim, class InputVector, int order>
   void
-  approximate_derivative_tensor(const Mapping<dim, spacedim> &mapping,
-                                const DH                    &dof,
-                                const InputVector                            &solution,
+  approximate_derivative_tensor
+  (const Mapping<dim, spacedim>                        &mapping,
+   const DoFHandlerType                                &dof,
+   const InputVector                                   &solution,
 #ifndef _MSC_VER
-                                const typename DH::active_cell_iterator &cell,
+   const typename DoFHandlerType::active_cell_iterator &cell,
 #else
-                                const TriaActiveIterator < dealii::DoFCellAccessor < DH, false > > &cell,
+   const TriaActiveIterator < dealii::DoFCellAccessor < DoFHandlerType, false > > &cell,
 #endif
-                                Tensor<order, dim>  &derivative,
-                                const unsigned int                            component)
+   Tensor<order, dim>                                  &derivative,
+   const unsigned int                                   component)
   {
-    internal::approximate_cell<typename internal::DerivativeSelector<order,DH::dimension>::DerivDescr>
+    internal::approximate_cell<typename internal::DerivativeSelector<order,DoFHandlerType::dimension>::DerivDescr>
     (mapping,
      dof,
      solution,
@@ -1092,20 +1099,21 @@ namespace DerivativeApproximation
 
 
 
-  template <class DH, int dim, int spacedim, class InputVector, int order>
+  template <typename DoFHandlerType, int dim, int spacedim, class InputVector, int order>
   void
-  approximate_derivative_tensor(const DH                     &dof,
-                                const InputVector                            &solution,
+  approximate_derivative_tensor
+  (const DoFHandlerType                                &dof,
+   const InputVector                                   &solution,
 #ifndef _MSC_VER
-                                const typename DH::active_cell_iterator &cell,
+   const typename DoFHandlerType::active_cell_iterator &cell,
 #else
-                                const TriaActiveIterator < dealii::DoFCellAccessor < DH, false > > &cell,
+   const TriaActiveIterator < dealii::DoFCellAccessor < DoFHandlerType, false > > &cell,
 #endif
-                                Tensor<order, dim>                  &derivative,
-                                const unsigned int                            component)
+   Tensor<order, dim>                                  &derivative,
+   const unsigned int                                   component)
   {
     // just call the respective function with Q1 mapping
-    approximate_derivative_tensor<DH, dim, spacedim, InputVector, order>
+    approximate_derivative_tensor<DoFHandlerType, dim, spacedim, InputVector, order>
     (StaticMappingQ1<dim, spacedim>::mapping,
      dof,
      solution,
diff --git a/source/numerics/error_estimator_1d.cc b/source/numerics/error_estimator_1d.cc
index 2b6451c276..2fc32678f0 100644
--- a/source/numerics/error_estimator_1d.cc
+++ b/source/numerics/error_estimator_1d.cc
@@ -51,20 +51,20 @@ DEAL_II_NAMESPACE_OPEN
 
 
 template <int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void
 KellyErrorEstimator<1,spacedim>::
-estimate (const Mapping<1,spacedim>      &mapping,
-          const DH   &dof_handler,
-          const Quadrature<0> &quadrature,
+estimate (const Mapping<1,spacedim>                  &mapping,
+          const DoFHandlerType                       &dof_handler,
+          const Quadrature<0>                        &quadrature,
           const typename FunctionMap<spacedim>::type &neumann_bc,
-          const InputVector       &solution,
-          Vector<float>           &error,
-          const ComponentMask &component_mask,
-          const Function<spacedim>     *coefficients,
-          const unsigned int       n_threads,
-          const types::subdomain_id subdomain_id,
-          const types::material_id       material_id)
+          const InputVector                          &solution,
+          Vector<float>                              &error,
+          const ComponentMask                        &component_mask,
+          const Function<spacedim>                   *coefficients,
+          const unsigned int                          n_threads,
+          const types::subdomain_id                   subdomain_id,
+          const types::material_id                    material_id)
 {
   // just pass on to the other function
   const std::vector<const InputVector *> solutions (1, &solution);
@@ -76,19 +76,19 @@ estimate (const Mapping<1,spacedim>      &mapping,
 
 
 template <int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void
 KellyErrorEstimator<1,spacedim>::
-estimate (const DH   &dof_handler,
-          const Quadrature<0> &quadrature,
+estimate (const DoFHandlerType                       &dof_handler,
+          const Quadrature<0>                        &quadrature,
           const typename FunctionMap<spacedim>::type &neumann_bc,
-          const InputVector       &solution,
-          Vector<float>           &error,
-          const ComponentMask &component_mask,
-          const Function<spacedim>     *coefficients,
-          const unsigned int       n_threads,
-          const types::subdomain_id subdomain_id,
-          const types::material_id       material_id)
+          const InputVector                          &solution,
+          Vector<float>                              &error,
+          const ComponentMask                        &component_mask,
+          const Function<spacedim>                   *coefficients,
+          const unsigned int                          n_threads,
+          const types::subdomain_id                   subdomain_id,
+          const types::material_id                    material_id)
 {
   estimate(StaticMappingQ1<1,spacedim>::mapping, dof_handler, quadrature, neumann_bc, solution,
            error, component_mask, coefficients, n_threads, subdomain_id, material_id);
@@ -97,19 +97,19 @@ estimate (const DH   &dof_handler,
 
 
 template <int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void
 KellyErrorEstimator<1,spacedim>::
-estimate (const DH   &dof_handler,
-          const Quadrature<0> &quadrature,
+estimate (const DoFHandlerType                       &dof_handler,
+          const Quadrature<0>                        &quadrature,
           const typename FunctionMap<spacedim>::type &neumann_bc,
-          const std::vector<const InputVector *> &solutions,
-          std::vector<Vector<float>*> &errors,
-          const ComponentMask &component_mask,
-          const Function<spacedim>     *coefficients,
-          const unsigned int       n_threads,
-          const types::subdomain_id subdomain_id,
-          const types::material_id       material_id)
+          const std::vector<const InputVector *>     &solutions,
+          std::vector<Vector<float>*>                &errors,
+          const ComponentMask                        &component_mask,
+          const Function<spacedim>                   *coefficients,
+          const unsigned int                          n_threads,
+          const types::subdomain_id                   subdomain_id,
+          const types::material_id                    material_id)
 {
   estimate(StaticMappingQ1<1,spacedim>::mapping, dof_handler, quadrature, neumann_bc, solutions,
            errors, component_mask, coefficients, n_threads, subdomain_id, material_id);
@@ -118,20 +118,20 @@ estimate (const DH   &dof_handler,
 
 
 template <int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void
 KellyErrorEstimator<1,spacedim>::
-estimate (const Mapping<1,spacedim>      &mapping,
-          const DH   &dof_handler,
-          const hp::QCollection<0> &quadrature,
+estimate (const Mapping<1,spacedim>                  &mapping,
+          const DoFHandlerType                       &dof_handler,
+          const hp::QCollection<0>                   &quadrature,
           const typename FunctionMap<spacedim>::type &neumann_bc,
-          const InputVector       &solution,
-          Vector<float>           &error,
-          const ComponentMask &component_mask,
-          const Function<spacedim>     *coefficients,
-          const unsigned int       n_threads,
-          const types::subdomain_id subdomain_id,
-          const types::material_id       material_id)
+          const InputVector                          &solution,
+          Vector<float>                              &error,
+          const ComponentMask                        &component_mask,
+          const Function<spacedim>                   *coefficients,
+          const unsigned int                          n_threads,
+          const types::subdomain_id                   subdomain_id,
+          const types::material_id                    material_id)
 {
   // just pass on to the other function
   const std::vector<const InputVector *> solutions (1, &solution);
@@ -142,19 +142,19 @@ estimate (const Mapping<1,spacedim>      &mapping,
 
 
 template <int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void
 KellyErrorEstimator<1,spacedim>::
-estimate (const DH   &dof_handler,
-          const hp::QCollection<0> &quadrature,
+estimate (const DoFHandlerType                       &dof_handler,
+          const hp::QCollection<0>                   &quadrature,
           const typename FunctionMap<spacedim>::type &neumann_bc,
-          const InputVector       &solution,
-          Vector<float>           &error,
-          const ComponentMask &component_mask,
-          const Function<spacedim>     *coefficients,
-          const unsigned int       n_threads,
-          const types::subdomain_id subdomain_id,
-          const types::material_id       material_id)
+          const InputVector                          &solution,
+          Vector<float>                              &error,
+          const ComponentMask                        &component_mask,
+          const Function<spacedim>                   *coefficients,
+          const unsigned int                          n_threads,
+          const types::subdomain_id                   subdomain_id,
+          const types::material_id                    material_id)
 {
   estimate(StaticMappingQ1<1,spacedim>::mapping, dof_handler, quadrature, neumann_bc, solution,
            error, component_mask, coefficients, n_threads, subdomain_id, material_id);
@@ -163,19 +163,19 @@ estimate (const DH   &dof_handler,
 
 
 template <int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void
 KellyErrorEstimator<1,spacedim>::
-estimate (const DH   &dof_handler,
-          const hp::QCollection<0> &quadrature,
+estimate (const DoFHandlerType                       &dof_handler,
+          const hp::QCollection<0>                   &quadrature,
           const typename FunctionMap<spacedim>::type &neumann_bc,
-          const std::vector<const InputVector *> &solutions,
-          std::vector<Vector<float>*> &errors,
-          const ComponentMask &component_mask,
-          const Function<spacedim>     *coefficients,
-          const unsigned int       n_threads,
-          const types::subdomain_id subdomain_id,
-          const types::material_id       material_id)
+          const std::vector<const InputVector *>     &solutions,
+          std::vector<Vector<float>*>                &errors,
+          const ComponentMask                        &component_mask,
+          const Function<spacedim>                   *coefficients,
+          const unsigned int                          n_threads,
+          const types::subdomain_id                   subdomain_id,
+          const types::material_id                    material_id)
 {
   estimate(StaticMappingQ1<1,spacedim>::mapping, dof_handler, quadrature, neumann_bc, solutions,
            errors, component_mask, coefficients, n_threads, subdomain_id, material_id);
@@ -185,18 +185,18 @@ estimate (const DH   &dof_handler,
 
 
 template <int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void KellyErrorEstimator<1,spacedim>::
-estimate (const Mapping<1,spacedim>                    &/*mapping*/,
-          const DH                            &/*dof_handler*/,
+estimate (const Mapping<1,spacedim>                  &/*mapping*/,
+          const DoFHandlerType                       &/*dof_handler*/,
           const hp::QCollection<0> &,
-          const typename FunctionMap<spacedim>::type          &/*neumann_bc*/,
-          const std::vector<const InputVector *> &/*solutions*/,
-          std::vector<Vector<float>*>            &/*errors*/,
-          const ComponentMask                &/*component_mask_*/,
-          const Function<spacedim>                   * /*coefficient*/,
+          const typename FunctionMap<spacedim>::type &/*neumann_bc*/,
+          const std::vector<const InputVector *>     &/*solutions*/,
+          std::vector<Vector<float>*>                &/*errors*/,
+          const ComponentMask                        &/*component_mask_*/,
+          const Function<spacedim>                   */*coefficient*/,
           const unsigned int,
-          const types::subdomain_id          /*subdomain_id*/,
+          const types::subdomain_id                  /*subdomain_id*/,
           const types::material_id                   /*material_id*/)
 {
   Assert (false, ExcInternalError());
@@ -205,19 +205,19 @@ estimate (const Mapping<1,spacedim>                    &/*mapping*/,
 
 
 template <int spacedim>
-template <typename InputVector, class DH>
+template <typename InputVector, typename DoFHandlerType>
 void KellyErrorEstimator<1,spacedim>::
-estimate (const Mapping<1,spacedim>                    &mapping,
-          const DH                 &dof_handler,
+estimate (const Mapping<1,spacedim>                  &mapping,
+          const DoFHandlerType                       &dof_handler,
           const Quadrature<0> &,
-          const typename FunctionMap<spacedim>::type          &neumann_bc,
-          const std::vector<const InputVector *> &solutions,
-          std::vector<Vector<float>*>              &errors,
-          const ComponentMask                  &component_mask,
+          const typename FunctionMap<spacedim>::type &neumann_bc,
+          const std::vector<const InputVector *>     &solutions,
+          std::vector<Vector<float>*>                &errors,
+          const ComponentMask                        &component_mask,
           const Function<spacedim>                   *coefficient,
           const unsigned int,
-          const types::subdomain_id         subdomain_id_,
-          const types::material_id                  material_id)
+          const types::subdomain_id                   subdomain_id_,
+          const types::material_id                    material_id)
 {
 #ifdef DEAL_II_WITH_P4EST
   if (dynamic_cast<const parallel::distributed::Triangulation<1,spacedim>*>
@@ -331,7 +331,7 @@ estimate (const Mapping<1,spacedim>                    &mapping,
   // loop over all cells and do something on the cells which we're told to
   // work on. note that the error indicator is only a sum over the two
   // contributions from the two vertices of each cell.
-  for (typename DH::active_cell_iterator cell = dof_handler.begin_active();
+  for (typename DoFHandlerType::active_cell_iterator cell = dof_handler.begin_active();
        cell != dof_handler.end();
        ++cell)
     if (((subdomain_id == numbers::invalid_subdomain_id)
@@ -350,7 +350,7 @@ estimate (const Mapping<1,spacedim>                    &mapping,
         for (unsigned int n=0; n<2; ++n)
           {
             // find left or right active neighbor
-            typename DH::cell_iterator neighbor = cell->neighbor(n);
+            typename DoFHandlerType::cell_iterator neighbor = cell->neighbor(n);
             if (neighbor.state() == IteratorState::valid)
               while (neighbor->has_children())
                 neighbor = neighbor->child(n==0 ? 1 : 0);
diff --git a/source/numerics/matrix_tools.cc b/source/numerics/matrix_tools.cc
index 2f494c053e..ddd5358422 100644
--- a/source/numerics/matrix_tools.cc
+++ b/source/numerics/matrix_tools.cc
@@ -73,13 +73,13 @@ namespace MatrixCreator
      * but is templatized on the
      * dof handler that should be used.
      */
-    template <typename DH>
+    template <typename DoFHandlerType>
     struct IteratorRange
     {
       /**
        * Typedef for the iterator type.
        */
-      typedef typename DH::active_cell_iterator active_cell_iterator;
+      typedef typename DoFHandlerType::active_cell_iterator active_cell_iterator;
 
       /**
        * Abbreviation for a pair of
@@ -112,9 +112,9 @@ namespace MatrixCreator
 
 
 
-    template <typename DH>
+    template <typename DoFHandlerType>
     inline
-    IteratorRange<DH>::
+    IteratorRange<DoFHandlerType>::
     IteratorRange (const active_cell_iterator &first,
                    const active_cell_iterator &second)
       :
@@ -124,9 +124,9 @@ namespace MatrixCreator
 
 
 
-    template <typename DH>
+    template <typename DoFHandlerType>
     inline
-    IteratorRange<DH>::IteratorRange (const iterator_pair &ip)
+    IteratorRange<DoFHandlerType>::IteratorRange (const iterator_pair &ip)
       :
       first (ip.first),
       second (ip.second)
@@ -614,7 +614,7 @@ namespace MatrixCreator
         Scratch() {}
       };
 
-      template <typename DH>
+      template <typename DoFHandlerType>
       struct CopyData
       {
         CopyData() {};
@@ -624,13 +624,13 @@ namespace MatrixCreator
         unsigned int dofs_per_cell;
         std::vector<types::global_dof_index> dofs;
         std::vector<std::vector<bool> > dof_is_on_face;
-        typename DH::active_cell_iterator cell;
+        typename DoFHandlerType::active_cell_iterator cell;
         std::vector<FullMatrix<double> > cell_matrix;
         std::vector<Vector<double> > cell_vector;
       };
 
-      template <typename DH>
-      CopyData<DH>::CopyData(CopyData const &data) :
+      template <typename DoFHandlerType>
+      CopyData<DoFHandlerType>::CopyData(CopyData const &data) :
         dofs_per_cell(data.dofs_per_cell),
         dofs(data.dofs),
         dof_is_on_face(data.dof_is_on_face),
diff --git a/source/numerics/solution_transfer.cc b/source/numerics/solution_transfer.cc
index 425ff48948..8c4630204c 100644
--- a/source/numerics/solution_transfer.cc
+++ b/source/numerics/solution_transfer.cc
@@ -34,8 +34,8 @@ DEAL_II_NAMESPACE_OPEN
 
 
 
-template<int dim, typename VectorType, class DH>
-SolutionTransfer<dim, VectorType, DH>::SolutionTransfer(const DH &dof)
+template<int dim, typename VectorType, typename DoFHandlerType>
+SolutionTransfer<dim, VectorType, DoFHandlerType>::SolutionTransfer(const DoFHandlerType &dof)
   :
   dof_handler(&dof, typeid(*this).name()),
   n_dofs_old(0),
@@ -44,16 +44,16 @@ SolutionTransfer<dim, VectorType, DH>::SolutionTransfer(const DH &dof)
 
 
 
-template<int dim, typename VectorType, class DH>
-SolutionTransfer<dim, VectorType, DH>::~SolutionTransfer()
+template<int dim, typename VectorType, typename DoFHandlerType>
+SolutionTransfer<dim, VectorType, DoFHandlerType>::~SolutionTransfer()
 {
   clear ();
 }
 
 
 
-template<int dim, typename VectorType, class DH>
-void SolutionTransfer<dim, VectorType, DH>::clear ()
+template<int dim, typename VectorType, typename DoFHandlerType>
+void SolutionTransfer<dim, VectorType, DoFHandlerType>::clear ()
 {
   indices_on_cell.clear();
   dof_values_on_cell.clear();
@@ -64,8 +64,8 @@ void SolutionTransfer<dim, VectorType, DH>::clear ()
 
 
 
-template<int dim, typename VectorType, class DH>
-void SolutionTransfer<dim, VectorType, DH>::prepare_for_pure_refinement()
+template<int dim, typename VectorType, typename DoFHandlerType>
+void SolutionTransfer<dim, VectorType, DoFHandlerType>::prepare_for_pure_refinement()
 {
   Assert(prepared_for!=pure_refinement, ExcAlreadyPrepForRef());
   Assert(prepared_for!=coarsening_and_refinement,
@@ -80,8 +80,8 @@ void SolutionTransfer<dim, VectorType, DH>::prepare_for_pure_refinement()
   std::vector<std::vector<types::global_dof_index> > (n_active_cells)
   .swap(indices_on_cell);
 
-  typename DH::active_cell_iterator cell = dof_handler->begin_active(),
-                                    endc = dof_handler->end();
+  typename DoFHandlerType::active_cell_iterator cell = dof_handler->begin_active(),
+                                                endc = dof_handler->end();
 
   for (unsigned int i=0; cell!=endc; ++cell, ++i)
     {
@@ -101,10 +101,11 @@ void SolutionTransfer<dim, VectorType, DH>::prepare_for_pure_refinement()
 
 
 
-template<int dim, typename VectorType, class DH>
+template<int dim, typename VectorType, typename DoFHandlerType>
 void
-SolutionTransfer<dim, VectorType, DH>::refine_interpolate (const VectorType &in,
-                                                           VectorType       &out) const
+SolutionTransfer<dim, VectorType, DoFHandlerType>::refine_interpolate
+(const VectorType &in,
+ VectorType       &out) const
 {
   Assert(prepared_for==pure_refinement, ExcNotPrepared());
   Assert(in.size()==n_dofs_old, ExcDimensionMismatch(in.size(),n_dofs_old));
@@ -116,8 +117,8 @@ SolutionTransfer<dim, VectorType, DH>::refine_interpolate (const VectorType &in,
 
   Vector<typename VectorType::value_type> local_values(0);
 
-  typename DH::cell_iterator cell = dof_handler->begin(),
-                             endc = dof_handler->end();
+  typename DoFHandlerType::cell_iterator cell = dof_handler->begin(),
+                                         endc = dof_handler->end();
 
   typename std::map<std::pair<unsigned int, unsigned int>, Pointerstruct>::const_iterator
   pointerstruct,
@@ -169,8 +170,8 @@ namespace internal
    * which no such interpolation is
    * implemented.
    */
-  template <typename DH>
-  void extract_interpolation_matrices (const DH &,
+  template <typename DoFHandlerType>
+  void extract_interpolation_matrices (const DoFHandlerType &,
                                        dealii::Table<2,FullMatrix<double> > &)
   {}
 
@@ -226,9 +227,9 @@ namespace internal
 
 
 
-template<int dim, typename VectorType, class DH>
+template<int dim, typename VectorType, typename DoFHandlerType>
 void
-SolutionTransfer<dim, VectorType, DH>::
+SolutionTransfer<dim, VectorType, DoFHandlerType>::
 prepare_for_coarsening_and_refinement(const std::vector<VectorType> &all_in)
 {
   Assert (prepared_for!=pure_refinement, ExcAlreadyPrepForRef());
@@ -257,7 +258,7 @@ prepare_for_coarsening_and_refinement(const std::vector<VectorType> &all_in)
   // and that'll stay or be refined
   unsigned int n_cells_to_coarsen=0;
   unsigned int n_cells_to_stay_or_refine=0;
-  for (typename DH::active_cell_iterator act_cell = dof_handler->begin_active();
+  for (typename DoFHandlerType::active_cell_iterator act_cell = dof_handler->begin_active();
        act_cell!=dof_handler->end(); ++act_cell)
     {
       if (act_cell->coarsen_flag_set())
@@ -269,7 +270,7 @@ prepare_for_coarsening_and_refinement(const std::vector<VectorType> &all_in)
          ExcInternalError());
 
   unsigned int n_coarsen_fathers=0;
-  for (typename DH::cell_iterator cell=dof_handler->begin();
+  for (typename DoFHandlerType::cell_iterator cell=dof_handler->begin();
        cell!=dof_handler->end(); ++cell)
     if (!cell->active() && cell->child(0)->coarsen_flag_set())
       ++n_coarsen_fathers;
@@ -296,7 +297,7 @@ prepare_for_coarsening_and_refinement(const std::vector<VectorType> &all_in)
   // the 'to_stay_or_refine' cells 'n_sr' and
   // the 'coarsen_fathers' cells 'n_cf',
   unsigned int n_sr=0, n_cf=0;
-  for (typename DH::cell_iterator cell=dof_handler->begin();
+  for (typename DoFHandlerType::cell_iterator cell=dof_handler->begin();
        cell!=dof_handler->end(); ++cell)
     {
       // CASE 1: active cell that remains as it is
@@ -379,9 +380,10 @@ prepare_for_coarsening_and_refinement(const std::vector<VectorType> &all_in)
 
 
 
-template<int dim, typename VectorType, class DH>
+template<int dim, typename VectorType, typename DoFHandlerType>
 void
-SolutionTransfer<dim, VectorType, DH>::prepare_for_coarsening_and_refinement (const VectorType &in)
+SolutionTransfer<dim, VectorType, DoFHandlerType>::prepare_for_coarsening_and_refinement
+(const VectorType &in)
 {
   std::vector<VectorType> all_in=std::vector<VectorType>(1, in);
   prepare_for_coarsening_and_refinement(all_in);
@@ -389,8 +391,8 @@ SolutionTransfer<dim, VectorType, DH>::prepare_for_coarsening_and_refinement (co
 
 
 
-template<int dim, typename VectorType, class DH>
-void SolutionTransfer<dim, VectorType, DH>::
+template<int dim, typename VectorType, typename DoFHandlerType>
+void SolutionTransfer<dim, VectorType, DoFHandlerType>::
 interpolate (const std::vector<VectorType> &all_in,
              std::vector<VectorType>       &all_out) const
 {
@@ -420,8 +422,8 @@ interpolate (const std::vector<VectorType> &all_in,
   internal::extract_interpolation_matrices (*dof_handler, interpolation_hp);
   Vector<typename VectorType::value_type> tmp, tmp2;
 
-  typename DH::cell_iterator cell = dof_handler->begin(),
-                             endc = dof_handler->end();
+  typename DoFHandlerType::cell_iterator cell = dof_handler->begin(),
+                                         endc = dof_handler->end();
   for (; cell!=endc; ++cell)
     {
       pointerstruct=cell_map.find(std::make_pair(cell->level(),cell->index()));
@@ -518,9 +520,10 @@ interpolate (const std::vector<VectorType> &all_in,
 
 
 
-template<int dim, typename VectorType, class DH>
-void SolutionTransfer<dim, VectorType, DH>::interpolate (const VectorType &in,
-                                                         VectorType       &out) const
+template<int dim, typename VectorType, typename DoFHandlerType>
+void SolutionTransfer<dim, VectorType, DoFHandlerType>::interpolate
+(const VectorType &in,
+ VectorType       &out) const
 {
   Assert (in.size()==n_dofs_old,
           ExcDimensionMismatch(in.size(), n_dofs_old));
@@ -538,9 +541,9 @@ void SolutionTransfer<dim, VectorType, DH>::interpolate (const VectorType &in,
 
 
 
-template<int dim, typename VectorType, class DH>
+template<int dim, typename VectorType, typename DoFHandlerType>
 std::size_t
-SolutionTransfer<dim, VectorType, DH>::memory_consumption () const
+SolutionTransfer<dim, VectorType, DoFHandlerType>::memory_consumption () const
 {
   // at the moment we do not include the memory
   // consumption of the cell_map as we have no
@@ -555,9 +558,9 @@ SolutionTransfer<dim, VectorType, DH>::memory_consumption () const
 
 
 
-template<int dim, typename VectorType, class DH>
+template<int dim, typename VectorType, typename DoFHandlerType>
 std::size_t
-SolutionTransfer<dim, VectorType, DH>::Pointerstruct::memory_consumption () const
+SolutionTransfer<dim, VectorType, DoFHandlerType>::Pointerstruct::memory_consumption () const
 {
   return sizeof(*this);
 }
diff --git a/tests/arpack/step-36_parpack.cc b/tests/arpack/step-36_parpack.cc
index aa32f368d7..954381d35e 100644
--- a/tests/arpack/step-36_parpack.cc
+++ b/tests/arpack/step-36_parpack.cc
@@ -37,9 +37,9 @@ const unsigned int dim = 2;//run in 2d to save time
 
 const double eps = 1e-10;
 
-template <class DH>
+template <typename DoFHandlerType>
 std::vector<dealii::IndexSet>
-locally_owned_dofs_per_subdomain (const DH  &dof_handler)
+locally_owned_dofs_per_subdomain (const DoFHandlerType  &dof_handler)
 {
   std::vector< dealii::types::subdomain_id > subdomain_association (dof_handler.n_dofs ());
   dealii::DoFTools::get_subdomain_association (dof_handler, subdomain_association);
diff --git a/tests/arpack/step-36_parpack_trilinos.cc b/tests/arpack/step-36_parpack_trilinos.cc
index e333de81bd..278b75a6e3 100644
--- a/tests/arpack/step-36_parpack_trilinos.cc
+++ b/tests/arpack/step-36_parpack_trilinos.cc
@@ -38,9 +38,9 @@ using namespace dealii;
 
 const double eps = 1e-10;
 
-template <class DH>
+template <typename DoFHandlerType>
 std::vector<IndexSet>
-locally_owned_dofs_per_subdomain (const DH  &dof_handler)
+locally_owned_dofs_per_subdomain (const DoFHandlerType  &dof_handler)
 {
   std::vector< types::subdomain_id > subdomain_association (dof_handler.n_dofs ());
   DoFTools::get_subdomain_association (dof_handler, subdomain_association);
diff --git a/tests/bits/data_out_08.cc b/tests/bits/data_out_08.cc
index dfb8812937..8a62524922 100644
--- a/tests/bits/data_out_08.cc
+++ b/tests/bits/data_out_08.cc
@@ -19,7 +19,7 @@
 /*
 466: --------------------------------------------------------
 466: An error occurred in line <306> of file </ssd/branch_port_the_testsuite/deal.II/source/numerics/data_out.cc> in function
-466:     void dealii::DataOut<dim, DH>::build_one_patch(const std::pair<typename dealii::DataOut_DoFData<DH, DH:: dimension, DH:: space_dimension>::cell_iterator, unsigned int>*, dealii::internal::DataOut::ParallelData<DH:: dimension, DH:: space_dimension>&, dealii::DataOutBase::Patch<DH:: dimension, DH:: space_dimension>&, dealii::DataOut<dim, DH>::CurvedCellRegion, std::vector<dealii::DataOutBase::Patch<DH:: dimension, DH:: space_dimension> >&) [with int dim = 2, DH = dealii::DoFHandler<2>, typename dealii::DataOut_DoFData<DH, DH:: dimension, DH:: space_dimension>::cell_iterator = dealii::TriaIterator<dealii::CellAccessor<2, 2> >]
+466:     void dealii::DataOut<dim, DoFHandlerType>::build_one_patch(const std::pair<typename dealii::DataOut_DoFData<DoFHandlerType, DoFHandlerType:: dimension, DoFHandlerType:: space_dimension>::cell_iterator, unsigned int>*, dealii::internal::DataOut::ParallelData<DoFHandlerType:: dimension, DoFHandlerType:: space_dimension>&, dealii::DataOutBase::Patch<DoFHandlerType:: dimension, DoFHandlerType:: space_dimension>&, dealii::DataOut<dim, DoFHandlerType>::CurvedCellRegion, std::vector<dealii::DataOutBase::Patch<DoFHandlerType:: dimension, DoFHandlerType:: space_dimension> >&) [with int dim = 2, DoFHandlerType = dealii::DoFHandler<2>, typename dealii::DataOut_DoFData<DoFHandlerType, DoFHandlerType:: dimension, DoFHandlerType:: space_dimension>::cell_iterator = dealii::TriaIterator<dealii::CellAccessor<2, 2> >]
 466: The violated condition was:
 466:     cell_and_index->second < patches.size()
 466: The name and call sequence of the exception was:
diff --git a/tests/dofs/accessor_01.cc b/tests/dofs/accessor_01.cc
index 4889f79f4d..b80f65ce06 100644
--- a/tests/dofs/accessor_01.cc
+++ b/tests/dofs/accessor_01.cc
@@ -40,11 +40,11 @@ operator << (LogStream &log, const TriaIterator<ACCESSOR> &i)
 }
 
 
-template <class DH>
-void test_in_dim(const DH &d1, const DH &d2)
+template <typename DoFHandlerType>
+void test_in_dim(const DoFHandlerType &d1, const DoFHandlerType &d2)
 {
-  typename DH::active_cell_iterator a = d1.begin_active();
-  typename DH::cell_iterator l = d1.begin(d1.get_tria().n_levels()-1);
+  typename DoFHandlerType::active_cell_iterator a = d1.begin_active();
+  typename DoFHandlerType::cell_iterator l = d1.begin(d1.get_tria().n_levels()-1);
 
   deallog << "a " << a << std::endl
           << "l " << l << std::endl;
diff --git a/tests/dofs/accessor_02.cc b/tests/dofs/accessor_02.cc
index 4889f79f4d..b80f65ce06 100644
--- a/tests/dofs/accessor_02.cc
+++ b/tests/dofs/accessor_02.cc
@@ -40,11 +40,11 @@ operator << (LogStream &log, const TriaIterator<ACCESSOR> &i)
 }
 
 
-template <class DH>
-void test_in_dim(const DH &d1, const DH &d2)
+template <typename DoFHandlerType>
+void test_in_dim(const DoFHandlerType &d1, const DoFHandlerType &d2)
 {
-  typename DH::active_cell_iterator a = d1.begin_active();
-  typename DH::cell_iterator l = d1.begin(d1.get_tria().n_levels()-1);
+  typename DoFHandlerType::active_cell_iterator a = d1.begin_active();
+  typename DoFHandlerType::cell_iterator l = d1.begin(d1.get_tria().n_levels()-1);
 
   deallog << "a " << a << std::endl
           << "l " << l << std::endl;
diff --git a/tests/mpi/derivative_approximation_01.cc b/tests/mpi/derivative_approximation_01.cc
index a87b5c3747..40776b37cb 100644
--- a/tests/mpi/derivative_approximation_01.cc
+++ b/tests/mpi/derivative_approximation_01.cc
@@ -19,7 +19,7 @@
 /*
  --------------------------------------------------------
  An error occurred in line <3349> of file </ssd/deal-trunk/deal.II/include/deal.II/dofs/dof_accessor.templates.h> in function
-     void dealii::DoFCellAccessor<DH, lda>::get_dof_values(const InputVector&, ForwardIterator, ForwardIterator) const [with InputVector = dealii::TrilinosWrappers::MPI::Vector, ForwardIterator = double*, DH = dealii::DoFHandler<2>, bool level_dof_access = false]
+     void dealii::DoFCellAccessor<DoFHandlerType, lda>::get_dof_values(const InputVector&, ForwardIterator, ForwardIterator) const [with InputVector = dealii::TrilinosWrappers::MPI::Vector, ForwardIterator = double*, DoFHandlerType = dealii::DoFHandler<2>, bool level_dof_access = false]
  The violated condition was:
      this->is_artificial() == false
  The name and call sequence of the exception was:
diff --git a/tests/numerics/no_flux_08.cc b/tests/numerics/no_flux_08.cc
index d569a43ec1..455cf1d661 100644
--- a/tests/numerics/no_flux_08.cc
+++ b/tests/numerics/no_flux_08.cc
@@ -18,7 +18,7 @@
 // we used to get this crash:
 //
 // An error occurred in line <4646> of file </w/heister/deal-trunk/deal.II/include/deal.II/numerics/vectors.templates.h> in function
-//     static void dealii::VectorTools::compute_no_normal_flux_constraints(const DH<dim, spacedim>&, unsigned int, const std::set<types::boundary_id>&, dealii::ConstraintMatrix&, const dealii::Mapping<dim, spacedim>&) [with int dim = 3, DH = dealii::DoFHandler, int spacedim = 3]
+//     static void dealii::VectorTools::compute_no_normal_flux_constraints(const DoFHandlerType<dim, spacedim>&, unsigned int, const std::set<types::boundary_id>&, dealii::ConstraintMatrix&, const dealii::Mapping<dim, spacedim>&) [with int dim = 3, DoFHandlerType = dealii::DoFHandler, int spacedim = 3]
 // The violated condition was:
 //     std::fabs (tangent.norm()-1) < 1e-12
 // The name and call sequence of the exception was:
diff --git a/tests/numerics/no_flux_12.cc b/tests/numerics/no_flux_12.cc
index 1a1d7230c7..9c6ef2aeea 100644
--- a/tests/numerics/no_flux_12.cc
+++ b/tests/numerics/no_flux_12.cc
@@ -21,7 +21,7 @@
 
 /*
 5: An error occurred in line <4586> of file </scratch/deal-trunk/deal.II/include/deal.II/numerics/vector_tools.templates.h> in function
-5:     void dealii::VectorTools::compute_no_normal_flux_constraints(const DH<dim, spacedim>&, unsigned int, const std::set<unsigned char>&, dealii::ConstraintMatrix&, const dealii::Mapping<dim, spacedim>&) [with int dim = 3; DH = dealii::DoFHandler; int spacedim = 3]
+5:     void dealii::VectorTools::compute_no_normal_flux_constraints(const DoFHandlerType<dim, spacedim>&, unsigned int, const std::set<unsigned char>&, dealii::ConstraintMatrix&, const dealii::Mapping<dim, spacedim>&) [with int dim = 3; DoFHandlerType = dealii::DoFHandler; int spacedim = 3]
 5: The violated condition was:
 5:     contribution->second.size() == dim-1
 5: The name and call sequence of the exception was: