From eed4ff20b6d999b35914e997be42a0ecab868b96 Mon Sep 17 00:00:00 2001
From: Peter Munch <peterrmuench@gmail.com>
Date: Wed, 24 Jun 2020 12:29:32 +0200
Subject: [PATCH] Remove DoFHandlerType from dofs/dof_accessor

---
 .../changes/incompatibilities/20200624Munch   |    5 +
 include/deal.II/dofs/dof_accessor.h           |  276 ++--
 include/deal.II/dofs/dof_accessor.templates.h | 1112 ++++++++---------
 include/deal.II/dofs/dof_handler.h            |    4 +-
 include/deal.II/dofs/dof_iterator_selector.h  |   22 +-
 include/deal.II/fe/fe_values.h                |   32 +-
 include/deal.II/grid/grid_tools.h             |    8 +-
 include/deal.II/hp/fe_values.h                |   15 +-
 include/deal.II/matrix_free/fe_evaluation.h   |   10 +-
 .../numerics/derivative_approximation.h       |   12 +-
 source/dofs/dof_accessor.cc                   |   61 +-
 source/dofs/dof_accessor.inst.in              |   72 +-
 source/dofs/dof_accessor_get.cc               |   12 +-
 source/dofs/dof_accessor_get.inst.in          |   15 +-
 source/dofs/dof_accessor_set.cc               |   12 +-
 source/dofs/dof_accessor_set.inst.in          |   15 +-
 source/fe/fe_values.cc                        |   34 +-
 source/fe/fe_values.inst.in                   |   15 +-
 source/hp/fe_values.cc                        |   33 +-
 source/hp/fe_values.inst.in                   |   15 +-
 source/numerics/derivative_approximation.cc   |   12 +-
 21 files changed, 849 insertions(+), 943 deletions(-)
 create mode 100644 doc/news/changes/incompatibilities/20200624Munch

diff --git a/doc/news/changes/incompatibilities/20200624Munch b/doc/news/changes/incompatibilities/20200624Munch
new file mode 100644
index 0000000000..063d6e3028
--- /dev/null
+++ b/doc/news/changes/incompatibilities/20200624Munch
@@ -0,0 +1,5 @@
+Changed: The template arguments of the classes DoFAccessor and DoFCellAccessor have changed.
+The template argument DoFHandlerType has been replaced by dimension and
+space dimension.  
+<br>
+(Peter Munch, 2020/06/24)
diff --git a/include/deal.II/dofs/dof_accessor.h b/include/deal.II/dofs/dof_accessor.h
index e5a7634cdb..21241cf7dc 100644
--- a/include/deal.II/dofs/dof_accessor.h
+++ b/include/deal.II/dofs/dof_accessor.h
@@ -188,8 +188,8 @@ namespace internal
  * @tparam structdim The dimensionality of the objects the accessor
  *   represents. For example, points have @p structdim equal to zero,
  *   edges have @p structdim equal to one, etc.
- * @tparam DoFHandlerType The type of the DoF handler into which accessor
- *   of this type point.
+ * @tparam dim Dimension of the underlying DoFHandler.
+ * @tparam spacedim Space dimension of the underlying DoFHandler.
  * @tparam level_dof_access If @p false, then the accessor simply represents
  *   a cell, face, or edge in a DoFHandler for which degrees of freedom only
  *   exist on the finest level. Some operations are not allowed in this case,
@@ -203,25 +203,22 @@ namespace internal
  * @ingroup dofs
  * @ingroup Accessors
  */
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
-class DoFAccessor
-  : public dealii::internal::DoFAccessorImplementation::Inheritance<
-      structdim,
-      DoFHandlerType::dimension,
-      DoFHandlerType::space_dimension>::BaseClass
+template <int structdim, int dim, int spacedim, bool level_dof_access>
+class DoFAccessor : public dealii::internal::DoFAccessorImplementation::
+                      Inheritance<structdim, dim, spacedim>::BaseClass
 {
 public:
   /**
    * A static variable that allows users of this class to discover the value
    * of the second template argument.
    */
-  static const unsigned int dimension = DoFHandlerType::dimension;
+  static const unsigned int dimension = dim;
 
   /**
    * A static variable that allows users of this class to discover the value
    * of the third template argument.
    */
-  static const unsigned int space_dimension = DoFHandlerType::space_dimension;
+  static const unsigned int space_dimension = spacedim;
 
   /**
    * Declare an alias to the base class to make accessing some of the
@@ -233,7 +230,7 @@ public:
   /**
    * Data type passed by the iterator class.
    */
-  using AccessorData = DoFHandlerType;
+  using AccessorData = DoFHandler<dimension, space_dimension>;
 
   /**
    * @name Constructors
@@ -262,11 +259,10 @@ public:
    *   accessor shall refer. This DoFHandler object must of course be built on
    *   the same triangulation as the one specified in the first argument.
    */
-  DoFAccessor(const Triangulation<DoFHandlerType::dimension,
-                                  DoFHandlerType::space_dimension> *tria,
-              const int                                             level,
-              const int                                             index,
-              const DoFHandlerType *dof_handler);
+  DoFAccessor(const Triangulation<dim, spacedim> *tria,
+              const int                           level,
+              const int                           index,
+              const DoFHandler<dim, spacedim> *   dof_handler);
 
   /**
    * Conversion constructor. This constructor exists to make certain
@@ -287,15 +283,15 @@ public:
    * Another conversion operator between objects that don't make sense, just
    * like the previous one.
    */
-  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
-  DoFAccessor(const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &);
+  template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
+  DoFAccessor(
+    const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &);
 
   /**
    * Copy constructor allowing to switch level access and active access.
    */
   template <bool level_dof_access2>
-  DoFAccessor(
-    const DoFAccessor<structdim, DoFHandlerType, level_dof_access2> &);
+  DoFAccessor(const DoFAccessor<structdim, dim, spacedim, level_dof_access2> &);
 
   /**
    * Copy operator. These operators are usually used in a context like
@@ -306,9 +302,9 @@ public:
    * this operation is not useful for iterators on DoF handler objects.
    * Consequently, this operator is declared as deleted and can not be used.
    */
-  DoFAccessor<structdim, DoFHandlerType, level_dof_access> &
-  operator=(const DoFAccessor<structdim, DoFHandlerType, level_dof_access>
-              &da) = delete;
+  DoFAccessor<structdim, dim, spacedim, level_dof_access> &
+  operator=(const DoFAccessor<structdim, dim, spacedim, level_dof_access> &da) =
+    delete;
 
   /**
    * @}
@@ -317,7 +313,7 @@ public:
   /**
    * Return a handle on the DoFHandler object which we are using.
    */
-  const DoFHandlerType &
+  const DoFHandler<dim, spacedim> &
   get_dof_handler() const;
 
   /**
@@ -325,16 +321,14 @@ public:
    */
   template <bool level_dof_access2>
   void
-  copy_from(const DoFAccessor<structdim, DoFHandlerType, level_dof_access2> &a);
+  copy_from(const DoFAccessor<structdim, dim, spacedim, 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,
-                                   DoFHandlerType::dimension,
-                                   DoFHandlerType::space_dimension> &da);
+  copy_from(const TriaAccessorBase<structdim, dim, spacedim> &da);
 
   /**
    * Tell the caller whether get_active_or_mg_dof_indices() accesses active or
@@ -353,7 +347,7 @@ public:
   /**
    * Return an iterator pointing to the @p c-th child.
    */
-  TriaIterator<DoFAccessor<structdim, DoFHandlerType, level_dof_access>>
+  TriaIterator<DoFAccessor<structdim, dim, spacedim, level_dof_access>>
   child(const unsigned int c) const;
 
   /**
@@ -362,7 +356,7 @@ public:
    * function returns an iterator to itself.
    */
   typename dealii::internal::DoFHandlerImplementation::
-    Iterators<DoFHandlerType, level_dof_access>::line_iterator
+    Iterators<DoFHandler<dim, spacedim>, level_dof_access>::line_iterator
     line(const unsigned int i) const;
 
   /**
@@ -371,7 +365,7 @@ public:
    * function returns an iterator to itself.
    */
   typename dealii::internal::DoFHandlerImplementation::
-    Iterators<DoFHandlerType, level_dof_access>::quad_iterator
+    Iterators<DoFHandler<dim, spacedim>, level_dof_access>::quad_iterator
     quad(const unsigned int i) const;
 
   /**
@@ -420,9 +414,9 @@ public:
    * <code>cell-@>active_fe_index</code> as last argument.
    */
   void
-  get_dof_indices(
-    std::vector<types::global_dof_index> &dof_indices,
-    const unsigned int fe_index = DoFHandlerType::invalid_fe_index) const;
+  get_dof_indices(std::vector<types::global_dof_index> &dof_indices,
+                  const unsigned int                    fe_index =
+                    DoFHandler<dim, spacedim>::invalid_fe_index) const;
 
   /**
    * Return the global multilevel indices of the degrees of freedom that live
@@ -431,10 +425,10 @@ public:
    * level this line lives on.
    */
   void
-  get_mg_dof_indices(
-    const int                             level,
-    std::vector<types::global_dof_index> &dof_indices,
-    const unsigned int fe_index = DoFHandlerType::invalid_fe_index) const;
+  get_mg_dof_indices(const int                             level,
+                     std::vector<types::global_dof_index> &dof_indices,
+                     const unsigned int                    fe_index =
+                       DoFHandler<dim, spacedim>::invalid_fe_index) const;
 
   /**
    * Set the level DoF indices that are returned by get_mg_dof_indices.
@@ -443,7 +437,7 @@ public:
   set_mg_dof_indices(
     const int                                   level,
     const std::vector<types::global_dof_index> &dof_indices,
-    const unsigned int fe_index = DoFHandlerType::invalid_fe_index);
+    const unsigned int fe_index = DoFHandler<dim, spacedim>::invalid_fe_index);
 
   /**
    * Global DoF index of the <i>i</i> degree associated with the @p vertexth
@@ -463,10 +457,10 @@ public:
    * 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 = DoFHandlerType::invalid_fe_index) const;
+  vertex_dof_index(const unsigned int vertex,
+                   const unsigned int i,
+                   const unsigned int fe_index =
+                     DoFHandler<dim, spacedim>::invalid_fe_index) const;
 
   /**
    * Return the global DoF index of the <code>i</code>th degree of freedom
@@ -474,11 +468,11 @@ public:
    * 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 = DoFHandlerType::invalid_fe_index) const;
+  mg_vertex_dof_index(const int          level,
+                      const unsigned int vertex,
+                      const unsigned int i,
+                      const unsigned int fe_index =
+                        DoFHandler<dim, spacedim>::invalid_fe_index) const;
 
   /**
    * Index of the <i>i</i>th degree of freedom of this object.
@@ -508,9 +502,9 @@ public:
    * the face.
    */
   types::global_dof_index
-  dof_index(
-    const unsigned int i,
-    const unsigned int fe_index = DoFHandlerType::invalid_fe_index) const;
+  dof_index(const unsigned int i,
+            const unsigned int fe_index =
+              DoFHandler<dim, spacedim>::invalid_fe_index) const;
 
   /**
    * Return the dof_index on the given level. Also see dof_index.
@@ -578,8 +572,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<DoFHandlerType::dimension,
-                      DoFHandlerType::space_dimension> &
+  const FiniteElement<dim, spacedim> &
   get_fe(const unsigned int fe_index) const;
 
   /**
@@ -631,7 +624,7 @@ protected:
   /**
    * Store the address of the DoFHandler object to be accessed.
    */
-  DoFHandlerType *dof_handler;
+  DoFHandler<dim, spacedim> *dof_handler;
 
 public:
   /**
@@ -647,25 +640,25 @@ public:
    * an iterator with level access can be equal to one with access to the
    * active degrees of freedom.
    */
-  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+  template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
   bool
   operator==(
-    const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &) const;
+    const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &) const;
 
   /**
    * Compare for inequality. The boolean not of operator==().
    */
-  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+  template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
   bool
   operator!=(
-    const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &) const;
+    const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &) const;
 
 protected:
   /**
    * Reset the DoF handler pointer.
    */
   void
-  set_dof_handler(DoFHandlerType *dh);
+  set_dof_handler(DoFHandler<dim, spacedim> *dh);
 
   /**
    * Set the index of the <i>i</i>th degree of freedom of this object to @p
@@ -686,10 +679,10 @@ protected:
    * active_fe_index().
    */
   void
-  set_dof_index(
-    const unsigned int            i,
-    const types::global_dof_index index,
-    const unsigned int fe_index = DoFHandlerType::invalid_fe_index) const;
+  set_dof_index(const unsigned int            i,
+                const types::global_dof_index index,
+                const unsigned int            fe_index =
+                  DoFHandler<dim, spacedim>::invalid_fe_index) const;
 
   void
   set_mg_dof_index(const int                     level,
@@ -715,33 +708,33 @@ protected:
    * 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 = DoFHandlerType::invalid_fe_index) const;
+  set_vertex_dof_index(const unsigned int            vertex,
+                       const unsigned int            i,
+                       const types::global_dof_index index,
+                       const unsigned int            fe_index =
+                         DoFHandler<dim, spacedim>::invalid_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::invalid_fe_index) const;
+  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 =
+                            DoFHandler<dim, spacedim>::invalid_fe_index) const;
 
   // Iterator classes need to be friends because they need to access
   // operator== and operator!=.
   template <typename>
   friend class TriaRawIterator;
-  template <int, class, bool>
+  template <int, int, int, bool>
   friend class DoFAccessor;
 
 private:
   // Make the DoFHandler class a friend so that it can call the set_xxx()
   // functions.
-  template <int dim, int spacedim>
+  template <int, int>
   friend class DoFHandler;
-  template <int dim, int spacedim>
+  template <int, int>
   friend class hp::DoFHandler;
 
   friend struct dealii::internal::DoFHandlerImplementation::Policy::
@@ -761,10 +754,8 @@ private:
  * general faces, this class does a few things differently than the general
  * template, but the interface should look the same.
  */
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
-class DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>
+template <int spacedim, bool level_dof_access>
+class DoFAccessor<0, 1, spacedim, level_dof_access>
   : public TriaAccessor<0, 1, spacedim>
 {
 public:
@@ -789,7 +780,7 @@ public:
   /**
    * Data type passed by the iterator class.
    */
-  using AccessorData = DoFHandlerType<1, spacedim>;
+  using AccessorData = DoFHandler<1, spacedim>;
 
   /**
    * @name Constructors
@@ -823,7 +814,7 @@ public:
     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);
+    const DoFHandler<1, spacedim> *                         dof_handler);
 
   /**
    * Constructor. This constructor exists in order to maintain interface
@@ -831,9 +822,9 @@ public:
    * anything useful here and so may not actually be called.
    */
   DoFAccessor(const Triangulation<1, spacedim> *,
-              const int                                      = 0,
-              const int                                      = 0,
-              const DoFHandlerType<1, spacedim> *dof_handler = 0);
+              const int                                  = 0,
+              const int                                  = 0,
+              const DoFHandler<1, spacedim> *dof_handler = 0);
 
   /**
    * Conversion constructor. This constructor exists to make certain
@@ -854,8 +845,9 @@ public:
    * Another conversion operator between objects that don't make sense, just
    * like the previous one.
    */
-  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
-  DoFAccessor(const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &);
+  template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
+  DoFAccessor(
+    const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &);
 
   /**
    * Copy operator. These operators are usually used in a context like
@@ -866,9 +858,8 @@ public:
    * this operation is not useful for iterators on DoF handler objects.
    * Consequently, this operator is declared as deleted and can not be used.
    */
-  DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access> &
-  operator=(const DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>
-              &da) = delete;
+  DoFAccessor<0, 1, spacedim, level_dof_access> &
+  operator=(const DoFAccessor<0, 1, spacedim, level_dof_access> &da) = delete;
 
   /**
    * @}
@@ -877,7 +868,7 @@ public:
   /**
    * Return a handle on the DoFHandler object which we are using.
    */
-  const DoFHandlerType<1, spacedim> &
+  const DoFHandler<1, spacedim> &
   get_dof_handler() const;
 
   /**
@@ -885,8 +876,7 @@ public:
    */
   template <bool level_dof_access2>
   void
-  copy_from(
-    const DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access2> &a);
+  copy_from(const DoFAccessor<0, 1, spacedim, level_dof_access2> &a);
 
   /**
    * Copy operator used by the iterator class. Keeps the previously set dof
@@ -907,7 +897,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, DoFHandlerType<1, spacedim>, level_dof_access>>
+  TriaIterator<DoFAccessor<0, 1, spacedim, level_dof_access>>
   child(const unsigned int c) const;
 
   /**
@@ -917,7 +907,7 @@ public:
    * an exception.
    */
   typename dealii::internal::DoFHandlerImplementation::
-    Iterators<DoFHandlerType<1, spacedim>, level_dof_access>::line_iterator
+    Iterators<DoFHandler<1, spacedim>, level_dof_access>::line_iterator
     line(const unsigned int i) const;
 
   /**
@@ -927,7 +917,7 @@ public:
    * an exception.
    */
   typename dealii::internal::DoFHandlerImplementation::
-    Iterators<DoFHandlerType<1, spacedim>, level_dof_access>::quad_iterator
+    Iterators<DoFHandler<1, spacedim>, level_dof_access>::quad_iterator
     quad(const unsigned int i) const;
 
   /**
@@ -1082,8 +1072,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<DoFHandlerType<1, spacedim>::dimension,
-                      DoFHandlerType<1, spacedim>::space_dimension> &
+  const FiniteElement<1, spacedim> &
   get_fe(const unsigned int fe_index) const;
 
   /**
@@ -1135,28 +1124,28 @@ protected:
   /**
    * Store the address of the DoFHandler object to be accessed.
    */
-  DoFHandlerType<1, spacedim> *dof_handler;
+  DoFHandler<1, spacedim> *dof_handler;
 
   /**
    * Compare for equality.
    */
-  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+  template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
   bool
   operator==(
-    const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &) const;
+    const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &) const;
 
   /**
    * Compare for inequality.
    */
-  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+  template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
   bool
   operator!=(
-    const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &) const;
+    const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &) const;
 
   /**
    * Reset the DoF handler pointer.
    */
-  void set_dof_handler(DoFHandlerType<1, spacedim> *dh);
+  void set_dof_handler(DoFHandler<1, spacedim> *dh);
 
   /**
    * Set the index of the <i>i</i>th degree of freedom of this object to @p
@@ -1328,46 +1317,48 @@ public:
  * @ingroup dofs
  * @ingroup Accessors
  */
-template <typename DoFHandlerType, bool level_dof_access>
-class DoFCellAccessor : public DoFAccessor<DoFHandlerType::dimension,
-                                           DoFHandlerType,
+template <int dimension_, int space_dimension_, bool level_dof_access>
+class DoFCellAccessor : public DoFAccessor<dimension_,
+                                           dimension_,
+                                           space_dimension_,
                                            level_dof_access>
 {
 public:
   /**
-   * Extract dimension from DoFHandlerType.
+   * Extract dimension from DoFHandler.
    */
-  static const unsigned int dim = DoFHandlerType::dimension;
+  static const unsigned int dim = dimension_;
 
   /**
-   * Extract space dimension from DoFHandlerType.
+   * Extract space dimension from DoFHandler.
    */
-  static const unsigned int spacedim = DoFHandlerType::space_dimension;
+  static const unsigned int spacedim = space_dimension_;
 
 
   /**
    * Data type passed by the iterator class.
    */
-  using AccessorData = DoFHandlerType;
+  using AccessorData = DoFHandler<dimension_, space_dimension_>;
 
   /**
    * Declare an alias to the base class to make accessing some of the
    * exception classes simpler.
    */
   using BaseClass =
-    DoFAccessor<DoFHandlerType::dimension, DoFHandlerType, level_dof_access>;
+    DoFAccessor<dimension_, dimension_, space_dimension_, level_dof_access>;
 
   /**
    * Define the type of the container this is part of.
    */
-  using Container = DoFHandlerType;
+  using Container = DoFHandler<dimension_, space_dimension_>;
 
   /**
    * A type for an iterator over the faces of a cell. This is what the face()
    * function returns.
    */
-  using face_iterator = TriaIterator<DoFAccessor<DoFHandlerType::dimension - 1,
-                                                 DoFHandlerType,
+  using face_iterator = TriaIterator<DoFAccessor<dimension_ - 1,
+                                                 dimension_,
+                                                 space_dimension_,
                                                  level_dof_access>>;
 
   /**
@@ -1380,10 +1371,9 @@ public:
   /**
    * Constructor
    */
-  DoFCellAccessor(const Triangulation<DoFHandlerType::dimension,
-                                      DoFHandlerType::space_dimension> *tria,
-                  const int                                             level,
-                  const int                                             index,
+  DoFCellAccessor(const Triangulation<dimension_, space_dimension_> *tria,
+                  const int                                          level,
+                  const int                                          index,
                   const AccessorData *local_data);
 
   /**
@@ -1405,9 +1395,9 @@ public:
    * Another conversion operator between objects that don't make sense, just
    * like the previous one.
    */
-  template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+  template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
   explicit DoFCellAccessor(
-    const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &);
+    const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &);
 
   /**
    * Copy operator. These operators are usually used in a context like
@@ -1418,8 +1408,9 @@ public:
    * this operation is not useful for iterators on DoF handler objects.
    * Consequently, this operator is declared as deleted and can not be used.
    */
-  DoFCellAccessor<DoFHandlerType, level_dof_access> &
-  operator=(const DoFCellAccessor<DoFHandlerType, level_dof_access> &da) =
+  DoFCellAccessor<dimension_, space_dimension_, level_dof_access> &
+  operator=(
+    const DoFCellAccessor<dimension_, space_dimension_, level_dof_access> &da) =
     delete;
 
   /**
@@ -1435,7 +1426,7 @@ public:
    * CellAccessor returns a triangulation cell accessor without access to the
    * DoF data.
    */
-  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>>
+  TriaIterator<DoFCellAccessor<dimension_, space_dimension_, level_dof_access>>
   parent() const;
 
   /**
@@ -1450,7 +1441,7 @@ public:
    * needed since the neighbor function of the base class returns a cell
    * accessor without access to the DoF data.
    */
-  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>>
+  TriaIterator<DoFCellAccessor<dimension_, space_dimension_, level_dof_access>>
   neighbor(const unsigned int i) const;
 
   /**
@@ -1458,7 +1449,7 @@ public:
    * is needed since the neighbor function of the base class returns a cell
    * accessor without access to the DoF data.
    */
-  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>>
+  TriaIterator<DoFCellAccessor<dimension_, space_dimension_, level_dof_access>>
   periodic_neighbor(const unsigned int i) const;
 
   /**
@@ -1466,7 +1457,7 @@ public:
    * This function is needed since the neighbor function of the base class
    * returns a cell accessor without access to the DoF data.
    */
-  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>>
+  TriaIterator<DoFCellAccessor<dimension_, space_dimension_, level_dof_access>>
   neighbor_or_periodic_neighbor(const unsigned int i) const;
 
   /**
@@ -1474,7 +1465,7 @@ public:
    * since the child function of the base class returns a cell accessor
    * without access to the DoF data.
    */
-  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>>
+  TriaIterator<DoFCellAccessor<dimension_, space_dimension_, level_dof_access>>
   child(const unsigned int i) const;
 
   /**
@@ -1489,8 +1480,7 @@ public:
   /**
    * Return an array of iterators to all faces of this cell.
    */
-  inline std::array<face_iterator,
-                    GeometryInfo<DoFHandlerType::dimension>::faces_per_cell>
+  inline std::array<face_iterator, GeometryInfo<dimension_>::faces_per_cell>
   face_iterators() const;
 
   /**
@@ -1499,7 +1489,7 @@ public:
    * function in the base class only returns an iterator with access to the
    * triangulation data).
    */
-  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>>
+  TriaIterator<DoFCellAccessor<dimension_, space_dimension_, level_dof_access>>
   neighbor_child_on_subface(const unsigned int face_no,
                             const unsigned int subface_no) const;
 
@@ -1509,7 +1499,7 @@ public:
    * data (the function in the base class only returns an iterator with access
    * to the triangulation data).
    */
-  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>>
+  TriaIterator<DoFCellAccessor<dimension_, space_dimension_, level_dof_access>>
   periodic_neighbor_child_on_subface(const unsigned int face_no,
                                      const unsigned int subface_no) const;
 
@@ -1649,7 +1639,8 @@ public:
   get_interpolated_dof_values(
     const InputVector &values,
     Vector<number> &   interpolated_values,
-    const unsigned int fe_index = DoFHandlerType::invalid_fe_index) const;
+    const unsigned int fe_index =
+      DoFHandler<dimension_, space_dimension_>::invalid_fe_index) const;
 
   /**
    * This function is the counterpart to get_interpolated_dof_values(): you
@@ -1708,7 +1699,8 @@ public:
   set_dof_values_by_interpolation(
     const Vector<number> &local_values,
     OutputVector &        values,
-    const unsigned int    fe_index = DoFHandlerType::invalid_fe_index) const;
+    const unsigned int    fe_index =
+      DoFHandler<dimension_, space_dimension_>::invalid_fe_index) const;
 
   /**
    * Distribute a local (cell based) vector to a global one by mapping the
@@ -1874,8 +1866,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<DoFHandlerType::dimension,
-                      DoFHandlerType::space_dimension> &
+  const FiniteElement<dimension_, space_dimension_> &
   get_fe() const;
 
   /**
@@ -1982,8 +1973,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<DoFHandlerType::dimension,
-                      DoFHandlerType::space_dimension> &
+  const FiniteElement<dimension_, space_dimension_> &
   get_future_fe() const;
 
   /**
@@ -2044,15 +2034,15 @@ public:
 private:
   // Make the DoFHandler class a friend so that it can call the
   // update_cell_dof_indices_cache() function
-  template <int dim, int spacedim>
+  template <int, int>
   friend class DoFHandler;
   friend struct dealii::internal::DoFCellAccessorImplementation::Implementation;
 };
 
 
-template <int sd, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline bool
-DoFAccessor<sd, DoFHandlerType, level_dof_access>::is_level_cell()
+DoFAccessor<structdim, dim, spacedim, 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 4d52fa12bc..d9628adfba 100644
--- a/include/deal.II/dofs/dof_accessor.templates.h
+++ b/include/deal.II/dofs/dof_accessor.templates.h
@@ -41,26 +41,23 @@ DEAL_II_NAMESPACE_OPEN
 /*------------------------- Functions: DoFAccessor ---------------------------*/
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
-inline DoFAccessor<structdim, DoFHandlerType, level_dof_access>::DoFAccessor()
+template <int structdim, int dim, int spacedim, bool level_dof_access>
+inline DoFAccessor<structdim, dim, spacedim, level_dof_access>::DoFAccessor()
 {
   Assert(false, ExcInvalidObject());
 }
 
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
-inline 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::DoFAccessorImplementation::Inheritance<
-      structdim,
-      DoFHandlerType::dimension,
-      DoFHandlerType::space_dimension>::BaseClass(tria, level, index)
-  , dof_handler(const_cast<DoFHandlerType *>(dof_handler))
+template <int structdim, int dim, int spacedim, bool level_dof_access>
+inline DoFAccessor<structdim, dim, spacedim, level_dof_access>::DoFAccessor(
+  const Triangulation<dim, spacedim> *tria,
+  const int                           level,
+  const int                           index,
+  const DoFHandler<dim, spacedim> *   dof_handler)
+  : dealii::internal::DoFAccessorImplementation::
+      Inheritance<structdim, dim, spacedim>::BaseClass(tria, level, index)
+  , dof_handler(const_cast<DoFHandler<dim, spacedim> *>(dof_handler))
 {
   Assert(
     tria == nullptr || &dof_handler->get_triangulation() == tria,
@@ -71,9 +68,9 @@ inline DoFAccessor<structdim, DoFHandlerType, level_dof_access>::DoFAccessor(
 
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 template <int structdim2, int dim2, int spacedim2>
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::DoFAccessor(
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::DoFAccessor(
   const InvalidAccessor<structdim2, dim2, spacedim2> &)
 {
   Assert(false, ExcInvalidObject());
@@ -81,10 +78,10 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::DoFAccessor(
 
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
-template <int dim2, class DoFHandlerType2, bool level_dof_access2>
-inline DoFAccessor<structdim, DoFHandlerType, level_dof_access>::DoFAccessor(
-  const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &other)
+template <int structdim, int dim, int spacedim, bool level_dof_access>
+template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
+inline DoFAccessor<structdim, dim, spacedim, level_dof_access>::DoFAccessor(
+  const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &other)
   : BaseClass(other)
   , dof_handler(nullptr)
 {
@@ -100,20 +97,20 @@ inline DoFAccessor<structdim, DoFHandlerType, level_dof_access>::DoFAccessor(
 
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 template <bool level_dof_access2>
-inline DoFAccessor<structdim, DoFHandlerType, level_dof_access>::DoFAccessor(
-  const DoFAccessor<structdim, DoFHandlerType, level_dof_access2> &other)
+inline DoFAccessor<structdim, dim, spacedim, level_dof_access>::DoFAccessor(
+  const DoFAccessor<structdim, dim, spacedim, level_dof_access2> &other)
   : BaseClass(other)
-  , dof_handler(const_cast<DoFHandlerType *>(other.dof_handler))
+  , dof_handler(const_cast<DoFHandler<dim, spacedim> *>(other.dof_handler))
 {}
 
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::set_dof_handler(
-  DoFHandlerType *dh)
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::set_dof_handler(
+  DoFHandler<dim, spacedim> *dh)
 {
   Assert(dh != nullptr, ExcInvalidObject());
   this->dof_handler = dh;
@@ -121,10 +118,9 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::set_dof_handler(
 
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
-inline const DoFHandlerType &
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::get_dof_handler()
-  const
+template <int structdim, int dim, int spacedim, bool level_dof_access>
+inline const DoFHandler<dim, spacedim> &
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::get_dof_handler() const
 {
   Assert(this->dof_handler != nullptr, ExcInvalidObject());
   return *this->dof_handler;
@@ -132,12 +128,10 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::get_dof_handler()
 
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::copy_from(
-  const TriaAccessorBase<structdim,
-                         DoFHandlerType::dimension,
-                         DoFHandlerType::space_dimension> &da)
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::copy_from(
+  const TriaAccessorBase<structdim, dim, spacedim> &da)
 {
   Assert(this->dof_handler != nullptr, ExcInvalidObject());
   BaseClass::copy_from(da);
@@ -145,11 +139,11 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::copy_from(
 
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 template <bool level_dof_access2>
 inline void
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::copy_from(
-  const DoFAccessor<structdim, DoFHandlerType, level_dof_access2> &a)
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::copy_from(
+  const DoFAccessor<structdim, dim, spacedim, level_dof_access2> &a)
 {
   BaseClass::copy_from(a);
   this->dof_handler = a.dof_handler;
@@ -157,49 +151,45 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::copy_from(
 
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
-template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
+template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
 inline bool
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::
-operator==(const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &a) const
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::operator==(
+  const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &a) const
 {
-  Assert(structdim == dim2, ExcCantCompareIterators());
+  Assert(structdim == structdim2, ExcCantCompareIterators());
   Assert(this->dof_handler == a.dof_handler, ExcCantCompareIterators());
   return (BaseClass::operator==(a));
 }
 
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
-template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
+template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
 inline bool
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::
-operator!=(const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &a) const
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::operator!=(
+  const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &a) const
 {
-  Assert(structdim == dim2, ExcCantCompareIterators());
+  Assert(structdim == structdim2, ExcCantCompareIterators());
   Assert(this->dof_handler == a.dof_handler, ExcCantCompareIterators());
   return (BaseClass::operator!=(a));
 }
 
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
-inline TriaIterator<DoFAccessor<structdim, DoFHandlerType, level_dof_access>>
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::child(
+template <int structdim, int dim, int spacedim, bool level_dof_access>
+inline TriaIterator<DoFAccessor<structdim, dim, spacedim, level_dof_access>>
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::child(
   const unsigned int i) const
 {
   Assert(static_cast<unsigned int>(this->present_level) <
            this->dof_handler->object_dof_indices.size(),
          ExcMessage("DoFHandler not initialized"));
 
-  TriaIterator<TriaAccessor<structdim,
-                            DoFHandlerType::dimension,
-                            DoFHandlerType::space_dimension>>
-    t = TriaAccessor<structdim,
-                     DoFHandlerType::dimension,
-                     DoFHandlerType::space_dimension>::child(i);
+  TriaIterator<TriaAccessor<structdim, dim, spacedim>> t =
+    TriaAccessor<structdim, dim, spacedim>::child(i);
 
-  TriaIterator<DoFAccessor<structdim, DoFHandlerType, level_dof_access>> q(
+  TriaIterator<DoFAccessor<structdim, dim, spacedim, level_dof_access>> q(
     *t, this->dof_handler);
   return q;
 }
@@ -215,12 +205,12 @@ namespace internal
      */
     struct Implementation
     {
-      template <typename DoFHandlerType>
+      template <int dim, int spacedim>
       static const types::global_dof_index *
-      get_cache_ptr(DoFHandlerType *   dof_handler,
-                    const unsigned int present_level,
-                    const unsigned int present_index,
-                    const unsigned int dofs_per_cell)
+      get_cache_ptr(DoFHandler<dim, spacedim> *dof_handler,
+                    const unsigned int         present_level,
+                    const unsigned int         present_index,
+                    const unsigned int         dofs_per_cell)
       {
         (void)dofs_per_cell;
 
@@ -237,23 +227,23 @@ namespace internal
        * finite element specified by @p fe_index on the vertex with global
        * number @p vertex_index to @p global_index.
        */
-      template <typename DoFHandlerType, int d>
+      template <int dim, int spacedim, int d>
       static void
-      set_dof_index(const DoFHandlerType &dof_handler,
-                    const unsigned int    obj_level,
-                    const unsigned int    obj_index,
-                    const unsigned int    fe_index,
-                    const unsigned int    local_index,
+      set_dof_index(const DoFHandler<dim, spacedim> &dof_handler,
+                    const unsigned int               obj_level,
+                    const unsigned int               obj_index,
+                    const unsigned int               fe_index,
+                    const unsigned int               local_index,
                     const std::integral_constant<int, d> &,
                     const types::global_dof_index global_index)
       {
-        Assert(d == DoFHandlerType::dimension || obj_level == 0,
-               ExcNotImplemented());
+        Assert(d == dim || obj_level == 0, ExcNotImplemented());
 
         // 1) no hp used -> fe_index == 0
         if (dof_handler.hp_capability_enabled == false)
           {
-            AssertDimension(fe_index, DoFHandlerType::default_fe_index);
+            AssertDimension(fe_index,
+                            (DoFHandler<dim, spacedim>::default_fe_index));
 
             if (d == 0)
               dof_handler.object_dof_indices
@@ -269,7 +259,7 @@ namespace internal
           }
 
         // 2) cell and hp is used -> there is only one fe_index
-        if (d == DoFHandlerType::dimension)
+        if (d == dim)
           {
             dof_handler.object_dof_indices
               [obj_level][d]
@@ -338,22 +328,22 @@ namespace internal
        * finite element specified by @p fe_index on the vertex with global
        * number @p vertex_index to @p global_index.
        */
-      template <typename DoFHandlerType, int d>
+      template <int dim, int spacedim, int d>
       static types::global_dof_index
-      get_dof_index(const DoFHandlerType &dof_handler,
-                    const unsigned int    obj_level,
-                    const unsigned int    obj_index,
-                    const unsigned int    fe_index,
-                    const unsigned int    local_index,
+      get_dof_index(const DoFHandler<dim, spacedim> &dof_handler,
+                    const unsigned int               obj_level,
+                    const unsigned int               obj_index,
+                    const unsigned int               fe_index,
+                    const unsigned int               local_index,
                     const std::integral_constant<int, d> &)
       {
-        Assert(d == DoFHandlerType::dimension || obj_level == 0,
-               ExcNotImplemented());
+        Assert(d == dim || obj_level == 0, ExcNotImplemented());
 
         // 1) no hp used -> fe_index == 0
         if (dof_handler.hp_capability_enabled == false)
           {
-            AssertDimension(fe_index, DoFHandlerType::default_fe_index);
+            AssertDimension(fe_index,
+                            (DoFHandler<dim, spacedim>::default_fe_index));
 
             if (d == 0)
               return dof_handler.object_dof_indices
@@ -367,7 +357,7 @@ namespace internal
           }
 
         // 2) cell and hp is used -> there is only one fe_index
-        if (d == DoFHandlerType::dimension)
+        if (d == dim)
           {
             return dof_handler.object_dof_indices
               [obj_level][d]
@@ -430,12 +420,12 @@ namespace internal
       }
 
 
-      template <typename DoFHandlerType>
+      template <int dim, int spacedim>
       static types::global_dof_index
-      mg_vertex_dof_index(const DoFHandlerType &dof_handler,
-                          const int             level,
-                          const unsigned int    vertex_index,
-                          const unsigned int    i)
+      mg_vertex_dof_index(const DoFHandler<dim, spacedim> &dof_handler,
+                          const int                        level,
+                          const unsigned int               vertex_index,
+                          const unsigned int               i)
       {
         Assert(dof_handler.hp_capability_enabled == false,
                ExcMessage(
@@ -447,13 +437,13 @@ namespace internal
 
 
 
-      template <typename DoFHandlerType>
+      template <int dim, int spacedim>
       static void
-      set_mg_vertex_dof_index(DoFHandlerType &        dof_handler,
-                              const int               level,
-                              const unsigned int      vertex_index,
-                              const unsigned int      i,
-                              types::global_dof_index index)
+      set_mg_vertex_dof_index(DoFHandler<dim, spacedim> &dof_handler,
+                              const int                  level,
+                              const unsigned int         vertex_index,
+                              const unsigned int         i,
+                              types::global_dof_index    index)
       {
         Assert(dof_handler.hp_capability_enabled == false,
                ExcMessage(
@@ -468,24 +458,23 @@ namespace internal
        * Return the number of different finite elements that are active on a
        * given vertex.
        */
-      template <typename DoFHandlerType, int d>
+      template <int dim, int spacedim, int d>
       static unsigned int
-      n_active_fe_indices(const DoFHandlerType &dof_handler,
-                          const unsigned int    obj_level,
-                          const unsigned int    obj_index,
+      n_active_fe_indices(const DoFHandler<dim, spacedim> &dof_handler,
+                          const unsigned int               obj_level,
+                          const unsigned int               obj_index,
                           const std::integral_constant<int, d> &)
       {
         (void)obj_level;
 
-        Assert(d == DoFHandlerType::dimension || obj_level == 0,
-               ExcNotImplemented());
+        Assert(d == dim || obj_level == 0, ExcNotImplemented());
 
         // 1) no hp used -> fe_index == 0
         if (dof_handler.hp_capability_enabled == false)
           return 1;
 
         // 2) cell and hp is used -> there is only one fe_index
-        if (d == DoFHandlerType::dimension)
+        if (d == dim)
           return 1;
 
         // 3) general entity and hp is used
@@ -502,28 +491,28 @@ namespace internal
        * Return the fe index of the n-th finite element active on a given
        * vertex.
        */
-      template <typename DoFHandlerType, int d>
+      template <int dim, int spacedim, int d>
       static unsigned int
-      nth_active_fe_index(const DoFHandlerType &dof_handler,
-                          const unsigned int    obj_level,
-                          const unsigned int    obj_index,
-                          const unsigned int    local_index,
+      nth_active_fe_index(const DoFHandler<dim, spacedim> &dof_handler,
+                          const unsigned int               obj_level,
+                          const unsigned int               obj_index,
+                          const unsigned int               local_index,
                           const std::integral_constant<int, d> &)
       {
-        Assert(d == DoFHandlerType::dimension || obj_level == 0,
-               ExcNotImplemented());
+        Assert(d == dim || obj_level == 0, ExcNotImplemented());
 
         // for cells only one active fe index available
-        Assert(((d == DoFHandlerType::dimension) &&
-                (local_index != DoFHandlerType::default_fe_index)) == false,
+        Assert(((d == dim) &&
+                (local_index != DoFHandler<dim, spacedim>::default_fe_index)) ==
+                 false,
                ExcNotImplemented());
 
         // 1) no hp used -> fe_index == 0
         if (dof_handler.hp_capability_enabled == false)
-          return DoFHandlerType::default_fe_index;
+          return DoFHandler<dim, spacedim>::default_fe_index;
 
         // 2) cell and hp is used -> there is only one fe_index
-        if (d == DoFHandlerType::dimension)
+        if (d == dim)
           return dof_handler.hp_cell_active_fe_indices[obj_level][obj_index];
 
         // 3) general entity and hp is used
@@ -547,22 +536,21 @@ namespace internal
        * The size of the returned set equals the number of finite elements that
        * are active on this vertex.
        */
-      template <typename DoFHandlerType, int d>
+      template <int dim, int spacedim, int d>
       static std::set<unsigned int>
-      get_active_fe_indices(const DoFHandlerType &                dof_handler,
+      get_active_fe_indices(const DoFHandler<dim, spacedim> &     dof_handler,
                             const unsigned int                    obj_level,
                             const unsigned int                    obj_index,
                             const std::integral_constant<int, d> &t)
       {
-        Assert(d == DoFHandlerType::dimension || obj_level == 0,
-               ExcNotImplemented());
+        Assert(d == dim || obj_level == 0, ExcNotImplemented());
 
         // 1) no hp used -> fe_index == 0
         if (dof_handler.hp_capability_enabled == false)
-          return {DoFHandlerType::default_fe_index};
+          return {DoFHandler<dim, spacedim>::default_fe_index};
 
         // 2) cell and hp is used -> there is only one fe_index
-        if (d == DoFHandlerType::dimension)
+        if (d == dim)
           return {dof_handler.hp_cell_active_fe_indices[obj_level][obj_index]};
 
         // 3) general entity and hp is used
@@ -577,23 +565,22 @@ namespace internal
 
 
 
-      template <typename DoFHandlerType, int d>
+      template <int dim, int spacedim, int d>
       static bool
-      fe_index_is_active(const DoFHandlerType &dof_handler,
-                         const unsigned int    obj_level,
-                         const unsigned int    obj_index,
-                         const unsigned int    fe_index,
+      fe_index_is_active(const DoFHandler<dim, spacedim> &dof_handler,
+                         const unsigned int               obj_level,
+                         const unsigned int               obj_index,
+                         const unsigned int               fe_index,
                          const std::integral_constant<int, d> &)
       {
-        Assert(d == DoFHandlerType::dimension || obj_level == 0,
-               ExcNotImplemented());
+        Assert(d == dim || obj_level == 0, ExcNotImplemented());
 
         // 1) no hp used -> fe_index == 0
         if (dof_handler.hp_capability_enabled == false)
-          return (fe_index == DoFHandlerType::default_fe_index);
+          return (fe_index == DoFHandler<dim, spacedim>::default_fe_index);
 
         // 2) cell and hp is used -> there is only one fe_index
-        if (d == DoFHandlerType::dimension)
+        if (d == dim)
           return dof_handler.hp_cell_active_fe_indices[obj_level][obj_index] ==
                  fe_index;
 
@@ -609,17 +596,15 @@ namespace internal
 
 
 
-      template <typename DoFHandlerType, bool level_dof_access>
+      template <int dim, int spacedim, bool level_dof_access>
       static void
       set_mg_dof_indices(
-        const dealii::DoFAccessor<1, DoFHandlerType, level_dof_access>
-          &                                         accessor,
-        const int                                   level,
+        const dealii::DoFAccessor<1, dim, spacedim, level_dof_access> &accessor,
+        const int                                                      level,
         const std::vector<types::global_dof_index> &dof_indices,
         const unsigned int                          fe_index)
       {
-        const FiniteElement<DoFHandlerType::dimension,
-                            DoFHandlerType::space_dimension> &fe =
+        const FiniteElement<dim, spacedim> &fe =
           accessor.get_dof_handler().get_fe(fe_index);
         std::vector<types::global_dof_index>::const_iterator next =
           dof_indices.begin();
@@ -637,15 +622,14 @@ namespace internal
 
 
 
-      template <typename DoFHandlerType, bool level_dof_access>
+      template <int dim, int spacedim, bool level_dof_access>
       static 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)
+        dealii::DoFAccessor<2, dim, spacedim, level_dof_access> &accessor,
+        const int                                                level,
+        const std::vector<types::global_dof_index> &             dof_indices,
+        const unsigned int                                       fe_index)
       {
-        const FiniteElement<DoFHandlerType::dimension,
-                            DoFHandlerType::space_dimension> &fe =
+        const FiniteElement<dim, spacedim> &fe =
           accessor.get_dof_handler().get_fe(fe_index);
         std::vector<types::global_dof_index>::const_iterator next =
           dof_indices.begin();
@@ -668,17 +652,15 @@ namespace internal
 
 
 
-      template <typename DoFHandlerType, bool level_dof_access>
+      template <int dim, int spacedim, bool level_dof_access>
       static void
       set_mg_dof_indices(
-        const dealii::DoFAccessor<3, DoFHandlerType, level_dof_access>
-          &                                         accessor,
-        const int                                   level,
+        const dealii::DoFAccessor<3, dim, spacedim, level_dof_access> &accessor,
+        const int                                                      level,
         const std::vector<types::global_dof_index> &dof_indices,
         const unsigned int                          fe_index)
       {
-        const FiniteElement<DoFHandlerType::dimension,
-                            DoFHandlerType::space_dimension> &fe =
+        const FiniteElement<dim, spacedim> &fe =
           accessor.get_dof_handler().get_fe(fe_index);
         std::vector<types::global_dof_index>::const_iterator next =
           dof_indices.begin();
@@ -813,14 +795,15 @@ namespace internal
        * provided @p accessor and @p fe_index and perform the static functions
        * provided by DoFOperation (set/get) on these.
        */
-      template <typename DoFHandlerType,
+      template <int  dim,
+                int  spacedim,
                 bool level_dof_access,
                 int  structdim,
                 typename DoFIndicesType,
                 typename DoFOperation>
       static void
       process_dof_indices(
-        const dealii::DoFAccessor<structdim, DoFHandlerType, level_dof_access>
+        const dealii::DoFAccessor<structdim, dim, spacedim, level_dof_access>
           &                accessor,
         DoFIndicesType &   dof_indices,
         const unsigned int fe_index,
@@ -902,7 +885,7 @@ namespace internal
        * An internal struct encapsulating the task of getting (vertex)
        * DoF indices.
        */
-      template <typename DoFHandlerType, bool level_dof_access, int structdim>
+      template <int dim, int spacedim, bool level_dof_access, int structdim>
       struct DoFIndexGetter
       {
         /**
@@ -910,7 +893,7 @@ namespace internal
          */
         static DEAL_II_ALWAYS_INLINE void
         process_vertex_dof(
-          const dealii::DoFAccessor<structdim, DoFHandlerType, level_dof_access>
+          const dealii::DoFAccessor<structdim, dim, spacedim, level_dof_access>
             &                      accessor,
           const unsigned int       vertex,
           const unsigned int       d,
@@ -925,12 +908,12 @@ namespace internal
          */
         template <int structdim_>
         static DEAL_II_ALWAYS_INLINE void
-        process_dof(const dealii::DoFAccessor<structdim_,
-                                              DoFHandlerType,
-                                              level_dof_access> &accessor,
-                    const unsigned int                           d,
-                    types::global_dof_index &                    index_value,
-                    const unsigned int                           fe_index)
+        process_dof(
+          const dealii::DoFAccessor<structdim_, dim, spacedim, level_dof_access>
+            &                      accessor,
+          const unsigned int       d,
+          types::global_dof_index &index_value,
+          const unsigned int       fe_index)
         {
           index_value = accessor.dof_index(d, fe_index);
         }
@@ -941,9 +924,7 @@ namespace internal
         template <int structdim_>
         static DEAL_II_ALWAYS_INLINE void
         process_dof(
-          const dealii::DoFInvalidAccessor<structdim_,
-                                           DoFHandlerType::dimension,
-                                           DoFHandlerType::space_dimension> &,
+          const dealii::DoFInvalidAccessor<structdim_, dim, spacedim> &,
           const unsigned int,
           types::global_dof_index &,
           const unsigned int)
@@ -958,7 +939,7 @@ namespace internal
        * An internal struct encapsulating the task of setting (vertex)
        * DoF indices.
        */
-      template <typename DoFHandlerType, bool level_dof_access, int structdim>
+      template <int dim, int spacedim, bool level_dof_access, int structdim>
       struct DoFIndexSetter
       {
         /**
@@ -966,7 +947,7 @@ namespace internal
          */
         static DEAL_II_ALWAYS_INLINE void
         process_vertex_dof(
-          const dealii::DoFAccessor<structdim, DoFHandlerType, level_dof_access>
+          const dealii::DoFAccessor<structdim, dim, spacedim, level_dof_access>
             &                            accessor,
           const unsigned int             vertex,
           const unsigned int             d,
@@ -981,12 +962,12 @@ namespace internal
          */
         template <int structdim_>
         static DEAL_II_ALWAYS_INLINE void
-        process_dof(const dealii::DoFAccessor<structdim_,
-                                              DoFHandlerType,
-                                              level_dof_access> &accessor,
-                    const unsigned int                           d,
-                    const types::global_dof_index &              index_value,
-                    const unsigned int                           fe_index)
+        process_dof(
+          const dealii::DoFAccessor<structdim_, dim, spacedim, level_dof_access>
+            &                            accessor,
+          const unsigned int             d,
+          const types::global_dof_index &index_value,
+          const unsigned int             fe_index)
         {
           accessor.set_dof_index(d, index_value, fe_index);
         }
@@ -997,9 +978,7 @@ namespace internal
         template <int structdim_>
         static DEAL_II_ALWAYS_INLINE void
         process_dof(
-          const dealii::DoFInvalidAccessor<structdim_,
-                                           DoFHandlerType::dimension,
-                                           DoFHandlerType::space_dimension> &,
+          const dealii::DoFInvalidAccessor<structdim_, dim, spacedim> &,
           const unsigned int,
           const types::global_dof_index &,
           const unsigned int)
@@ -1010,10 +989,10 @@ namespace internal
 
 
 
-      template <typename DoFHandlerType, bool level_dof_access, int structdim>
+      template <int dim, int spacedim, bool level_dof_access, int structdim>
       static void
       get_dof_indices(
-        const dealii::DoFAccessor<structdim, DoFHandlerType, level_dof_access>
+        const dealii::DoFAccessor<structdim, dim, spacedim, level_dof_access>
           &                                   accessor,
         std::vector<types::global_dof_index> &dof_indices,
         const unsigned int                    fe_index)
@@ -1022,15 +1001,15 @@ namespace internal
           accessor,
           dof_indices,
           fe_index,
-          DoFIndexGetter<DoFHandlerType, level_dof_access, structdim>());
+          DoFIndexGetter<dim, spacedim, level_dof_access, structdim>());
       }
 
 
 
-      template <typename DoFHandlerType, bool level_dof_access, int structdim>
+      template <int dim, int spacedim, bool level_dof_access, int structdim>
       static void
       set_dof_indices(
-        const dealii::DoFAccessor<structdim, DoFHandlerType, level_dof_access>
+        const dealii::DoFAccessor<structdim, dim, spacedim, level_dof_access>
           &                                         accessor,
         const std::vector<types::global_dof_index> &dof_indices,
         const unsigned int                          fe_index)
@@ -1041,7 +1020,7 @@ namespace internal
         // internal::DoFHandlerImplementation::Policy::Implementation::distribute_dofs().
         // In the case of new use cases, this assert can be removed.
         Assert(
-          DoFHandlerType::dimension == structdim,
+          dim == structdim,
           ExcMessage(
             "This function is intended to be used for DoFCellAccessor, i.e., dimension == structdim."));
 
@@ -1049,7 +1028,7 @@ namespace internal
           accessor,
           dof_indices,
           fe_index,
-          DoFIndexSetter<DoFHandlerType, level_dof_access, structdim>());
+          DoFIndexSetter<dim, spacedim, level_dof_access, structdim>());
       }
     };
   } // namespace DoFAccessorImplementation
@@ -1057,16 +1036,16 @@ namespace internal
 
 
 
-template <int dim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline types::global_dof_index
-DoFAccessor<dim, DoFHandlerType, level_dof_access>::dof_index(
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::dof_index(
   const unsigned int i,
   const unsigned int fe_index_) const
 {
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType::invalid_fe_index) ?
-      DoFHandlerType::default_fe_index :
+     fe_index_ == DoFHandler<dim, spacedim>::invalid_fe_index) ?
+      DoFHandler<dim, spacedim>::default_fe_index :
       fe_index_;
 
   // access the respective DoF
@@ -1076,13 +1055,13 @@ DoFAccessor<dim, DoFHandlerType, level_dof_access>::dof_index(
                   this->present_index,
                   fe_index,
                   i,
-                  std::integral_constant<int, dim>());
+                  std::integral_constant<int, structdim>());
 }
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline types::global_dof_index
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::mg_dof_index(
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::mg_dof_index(
   const int          level,
   const unsigned int i) const
 {
@@ -1091,17 +1070,17 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::mg_dof_index(
 }
 
 
-template <int dim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<dim, DoFHandlerType, level_dof_access>::set_dof_index(
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::set_dof_index(
   const unsigned int            i,
   const types::global_dof_index index,
   const unsigned int            fe_index_) const
 {
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType::invalid_fe_index) ?
-      DoFHandlerType::default_fe_index :
+     fe_index_ == DoFHandler<dim, spacedim>::invalid_fe_index) ?
+      DoFHandler<dim, spacedim>::default_fe_index :
       fe_index_;
 
   // access the respective DoF
@@ -1111,29 +1090,30 @@ DoFAccessor<dim, DoFHandlerType, level_dof_access>::set_dof_index(
     this->present_index,
     fe_index,
     i,
-    std::integral_constant<int, dim>(),
+    std::integral_constant<int, structdim>(),
     index);
 }
 
 
 
-template <int dim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline unsigned int
-DoFAccessor<dim, DoFHandlerType, level_dof_access>::n_active_fe_indices() const
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::n_active_fe_indices()
+  const
 {
   // access the respective DoF
   return dealii::internal::DoFAccessorImplementation::Implementation::
     n_active_fe_indices(*this->dof_handler,
                         this->level(),
                         this->present_index,
-                        std::integral_constant<int, dim>());
+                        std::integral_constant<int, structdim>());
 }
 
 
 
-template <int dim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline unsigned int
-DoFAccessor<dim, DoFHandlerType, level_dof_access>::nth_active_fe_index(
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::nth_active_fe_index(
   const unsigned int n) const
 {
   // access the respective DoF
@@ -1142,14 +1122,14 @@ DoFAccessor<dim, DoFHandlerType, level_dof_access>::nth_active_fe_index(
                         this->level(),
                         this->present_index,
                         n,
-                        std::integral_constant<int, dim>());
+                        std::integral_constant<int, structdim>());
 }
 
 
 
-template <int dim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline std::set<unsigned int>
-DoFAccessor<dim, DoFHandlerType, level_dof_access>::get_active_fe_indices()
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::get_active_fe_indices()
   const
 {
   std::set<unsigned int> active_fe_indices;
@@ -1160,9 +1140,9 @@ DoFAccessor<dim, DoFHandlerType, level_dof_access>::get_active_fe_indices()
 
 
 
-template <int dim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline bool
-DoFAccessor<dim, DoFHandlerType, level_dof_access>::fe_index_is_active(
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::fe_index_is_active(
   const unsigned int fe_index) const
 {
   // access the respective DoF
@@ -1171,22 +1151,22 @@ DoFAccessor<dim, DoFHandlerType, level_dof_access>::fe_index_is_active(
                        this->level(),
                        this->present_index,
                        fe_index,
-                       std::integral_constant<int, dim>());
+                       std::integral_constant<int, structdim>());
 }
 
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline types::global_dof_index
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::vertex_dof_index(
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::vertex_dof_index(
   const unsigned int vertex,
   const unsigned int i,
   const unsigned int fe_index_) const
 {
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType::invalid_fe_index) ?
-      DoFHandlerType::default_fe_index :
+     fe_index_ == DoFHandler<dim, spacedim>::invalid_fe_index) ?
+      DoFHandler<dim, spacedim>::default_fe_index :
       fe_index_;
 
   return dealii::internal::DoFAccessorImplementation::Implementation::
@@ -1199,9 +1179,9 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::vertex_dof_index(
 }
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline types::global_dof_index
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::mg_vertex_dof_index(
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::mg_vertex_dof_index(
   const int          level,
   const unsigned int vertex,
   const unsigned int i,
@@ -1209,8 +1189,8 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::mg_vertex_dof_index(
 {
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType::invalid_fe_index) ?
-      DoFHandlerType::default_fe_index :
+     fe_index_ == DoFHandler<dim, spacedim>::invalid_fe_index) ?
+      DoFHandler<dim, spacedim>::default_fe_index :
       fe_index_;
   (void)fe_index;
   Assert(this->dof_handler != nullptr, ExcInvalidObject());
@@ -1225,9 +1205,9 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::mg_vertex_dof_index(
 }
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::set_vertex_dof_index(
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::set_vertex_dof_index(
   const unsigned int            vertex,
   const unsigned int            i,
   const types::global_dof_index index,
@@ -1235,8 +1215,8 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::set_vertex_dof_index(
 {
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType::invalid_fe_index) ?
-      DoFHandlerType::default_fe_index :
+     fe_index_ == DoFHandler<dim, spacedim>::invalid_fe_index) ?
+      DoFHandler<dim, spacedim>::default_fe_index :
       fe_index_;
 
   dealii::internal::DoFAccessorImplementation::Implementation::set_dof_index(
@@ -1250,9 +1230,9 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::set_vertex_dof_index(
 }
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::
   set_mg_vertex_dof_index(const int                     level,
                           const unsigned int            vertex,
                           const unsigned int            i,
@@ -1261,8 +1241,8 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::
 {
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType::invalid_fe_index) ?
-      DoFHandlerType::default_fe_index :
+     fe_index_ == DoFHandler<dim, spacedim>::invalid_fe_index) ?
+      DoFHandler<dim, spacedim>::default_fe_index :
       fe_index_;
   (void)fe_index;
   Assert(this->dof_handler != nullptr, ExcInvalidObject());
@@ -1277,9 +1257,9 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::
 }
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::set_mg_dof_index(
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::set_mg_dof_index(
   const int                     level,
   const unsigned int            i,
   const types::global_dof_index index) const
@@ -1290,10 +1270,9 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::set_mg_dof_index(
 
 
 
-template <int dim, typename DoFHandlerType, bool level_dof_access>
-inline const FiniteElement<DoFHandlerType::dimension,
-                           DoFHandlerType::space_dimension> &
-DoFAccessor<dim, DoFHandlerType, level_dof_access>::get_fe(
+template <int structdim, int dim, int spacedim, bool level_dof_access>
+inline const FiniteElement<dim, spacedim> &
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::get_fe(
   const unsigned int fe_index) const
 {
   Assert(fe_index_is_active(fe_index) == true,
@@ -1308,19 +1287,17 @@ namespace internal
 {
   namespace DoFAccessorImplementation
   {
-    template <typename DoFHandlerType, bool level_dof_access>
+    template <int dim, int spacedim, bool level_dof_access>
     void
     get_mg_dof_indices(
-      const dealii::DoFAccessor<1, DoFHandlerType, level_dof_access> &accessor,
-      const int                                                       level,
+      const dealii::DoFAccessor<1, dim, spacedim, level_dof_access> &accessor,
+      const int                                                      level,
       std::vector<types::global_dof_index> &dof_indices,
       const unsigned int                    fe_index)
     {
-      const DoFHandlerType &handler = accessor.get_dof_handler();
+      const DoFHandler<dim, spacedim> &handler = accessor.get_dof_handler();
 
-      const FiniteElement<DoFHandlerType::dimension,
-                          DoFHandlerType::space_dimension> &fe =
-        handler.get_fe(fe_index);
+      const FiniteElement<dim, spacedim> &fe = handler.get_fe(fe_index);
       std::vector<types::global_dof_index>::iterator next = dof_indices.begin();
 
       for (const unsigned int vertex : GeometryInfo<1>::vertex_indices())
@@ -1335,19 +1312,17 @@ namespace internal
 
 
 
-    template <typename DoFHandlerType, bool level_dof_access>
+    template <int dim, int spacedim, bool level_dof_access>
     void
     get_mg_dof_indices(
-      const dealii::DoFAccessor<2, DoFHandlerType, level_dof_access> &accessor,
-      const int                                                       level,
+      const dealii::DoFAccessor<2, dim, spacedim, level_dof_access> &accessor,
+      const int                                                      level,
       std::vector<types::global_dof_index> &dof_indices,
       const unsigned int                    fe_index)
     {
-      const DoFHandlerType &handler = accessor.get_dof_handler();
+      const DoFHandler<dim, spacedim> &handler = accessor.get_dof_handler();
 
-      const FiniteElement<DoFHandlerType::dimension,
-                          DoFHandlerType::space_dimension> &fe =
-        handler.get_fe(fe_index);
+      const FiniteElement<dim, spacedim> &fe = handler.get_fe(fe_index);
       std::vector<types::global_dof_index>::iterator next = dof_indices.begin();
 
       for (const unsigned int vertex : GeometryInfo<2>::vertex_indices())
@@ -1367,19 +1342,17 @@ namespace internal
 
 
 
-    template <typename DoFHandlerType, bool level_dof_access>
+    template <int dim, int spacedim, bool level_dof_access>
     void
     get_mg_dof_indices(
-      const dealii::DoFAccessor<3, DoFHandlerType, level_dof_access> &accessor,
-      const int                                                       level,
+      const dealii::DoFAccessor<3, dim, spacedim, level_dof_access> &accessor,
+      const int                                                      level,
       std::vector<types::global_dof_index> &dof_indices,
       const unsigned int                    fe_index)
     {
-      const DoFHandlerType &handler = accessor.get_dof_handler();
+      const DoFHandler<dim, spacedim> &handler = accessor.get_dof_handler();
 
-      const FiniteElement<DoFHandlerType::dimension,
-                          DoFHandlerType::space_dimension> &fe =
-        handler.get_fe(fe_index);
+      const FiniteElement<dim, spacedim> &fe = handler.get_fe(fe_index);
       std::vector<types::global_dof_index>::iterator next = dof_indices.begin();
 
       for (const unsigned int vertex : GeometryInfo<3>::vertex_indices())
@@ -1418,9 +1391,9 @@ namespace internal
 } // namespace internal
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::get_dof_indices(
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::get_dof_indices(
   std::vector<types::global_dof_index> &dof_indices,
   const unsigned int                    fe_index_) const
 {
@@ -1428,8 +1401,8 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::get_dof_indices(
 
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType::invalid_fe_index) ?
-      DoFHandlerType::default_fe_index :
+     fe_index_ == DoFHandler<dim, spacedim>::invalid_fe_index) ?
+      DoFHandler<dim, spacedim>::default_fe_index :
       fe_index_;
 
   Assert(static_cast<unsigned int>(this->level()) <
@@ -1497,9 +1470,9 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::get_dof_indices(
 
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::get_mg_dof_indices(
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::get_mg_dof_indices(
   const int                             level,
   std::vector<types::global_dof_index> &dof_indices,
   const unsigned int                    fe_index_) const
@@ -1508,8 +1481,8 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::get_mg_dof_indices(
 
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType::invalid_fe_index) ?
-      DoFHandlerType::default_fe_index :
+     fe_index_ == DoFHandler<dim, spacedim>::invalid_fe_index) ?
+      DoFHandler<dim, spacedim>::default_fe_index :
       fe_index_;
 
   switch (structdim)
@@ -1561,9 +1534,9 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::get_mg_dof_indices(
 }
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<structdim, DoFHandlerType, level_dof_access>::set_mg_dof_indices(
+DoFAccessor<structdim, dim, spacedim, level_dof_access>::set_mg_dof_indices(
   const int                                   level,
   const std::vector<types::global_dof_index> &dof_indices,
   const unsigned int                          fe_index_)
@@ -1572,8 +1545,8 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::set_mg_dof_indices(
 
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType::invalid_fe_index) ?
-      DoFHandlerType::default_fe_index :
+     fe_index_ == DoFHandler<dim, spacedim>::invalid_fe_index) ?
+      DoFHandler<dim, spacedim>::default_fe_index :
       fe_index_;
 
   switch (structdim)
@@ -1623,10 +1596,10 @@ DoFAccessor<structdim, DoFHandlerType, level_dof_access>::set_mg_dof_indices(
 }
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline typename dealii::internal::DoFHandlerImplementation::
-  Iterators<DoFHandlerType, level_dof_access>::line_iterator
-  DoFAccessor<structdim, DoFHandlerType, level_dof_access>::line(
+  Iterators<DoFHandler<dim, spacedim>, level_dof_access>::line_iterator
+  DoFAccessor<structdim, dim, spacedim, level_dof_access>::line(
     const unsigned int i) const
 {
   // if we are asking for a particular line and this object refers to
@@ -1638,7 +1611,7 @@ inline typename dealii::internal::DoFHandlerImplementation::
              ExcMessage("You can only ask for line zero if the "
                         "current object is a line itself."));
       return typename dealii::internal::DoFHandlerImplementation::Iterators<
-        DoFHandlerType,
+        DoFHandler<dim, spacedim>,
         level_dof_access>::cell_iterator(&this->get_triangulation(),
                                          this->level(),
                                          this->index(),
@@ -1647,12 +1620,11 @@ inline typename dealii::internal::DoFHandlerImplementation::
 
   // otherwise we need to be in structdim>=2
   Assert(structdim > 1, ExcImpossibleInDim(structdim));
-  Assert(DoFHandlerType::dimension > 1,
-         ExcImpossibleInDim(DoFHandlerType::dimension));
+  Assert(dim > 1, ExcImpossibleInDim(dim));
 
   // checking of 'i' happens in line_index(i)
   return typename dealii::internal::DoFHandlerImplementation::
-    Iterators<DoFHandlerType, level_dof_access>::line_iterator(
+    Iterators<DoFHandler<dim, spacedim>, level_dof_access>::line_iterator(
       this->tria,
       0, // only sub-objects are allowed, which have no level
       this->line_index(i),
@@ -1660,10 +1632,10 @@ inline typename dealii::internal::DoFHandlerImplementation::
 }
 
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 inline typename dealii::internal::DoFHandlerImplementation::
-  Iterators<DoFHandlerType, level_dof_access>::quad_iterator
-  DoFAccessor<structdim, DoFHandlerType, level_dof_access>::quad(
+  Iterators<DoFHandler<dim, spacedim>, level_dof_access>::quad_iterator
+  DoFAccessor<structdim, dim, spacedim, level_dof_access>::quad(
     const unsigned int i) const
 {
   // if we are asking for a
@@ -1677,20 +1649,19 @@ inline typename dealii::internal::DoFHandlerImplementation::
              ExcMessage("You can only ask for quad zero if the "
                         "current object is a quad itself."));
       return typename dealii::internal::DoFHandlerImplementation::Iterators<
-        DoFHandlerType>::cell_iterator(&this->get_triangulation(),
-                                       this->level(),
-                                       this->index(),
-                                       &this->get_dof_handler());
+        DoFHandler<dim, spacedim>>::cell_iterator(&this->get_triangulation(),
+                                                  this->level(),
+                                                  this->index(),
+                                                  &this->get_dof_handler());
     }
 
   // otherwise we need to be in structdim>=3
   Assert(structdim > 2, ExcImpossibleInDim(structdim));
-  Assert(DoFHandlerType::dimension > 2,
-         ExcImpossibleInDim(DoFHandlerType::dimension));
+  Assert(dim > 2, ExcImpossibleInDim(dim));
 
   // checking of 'i' happens in quad_index(i)
   return typename dealii::internal::DoFHandlerImplementation::
-    Iterators<DoFHandlerType, level_dof_access>::quad_iterator(
+    Iterators<DoFHandler<dim, spacedim>, level_dof_access>::quad_iterator(
       this->tria,
       0, // only sub-objects are allowed, which have no level
       this->quad_index(i),
@@ -1701,40 +1672,32 @@ inline typename dealii::internal::DoFHandlerImplementation::
 /*----------------- Functions: DoFAccessor<0,1,spacedim> --------------------*/
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
-inline DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
-  DoFAccessor()
+template <int spacedim, bool level_dof_access>
+inline DoFAccessor<0, 1, spacedim, level_dof_access>::DoFAccessor()
 {
   Assert(false, ExcInvalidObject());
 }
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
-inline 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)
+template <int spacedim, bool level_dof_access>
+inline DoFAccessor<0, 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 DoFHandler<1, spacedim> *                         dof_handler)
   : BaseClass(tria, vertex_kind, vertex_index)
-  , dof_handler(const_cast<DoFHandlerType<1, spacedim> *>(dof_handler))
+  , dof_handler(const_cast<DoFHandler<1, spacedim> *>(dof_handler))
 {}
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
-inline DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
-  DoFAccessor(const Triangulation<1, spacedim> *,
-              const int,
-              const int,
-              const DoFHandlerType<1, spacedim> *)
+template <int spacedim, bool level_dof_access>
+inline DoFAccessor<0, 1, spacedim, level_dof_access>::DoFAccessor(
+  const Triangulation<1, spacedim> *,
+  const int,
+  const int,
+  const DoFHandler<1, spacedim> *)
   : dof_handler(nullptr)
 {
   Assert(false,
@@ -1744,11 +1707,9 @@ inline DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 template <int structdim2, int dim2, int spacedim2>
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::DoFAccessor(
+DoFAccessor<0, 1, spacedim, level_dof_access>::DoFAccessor(
   const InvalidAccessor<structdim2, dim2, spacedim2> &)
 {
   Assert(false, ExcInvalidObject());
@@ -1756,23 +1717,19 @@ DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::DoFAccessor(
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
-template <int dim2, class DoFHandlerType2, bool level_dof_access2>
-inline DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
-  DoFAccessor(const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &)
+template <int spacedim, bool level_dof_access>
+template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
+inline DoFAccessor<0, 1, spacedim, level_dof_access>::DoFAccessor(
+  const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &)
 {
   Assert(false, ExcInvalidObject());
 }
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
-inline void DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
-  set_dof_handler(DoFHandlerType<1, spacedim> *dh)
+template <int spacedim, bool level_dof_access>
+inline void DoFAccessor<0, 1, spacedim, level_dof_access>::set_dof_handler(
+  DoFHandler<1, spacedim> *dh)
 {
   Assert(dh != nullptr, ExcInvalidObject());
   this->dof_handler = dh;
@@ -1780,11 +1737,9 @@ inline void DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::set_dof_index(
+DoFAccessor<0, 1, spacedim, level_dof_access>::set_dof_index(
   const unsigned int /*i*/,
   const types::global_dof_index /*index*/,
   const unsigned int /*fe_index*/) const
@@ -1794,45 +1749,38 @@ DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::set_dof_index(
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<0, DoFHandlerType<1, spacedim>, 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
+DoFAccessor<0, 1, spacedim, 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
 {
   Assert(false, ExcNotImplemented());
 }
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
-inline const DoFHandlerType<1, spacedim> &
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::get_dof_handler()
-  const
+template <int spacedim, bool level_dof_access>
+inline const DoFHandler<1, spacedim> &
+DoFAccessor<0, 1, spacedim, level_dof_access>::get_dof_handler() const
 {
   return *this->dof_handler;
 }
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::get_dof_indices(
+DoFAccessor<0, 1, spacedim, level_dof_access>::get_dof_indices(
   std::vector<types::global_dof_index> &dof_indices,
   const unsigned int                    fe_index_) const
 {
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType<1, spacedim>::invalid_fe_index) ?
-      DoFHandlerType<1, spacedim>::default_fe_index :
+     fe_index_ == DoFHandler<1, spacedim>::invalid_fe_index) ?
+      DoFHandler<1, spacedim>::default_fe_index :
       fe_index_;
 
   for (unsigned int i = 0; i < dof_indices.size(); ++i)
@@ -1847,22 +1795,20 @@ DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::get_dof_indices(
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
-  get_mg_dof_indices(const int                             level,
-                     std::vector<types::global_dof_index> &dof_indices,
-                     const unsigned int                    fe_index_) const
+DoFAccessor<0, 1, spacedim, level_dof_access>::get_mg_dof_indices(
+  const int                             level,
+  std::vector<types::global_dof_index> &dof_indices,
+  const unsigned int                    fe_index_) const
 {
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType<1, spacedim>::invalid_fe_index) ?
-      DoFHandlerType<1, spacedim>::default_fe_index :
+     fe_index_ == DoFHandler<1, spacedim>::invalid_fe_index) ?
+      DoFHandler<1, spacedim>::default_fe_index :
       fe_index_;
   (void)fe_index;
-  AssertDimension(fe_index, (DoFHandlerType<1, spacedim>::default_fe_index));
+  AssertDimension(fe_index, (DoFHandler<1, spacedim>::default_fe_index));
 
   for (unsigned int i = 0; i < dof_indices.size(); ++i)
     dof_indices[i] =
@@ -1872,19 +1818,17 @@ DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 inline types::global_dof_index
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::vertex_dof_index(
+DoFAccessor<0, 1, spacedim, level_dof_access>::vertex_dof_index(
   const unsigned int vertex,
   const unsigned int i,
   const unsigned int fe_index_) const
 {
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType<1, spacedim>::invalid_fe_index) ?
-      DoFHandlerType<1, spacedim>::default_fe_index :
+     fe_index_ == DoFHandler<1, spacedim>::invalid_fe_index) ?
+      DoFHandler<1, spacedim>::default_fe_index :
       fe_index_;
 
   (void)vertex;
@@ -1900,18 +1844,16 @@ DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::vertex_dof_index(
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 inline types::global_dof_index
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::dof_index(
+DoFAccessor<0, 1, spacedim, level_dof_access>::dof_index(
   const unsigned int i,
   const unsigned int fe_index_) const
 {
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType<1, spacedim>::invalid_fe_index) ?
-      DoFHandlerType<1, spacedim>::default_fe_index :
+     fe_index_ == DoFHandler<1, spacedim>::invalid_fe_index) ?
+      DoFHandler<1, spacedim>::default_fe_index :
       fe_index_;
 
   return dealii::internal::DoFAccessorImplementation::Implementation::
@@ -1925,14 +1867,11 @@ DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::dof_index(
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 inline unsigned int
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
-  n_active_fe_indices() const
+DoFAccessor<0, 1, spacedim, level_dof_access>::n_active_fe_indices() const
 {
-  Assert((std::is_same<DoFHandlerType<1, spacedim>,
+  Assert((std::is_same<DoFHandler<1, spacedim>,
                        dealii::DoFHandler<1, spacedim>>::value == true),
          ExcNotImplemented());
 
@@ -1941,14 +1880,12 @@ DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 inline unsigned int
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
-  nth_active_fe_index(const unsigned int /*n*/) const
+DoFAccessor<0, 1, spacedim, level_dof_access>::nth_active_fe_index(
+  const unsigned int /*n*/) const
 {
-  Assert((std::is_same<DoFHandlerType<1, spacedim>,
+  Assert((std::is_same<DoFHandler<1, spacedim>,
                        dealii::DoFHandler<1, spacedim>>::value == true),
          ExcNotImplemented());
 
@@ -1957,12 +1894,10 @@ DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 inline bool
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
-  fe_index_is_active(const unsigned int /*fe_index*/) const
+DoFAccessor<0, 1, spacedim, level_dof_access>::fe_index_is_active(
+  const unsigned int /*fe_index*/) const
 {
   Assert(false, ExcNotImplemented());
   return false;
@@ -1970,12 +1905,9 @@ DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
-inline const FiniteElement<DoFHandlerType<1, spacedim>::dimension,
-                           DoFHandlerType<1, spacedim>::space_dimension> &
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::get_fe(
+template <int spacedim, bool level_dof_access>
+inline const FiniteElement<1, spacedim> &
+DoFAccessor<0, 1, spacedim, level_dof_access>::get_fe(
   const unsigned int fe_index) const
 {
   Assert(this->dof_handler != nullptr, ExcInvalidObject());
@@ -1984,11 +1916,9 @@ DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::get_fe(
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 inline void
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::copy_from(
+DoFAccessor<0, 1, spacedim, level_dof_access>::copy_from(
   const TriaAccessorBase<0, 1, spacedim> &da)
 {
   Assert(this->dof_handler != nullptr, ExcInvalidObject());
@@ -1997,13 +1927,11 @@ DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::copy_from(
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 template <bool level_dof_access2>
 inline void
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::copy_from(
-  const DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access2> &a)
+DoFAccessor<0, 1, spacedim, level_dof_access>::copy_from(
+  const DoFAccessor<0, 1, spacedim, level_dof_access2> &a)
 {
   BaseClass::copy_from(a);
   set_dof_handler(a.dof_handler);
@@ -2011,74 +1939,62 @@ DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::copy_from(
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
-inline TriaIterator<
-  DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>>
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::child(
+template <int spacedim, bool level_dof_access>
+inline TriaIterator<DoFAccessor<0, 1, spacedim, level_dof_access>>
+DoFAccessor<0, 1, spacedim, level_dof_access>::child(
   const unsigned int /*i*/) const
 {
-  return TriaIterator<
-    DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>>();
+  return TriaIterator<DoFAccessor<0, 1, spacedim, level_dof_access>>();
 }
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 inline typename dealii::internal::DoFHandlerImplementation::
-  Iterators<DoFHandlerType<1, spacedim>, level_dof_access>::line_iterator
-  DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::line(
+  Iterators<DoFHandler<1, spacedim>, level_dof_access>::line_iterator
+  DoFAccessor<0, 1, spacedim, level_dof_access>::line(
     const unsigned int /*c*/) const
 {
   Assert(false, ExcNotImplemented());
   return typename dealii::internal::DoFHandlerImplementation::
-    Iterators<DoFHandlerType<1, spacedim>, level_dof_access>::line_iterator();
+    Iterators<DoFHandler<1, spacedim>, level_dof_access>::line_iterator();
 }
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
+template <int spacedim, bool level_dof_access>
 inline typename dealii::internal::DoFHandlerImplementation::
-  Iterators<DoFHandlerType<1, spacedim>, level_dof_access>::quad_iterator
-  DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::quad(
+  Iterators<DoFHandler<1, spacedim>, level_dof_access>::quad_iterator
+  DoFAccessor<0, 1, spacedim, level_dof_access>::quad(
     const unsigned int /*c*/) const
 {
   Assert(false, ExcNotImplemented());
   return typename dealii::internal::DoFHandlerImplementation::
-    Iterators<DoFHandlerType<1, spacedim>, level_dof_access>::quad_iterator();
+    Iterators<DoFHandler<1, spacedim>, level_dof_access>::quad_iterator();
 }
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
-template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+template <int spacedim, bool level_dof_access>
+template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
 inline bool
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
-operator==(const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &a) const
+DoFAccessor<0, 1, spacedim, level_dof_access>::operator==(
+  const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &a) const
 {
-  Assert(dim2 == 0, ExcCantCompareIterators());
+  Assert(structdim2 == 0, ExcCantCompareIterators());
   Assert(this->dof_handler == a.dof_handler, ExcCantCompareIterators());
   return (BaseClass::operator==(a));
 }
 
 
 
-template <template <int, int> class DoFHandlerType,
-          int  spacedim,
-          bool level_dof_access>
-template <int dim2, class DoFHandlerType2, bool level_dof_access2>
+template <int spacedim, bool level_dof_access>
+template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
 inline bool
-DoFAccessor<0, DoFHandlerType<1, spacedim>, level_dof_access>::
-operator!=(const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &a) const
+DoFAccessor<0, 1, spacedim, level_dof_access>::operator!=(
+  const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &a) const
 {
-  Assert(dim2 == 0, ExcCantCompareIterators());
+  Assert(structdim2 == 0, ExcCantCompareIterators());
   Assert(this->dof_handler == a.dof_handler, ExcCantCompareIterators());
   return (BaseClass::operator!=(a));
 }
@@ -2108,10 +2024,10 @@ namespace internal
       /**
        * Implement the updating of the cache.
        */
-      template <typename DoFHandlerType, bool level_dof_access>
+      template <int dim, int spacedim, bool level_dof_access>
       static void
       update_cell_dof_indices_cache(
-        const DoFCellAccessor<DoFHandlerType, level_dof_access> &accessor)
+        const DoFCellAccessor<dim, spacedim, level_dof_access> &accessor)
       {
         // caches are only for cells with DoFs, i.e., for active ones and not
         // FE_Nothing
@@ -2126,9 +2042,9 @@ namespace internal
         // corresponding function of DoFCellAccessor can then later use the
         // cache
         std::vector<types::global_dof_index> dof_indices(dofs_per_cell);
-        static_cast<const dealii::DoFAccessor<DoFHandlerType::dimension,
-                                              DoFHandlerType,
-                                              level_dof_access> &>(accessor)
+        static_cast<
+          const dealii::DoFAccessor<dim, dim, spacedim, level_dof_access> &>(
+          accessor)
           .get_dof_indices(dof_indices, accessor.active_fe_index());
 
         types::global_dof_index *next_dof_index =
@@ -2149,10 +2065,10 @@ namespace internal
        * Do what the active_fe_index function in the parent class is supposed to
        * do.
        */
-      template <typename DoFHandlerType, bool level_dof_access>
+      template <int dim, int spacedim, bool level_dof_access>
       static unsigned int
       active_fe_index(
-        const DoFCellAccessor<DoFHandlerType, level_dof_access> &accessor)
+        const DoFCellAccessor<dim, spacedim, level_dof_access> &accessor)
       {
         if (accessor.dof_handler->hp_capability_enabled == false)
           return 0; // ::DoFHandler only supports a single active fe with index
@@ -2175,16 +2091,16 @@ namespace internal
        * Do what the set_active_fe_index function in the parent class is
        * supposed to do.
        */
-      template <typename DoFHandlerType, bool level_dof_access>
+      template <int dim, int spacedim, bool level_dof_access>
       static void
       set_active_fe_index(
-        const DoFCellAccessor<DoFHandlerType, level_dof_access> &accessor,
-        const unsigned int                                       i)
+        const DoFCellAccessor<dim, spacedim, level_dof_access> &accessor,
+        const unsigned int                                      i)
       {
         if (accessor.dof_handler->hp_capability_enabled == false)
           {
             // ::DoFHandler only supports a single active fe with index zero
-            AssertDimension(i, DoFHandlerType::default_fe_index);
+            AssertDimension(i, (DoFHandler<dim, spacedim>::default_fe_index));
             return;
           }
 
@@ -2206,15 +2122,16 @@ namespace internal
        * Do what the future_fe_index function in the parent class is supposed to
        * do.
        */
-      template <typename DoFHandlerType, bool level_dof_access>
+      template <int dim, int spacedim, bool level_dof_access>
       static unsigned int
       future_fe_index(
-        const DoFCellAccessor<DoFHandlerType, level_dof_access> &accessor)
+        const DoFCellAccessor<dim, spacedim, level_dof_access> &accessor)
       {
         if (accessor.dof_handler->hp_capability_enabled == false)
-          return DoFHandlerType::default_fe_index; // ::DoFHandler only supports
-                                                   // a single active fe with
-                                                   // index zero
+          return DoFHandler<dim, spacedim>::
+            default_fe_index; // ::DoFHandler only supports
+                              // a single active fe with
+                              // index zero
 
         Assert(
           accessor.dof_handler != nullptr,
@@ -2238,16 +2155,16 @@ namespace internal
        * Do what the set_future_fe_index function in the parent class is
        * supposed to do.
        */
-      template <typename DoFHandlerType, bool level_dof_access>
+      template <int dim, int spacedim, bool level_dof_access>
       static void
       set_future_fe_index(
-        const DoFCellAccessor<DoFHandlerType, level_dof_access> &accessor,
-        const unsigned int                                       i)
+        const DoFCellAccessor<dim, spacedim, level_dof_access> &accessor,
+        const unsigned int                                      i)
       {
         if (accessor.dof_handler->hp_capability_enabled == false)
           {
             // ::DoFHandler only supports a single active fe with index zero
-            AssertDimension(i, DoFHandlerType::default_fe_index);
+            AssertDimension(i, (DoFHandler<dim, spacedim>::default_fe_index));
             return;
           }
 
@@ -2269,10 +2186,10 @@ namespace internal
        * Do what the future_fe_index_set function in the parent class is
        * supposed to do.
        */
-      template <typename DoFHandlerType, bool level_dof_access>
+      template <int dim, int spacedim, bool level_dof_access>
       static bool
       future_fe_index_set(
-        const DoFCellAccessor<DoFHandlerType, level_dof_access> &accessor)
+        const DoFCellAccessor<dim, spacedim, level_dof_access> &accessor)
       {
         if (accessor.dof_handler->hp_capability_enabled == false)
           return false; // ::DoFHandler only supports a single active fe with
@@ -2288,7 +2205,7 @@ namespace internal
         return accessor.dof_handler
                  ->hp_cell_future_fe_indices[accessor.level()]
                                             [accessor.present_index] !=
-               DoFHandlerType::invalid_active_fe_index;
+               DoFHandler<dim, spacedim>::invalid_active_fe_index;
       }
 
 
@@ -2297,10 +2214,10 @@ namespace internal
        * Do what the clear_fe_index function in the parent class is supposed to
        * do.
        */
-      template <typename DoFHandlerType, bool level_dof_access>
+      template <int dim, int spacedim, bool level_dof_access>
       static void
       clear_future_fe_index(
-        const DoFCellAccessor<DoFHandlerType, level_dof_access> &accessor)
+        const DoFCellAccessor<dim, spacedim, level_dof_access> &accessor)
       {
         if (accessor.dof_handler->hp_capability_enabled == false)
           return; // ::DoFHandler only supports a single active fe with index
@@ -2328,14 +2245,13 @@ namespace internal
 } // namespace internal
 
 
-template <typename DoFHandlerType, bool level_dof_access>
-inline 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<DoFHandlerType::dimension, DoFHandlerType, level_dof_access>(
+template <int dimension_, int space_dimension_, bool level_dof_access>
+inline DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  DoFCellAccessor(const Triangulation<dimension_, space_dimension_> *tria,
+                  const int                                          level,
+                  const int                                          index,
+                  const AccessorData *                               local_data)
+  : DoFAccessor<dimension_, dimension_, space_dimension_, level_dof_access>(
       tria,
       level,
       index,
@@ -2343,34 +2259,36 @@ inline DoFCellAccessor<DoFHandlerType, level_dof_access>::DoFCellAccessor(
 {}
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 template <int structdim2, int dim2, int spacedim2>
-inline DoFCellAccessor<DoFHandlerType, level_dof_access>::DoFCellAccessor(
-  const InvalidAccessor<structdim2, dim2, spacedim2> &)
+inline DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  DoFCellAccessor(const InvalidAccessor<structdim2, dim2, spacedim2> &)
 {
   Assert(false, typename BaseClass::ExcInvalidObject());
 }
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
-template <int dim2, class DoFHandlerType2, bool level_dof_access2>
-inline DoFCellAccessor<DoFHandlerType, level_dof_access>::DoFCellAccessor(
-  const DoFAccessor<dim2, DoFHandlerType2, level_dof_access2> &other)
+template <int dimension_, int space_dimension_, bool level_dof_access>
+template <int structdim2, int dim2, int spacedim2, bool level_dof_access2>
+inline DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  DoFCellAccessor(
+    const DoFAccessor<structdim2, dim2, spacedim2, level_dof_access2> &other)
   : BaseClass(other)
 {}
 
 
-template <typename DoFHandlerType, bool level_dof_access>
-inline TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>>
-DoFCellAccessor<DoFHandlerType, level_dof_access>::neighbor(
+template <int dimension_, int space_dimension_, bool level_dof_access>
+inline TriaIterator<
+  DoFCellAccessor<dimension_, space_dimension_, level_dof_access>>
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::neighbor(
   const unsigned int i) const
 {
-  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>> q(
-    this->tria,
-    this->neighbor_level(i),
-    this->neighbor_index(i),
-    this->dof_handler);
+  TriaIterator<DoFCellAccessor<dimension_, space_dimension_, level_dof_access>>
+    q(this->tria,
+      this->neighbor_level(i),
+      this->neighbor_index(i),
+      this->dof_handler);
 
 #ifdef DEBUG
   if (q.state() != IteratorState::past_the_end)
@@ -2380,13 +2298,14 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::neighbor(
 }
 
 
-template <typename DoFHandlerType, bool level_dof_access>
-inline TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>>
-DoFCellAccessor<DoFHandlerType, level_dof_access>::child(
+template <int dimension_, int space_dimension_, bool level_dof_access>
+inline TriaIterator<
+  DoFCellAccessor<dimension_, space_dimension_, level_dof_access>>
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::child(
   const unsigned int i) const
 {
-  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>> q(
-    this->tria, this->level() + 1, this->child_index(i), this->dof_handler);
+  TriaIterator<DoFCellAccessor<dimension_, space_dimension_, level_dof_access>>
+    q(this->tria, this->level() + 1, this->child_index(i), this->dof_handler);
 
 #ifdef DEBUG
   if (q.state() != IteratorState::past_the_end)
@@ -2396,12 +2315,13 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::child(
 }
 
 
-template <typename DoFHandlerType, bool level_dof_access>
-inline TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>>
-DoFCellAccessor<DoFHandlerType, level_dof_access>::parent() const
+template <int dimension_, int space_dimension_, bool level_dof_access>
+inline TriaIterator<
+  DoFCellAccessor<dimension_, space_dimension_, level_dof_access>>
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::parent() const
 {
-  TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>> q(
-    this->tria, this->level() - 1, this->parent_index(), this->dof_handler);
+  TriaIterator<DoFCellAccessor<dimension_, space_dimension_, level_dof_access>>
+    q(this->tria, this->level() - 1, this->parent_index(), this->dof_handler);
 
   return q;
 }
@@ -2411,52 +2331,46 @@ namespace internal
 {
   namespace DoFCellAccessorImplementation
   {
-    template <typename DoFHandlerType, bool level_dof_access>
-    inline TriaIterator<dealii::DoFAccessor<DoFHandlerType::dimension - 1,
-                                            DoFHandlerType,
-                                            level_dof_access>>
+    template <int dim, int spacedim, bool level_dof_access>
+    inline TriaIterator<
+      dealii::DoFAccessor<dim - 1, dim, spacedim, level_dof_access>>
     get_face(
-      const dealii::DoFCellAccessor<DoFHandlerType, level_dof_access> &cell,
-      const unsigned int                                               i,
+      const dealii::DoFCellAccessor<dim, spacedim, level_dof_access> &cell,
+      const unsigned int                                              i,
       const std::integral_constant<int, 1>)
     {
-      dealii::DoFAccessor<0, DoFHandlerType, level_dof_access> a(
+      dealii::DoFAccessor<0, dim, spacedim, level_dof_access> a(
         &cell.get_triangulation(),
         ((i == 0) && cell.at_boundary(0) ?
-           dealii::TriaAccessor<0, 1, DoFHandlerType::space_dimension>::
-             left_vertex :
+           dealii::TriaAccessor<0, 1, spacedim>::left_vertex :
            ((i == 1) && cell.at_boundary(1) ?
-              dealii::TriaAccessor<0, 1, DoFHandlerType::space_dimension>::
-                right_vertex :
-              dealii::TriaAccessor<0, 1, DoFHandlerType::space_dimension>::
-                interior_vertex)),
+              dealii::TriaAccessor<0, 1, spacedim>::right_vertex :
+              dealii::TriaAccessor<0, 1, spacedim>::interior_vertex)),
         cell.vertex_index(i),
         &cell.get_dof_handler());
       return dealii::TriaIterator<
-        dealii::DoFAccessor<0, DoFHandlerType, level_dof_access>>(a);
+        dealii::DoFAccessor<0, dim, spacedim, level_dof_access>>(a);
     }
 
 
-    template <typename DoFHandlerType, bool level_dof_access>
-    inline TriaIterator<dealii::DoFAccessor<DoFHandlerType::dimension - 1,
-                                            DoFHandlerType,
-                                            level_dof_access>>
+    template <int dim, int spacedim, bool level_dof_access>
+    inline TriaIterator<
+      dealii::DoFAccessor<dim - 1, dim, spacedim, level_dof_access>>
     get_face(
-      const dealii::DoFCellAccessor<DoFHandlerType, level_dof_access> &cell,
-      const unsigned int                                               i,
+      const dealii::DoFCellAccessor<dim, spacedim, level_dof_access> &cell,
+      const unsigned int                                              i,
       const std::integral_constant<int, 2>)
     {
       return cell.line(i);
     }
 
 
-    template <typename DoFHandlerType, bool level_dof_access>
-    inline TriaIterator<dealii::DoFAccessor<DoFHandlerType::dimension - 1,
-                                            DoFHandlerType,
-                                            level_dof_access>>
+    template <int dim, int spacedim, bool level_dof_access>
+    inline TriaIterator<
+      dealii::DoFAccessor<dim - 1, dim, spacedim, level_dof_access>>
     get_face(
-      const dealii::DoFCellAccessor<DoFHandlerType, level_dof_access> &cell,
-      const unsigned int                                               i,
+      const dealii::DoFCellAccessor<dim, spacedim, level_dof_access> &cell,
+      const unsigned int                                              i,
       const std::integral_constant<int, 3>)
     {
       return cell.quad(i);
@@ -2465,46 +2379,49 @@ namespace internal
 } // namespace internal
 
 
-template <typename DoFHandlerType, bool level_dof_access>
-inline typename DoFCellAccessor<DoFHandlerType, level_dof_access>::face_iterator
-DoFCellAccessor<DoFHandlerType, level_dof_access>::face(
+template <int dimension_, int space_dimension_, bool level_dof_access>
+inline typename DoFCellAccessor<dimension_,
+                                space_dimension_,
+                                level_dof_access>::face_iterator
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::face(
   const unsigned int i) const
 {
-  AssertIndexRange(i, GeometryInfo<dim>::faces_per_cell);
+  AssertIndexRange(i, GeometryInfo<dimension_>::faces_per_cell);
 
-  const unsigned int dim = DoFHandlerType::dimension;
   return dealii::internal::DoFCellAccessorImplementation::get_face(
-    *this, i, std::integral_constant<int, dim>());
+    *this, i, std::integral_constant<int, dimension_>());
 }
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
-inline std::array<
-  typename DoFCellAccessor<DoFHandlerType, level_dof_access>::face_iterator,
-  GeometryInfo<DoFHandlerType::dimension>::faces_per_cell>
-DoFCellAccessor<DoFHandlerType, level_dof_access>::face_iterators() const
+template <int dimension_, int space_dimension_, bool level_dof_access>
+inline std::array<typename DoFCellAccessor<dimension_,
+                                           space_dimension_,
+                                           level_dof_access>::face_iterator,
+                  GeometryInfo<dimension_>::faces_per_cell>
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  face_iterators() const
 {
-  std::array<
-    typename DoFCellAccessor<DoFHandlerType, level_dof_access>::face_iterator,
-    GeometryInfo<dim>::faces_per_cell>
+  std::array<typename DoFCellAccessor<dimension_,
+                                      space_dimension_,
+                                      level_dof_access>::face_iterator,
+             GeometryInfo<dimension_>::faces_per_cell>
     face_iterators;
 
-  const unsigned int dim = DoFHandlerType::dimension;
-  for (unsigned int i : GeometryInfo<dim>::face_indices())
+  for (unsigned int i : GeometryInfo<dimension_>::face_indices())
     face_iterators[i] =
       dealii::internal::DoFCellAccessorImplementation::get_face(
-        *this, i, std::integral_constant<int, dim>());
+        *this, i, std::integral_constant<int, dimension_>());
 
   return face_iterators;
 }
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::get_dof_indices(
-  std::vector<types::global_dof_index> &dof_indices) const
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  get_dof_indices(std::vector<types::global_dof_index> &dof_indices) const
 {
   Assert(this->is_active(),
          ExcMessage("get_dof_indices() only works on active cells."));
@@ -2528,32 +2445,33 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::get_dof_indices(
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::get_mg_dof_indices(
-  std::vector<types::global_dof_index> &dof_indices) const
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  get_mg_dof_indices(std::vector<types::global_dof_index> &dof_indices) const
 {
-  DoFAccessor<dim, DoFHandlerType, level_dof_access>::get_mg_dof_indices(
-    this->level(), dof_indices);
+  DoFAccessor<dimension_, dimension_, space_dimension_, level_dof_access>::
+    get_mg_dof_indices(this->level(), dof_indices);
 }
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::set_mg_dof_indices(
-  const std::vector<types::global_dof_index> &dof_indices)
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  set_mg_dof_indices(const std::vector<types::global_dof_index> &dof_indices)
 {
-  DoFAccessor<dim, DoFHandlerType, level_dof_access>::set_mg_dof_indices(
-    this->level(), dof_indices);
+  DoFAccessor<dimension_, dimension_, space_dimension_, level_dof_access>::
+    set_mg_dof_indices(this->level(), dof_indices);
 }
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::get_active_or_mg_dof_indices(
-  std::vector<types::global_dof_index> &dof_indices) const
+DoFCellAccessor<dimension_, space_dimension_, 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);
@@ -2563,10 +2481,10 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::get_active_or_mg_dof_indices(
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 template <class InputVector, typename number>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::get_dof_values(
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::get_dof_values(
   const InputVector &values,
   Vector<number> &   local_values) const
 {
@@ -2575,10 +2493,10 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::get_dof_values(
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 template <class InputVector, typename ForwardIterator>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::get_dof_values(
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::get_dof_values(
   const InputVector &values,
   ForwardIterator    local_values_begin,
   ForwardIterator    local_values_end) const
@@ -2610,10 +2528,10 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::get_dof_values(
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 template <class InputVector, typename ForwardIterator>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::get_dof_values(
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::get_dof_values(
   const AffineConstraints<typename InputVector::value_type> &constraints,
   const InputVector &                                        values,
   ForwardIterator                                            local_values_begin,
@@ -2645,10 +2563,10 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::get_dof_values(
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 template <class OutputVector, typename number>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::set_dof_values(
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::set_dof_values(
   const Vector<number> &local_values,
   OutputVector &        values) const
 {
@@ -2677,10 +2595,9 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::set_dof_values(
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
-inline const FiniteElement<DoFHandlerType::dimension,
-                           DoFHandlerType::space_dimension> &
-DoFCellAccessor<DoFHandlerType, level_dof_access>::get_fe() const
+template <int dimension_, int space_dimension_, bool level_dof_access>
+inline const FiniteElement<dimension_, space_dimension_> &
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::get_fe() const
 {
   Assert(this->dof_handler != nullptr, typename BaseClass::ExcInvalidObject());
   Assert((this->dof_handler->hp_capability_enabled == false) ||
@@ -2695,9 +2612,10 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::get_fe() const
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 inline unsigned int
-DoFCellAccessor<DoFHandlerType, level_dof_access>::active_fe_index() const
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  active_fe_index() const
 {
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            this->is_active(),
@@ -2718,10 +2636,10 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::active_fe_index() const
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::set_active_fe_index(
-  const unsigned int i) const
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  set_active_fe_index(const unsigned int i) const
 {
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            this->is_active(),
@@ -2743,10 +2661,10 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::set_active_fe_index(
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
-inline const FiniteElement<DoFHandlerType::dimension,
-                           DoFHandlerType::space_dimension> &
-DoFCellAccessor<DoFHandlerType, level_dof_access>::get_future_fe() const
+template <int dimension_, int space_dimension_, bool level_dof_access>
+inline const FiniteElement<dimension_, space_dimension_> &
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::get_future_fe()
+  const
 {
   Assert(this->dof_handler != nullptr, typename BaseClass::ExcInvalidObject());
   Assert((this->dof_handler->hp_capability_enabled == false) ||
@@ -2761,9 +2679,10 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::get_future_fe() const
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 inline unsigned int
-DoFCellAccessor<DoFHandlerType, level_dof_access>::future_fe_index() const
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  future_fe_index() const
 {
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            (this->has_children() == false),
@@ -2783,10 +2702,10 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::future_fe_index() const
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::set_future_fe_index(
-  const unsigned int i) const
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  set_future_fe_index(const unsigned int i) const
 {
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            (this->has_children() == false),
@@ -2805,9 +2724,10 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::set_future_fe_index(
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 inline bool
-DoFCellAccessor<DoFHandlerType, level_dof_access>::future_fe_index_set() const
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  future_fe_index_set() const
 {
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            (this->has_children() == false),
@@ -2827,9 +2747,10 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::future_fe_index_set() const
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::clear_future_fe_index() const
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  clear_future_fe_index() const
 {
   Assert((this->dof_handler->hp_capability_enabled == false) ||
            (this->has_children() == false),
@@ -2849,12 +2770,12 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::clear_future_fe_index() const
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 template <typename number, typename OutputVector>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::distribute_local_to_global(
-  const Vector<number> &local_source,
-  OutputVector &        global_destination) const
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  distribute_local_to_global(const Vector<number> &local_source,
+                             OutputVector &        global_destination) const
 {
   this->distribute_local_to_global(local_source.begin(),
                                    local_source.end(),
@@ -2863,13 +2784,13 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::distribute_local_to_global(
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 template <typename ForwardIterator, typename OutputVector>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::distribute_local_to_global(
-  ForwardIterator local_source_begin,
-  ForwardIterator local_source_end,
-  OutputVector &  global_destination) const
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  distribute_local_to_global(ForwardIterator local_source_begin,
+                             ForwardIterator local_source_end,
+                             OutputVector &  global_destination) const
 {
   Assert(this->dof_handler != nullptr,
          (typename std::decay<decltype(*this)>::type::ExcInvalidObject()));
@@ -2893,14 +2814,15 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::distribute_local_to_global(
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 template <typename ForwardIterator, typename OutputVector>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::distribute_local_to_global(
-  const AffineConstraints<typename OutputVector::value_type> &constraints,
-  ForwardIterator local_source_begin,
-  ForwardIterator local_source_end,
-  OutputVector &  global_destination) const
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  distribute_local_to_global(
+    const AffineConstraints<typename OutputVector::value_type> &constraints,
+    ForwardIterator local_source_begin,
+    ForwardIterator local_source_end,
+    OutputVector &  global_destination) const
 {
   Assert(this->dof_handler != nullptr,
          (typename std::decay<decltype(*this)>::type::ExcInvalidObject()));
@@ -2926,12 +2848,12 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::distribute_local_to_global(
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 template <typename number, typename OutputMatrix>
 inline void
-DoFCellAccessor<DoFHandlerType, level_dof_access>::distribute_local_to_global(
-  const FullMatrix<number> &local_source,
-  OutputMatrix &            global_destination) const
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  distribute_local_to_global(const FullMatrix<number> &local_source,
+                             OutputMatrix &            global_destination) const
 {
   Assert(this->dof_handler != nullptr,
          (typename std::decay<decltype(*this)>::type::ExcInvalidObject()));
@@ -2959,14 +2881,14 @@ DoFCellAccessor<DoFHandlerType, level_dof_access>::distribute_local_to_global(
 
 
 
-template <typename DoFHandlerType, bool level_dof_access>
+template <int dimension_, int space_dimension_, bool level_dof_access>
 template <typename number, typename OutputMatrix, typename OutputVector>
 inline void
-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
+DoFCellAccessor<dimension_, space_dimension_, level_dof_access>::
+  distribute_local_to_global(const FullMatrix<number> &local_matrix,
+                             const Vector<number> &    local_vector,
+                             OutputMatrix &            global_matrix,
+                             OutputVector &            global_vector) const
 {
   Assert(this->dof_handler != nullptr,
          (typename std::decay<decltype(*this)>::type::ExcInvalidObject()));
diff --git a/include/deal.II/dofs/dof_handler.h b/include/deal.II/dofs/dof_handler.h
index fe4934b5a2..c6f8bf29b6 100644
--- a/include/deal.II/dofs/dof_handler.h
+++ b/include/deal.II/dofs/dof_handler.h
@@ -1670,9 +1670,9 @@ private:
 
 
   // Make accessor objects friends.
-  template <int, class, bool>
+  template <int, int, int, bool>
   friend class dealii::DoFAccessor;
-  template <class, bool>
+  template <int, int, bool>
   friend class dealii::DoFCellAccessor;
   friend struct dealii::internal::DoFAccessorImplementation::Implementation;
   friend struct dealii::internal::DoFCellAccessorImplementation::Implementation;
diff --git a/include/deal.II/dofs/dof_iterator_selector.h b/include/deal.II/dofs/dof_iterator_selector.h
index bb228aba51..6fe09c553c 100644
--- a/include/deal.II/dofs/dof_iterator_selector.h
+++ b/include/deal.II/dofs/dof_iterator_selector.h
@@ -26,9 +26,9 @@ DEAL_II_NAMESPACE_OPEN
 template <int, int, int>
 class DoFInvalidAccessor;
 
-template <int structdim, typename DoFHandlerType, bool lda>
+template <int structdim, int dim, int spacedim, bool lda>
 class DoFAccessor;
-template <typename DoFHandlerType, bool lda>
+template <int dim, int spacedim, bool lda>
 class DoFCellAccessor;
 
 template <typename Accessor>
@@ -60,8 +60,8 @@ namespace internal
     struct Iterators<DoFHandlerType<1, spacedim>, lda>
     {
       using DoFHandler_type = DoFHandlerType<1, spacedim>;
-      using CellAccessor    = dealii::DoFCellAccessor<DoFHandler_type, lda>;
-      using FaceAccessor    = dealii::DoFAccessor<0, DoFHandler_type, lda>;
+      using CellAccessor    = dealii::DoFCellAccessor<1, spacedim, lda>;
+      using FaceAccessor    = dealii::DoFAccessor<0, 1, spacedim, lda>;
 
       using raw_line_iterator    = TriaRawIterator<CellAccessor>;
       using line_iterator        = TriaIterator<CellAccessor>;
@@ -103,8 +103,8 @@ namespace internal
     struct Iterators<DoFHandlerType<2, spacedim>, lda>
     {
       using DoFHandler_type = DoFHandlerType<2, spacedim>;
-      using CellAccessor    = dealii::DoFCellAccessor<DoFHandler_type, lda>;
-      using FaceAccessor    = dealii::DoFAccessor<1, DoFHandler_type, lda>;
+      using CellAccessor    = dealii::DoFCellAccessor<2, spacedim, lda>;
+      using FaceAccessor    = dealii::DoFAccessor<1, 2, spacedim, lda>;
 
       using raw_line_iterator    = TriaRawIterator<FaceAccessor>;
       using line_iterator        = TriaIterator<FaceAccessor>;
@@ -144,15 +144,15 @@ namespace internal
     struct Iterators<DoFHandlerType<3, spacedim>, lda>
     {
       using DoFHandler_type = DoFHandlerType<3, spacedim>;
-      using CellAccessor    = dealii::DoFCellAccessor<DoFHandler_type, lda>;
-      using FaceAccessor    = dealii::DoFAccessor<2, DoFHandler_type, lda>;
+      using CellAccessor    = dealii::DoFCellAccessor<3, spacedim, lda>;
+      using FaceAccessor    = dealii::DoFAccessor<2, 3, spacedim, lda>;
 
       using raw_line_iterator =
-        TriaRawIterator<dealii::DoFAccessor<1, DoFHandler_type, lda>>;
+        TriaRawIterator<dealii::DoFAccessor<1, 3, spacedim, lda>>;
       using line_iterator =
-        TriaIterator<dealii::DoFAccessor<1, DoFHandler_type, lda>>;
+        TriaIterator<dealii::DoFAccessor<1, 3, spacedim, lda>>;
       using active_line_iterator =
-        TriaActiveIterator<dealii::DoFAccessor<1, DoFHandler_type, lda>>;
+        TriaActiveIterator<dealii::DoFAccessor<1, 3, spacedim, lda>>;
 
       using raw_quad_iterator    = TriaRawIterator<FaceAccessor>;
       using quad_iterator        = TriaIterator<FaceAccessor>;
diff --git a/include/deal.II/fe/fe_values.h b/include/deal.II/fe/fe_values.h
index 3c23680332..1f45a8b8eb 100644
--- a/include/deal.II/fe/fe_values.h
+++ b/include/deal.II/fe/fe_values.h
@@ -3634,8 +3634,8 @@ public:
    */
   template <bool level_dof_access>
   void
-  reinit(const TriaIterator<
-         DoFCellAccessor<DoFHandler<dim, spacedim>, level_dof_access>> &cell);
+  reinit(
+    const TriaIterator<DoFCellAccessor<dim, spacedim, level_dof_access>> &cell);
 
   /**
    * Reinitialize the gradients, Jacobi determinants, etc for the given cell
@@ -3854,9 +3854,9 @@ public:
    */
   template <bool level_dof_access>
   void
-  reinit(const TriaIterator<
-           DoFCellAccessor<DoFHandler<dim, spacedim>, level_dof_access>> &cell,
-         const unsigned int face_no);
+  reinit(
+    const TriaIterator<DoFCellAccessor<dim, spacedim, level_dof_access>> &cell,
+    const unsigned int face_no);
 
   /**
    * Reinitialize the gradients, Jacobi determinants, etc for face @p face
@@ -3866,9 +3866,9 @@ public:
    */
   template <bool level_dof_access>
   void
-  reinit(const TriaIterator<
-           DoFCellAccessor<DoFHandler<dim, spacedim>, level_dof_access>> &cell,
-         const typename Triangulation<dim, spacedim>::face_iterator &     face);
+  reinit(
+    const TriaIterator<DoFCellAccessor<dim, spacedim, level_dof_access>> &cell,
+    const typename Triangulation<dim, spacedim>::face_iterator &          face);
 
   /**
    * Reinitialize the gradients, Jacobi determinants, etc for the given face
@@ -4003,10 +4003,10 @@ public:
    */
   template <bool level_dof_access>
   void
-  reinit(const TriaIterator<
-           DoFCellAccessor<DoFHandler<dim, spacedim>, level_dof_access>> &cell,
-         const unsigned int face_no,
-         const unsigned int subface_no);
+  reinit(
+    const TriaIterator<DoFCellAccessor<dim, spacedim, level_dof_access>> &cell,
+    const unsigned int face_no,
+    const unsigned int subface_no);
 
   /**
    * Alternative reinitialization function that takes, as arguments, iterators
@@ -4014,10 +4014,10 @@ public:
    */
   template <bool level_dof_access>
   void
-  reinit(const TriaIterator<
-           DoFCellAccessor<DoFHandler<dim, spacedim>, level_dof_access>> &cell,
-         const typename Triangulation<dim, spacedim>::face_iterator &     face,
-         const typename Triangulation<dim, spacedim>::face_iterator &subface);
+  reinit(
+    const TriaIterator<DoFCellAccessor<dim, spacedim, level_dof_access>> &cell,
+    const typename Triangulation<dim, spacedim>::face_iterator &          face,
+    const typename Triangulation<dim, spacedim>::face_iterator &subface);
 
   /**
    * Reinitialize the gradients, Jacobi determinants, etc for the given
diff --git a/include/deal.II/grid/grid_tools.h b/include/deal.II/grid/grid_tools.h
index bc3a3478fa..1779e8e066 100644
--- a/include/deal.II/grid/grid_tools.h
+++ b/include/deal.II/grid/grid_tools.h
@@ -100,8 +100,8 @@ namespace internal
   class ActiveCellIterator<dim, spacedim, dealii::DoFHandler<dim, spacedim>>
   {
   public:
-    using type = TriaActiveIterator<
-      dealii::DoFCellAccessor<dealii::DoFHandler<dim, spacedim>, false>>;
+    using type =
+      TriaActiveIterator<dealii::DoFCellAccessor<dim, spacedim, false>>;
   };
 #  endif
 
@@ -111,8 +111,8 @@ namespace internal
   class ActiveCellIterator<dim, spacedim, dealii::hp::DoFHandler<dim, spacedim>>
   {
   public:
-    using type = TriaActiveIterator<
-      dealii::DoFCellAccessor<dealii::DoFHandler<dim, spacedim>, false>>;
+    using type =
+      TriaActiveIterator<dealii::DoFCellAccessor<dim, spacedim, false>>;
   };
 #  endif
 } // namespace internal
diff --git a/include/deal.II/hp/fe_values.h b/include/deal.II/hp/fe_values.h
index 44fa1b968e..2debb37cb5 100644
--- a/include/deal.II/hp/fe_values.h
+++ b/include/deal.II/hp/fe_values.h
@@ -351,8 +351,7 @@ namespace hp
      */
     template <bool lda>
     void
-    reinit(const TriaIterator<
-             DoFCellAccessor<dealii::DoFHandler<dim, spacedim>, lda>> cell,
+    reinit(const TriaIterator<DoFCellAccessor<dim, spacedim, 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);
@@ -471,9 +470,8 @@ namespace hp
      */
     template <bool lda>
     void
-    reinit(const TriaIterator<
-             DoFCellAccessor<dealii::DoFHandler<dim, spacedim>, lda>> cell,
-           const unsigned int                                         face_no,
+    reinit(const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> cell,
+           const unsigned int                                      face_no,
            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);
@@ -568,10 +566,9 @@ namespace hp
      */
     template <bool lda>
     void
-    reinit(const TriaIterator<
-             DoFCellAccessor<dealii::DoFHandler<dim, spacedim>, lda>> cell,
-           const unsigned int                                         face_no,
-           const unsigned int subface_no,
+    reinit(const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> cell,
+           const unsigned int                                      face_no,
+           const unsigned int                                      subface_no,
            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);
diff --git a/include/deal.II/matrix_free/fe_evaluation.h b/include/deal.II/matrix_free/fe_evaluation.h
index cbde241e1f..ca7dfb1f0b 100644
--- a/include/deal.II/matrix_free/fe_evaluation.h
+++ b/include/deal.II/matrix_free/fe_evaluation.h
@@ -2569,10 +2569,9 @@ public:
    * also read from vectors (but less efficient than with data coming from
    * MatrixFree).
    */
-  template <typename DoFHandlerType, bool level_dof_access>
+  template <bool level_dof_access>
   void
-  reinit(const TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>>
-           &cell);
+  reinit(const TriaIterator<DoFCellAccessor<dim, dim, level_dof_access>> &cell);
 
   /**
    * Initialize the data to the current cell using a TriaIterator object as
@@ -7001,7 +7000,7 @@ template <int dim,
           int n_components_,
           typename Number,
           typename VectorizedArrayType>
-template <typename DoFHandlerType, bool level_dof_access>
+template <bool level_dof_access>
 inline void
 FEEvaluation<dim,
              fe_degree,
@@ -7009,8 +7008,7 @@ FEEvaluation<dim,
              n_components_,
              Number,
              VectorizedArrayType>::
-  reinit(
-    const TriaIterator<DoFCellAccessor<DoFHandlerType, level_dof_access>> &cell)
+  reinit(const TriaIterator<DoFCellAccessor<dim, dim, level_dof_access>> &cell)
 {
   Assert(this->matrix_info == nullptr,
          ExcMessage("Cannot use initialization from cell iterator if "
diff --git a/include/deal.II/numerics/derivative_approximation.h b/include/deal.II/numerics/derivative_approximation.h
index a56db9c77f..732b6e52ff 100644
--- a/include/deal.II/numerics/derivative_approximation.h
+++ b/include/deal.II/numerics/derivative_approximation.h
@@ -261,8 +261,10 @@ namespace DerivativeApproximation
 #ifndef _MSC_VER
     const typename DoFHandlerType::active_cell_iterator &cell,
 #else
-    const TriaActiveIterator<dealii::DoFCellAccessor<DoFHandlerType, false>>
-      &cell,
+    const TriaActiveIterator<
+      dealii::DoFCellAccessor<DoFHandlerType::dimension,
+                              DoFHandlerType::space_dimension,
+                              false>> &cell,
 #endif
     Tensor<order, DoFHandlerType::dimension> &derivative,
     const unsigned int                        component = 0);
@@ -278,8 +280,10 @@ namespace DerivativeApproximation
 #ifndef _MSC_VER
     const typename DoFHandlerType::active_cell_iterator &cell,
 #else
-    const TriaActiveIterator<dealii::DoFCellAccessor<DoFHandlerType, false>>
-      &cell,
+    const TriaActiveIterator<
+      dealii::DoFCellAccessor<DoFHandlerType::dimension,
+                              DoFHandlerType::space_dimension,
+                              false>> &cell,
 #endif
     Tensor<order, DoFHandlerType::dimension> &derivative,
     const unsigned int                        component = 0);
diff --git a/source/dofs/dof_accessor.cc b/source/dofs/dof_accessor.cc
index b3ea2c02a1..836f4dbc33 100644
--- a/source/dofs/dof_accessor.cc
+++ b/source/dofs/dof_accessor.cc
@@ -30,13 +30,13 @@ DEAL_II_NAMESPACE_OPEN
 
 /* --------------------- Static variables: DoFAccessor --------------------- */
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 const unsigned int
-  DoFAccessor<structdim, DoFHandlerType, level_dof_access>::dimension;
+  DoFAccessor<structdim, dim, spacedim, level_dof_access>::dimension;
 
-template <int structdim, typename DoFHandlerType, bool level_dof_access>
+template <int structdim, int dim, int spacedim, bool level_dof_access>
 const unsigned int
-  DoFAccessor<structdim, DoFHandlerType, level_dof_access>::space_dimension;
+  DoFAccessor<structdim, dim, spacedim, level_dof_access>::space_dimension;
 
 
 
@@ -103,9 +103,9 @@ DoFInvalidAccessor<structdim, dim, spacedim>::set_dof_index(
 
 
 
-template <typename DoFHandlerType, bool lda>
+template <int dim, int spacedim, bool lda>
 void
-DoFCellAccessor<DoFHandlerType, lda>::update_cell_dof_indices_cache() const
+DoFCellAccessor<dim, spacedim, lda>::update_cell_dof_indices_cache() const
 {
   Assert(static_cast<unsigned int>(this->present_level) <
            this->dof_handler->object_dof_indices.size(),
@@ -119,9 +119,9 @@ DoFCellAccessor<DoFHandlerType, lda>::update_cell_dof_indices_cache() const
 
 
 
-template <typename DoFHandlerType, bool lda>
+template <int dim, int spacedim, bool lda>
 void
-DoFCellAccessor<DoFHandlerType, lda>::set_dof_indices(
+DoFCellAccessor<dim, spacedim, lda>::set_dof_indices(
   const std::vector<types::global_dof_index> &local_dof_indices)
 {
   Assert(static_cast<unsigned int>(this->present_level) <
@@ -133,63 +133,64 @@ DoFCellAccessor<DoFHandlerType, lda>::set_dof_indices(
   AssertDimension(local_dof_indices.size(), this->get_fe().dofs_per_cell);
 
   internal::DoFAccessorImplementation::Implementation::
-    template set_dof_indices<DoFHandlerType, lda, DoFHandlerType::dimension>(
-      *this, local_dof_indices, this->active_fe_index());
+    template set_dof_indices<dim, spacedim, lda, dim>(*this,
+                                                      local_dof_indices,
+                                                      this->active_fe_index());
 }
 
 
 
-template <typename DoFHandlerType, bool lda>
-TriaIterator<DoFCellAccessor<DoFHandlerType, lda>>
-DoFCellAccessor<DoFHandlerType, lda>::neighbor_child_on_subface(
+template <int dim, int spacedim, bool lda>
+TriaIterator<DoFCellAccessor<dim, spacedim, lda>>
+DoFCellAccessor<dim, spacedim, 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<DoFHandlerType, lda>>(*q,
-                                                            this->dof_handler);
+  return TriaIterator<DoFCellAccessor<dim, spacedim, lda>>(*q,
+                                                           this->dof_handler);
 }
 
 
 
-template <typename DoFHandlerType, bool lda>
-TriaIterator<DoFCellAccessor<DoFHandlerType, lda>>
-DoFCellAccessor<DoFHandlerType, lda>::periodic_neighbor_child_on_subface(
+template <int dim, int spacedim, bool lda>
+TriaIterator<DoFCellAccessor<dim, spacedim, lda>>
+DoFCellAccessor<dim, spacedim, lda>::periodic_neighbor_child_on_subface(
   const unsigned int face,
   const unsigned int subface) const
 {
   const TriaIterator<CellAccessor<dim, spacedim>> q =
     CellAccessor<dim, spacedim>::periodic_neighbor_child_on_subface(face,
                                                                     subface);
-  return TriaIterator<DoFCellAccessor<DoFHandlerType, lda>>(*q,
-                                                            this->dof_handler);
+  return TriaIterator<DoFCellAccessor<dim, spacedim, lda>>(*q,
+                                                           this->dof_handler);
 }
 
 
 
-template <typename DoFHandlerType, bool lda>
-inline TriaIterator<DoFCellAccessor<DoFHandlerType, lda>>
-DoFCellAccessor<DoFHandlerType, lda>::periodic_neighbor(
+template <int dim, int spacedim, bool lda>
+inline TriaIterator<DoFCellAccessor<dim, spacedim, lda>>
+DoFCellAccessor<dim, spacedim, lda>::periodic_neighbor(
   const unsigned int face) const
 {
   const TriaIterator<CellAccessor<dim, spacedim>> q =
     CellAccessor<dim, spacedim>::periodic_neighbor(face);
-  return TriaIterator<DoFCellAccessor<DoFHandlerType, lda>>(*q,
-                                                            this->dof_handler);
+  return TriaIterator<DoFCellAccessor<dim, spacedim, lda>>(*q,
+                                                           this->dof_handler);
 }
 
 
 
-template <typename DoFHandlerType, bool lda>
-inline TriaIterator<DoFCellAccessor<DoFHandlerType, lda>>
-DoFCellAccessor<DoFHandlerType, lda>::neighbor_or_periodic_neighbor(
+template <int dim, int spacedim, bool lda>
+inline TriaIterator<DoFCellAccessor<dim, spacedim, lda>>
+DoFCellAccessor<dim, spacedim, lda>::neighbor_or_periodic_neighbor(
   const unsigned int face) const
 {
   const TriaIterator<CellAccessor<dim, spacedim>> q =
     CellAccessor<dim, spacedim>::neighbor_or_periodic_neighbor(face);
-  return TriaIterator<DoFCellAccessor<DoFHandlerType, lda>>(*q,
-                                                            this->dof_handler);
+  return TriaIterator<DoFCellAccessor<dim, spacedim, lda>>(*q,
+                                                           this->dof_handler);
 }
 
 
diff --git a/source/dofs/dof_accessor.inst.in b/source/dofs/dof_accessor.inst.in
index c6eb2c2314..31f8375378 100644
--- a/source/dofs/dof_accessor.inst.in
+++ b/source/dofs/dof_accessor.inst.in
@@ -22,36 +22,37 @@ for (deal_II_dimension : DIMENSIONS; lda : BOOL)
 
 
 #if deal_II_dimension == 2
-    template class DoFAccessor<1, DoFHandler<2>, lda>;
+    template class DoFAccessor<1, 2, 2, lda>;
 
-    template class TriaRawIterator<DoFAccessor<1, DoFHandler<2>, lda>>;
-    template class TriaIterator<DoFAccessor<1, DoFHandler<2>, lda>>;
-    template class TriaActiveIterator<DoFAccessor<1, DoFHandler<2>, lda>>;
+    template class TriaRawIterator<DoFAccessor<1, 2, 2, lda>>;
+    template class TriaIterator<DoFAccessor<1, 2, 2, lda>>;
+    template class TriaActiveIterator<DoFAccessor<1, 2, 2, lda>>;
 #endif
 
 #if deal_II_dimension == 3
-    template class DoFAccessor<1, DoFHandler<3>, lda>;
-    template class DoFAccessor<2, DoFHandler<3>, lda>;
-
-    template class TriaRawIterator<DoFAccessor<1, DoFHandler<3>, lda>>;
-    template class TriaIterator<DoFAccessor<1, DoFHandler<3>, lda>>;
-    template class TriaActiveIterator<DoFAccessor<1, DoFHandler<3>, lda>>;
-    template class TriaRawIterator<DoFAccessor<2, DoFHandler<3>, lda>>;
-    template class TriaIterator<DoFAccessor<2, DoFHandler<3>, lda>>;
-    template class TriaActiveIterator<DoFAccessor<2, DoFHandler<3>, lda>>;
+    template class DoFAccessor<1, 3, 3, lda>;
+    template class DoFAccessor<2, 3, 3, lda>;
+
+    template class TriaRawIterator<DoFAccessor<1, 3, 3, lda>>;
+    template class TriaIterator<DoFAccessor<1, 3, 3, lda>>;
+    template class TriaActiveIterator<DoFAccessor<1, 3, 3, lda>>;
+    template class TriaRawIterator<DoFAccessor<2, 3, 3, lda>>;
+    template class TriaIterator<DoFAccessor<2, 3, 3, lda>>;
+    template class TriaActiveIterator<DoFAccessor<2, 3, 3, lda>>;
 #endif
 
     template class DoFAccessor<deal_II_dimension,
-                               DoFHandler<deal_II_dimension>,
+                               deal_II_dimension,
+                               deal_II_dimension,
                                lda>;
-    template class DoFCellAccessor<DoFHandler<deal_II_dimension>, lda>;
+    template class DoFCellAccessor<deal_II_dimension, deal_II_dimension, lda>;
 
     template class TriaRawIterator<
-      DoFCellAccessor<DoFHandler<deal_II_dimension>, lda>>;
+      DoFCellAccessor<deal_II_dimension, deal_II_dimension, lda>>;
     template class TriaIterator<
-      DoFCellAccessor<DoFHandler<deal_II_dimension>, lda>>;
+      DoFCellAccessor<deal_II_dimension, deal_II_dimension, lda>>;
     template class TriaActiveIterator<
-      DoFCellAccessor<DoFHandler<deal_II_dimension>, lda>>;
+      DoFCellAccessor<deal_II_dimension, deal_II_dimension, lda>>;
 
 
 
@@ -60,42 +61,39 @@ for (deal_II_dimension : DIMENSIONS; lda : BOOL)
     // // explicit instantiations (for DoFHandler)
 
 #if deal_II_dimension == 1
-    template class DoFAccessor<1, DoFHandler<1, 2>, lda>;
+    template class DoFAccessor<1, 1, 2, lda>;
 #endif
 
 #if deal_II_dimension == 2
-    template class DoFAccessor<1, DoFHandler<2, 3>, lda>;
-    template class DoFAccessor<2, DoFHandler<2, 3>, lda>;
+    template class DoFAccessor<1, 2, 3, lda>;
+    template class DoFAccessor<2, 2, 3, lda>;
 
-    template class TriaRawIterator<DoFAccessor<1, DoFHandler<2, 3>, lda>>;
-    template class TriaIterator<DoFAccessor<1, DoFHandler<2, 3>, lda>>;
-    template class TriaActiveIterator<DoFAccessor<1, DoFHandler<2, 3>, lda>>;
+    template class TriaRawIterator<DoFAccessor<1, 2, 3, lda>>;
+    template class TriaIterator<DoFAccessor<1, 2, 3, lda>>;
+    template class TriaActiveIterator<DoFAccessor<1, 2, 3, lda>>;
 #endif
 
 
 #if deal_II_dimension != 3
-    template class DoFCellAccessor<
-      DoFHandler<deal_II_dimension, deal_II_dimension + 1>,
-      lda>;
+    template class DoFCellAccessor<deal_II_dimension,
+                                   deal_II_dimension + 1,
+                                   lda>;
 
     template class TriaRawIterator<
-      DoFCellAccessor<DoFHandler<deal_II_dimension, deal_II_dimension + 1>,
-                      lda>>;
+      DoFCellAccessor<deal_II_dimension, deal_II_dimension + 1, lda>>;
     template class TriaIterator<
-      DoFCellAccessor<DoFHandler<deal_II_dimension, deal_II_dimension + 1>,
-                      lda>>;
+      DoFCellAccessor<deal_II_dimension, deal_II_dimension + 1, lda>>;
     template class TriaActiveIterator<
-      DoFCellAccessor<DoFHandler<deal_II_dimension, deal_II_dimension + 1>,
-                      lda>>;
+      DoFCellAccessor<deal_II_dimension, deal_II_dimension + 1, lda>>;
 #endif
 
 
 #if deal_II_dimension == 3
-    template class DoFCellAccessor<DoFHandler<1, 3>, lda>;
+    template class DoFCellAccessor<1, 3, lda>;
 
-    template class TriaRawIterator<DoFCellAccessor<DoFHandler<1, 3>, lda>>;
-    template class TriaIterator<DoFCellAccessor<DoFHandler<1, 3>, lda>>;
-    template class TriaActiveIterator<DoFCellAccessor<DoFHandler<1, 3>, lda>>;
+    template class TriaRawIterator<DoFCellAccessor<1, 3, lda>>;
+    template class TriaIterator<DoFCellAccessor<1, 3, lda>>;
+    template class TriaActiveIterator<DoFCellAccessor<1, 3, lda>>;
 #endif
   }
 
diff --git a/source/dofs/dof_accessor_get.cc b/source/dofs/dof_accessor_get.cc
index 9638582862..b9b2f7c6fe 100644
--- a/source/dofs/dof_accessor_get.cc
+++ b/source/dofs/dof_accessor_get.cc
@@ -42,18 +42,18 @@
 DEAL_II_NAMESPACE_OPEN
 
 
-template <typename DoFHandlerType, bool lda>
+template <int dim, int spacedim, bool lda>
 template <class InputVector, typename number>
 void
-DoFCellAccessor<DoFHandlerType, lda>::get_interpolated_dof_values(
+DoFCellAccessor<dim, spacedim, lda>::get_interpolated_dof_values(
   const InputVector &values,
   Vector<number> &   interpolated_values,
   const unsigned int fe_index_) const
 {
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType::invalid_fe_index) ?
-      DoFHandlerType::default_fe_index :
+     fe_index_ == DoFHandler<dim, spacedim>::invalid_fe_index) ?
+      DoFHandler<dim, spacedim>::default_fe_index :
       fe_index_;
 
   if (this->is_active())
@@ -66,7 +66,7 @@ DoFCellAccessor<DoFHandlerType, lda>::get_interpolated_dof_values(
           // active cells, you either don't specify an fe_index,
           // or that you specify the correct one
           (fe_index == this->active_fe_index()) ||
-          (fe_index == DoFHandlerType::invalid_fe_index))
+          (fe_index == DoFHandler<dim, spacedim>::invalid_fe_index))
         this->get_dof_values(values, interpolated_values);
       else
         {
@@ -104,7 +104,7 @@ DoFCellAccessor<DoFHandlerType, lda>::get_interpolated_dof_values(
       // space to this cell's (unknown) FE space unless an explicit
       // fe_index is given
       Assert((this->dof_handler->hp_capability_enabled == false) ||
-               (fe_index != DoFHandlerType::invalid_fe_index),
+               (fe_index != DoFHandler<dim, spacedim>::invalid_fe_index),
              ExcMessage(
                "You cannot call this function on non-active cells "
                "of hp::DoFHandler objects unless you provide an explicit "
diff --git a/source/dofs/dof_accessor_get.inst.in b/source/dofs/dof_accessor_get.inst.in
index 34c5d3b231..9c51819430 100644
--- a/source/dofs/dof_accessor_get.inst.in
+++ b/source/dofs/dof_accessor_get.inst.in
@@ -17,25 +17,24 @@
 
 for (VEC : VECTOR_TYPES; deal_II_dimension : DIMENSIONS; lda : BOOL)
   {
-    template void DoFCellAccessor<DoFHandler<deal_II_dimension>, lda>::
+    template void DoFCellAccessor<deal_II_dimension, deal_II_dimension, lda>::
       get_interpolated_dof_values(const VEC &,
                                   Vector<VEC::value_type> &,
                                   const unsigned int fe_index) const;
 
 #if deal_II_dimension != 3
 
-    template void DoFCellAccessor<
-      DoFHandler<deal_II_dimension, deal_II_dimension + 1>,
-      lda>::get_interpolated_dof_values(const VEC &,
-                                        Vector<VEC::value_type> &,
-                                        const unsigned int fe_index) const;
+    template void
+    DoFCellAccessor<deal_II_dimension, deal_II_dimension + 1, lda>::
+      get_interpolated_dof_values(const VEC &,
+                                  Vector<VEC::value_type> &,
+                                  const unsigned int fe_index) const;
 
 #endif
 
 #if deal_II_dimension == 3
 
-    template void
-    DoFCellAccessor<DoFHandler<1, 3>, lda>::get_interpolated_dof_values(
+    template void DoFCellAccessor<1, 3, lda>::get_interpolated_dof_values(
       const VEC &, Vector<VEC::value_type> &, const unsigned int fe_index)
       const;
 
diff --git a/source/dofs/dof_accessor_set.cc b/source/dofs/dof_accessor_set.cc
index 8e3a615381..b5c1143819 100644
--- a/source/dofs/dof_accessor_set.cc
+++ b/source/dofs/dof_accessor_set.cc
@@ -42,18 +42,18 @@
 DEAL_II_NAMESPACE_OPEN
 
 
-template <typename DoFHandlerType, bool lda>
+template <int dim, int spacedim, bool lda>
 template <class OutputVector, typename number>
 void
-DoFCellAccessor<DoFHandlerType, lda>::set_dof_values_by_interpolation(
+DoFCellAccessor<dim, spacedim, lda>::set_dof_values_by_interpolation(
   const Vector<number> &local_values,
   OutputVector &        values,
   const unsigned int    fe_index_) const
 {
   const unsigned int fe_index =
     (this->dof_handler->hp_capability_enabled == false &&
-     fe_index_ == DoFHandlerType::invalid_fe_index) ?
-      DoFHandlerType::default_fe_index :
+     fe_index_ == DoFHandler<dim, spacedim>::invalid_fe_index) ?
+      DoFHandler<dim, spacedim>::default_fe_index :
       fe_index_;
 
   if (this->is_active() && !this->is_artificial())
@@ -63,7 +63,7 @@ DoFCellAccessor<DoFHandlerType, lda>::set_dof_values_by_interpolation(
           // active cells, you either don't specify an fe_index,
           // or that you specify the correct one
           (fe_index == this->active_fe_index()) ||
-          (fe_index == DoFHandlerType::invalid_fe_index))
+          (fe_index == DoFHandler<dim, spacedim>::invalid_fe_index))
         // simply set the values on this cell
         this->set_dof_values(local_values, values);
       else
@@ -94,7 +94,7 @@ DoFCellAccessor<DoFHandlerType, lda>::set_dof_values_by_interpolation(
     // otherwise distribute them to the children
     {
       Assert((this->dof_handler->hp_capability_enabled == false) ||
-               (fe_index != DoFHandlerType::invalid_fe_index),
+               (fe_index != DoFHandler<dim, spacedim>::invalid_fe_index),
              ExcMessage(
                "You cannot call this function on non-active cells "
                "of hp::DoFHandler objects unless you provide an explicit "
diff --git a/source/dofs/dof_accessor_set.inst.in b/source/dofs/dof_accessor_set.inst.in
index e158168e9a..57390740b8 100644
--- a/source/dofs/dof_accessor_set.inst.in
+++ b/source/dofs/dof_accessor_set.inst.in
@@ -17,25 +17,24 @@
 
 for (VEC : VECTOR_TYPES; deal_II_dimension : DIMENSIONS; lda : BOOL)
   {
-    template void DoFCellAccessor<DoFHandler<deal_II_dimension>, lda>::
+    template void DoFCellAccessor<deal_II_dimension, deal_II_dimension, lda>::
       set_dof_values_by_interpolation(const Vector<VEC::value_type> &,
                                       VEC &,
                                       const unsigned int fe_index) const;
 
 #if deal_II_dimension != 3
 
-    template void DoFCellAccessor<
-      DoFHandler<deal_II_dimension, deal_II_dimension + 1>,
-      lda>::set_dof_values_by_interpolation(const Vector<VEC::value_type> &,
-                                            VEC &,
-                                            const unsigned int fe_index) const;
+    template void
+    DoFCellAccessor<deal_II_dimension, deal_II_dimension + 1, lda>::
+      set_dof_values_by_interpolation(const Vector<VEC::value_type> &,
+                                      VEC &,
+                                      const unsigned int fe_index) const;
 
 #endif
 
 #if deal_II_dimension == 3
 
-    template void
-    DoFCellAccessor<DoFHandler<1, 3>, lda>::set_dof_values_by_interpolation(
+    template void DoFCellAccessor<1, 3, lda>::set_dof_values_by_interpolation(
       const Vector<VEC::value_type> &, VEC &, const unsigned int fe_index)
       const;
 
diff --git a/source/fe/fe_values.cc b/source/fe/fe_values.cc
index e706b49197..a8cdac76fc 100644
--- a/source/fe/fe_values.cc
+++ b/source/fe/fe_values.cc
@@ -4527,7 +4527,7 @@ template <int dim, int spacedim>
 template <bool lda>
 void
 FEValues<dim, spacedim>::reinit(
-  const TriaIterator<DoFCellAccessor<DoFHandler<dim, spacedim>, lda>> &cell)
+  const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> &cell)
 {
   // assert that the finite elements passed to the constructor and
   // used by the DoFHandler used by this cell, are the same
@@ -4540,8 +4540,8 @@ FEValues<dim, spacedim>::reinit(
 
   reset_pointer_in_place_if_possible<
     typename FEValuesBase<dim, spacedim>::template CellIterator<
-      TriaIterator<DoFCellAccessor<DoFHandler<dim, spacedim>, lda>>>>(
-    this->present_cell, cell);
+      TriaIterator<DoFCellAccessor<dim, spacedim, lda>>>>(this->present_cell,
+                                                          cell);
 
   // this was the part of the work that is dependent on the actual
   // data type of the iterator. now pass on to the function doing
@@ -4734,8 +4734,8 @@ template <int dim, int spacedim>
 template <bool lda>
 void
 FEFaceValues<dim, spacedim>::reinit(
-  const TriaIterator<DoFCellAccessor<DoFHandler<dim, spacedim>, lda>> &cell,
-  const unsigned int                                                   face_no)
+  const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> &cell,
+  const unsigned int                                       face_no)
 {
   // assert that the finite elements passed to the constructor and
   // used by the DoFHandler used by this cell, are the same
@@ -4749,8 +4749,8 @@ FEFaceValues<dim, spacedim>::reinit(
   this->maybe_invalidate_previous_present_cell(cell);
   reset_pointer_in_place_if_possible<
     typename FEValuesBase<dim, spacedim>::template CellIterator<
-      TriaIterator<DoFCellAccessor<DoFHandler<dim, spacedim>, lda>>>>(
-    this->present_cell, cell);
+      TriaIterator<DoFCellAccessor<dim, spacedim, lda>>>>(this->present_cell,
+                                                          cell);
 
   // this was the part of the work that is dependent on the actual
   // data type of the iterator. now pass on to the function doing
@@ -4764,8 +4764,8 @@ template <int dim, int spacedim>
 template <bool lda>
 void
 FEFaceValues<dim, spacedim>::reinit(
-  const TriaIterator<DoFCellAccessor<DoFHandler<dim, spacedim>, lda>> &cell,
-  const typename Triangulation<dim, spacedim>::face_iterator &         face)
+  const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> &   cell,
+  const typename Triangulation<dim, spacedim>::face_iterator &face)
 {
   const auto face_n = cell->face_iterator_to_index(face);
   reinit(cell, face_n);
@@ -4935,9 +4935,9 @@ template <int dim, int spacedim>
 template <bool lda>
 void
 FESubfaceValues<dim, spacedim>::reinit(
-  const TriaIterator<DoFCellAccessor<DoFHandler<dim, spacedim>, lda>> &cell,
-  const unsigned int                                                   face_no,
-  const unsigned int subface_no)
+  const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> &cell,
+  const unsigned int                                       face_no,
+  const unsigned int                                       subface_no)
 {
   // assert that the finite elements passed to the constructor and
   // used by the DoFHandler used by this cell, are the same
@@ -4968,8 +4968,8 @@ FESubfaceValues<dim, spacedim>::reinit(
   this->maybe_invalidate_previous_present_cell(cell);
   reset_pointer_in_place_if_possible<
     typename FEValuesBase<dim, spacedim>::template CellIterator<
-      TriaIterator<DoFCellAccessor<DoFHandler<dim, spacedim>, lda>>>>(
-    this->present_cell, cell);
+      TriaIterator<DoFCellAccessor<dim, spacedim, lda>>>>(this->present_cell,
+                                                          cell);
 
   // this was the part of the work that is dependent on the actual
   // data type of the iterator. now pass on to the function doing
@@ -4983,9 +4983,9 @@ template <int dim, int spacedim>
 template <bool lda>
 void
 FESubfaceValues<dim, spacedim>::reinit(
-  const TriaIterator<DoFCellAccessor<DoFHandler<dim, spacedim>, lda>> &cell,
-  const typename Triangulation<dim, spacedim>::face_iterator &         face,
-  const typename Triangulation<dim, spacedim>::face_iterator &         subface)
+  const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> &   cell,
+  const typename Triangulation<dim, spacedim>::face_iterator &face,
+  const typename Triangulation<dim, spacedim>::face_iterator &subface)
 {
   reinit(cell,
          cell->face_iterator_to_index(face),
diff --git a/source/fe/fe_values.inst.in b/source/fe/fe_values.inst.in
index 317dedf94b..675d2bbb89 100644
--- a/source/fe/fe_values.inst.in
+++ b/source/fe/fe_values.inst.in
@@ -58,20 +58,17 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS;
 #if deal_II_dimension <= deal_II_space_dimension
     template void FEValues<deal_II_dimension, deal_II_space_dimension>::reinit(
       const TriaIterator<
-        DoFCellAccessor<DoFHandler<deal_II_dimension, deal_II_space_dimension>,
-                        lda>> &);
+        DoFCellAccessor<deal_II_dimension, deal_II_space_dimension, lda>> &);
     template void
     FEFaceValues<deal_II_dimension, deal_II_space_dimension>::reinit(
       const TriaIterator<
-        DoFCellAccessor<DoFHandler<deal_II_dimension, deal_II_space_dimension>,
-                        lda>> &,
+        DoFCellAccessor<deal_II_dimension, deal_II_space_dimension, lda>> &,
       unsigned int);
 
     template void
     FEFaceValues<deal_II_dimension, deal_II_space_dimension>::reinit(
       const TriaIterator<
-        DoFCellAccessor<DoFHandler<deal_II_dimension, deal_II_space_dimension>,
-                        lda>> &,
+        DoFCellAccessor<deal_II_dimension, deal_II_space_dimension, lda>> &,
       const TriaIterator<TriaAccessor<deal_II_dimension - 1,
                                       deal_II_dimension,
                                       deal_II_space_dimension>> &);
@@ -79,16 +76,14 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS;
     template void
     FESubfaceValues<deal_II_dimension, deal_II_space_dimension>::reinit(
       const TriaIterator<
-        DoFCellAccessor<DoFHandler<deal_II_dimension, deal_II_space_dimension>,
-                        lda>> &,
+        DoFCellAccessor<deal_II_dimension, deal_II_space_dimension, lda>> &,
       const unsigned int,
       const unsigned int);
 
     template void
     FESubfaceValues<deal_II_dimension, deal_II_space_dimension>::reinit(
       const TriaIterator<
-        DoFCellAccessor<DoFHandler<deal_II_dimension, deal_II_space_dimension>,
-                        lda>> &,
+        DoFCellAccessor<deal_II_dimension, deal_II_space_dimension, lda>> &,
       const TriaIterator<TriaAccessor<deal_II_dimension - 1,
                                       deal_II_dimension,
                                       deal_II_space_dimension>> &,
diff --git a/source/hp/fe_values.cc b/source/hp/fe_values.cc
index 233b474ab5..aa7c60f983 100644
--- a/source/hp/fe_values.cc
+++ b/source/hp/fe_values.cc
@@ -226,11 +226,10 @@ namespace hp
   template <bool lda>
   void
   FEValues<dim, spacedim>::reinit(
-    const TriaIterator<DoFCellAccessor<dealii::DoFHandler<dim, spacedim>, lda>>
-                       cell,
-    const unsigned int q_index,
-    const unsigned int mapping_index,
-    const unsigned int fe_index)
+    const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> cell,
+    const unsigned int                                      q_index,
+    const unsigned int                                      mapping_index,
+    const unsigned int                                      fe_index)
   {
     // determine which indices we
     // should actually use
@@ -338,12 +337,11 @@ namespace hp
   template <bool lda>
   void
   FEFaceValues<dim, spacedim>::reinit(
-    const TriaIterator<DoFCellAccessor<dealii::DoFHandler<dim, spacedim>, lda>>
-                       cell,
-    const unsigned int face_no,
-    const unsigned int q_index,
-    const unsigned int mapping_index,
-    const unsigned int fe_index)
+    const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> cell,
+    const unsigned int                                      face_no,
+    const unsigned int                                      q_index,
+    const unsigned int                                      mapping_index,
+    const unsigned int                                      fe_index)
   {
     // determine which indices we
     // should actually use
@@ -452,13 +450,12 @@ namespace hp
   template <bool lda>
   void
   FESubfaceValues<dim, spacedim>::reinit(
-    const TriaIterator<DoFCellAccessor<dealii::DoFHandler<dim, spacedim>, lda>>
-                       cell,
-    const unsigned int face_no,
-    const unsigned int subface_no,
-    const unsigned int q_index,
-    const unsigned int mapping_index,
-    const unsigned int fe_index)
+    const TriaIterator<DoFCellAccessor<dim, spacedim, lda>> cell,
+    const unsigned int                                      face_no,
+    const unsigned int                                      subface_no,
+    const unsigned int                                      q_index,
+    const unsigned int                                      mapping_index,
+    const unsigned int                                      fe_index)
   {
     // determine which indices we
     // should actually use
diff --git a/source/hp/fe_values.inst.in b/source/hp/fe_values.inst.in
index dac83a8e80..592ab00cbd 100644
--- a/source/hp/fe_values.inst.in
+++ b/source/hp/fe_values.inst.in
@@ -91,26 +91,23 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS;
 
       template void
       FEValues<deal_II_dimension, deal_II_space_dimension>::reinit(
-        TriaIterator<DoFCellAccessor<
-          dealii::DoFHandler<deal_II_dimension, deal_II_space_dimension>,
-          lda>>,
+        TriaIterator<
+          DoFCellAccessor<deal_II_dimension, deal_II_space_dimension, lda>>,
         unsigned int,
         unsigned int,
         unsigned int);
       template void
       FEFaceValues<deal_II_dimension, deal_II_space_dimension>::reinit(
-        TriaIterator<DoFCellAccessor<
-          dealii::DoFHandler<deal_II_dimension, deal_II_space_dimension>,
-          lda>>,
+        TriaIterator<
+          DoFCellAccessor<deal_II_dimension, deal_II_space_dimension, lda>>,
         unsigned int,
         unsigned int,
         unsigned int,
         unsigned int);
       template void
       FESubfaceValues<deal_II_dimension, deal_II_space_dimension>::reinit(
-        TriaIterator<DoFCellAccessor<
-          dealii::DoFHandler<deal_II_dimension, deal_II_space_dimension>,
-          lda>>,
+        TriaIterator<
+          DoFCellAccessor<deal_II_dimension, deal_II_space_dimension, lda>>,
         unsigned int,
         unsigned int,
         unsigned int,
diff --git a/source/numerics/derivative_approximation.cc b/source/numerics/derivative_approximation.cc
index 877253ae73..3c6aa413c9 100644
--- a/source/numerics/derivative_approximation.cc
+++ b/source/numerics/derivative_approximation.cc
@@ -1096,8 +1096,10 @@ namespace DerivativeApproximation
 #ifndef _MSC_VER
     const typename DoFHandlerType::active_cell_iterator &cell,
 #else
-    const TriaActiveIterator<dealii::DoFCellAccessor<DoFHandlerType, false>>
-      &cell,
+    const TriaActiveIterator<
+      dealii::DoFCellAccessor<DoFHandlerType::dimension,
+                              DoFHandlerType::space_dimension,
+                              false>> &cell,
 #endif
     Tensor<order, DoFHandlerType::dimension> &derivative,
     const unsigned int                        component)
@@ -1117,8 +1119,10 @@ namespace DerivativeApproximation
 #ifndef _MSC_VER
     const typename DoFHandlerType::active_cell_iterator &cell,
 #else
-    const TriaActiveIterator<dealii::DoFCellAccessor<DoFHandlerType, false>>
-      &cell,
+    const TriaActiveIterator<
+      dealii::DoFCellAccessor<DoFHandlerType::dimension,
+                              DoFHandlerType::space_dimension,
+                              false>> &cell,
 #endif
     Tensor<order, DoFHandlerType::dimension> &derivative,
     const unsigned int                        component)
-- 
2.39.5