From: Timo Heister <timo.heister@gmail.com>
Date: Fri, 26 Dec 2014 16:37:34 +0000 (-0500)
Subject: wrapcomments on all files
X-Git-Tag: v8.3.0-rc1~582^2
X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=refs%2Fpull%2F381%2Fhead;p=dealii.git

wrapcomments on all files
---

diff --git a/include/deal.II/base/exceptions.h b/include/deal.II/base/exceptions.h
index b2f68a6661..00de2c0bc1 100644
--- a/include/deal.II/base/exceptions.h
+++ b/include/deal.II/base/exceptions.h
@@ -32,8 +32,9 @@ DEAL_II_NAMESPACE_OPEN
  * <tt>DeclException</tt> macro family.
  *
  * See the
- * @ref Exceptions module for more details on this class and what can be done
- * with classes derived from it.
+ * @ref Exceptions
+ * module for more details on this class and what can be done with classes
+ * derived from it.
  *
  * @ingroup Exceptions
  * @author Wolfgang Bangerth, 1997, 1998, Matthias Maier, 2013
diff --git a/include/deal.II/base/function.h b/include/deal.II/base/function.h
index be6ae8177d..dee2948173 100644
--- a/include/deal.II/base/function.h
+++ b/include/deal.II/base/function.h
@@ -429,8 +429,8 @@ protected:
  * a few vector components, rather than the entire vector-valued solution. In
  * other words, it acts as a component mask with a single component selected
  * (see the
- * @ref GlossComponentMask "the glossary entry on component masks"). See the
- * step-20 tutorial program for a detailed explanation and a use case.
+ * @ref GlossComponentMask "the glossary entry on component masks").
+ * See the step-20 tutorial program for a detailed explanation and a use case.
  *
  * @ingroup functions
  * @author Guido Kanschat, 2000, Wolfgang Bangerth 2006
diff --git a/include/deal.II/base/geometry_info.h b/include/deal.II/base/geometry_info.h
index 66cbc39584..a883e846ef 100644
--- a/include/deal.II/base/geometry_info.h
+++ b/include/deal.II/base/geometry_info.h
@@ -1099,7 +1099,8 @@ struct GeometryInfo<0>
  * but a few places in the library make use of this. Note that in 2d, the
  * result is always @p true. More information on the topic can be found in
  * this
- * @ref GlossFaceOrientation "glossary" article.
+ * @ref GlossFaceOrientation "glossary"
+ * article.
  *
  * In order to allow all kinds of meshes in 3d, including
  * <em>Moebius</em>-loops, a face might even be rotated looking from one cell,
@@ -1304,7 +1305,8 @@ struct GeometryInfo<0>
  *
  * @note Instantiations for this template are provided for dimensions 1,2,3,4,
  * and there is a specialization for dim=0 (see the section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @ingroup grid geomprimitives aniso
  * @author Wolfgang Bangerth, 1998, Ralf Hartmann, 2005, Tobias Leicht, 2007
@@ -1547,7 +1549,8 @@ struct GeometryInfo
    * defaults to <tt>true</tt>, <tt>face_flip</tt> and <tt>face_rotation</tt>
    * default to <tt>false</tt> (standard orientation) and has no effect in 2d.
    * The concept of face orientations is explained in this
-   * @ref GlossFaceOrientation "glossary" entry.
+   * @ref GlossFaceOrientation "glossary"
+   * entry.
    *
    * In the case of anisotropically refined cells and faces, the @p
    * RefinementCase of the face, <tt>face_ref_case</tt>, might have an
@@ -1595,7 +1598,8 @@ struct GeometryInfo
    * defaults to <tt>true</tt>, <tt>face_flip</tt> and <tt>face_rotation</tt>
    * default to <tt>false</tt> (standard orientation). In 2d only
    * <tt>face_flip</tt> is considered. See this
-   * @ref GlossFaceOrientation "glossary" article for more information.
+   * @ref GlossFaceOrientation "glossary"
+   * article for more information.
    *
    * As the children of a cell are ordered according to the vertices of the
    * cell, this call is passed down to the child_cell_on_face() function.
@@ -1848,7 +1852,8 @@ struct GeometryInfo
    *
    * This function is used in order to determine how distorted a cell is (see
    * the entry on
-   * @ref GlossDistorted "distorted cells" in the glossary).
+   * @ref GlossDistorted "distorted cells"
+   * in the glossary).
    */
   template <int spacedim>
   static void
@@ -1885,7 +1890,8 @@ struct GeometryInfo
    * least in 3d, actual faces of cells in a triangulation can also have the
    * opposite orientation, depending on a flag that one can query from the
    * cell it belongs to. For more information, see the
-   * @ref GlossFaceOrientation "glossary" entry on face orientation.
+   * @ref GlossFaceOrientation "glossary"
+   * entry on face orientation.
    */
   static const int unit_normal_orientation[faces_per_cell];
 
diff --git a/include/deal.II/base/multithread_info.h b/include/deal.II/base/multithread_info.h
index 6990da4114..ba86c5da36 100644
--- a/include/deal.II/base/multithread_info.h
+++ b/include/deal.II/base/multithread_info.h
@@ -30,14 +30,16 @@ DEAL_II_NAMESPACE_OPEN
  * deal.II is compiled with multithreading support, some functions will use
  * multiple threads for their action. Currently the library supports both
  * thread-based and task-based parallelism.
- * @ref threads describes the different uses of each. The default number of
- * threads used for task-based parallel methods is selected automatically by
- * the Threading Building Blocks library. See
- * @ref threads for more information on this.  Thread-based parallel methods
- * need to explicitly created threads and may want to use a number of threads
- * that is related to the number of CPUs in your system. This can be queried
- * using the variable <code> multithread_info.n_cpus; </code> of a global
- * variable <code>multithread_info</code> of this class that, or using <code>
+ * @ref threads
+ * describes the different uses of each. The default number of threads used
+ * for task-based parallel methods is selected automatically by the Threading
+ * Building Blocks library. See
+ * @ref threads
+ * for more information on this.  Thread-based parallel methods need to
+ * explicitly created threads and may want to use a number of threads that is
+ * related to the number of CPUs in your system. This can be queried using the
+ * variable <code> multithread_info.n_cpus; </code> of a global variable
+ * <code>multithread_info</code> of this class that, or using <code>
  * multithread_info.n_threads(); </code>
  *
  * @ingroup threads
diff --git a/include/deal.II/base/parallel.h b/include/deal.II/base/parallel.h
index e186543f21..8b9fc278e6 100644
--- a/include/deal.II/base/parallel.h
+++ b/include/deal.II/base/parallel.h
@@ -149,7 +149,8 @@ namespace parallel
    *
    * For a discussion of the kind of problems to which this function is
    * applicable, see the
-   * @ref threads "Parallel computing with multiple processors" module.
+   * @ref threads "Parallel computing with multiple processors"
+   * module.
    */
   template <typename InputIterator,
             typename OutputIterator,
@@ -202,7 +203,8 @@ namespace parallel
    *
    * For a discussion of the kind of problems to which this function is
    * applicable, see the
-   * @ref threads "Parallel computing with multiple processors" module.
+   * @ref threads "Parallel computing with multiple processors"
+   * module.
    */
   template <typename InputIterator1,
             typename InputIterator2,
@@ -259,7 +261,8 @@ namespace parallel
    *
    * For a discussion of the kind of problems to which this function is
    * applicable, see the
-   * @ref threads "Parallel computing with multiple processors" module.
+   * @ref threads "Parallel computing with multiple processors"
+   * module.
    */
   template <typename InputIterator1,
             typename InputIterator2,
@@ -383,7 +386,8 @@ namespace parallel
    *
    * For a discussion of the kind of problems to which this function is
    * applicable, see also the
-   * @ref threads "Parallel computing with multiple processors" module.
+   * @ref threads "Parallel computing with multiple processors"
+   * module.
    */
   template <typename RangeType, typename Function>
   void apply_to_subranges (const RangeType                          &begin,
@@ -623,7 +627,8 @@ namespace parallel
    *
    * For a discussion of the kind of problems to which this function is
    * applicable, see also the
-   * @ref threads "Parallel computing with multiple processors" module.
+   * @ref threads "Parallel computing with multiple processors"
+   * module.
    */
   template <typename ResultType, typename RangeType, typename Function>
   ResultType accumulate_from_subranges (const Function &f,
diff --git a/include/deal.II/base/parameter_handler.h b/include/deal.II/base/parameter_handler.h
index 86dae53a6b..e20c01ae3d 100644
--- a/include/deal.II/base/parameter_handler.h
+++ b/include/deal.II/base/parameter_handler.h
@@ -188,15 +188,17 @@ namespace Patterns
   private:
     /**
      * Value of the lower bound. A number that satisfies the
-     * @ref match operation of this class must be equal to this value or
-     * larger, if the bounds of the interval for a valid range.
+     * @ref match
+     * operation of this class must be equal to this value or larger, if the
+     * bounds of the interval for a valid range.
      */
     const int lower_bound;
 
     /**
      * Value of the upper bound. A number that satisfies the
-     * @ref match operation of this class must be equal to this value or less,
-     * if the bounds of the interval for a valid range.
+     * @ref match
+     * operation of this class must be equal to this value or less, if the
+     * bounds of the interval for a valid range.
      */
     const int upper_bound;
 
@@ -280,15 +282,17 @@ namespace Patterns
   private:
     /**
      * Value of the lower bound. A number that satisfies the
-     * @ref match operation of this class must be equal to this value or
-     * larger, if the bounds of the interval for a valid range.
+     * @ref match
+     * operation of this class must be equal to this value or larger, if the
+     * bounds of the interval for a valid range.
      */
     const double lower_bound;
 
     /**
      * Value of the upper bound. A number that satisfies the
-     * @ref match operation of this class must be equal to this value or less,
-     * if the bounds of the interval for a valid range.
+     * @ref match
+     * operation of this class must be equal to this value or less, if the
+     * bounds of the interval for a valid range.
      */
     const double upper_bound;
 
@@ -302,9 +306,10 @@ namespace Patterns
    * Test for the string being one of a sequence of values given like a
    * regular expression. For example, if the string given to the constructor
    * is <tt>"red|blue|black"</tt>, then the
-   * @ref match function returns <tt>true</tt> exactly if the string is either
-   * "red" or "blue" or "black". Spaces around the pipe signs do not matter
-   * and are eliminated.
+   * @ref match
+   * function returns <tt>true</tt> exactly if the string is either "red" or
+   * "blue" or "black". Spaces around the pipe signs do not matter and are
+   * eliminated.
    */
   class Selection : public PatternBase
   {
@@ -887,8 +892,9 @@ namespace Patterns
  * logical structure, and input files may include other files.
  *
  * The ParameterHandler class is discussed in detail in the
- * @ref step_19 "step-19" example program, and is used in more realistic
- * situations in step-29, step-33 and step-34.
+ * @ref step_19 "step-19"
+ * example program, and is used in more realistic situations in step-29,
+ * step-33 and step-34.
  *
  * <h3>Declaring entries</h3>
  *
diff --git a/include/deal.II/base/qprojector.h b/include/deal.II/base/qprojector.h
index c634b023b6..37392822eb 100644
--- a/include/deal.II/base/qprojector.h
+++ b/include/deal.II/base/qprojector.h
@@ -64,9 +64,9 @@ DEAL_II_NAMESPACE_OPEN
  * formula onto faces and subfaces in two orientations. (Refer to the
  * documentation of the Triangulation class for a description of the
  * orientation of the different faces, as well as to
- * @ref GlossFaceOrientation "the glossary entry on face orientation" for more
- * information on this.) The DataSetDescriptor member class is used to
- * identify where each dataset starts.
+ * @ref GlossFaceOrientation "the glossary entry on face orientation"
+ * for more information on this.) The DataSetDescriptor member class is used
+ * to identify where each dataset starts.
  *
  * @author Wolfgang Bangerth, Guido Kanschat, 1998, 1999, 2003, 2005
  */
diff --git a/include/deal.II/base/types.h b/include/deal.II/base/types.h
index 248c08fc40..61b4654dba 100644
--- a/include/deal.II/base/types.h
+++ b/include/deal.II/base/types.h
@@ -31,7 +31,8 @@ namespace types
    * The type used to denote subdomain_ids of cells.
    *
    * See the
-   * @ref GlossSubdomainId "glossary" for more information.
+   * @ref GlossSubdomainId "glossary"
+   * for more information.
    *
    * There is a special value, numbers::invalid_subdomain_id that is used to
    * indicate an invalid value of this type.
@@ -64,8 +65,8 @@ namespace types
    * The data type always indicates an unsigned integer type.
    *
    * See the
-   * @ref GlobalDoFIndex page for guidance on when this type should or should
-   * not be used.
+   * @ref GlobalDoFIndex
+   * page for guidance on when this type should or should not be used.
    */
   // TODO: we should check that unsigned long long int
   // has the same size as uint64_t
@@ -252,7 +253,8 @@ namespace numbers
    * subdomain id that is not to be used.
    *
    * See the
-   * @ref GlossSubdomainId "glossary" for more information.
+   * @ref GlossSubdomainId "glossary"
+   * for more information.
    */
   const types::subdomain_id invalid_subdomain_id = static_cast<types::subdomain_id>(-1);
 
@@ -263,9 +265,12 @@ namespace numbers
    * "artificial".
    *
    * See the glossary entries on
-   * @ref GlossSubdomainId "subdomain ids" and
-   * @ref GlossArtificialCell "artificial cells" as well as the
-   * @ref distributed module for more information.
+   * @ref GlossSubdomainId "subdomain ids"
+   * and
+   * @ref GlossArtificialCell "artificial cells"
+   * as well as the
+   * @ref distributed
+   * module for more information.
    */
   const types::subdomain_id artificial_subdomain_id = static_cast<types::subdomain_id>(-2);
 }
diff --git a/include/deal.II/base/work_stream.h b/include/deal.II/base/work_stream.h
index 5ddb2a9ef9..0d831eadca 100644
--- a/include/deal.II/base/work_stream.h
+++ b/include/deal.II/base/work_stream.h
@@ -47,9 +47,9 @@ DEAL_II_NAMESPACE_OPEN
  * uses the Intel Threading Building Blocks (TBB) to load balance the
  * individual subranges onto the available threads. For a lengthy discussion
  * of the rationale of this class, see the
- * @ref threads "Parallel computing with multiple processors" module. It is
- * used in the tutorial first in step-9, and again in step-13, step-14,
- * step-32 and others.
+ * @ref threads "Parallel computing with multiple processors"
+ * module. It is used in the tutorial first in step-9, and again in step-13,
+ * step-14, step-32 and others.
  *
  * The class is built on the following premise: One frequently has some work
  * that needs to be done on a sequence of objects; a prototypical example is
@@ -919,15 +919,15 @@ namespace WorkStream
    * This is one of two main functions of the WorkStream concept, doing work
    * as described in the introduction to this namespace. It corresponds to
    * implementation 3 of the paper by Turcksin, Kronbichler and Bangerth, see
-   * @ref workstream_paper. As such, it takes not a range of iterators
-   * described by a begin and end iterator, but a "colored" graph of iterators
-   * where each color represents cells for which writing the cell
-   * contributions into the global object does not conflict (in other words,
-   * these cells are not neighbors). Each "color" is represented by
-   * std::vectors of cells. The first argument to this function, a set of sets
-   * of cells (which are represent as a vector of vectors, for efficiency), is
-   * typically constructed by calling GraphColoring::make_graph_coloring().
-   * See there for more information.
+   * @ref workstream_paper.
+   * As such, it takes not a range of iterators described by a begin and end
+   * iterator, but a "colored" graph of iterators where each color represents
+   * cells for which writing the cell contributions into the global object
+   * does not conflict (in other words, these cells are not neighbors). Each
+   * "color" is represented by std::vectors of cells. The first argument to
+   * this function, a set of sets of cells (which are represent as a vector of
+   * vectors, for efficiency), is typically constructed by calling
+   * GraphColoring::make_graph_coloring(). See there for more information.
    *
    * This function that can be used for worker and copier objects that are
    * either pointers to non-member functions or objects that allow to be
diff --git a/include/deal.II/distributed/tria.h b/include/deal.II/distributed/tria.h
index 5b285b99d8..a451d05253 100644
--- a/include/deal.II/distributed/tria.h
+++ b/include/deal.II/distributed/tria.h
@@ -173,9 +173,11 @@ namespace parallel
      * algorithms under the hood that ensure we always have a load-balanced,
      * fully distributed mesh. Use of this class is explained in step-40,
      * step-32, the
-     * @ref distributed documentation module, as well as the
-     * @ref distributed_paper. See there for more information. This class
-     * satisfies the requirements outlined in
+     * @ref distributed
+     * documentation module, as well as the
+     * @ref distributed_paper.
+     * See there for more information. This class satisfies the requirements
+     * outlined in
      * @ref GlossMeshAsAContainer "Meshes as containers".
      *
      * @note This class does not support anisotropic refinement, because it
@@ -194,11 +196,11 @@ namespace parallel
      * locally stored set of cells until we have finally gotten from the
      * previous to the next triangulation. This process is described in more
      * detail in the
-     * @ref distributed_paper. Unfortunately, in this process, some
-     * information can get lost relating to flags that are set by user code
-     * and that are inherited from mother to child cell but that are not moved
-     * along with a cell if that cell is migrated from one processor to
-     * another.
+     * @ref distributed_paper.
+     * Unfortunately, in this process, some information can get lost relating
+     * to flags that are set by user code and that are inherited from mother
+     * to child cell but that are not moved along with a cell if that cell is
+     * migrated from one processor to another.
      *
      * An example are boundary indicators. Assume, for example, that you start
      * with a single cell that is refined once globally, yielding four
@@ -346,8 +348,8 @@ namespace parallel
 
       /**
        * A typedef that is used to to identify
-       * @ref GlossActive "active cell iterators". The concept of iterators is
-       * discussed at length in the
+       * @ref GlossActive "active cell iterators".
+       * The concept of iterators is discussed at length in the
        * @ref Iterators "iterators documentation module".
        *
        * The current typedef identifies active cells in a triangulation. You
@@ -543,7 +545,8 @@ namespace parallel
        * always smaller or equal to the result of the function with the same
        * name in the ::Triangulation base class, which includes the active
        * ghost and artificial cells (see also
-       * @ref GlossArtificialCell and
+       * @ref GlossArtificialCell
+       * and
        * @ref GlossGhostCell).
        */
       unsigned int n_locally_owned_active_cells () const;
@@ -574,10 +577,10 @@ namespace parallel
        * nodes between cells that are not locally owned or ghost cells (i.e.,
        * between ghost cells and artificial cells, or between artificial and
        * artificial cells; see
-       * @ref GlossArtificialCell "the glossary"). One is not typically
-       * interested in this case, so the function returns whether there are
-       * hanging nodes between any two cells of the "global" mesh, i.e., the
-       * union of locally owned cells on all processors.
+       * @ref GlossArtificialCell "the glossary").
+       * One is not typically interested in this case, so the function returns
+       * whether there are hanging nodes between any two cells of the "global"
+       * mesh, i.e., the union of locally owned cells on all processors.
        */
       virtual
       bool has_hanging_nodes() const;
diff --git a/include/deal.II/dofs/dof_accessor.h b/include/deal.II/dofs/dof_accessor.h
index 6ace785bb4..70e91715a0 100644
--- a/include/deal.II/dofs/dof_accessor.h
+++ b/include/deal.II/dofs/dof_accessor.h
@@ -529,7 +529,8 @@ public:
   DeclException0 (ExcMatrixDoesNotMatch);
   /**
    * A function has been called for a cell which should be
-   * @ref GlossActive "active", but is refined.
+   * @ref GlossActive "active",
+   * but is refined.
    *
    * @ingroup Exceptions
    */
@@ -999,7 +1000,8 @@ public:
   DeclException0 (ExcMatrixDoesNotMatch);
   /**
    * A function has been called for a cell which should be
-   * @ref GlossActive "active", but is refined.
+   * @ref GlossActive "active",
+   * but is refined.
    *
    * @ingroup Exceptions
    */
diff --git a/include/deal.II/dofs/dof_handler.h b/include/deal.II/dofs/dof_handler.h
index 976b353bd7..e2bd6a6da0 100644
--- a/include/deal.II/dofs/dof_handler.h
+++ b/include/deal.II/dofs/dof_handler.h
@@ -67,8 +67,8 @@ namespace internal
 /**
  * Manage the distribution and numbering of the degrees of freedom for non-
  * multigrid algorithms. This class satisfies the requirements outlined in
- * @ref GlossMeshAsAContainer "Meshes as containers". It is first used in the
- * step-2 tutorial program.
+ * @ref GlossMeshAsAContainer "Meshes as containers".
+ * It is first used in the step-2 tutorial program.
  *
  * For each vertex, line, quad, etc, this class stores a list of the indices
  * of degrees of freedom living on this object. These indices refer to the
@@ -127,9 +127,10 @@ namespace internal
  * single processor. However, it can also be of type
  * parallel::distributed::Triangulation (see, for example, step-32, step-40
  * and in particular the
- * @ref distributed module) in which case the DoFHandler object will proceed
- * to only manage degrees of freedom on locally owned and ghost cells. This
- * process is entirely transparent to the used.
+ * @ref distributed
+ * module) in which case the DoFHandler object will proceed to only manage
+ * degrees of freedom on locally owned and ghost cells. This process is
+ * entirely transparent to the used.
  *
  *
  * <h3>User defined renumbering schemes</h3>
@@ -197,8 +198,8 @@ public:
 
   /**
    * A typedef that is used to to identify
-   * @ref GlossActive "active cell iterators". The concept of iterators is
-   * discussed at length in the
+   * @ref GlossActive "active cell iterators".
+   * The concept of iterators is discussed at length in the
    * @ref Iterators "iterators documentation module".
    *
    * The current typedef identifies active cells in a DoFHandler object. While
@@ -224,11 +225,11 @@ public:
    *
    * The current typedef identifies cells in a DoFHandler object. Some of
    * these cells may in fact be active (see
-   * @ref GlossActive "active cell iterators") in which case they can in fact
-   * be asked for the degrees of freedom that live on them. On the other hand,
-   * if the cell is not active, any such query will result in an error. Note
-   * that this is what distinguishes this typedef from the level_cell_iterator
-   * typedef.
+   * @ref GlossActive "active cell iterators")
+   * in which case they can in fact be asked for the degrees of freedom that
+   * live on them. On the other hand, if the cell is not active, any such
+   * query will result in an error. Note that this is what distinguishes this
+   * typedef from the level_cell_iterator typedef.
    *
    * While the actual data type of the typedef is hidden behind a few layers
    * of (unfortunately necessary) indirections, it is in essence
@@ -721,8 +722,8 @@ public:
    *
    * If an FESystem is used in distribute_dofs(), degrees of freedom naturally
    * split into several
-   * @ref GlossBlock "blocks". For each base element as many blocks appear as
-   * its multiplicity.
+   * @ref GlossBlock "blocks".
+   * For each base element as many blocks appear as its multiplicity.
    *
    * At the end of distribute_dofs(), the number of degrees of freedom in each
    * block is counted, and stored in a BlockInfo object, which can be accessed
diff --git a/include/deal.II/dofs/dof_iterator_selector.h b/include/deal.II/dofs/dof_iterator_selector.h
index 58f0bd6f7b..f8072a9159 100644
--- a/include/deal.II/dofs/dof_iterator_selector.h
+++ b/include/deal.II/dofs/dof_iterator_selector.h
@@ -48,7 +48,8 @@ namespace internal
      * The types have the same meaning as those declared in
      * internal::Triangulation::Iterators<1,spacedim>, only the treatment of
      * templates is a little more complicated. See the
-     * @ref Iterators module for more information.
+     * @ref Iterators
+     * module for more information.
      *
      * @author Wolfgang Bangerth, Oliver Kayser-Herold, Guido Kanschat, 1998,
      * 2003, 2008, 2010
@@ -90,7 +91,8 @@ namespace internal
      * The types have the same meaning as those declared in
      * internal::Triangulation::Iterators<2,spacedim>, only the treatment of
      * templates is a little more complicated. See the
-     * @ref Iterators module for more information.
+     * @ref Iterators
+     * module for more information.
      *
      * @author Wolfgang Bangerth, Oliver Kayser-Herold, Guido Kanschat, 1998,
      * 2003, 2008, 2010
@@ -132,7 +134,8 @@ namespace internal
      * The types have the same meaning as those declared in
      * internal::Triangulation::Iterators<3,spacedim>, only the treatment of
      * templates is a little more complicated. See the
-     * @ref Iterators module for more information.
+     * @ref Iterators
+     * module for more information.
      *
      * @author Wolfgang Bangerth, Oliver Kayser-Herold, Guido Kanschat, 1998,
      * 2003, 2008, 2010
diff --git a/include/deal.II/dofs/dof_renumbering.h b/include/deal.II/dofs/dof_renumbering.h
index ce220961a0..b0dfebb3fa 100644
--- a/include/deal.II/dofs/dof_renumbering.h
+++ b/include/deal.II/dofs/dof_renumbering.h
@@ -164,10 +164,12 @@ DEAL_II_NAMESPACE_OPEN
  * vector components, but also allows to group together vector components into
  * "blocks" using a defaulted argument to the various
  * DoFRenumber::component_wise() functions (see
- * @ref GlossComponent vs
- * @ref GlossBlock for a description of the difference). The blocks designated
- * through this argument may, but do not have to be, equal to the blocks that
- * the finite element reports. For example, a typical Stokes element would be
+ * @ref GlossComponent
+ * vs
+ * @ref GlossBlock
+ * for a description of the difference). The blocks designated through this
+ * argument may, but do not have to be, equal to the blocks that the finite
+ * element reports. For example, a typical Stokes element would be
  * @code
  *   FESystem<dim> stokes_fe (FE_Q<dim>(2), dim,   // dim velocities
  *                            FE_Q<dim>(1), 1);    // one pressure
@@ -677,13 +679,14 @@ namespace DoFRenumbering
    * This function only succeeds if each of the elements in the
    * hp::FECollection attached to the hp::DoFHandler argument has exactly the
    * same number of blocks (see
-   * @ref GlossBlock "the glossary" for more information). Note that this is
-   * not always given: while the hp::FECollection class ensures that all of
-   * its elements have the same number of vector components, they need not
-   * have the same number of blocks. At the same time, this function here
-   * needs to match individual blocks across elements and therefore requires
-   * that elements have the same number of blocks and that subsequent blocks
-   * in one element have the same meaning as in another element.
+   * @ref GlossBlock "the glossary"
+   * for more information). Note that this is not always given: while the
+   * hp::FECollection class ensures that all of its elements have the same
+   * number of vector components, they need not have the same number of
+   * blocks. At the same time, this function here needs to match individual
+   * blocks across elements and therefore requires that elements have the same
+   * number of blocks and that subsequent blocks in one element have the same
+   * meaning as in another element.
    */
   template <int dim>
   void
diff --git a/include/deal.II/dofs/dof_tools.h b/include/deal.II/dofs/dof_tools.h
index 26e75ce5f8..0d7f8ff567 100644
--- a/include/deal.II/dofs/dof_tools.h
+++ b/include/deal.II/dofs/dof_tools.h
@@ -647,8 +647,8 @@ namespace DoFTools
    * global system matrix and right hand side, and to extend the solution
    * vectors from the true degrees of freedom also to the constraint nodes.
    * This function is explained in detail in the
-   * @ref step_6 "step-6" tutorial program and is used in almost all following
-   * programs as well.
+   * @ref step_6 "step-6"
+   * tutorial program and is used in almost all following programs as well.
    *
    * This function does not clear the constraint matrix object before use, in
    * order to allow adding constraints from different sources to the same
@@ -814,13 +814,13 @@ namespace DoFTools
    * happens.
    *
    * The flags in the @p component_mask (see
-   * @ref GlossComponentMask) denote which components of the finite element
-   * space shall be constrained with periodic boundary conditions. If it is
-   * left as specified by the default value all components are constrained. If
-   * it is different from the default value, it is assumed that the number of
-   * entries equals the number of components of the finite element. This can
-   * be used to enforce periodicity in only one variable in a system of
-   * equations.
+   * @ref GlossComponentMask)
+   * denote which components of the finite element space shall be constrained
+   * with periodic boundary conditions. If it is left as specified by the
+   * default value all components are constrained. If it is different from the
+   * default value, it is assumed that the number of entries equals the number
+   * of components of the finite element. This can be used to enforce
+   * periodicity in only one variable in a system of equations.
    *
    * @p face_orientation, @p face_flip and @p face_rotation describe an
    * orientation that should be applied to @p face_1 prior to matching and
@@ -962,7 +962,8 @@ namespace DoFTools
    * before.
    *
    * @see
-   * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions" for further information.
+   * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
+   * for further information.
    *
    * @author Daniel Arndt, Matthias Maier, 2013, 2014
    */
@@ -1002,13 +1003,14 @@ namespace DoFTools
    * happens.
    *
    * The flags in the last parameter, @p component_mask (see
-   * @ref GlossComponentMask) denote which components of the finite element
-   * space shall be constrained with periodic boundary conditions. If it is
-   * left as specified by the default value all components are constrained. If
-   * it is different from the default value, it is assumed that the number of
-   * entries equals the number of components in the boundary functions and the
-   * finite element, and those components in the given boundary function will
-   * be used for which the respective flag was set in the component mask.
+   * @ref GlossComponentMask)
+   * denote which components of the finite element space shall be constrained
+   * with periodic boundary conditions. If it is left as specified by the
+   * default value all components are constrained. If it is different from the
+   * default value, it is assumed that the number of entries equals the number
+   * of components in the boundary functions and the finite element, and those
+   * components in the given boundary function will be used for which the
+   * respective flag was set in the component mask.
    *
    * @note: This function is a convenience wrapper. It internally calls
    * GridTools::collect_periodic_faces() with the supplied paramaters and
@@ -1016,7 +1018,8 @@ namespace DoFTools
    * need more functionality use GridTools::collect_periodic_faces() directly.
    *
    * @see
-   * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions" for further information.
+   * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
+   * for further information.
    *
    * @author Matthias Maier, 2012
    */
@@ -1053,7 +1056,8 @@ namespace DoFTools
    * need more functionality use GridTools::collect_periodic_faces() directly.
    *
    * @see
-   * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions" for further information.
+   * @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
+   * for further information.
    */
   template<typename DH>
   void
@@ -1180,9 +1184,9 @@ namespace DoFTools
    * then shape functions cannot be associated with a single vector component.
    * In this case, if <em>one</em> shape vector component of this element is
    * flagged in @p component_mask (see
-   * @ref GlossComponentMask), then this is equivalent to selecting
-   * <em>all</em> vector components corresponding to this non-primitive base
-   * element.
+   * @ref GlossComponentMask),
+   * then this is equivalent to selecting <em>all</em> vector components
+   * corresponding to this non-primitive base element.
    *
    * @note If the @p blocks argument is true,
    */
@@ -1205,10 +1209,11 @@ namespace DoFTools
    * This function is the equivalent to the DoFTools::extract_dofs() functions
    * above except that the selection of which degrees of freedom to extract is
    * not done based on components (see
-   * @ref GlossComponent) but instead based on whether they are part of a
-   * particular block (see
-   * @ref GlossBlock). Consequently, the second argument is not a
-   * ComponentMask but a BlockMask object.
+   * @ref GlossComponent)
+   * but instead based on whether they are part of a particular block (see
+   * @ref GlossBlock).
+   * Consequently, the second argument is not a ComponentMask but a BlockMask
+   * object.
    *
    * @param dof_handler The DoFHandler object from which to extract degrees of
    * freedom
@@ -1268,8 +1273,9 @@ namespace DoFTools
    * all boundary indicators are accepted.
    *
    * The size of @p component_mask (see
-   * @ref GlossComponentMask) shall equal the number of components in the
-   * finite element used by @p dof. The size of @p selected_dofs shall equal
+   * @ref GlossComponentMask)
+   * shall equal the number of components in the finite element used by @p
+   * dof. The size of @p selected_dofs shall equal
    * <tt>dof_handler.n_dofs()</tt>. Previous contents of this array or
    * overwritten.
    *
@@ -1374,10 +1380,11 @@ namespace DoFTools
   /**
    * Extract a vector that represents the constant modes of the DoFHandler for
    * the components chosen by <tt>component_mask</tt> (see
-   * @ref GlossComponentMask). The constant modes on a discretization are the
-   * null space of a Laplace operator on the selected components with Neumann
-   * boundary conditions applied. The null space is a necessary ingredient for
-   * obtaining a good AMG preconditioner when using the class
+   * @ref GlossComponentMask).
+   * The constant modes on a discretization are the null space of a Laplace
+   * operator on the selected components with Neumann boundary conditions
+   * applied. The null space is a necessary ingredient for obtaining a good
+   * AMG preconditioner when using the class
    * TrilinosWrappers::PreconditionAMG.  Since the ML AMG package only works
    * on algebraic properties of the respective matrix, it has no chance to
    * detect whether the matrix comes from a scalar or a vector valued problem.
@@ -1387,18 +1394,18 @@ namespace DoFTools
    * underlying the given DoFHandler and for most elements, the null space
    * will consist of as many vectors as there are true arguments in
    * <tt>component_mask</tt> (see
-   * @ref GlossComponentMask), each of which will be one in one vector
-   * component and zero in all others. However, the representation of the
-   * constant function for e.g. FE_DGP is different (the first component on
-   * each element one, all other components zero), and some scalar elements
-   * may even have two constant modes (FE_Q_DG0). Therefore, we store this
-   * object in a vector of vectors, where the outer vector contains the
-   * collection of the actual constant modes on the DoFHandler. Each inner
-   * vector has as many components as there are (locally owned) degrees of
-   * freedom in the selected components. Note that any matrix associated with
-   * this null space must have been constructed using the same
-   * <tt>component_mask</tt> argument, since the numbering of DoFs is done
-   * relative to the selected dofs, not to all dofs.
+   * @ref GlossComponentMask),
+   * each of which will be one in one vector component and zero in all others.
+   * However, the representation of the constant function for e.g. FE_DGP is
+   * different (the first component on each element one, all other components
+   * zero), and some scalar elements may even have two constant modes
+   * (FE_Q_DG0). Therefore, we store this object in a vector of vectors, where
+   * the outer vector contains the collection of the actual constant modes on
+   * the DoFHandler. Each inner vector has as many components as there are
+   * (locally owned) degrees of freedom in the selected components. Note that
+   * any matrix associated with this null space must have been constructed
+   * using the same <tt>component_mask</tt> argument, since the numbering of
+   * DoFs is done relative to the selected dofs, not to all dofs.
    *
    * The main reason for this program is the use of the null space with the
    * AMG preconditioner.
@@ -1808,9 +1815,10 @@ namespace DoFTools
    * Count the degrees of freedom in each block. This function is similar to
    * count_dofs_per_component(), with the difference that the counting is done
    * by blocks. See
-   * @ref GlossBlock "blocks" in the glossary for details. Again the vectors
-   * are assumed to have the correct size before calling this function. If
-   * this is not the case, an assertion is thrown.
+   * @ref GlossBlock "blocks"
+   * in the glossary for details. Again the vectors are assumed to have the
+   * correct size before calling this function. If this is not the case, an
+   * assertion is thrown.
    *
    * This function is used in the step-22, step-31, and step-32 tutorial
    * programs.
@@ -1980,11 +1988,11 @@ namespace DoFTools
 
   /**
    * Return a list of support points (see this
-   * @ref GlossSupport "glossary entry") for all the degrees of freedom
-   * handled by this DoF handler object. This function, of course, only works
-   * if the finite element object used by the DoF handler object actually
-   * provides support points, i.e. no edge elements or the like. Otherwise, an
-   * exception is thrown.
+   * @ref GlossSupport "glossary entry")
+   * for all the degrees of freedom handled by this DoF handler object. This
+   * function, of course, only works if the finite element object used by the
+   * DoF handler object actually provides support points, i.e. no edge
+   * elements or the like. Otherwise, an exception is thrown.
    *
    * @pre The given array must have a length of as many elements as there are
    * degrees of freedom.
@@ -2014,17 +2022,18 @@ namespace DoFTools
   /**
    * This function is a version of the above map_dofs_to_support_points
    * function that doesn't simply return a vector of support points (see this
-   * @ref GlossSupport "glossary entry") with one entry for each global degree
-   * of freedom, but instead a map that maps from the DoFs index to its
-   * location. The point of this function is that it is also usable in cases
-   * where the DoFHandler is based on a parallel::distributed::Triangulation
-   * object. In such cases, each processor will not be able to determine the
-   * support point location of all DoFs, and worse no processor may be able to
-   * hold a vector that would contain the locations of all DoFs even if they
-   * were known. As a consequence, this function constructs a map from those
-   * DoFs for which we can know the locations (namely, those DoFs that are
-   * locally relevant (see
-   * @ref GlossLocallyRelevantDof "locally relevant DoFs") to their locations.
+   * @ref GlossSupport "glossary entry")
+   * with one entry for each global degree of freedom, but instead a map that
+   * maps from the DoFs index to its location. The point of this function is
+   * that it is also usable in cases where the DoFHandler is based on a
+   * parallel::distributed::Triangulation object. In such cases, each
+   * processor will not be able to determine the support point location of all
+   * DoFs, and worse no processor may be able to hold a vector that would
+   * contain the locations of all DoFs even if they were known. As a
+   * consequence, this function constructs a map from those DoFs for which we
+   * can know the locations (namely, those DoFs that are locally relevant (see
+   * @ref GlossLocallyRelevantDof "locally relevant DoFs")
+   * to their locations.
    *
    * For non-distributed triangulations, the map returned as @p support_points
    * is of course dense, i.e., every DoF is to be found in it.
@@ -2111,16 +2120,18 @@ namespace DoFTools
    * on the boundary treated here. If there are previously existing
    * constraints for degrees of freedom located on the boundary, then this
    * would constitute a conflict. See the
-   * @ref constraints module for handling the case where there are conflicting
-   * constraints on individual degrees of freedom.
+   * @ref constraints
+   * module for handling the case where there are conflicting constraints on
+   * individual degrees of freedom.
    * @param component_mask An optional component mask that restricts the
    * functionality of this function to a subset of an FESystem. For non-
-   * @ref GlossPrimitive "primitive" shape functions, any degree of freedom is
-   * affected that belongs to a shape function where at least one of its
-   * nonzero components is affected by the component mask (see
-   * @ref GlossComponentMask). If this argument is omitted, all components of
-   * the finite element with degrees of freedom at the boundary will be
-   * considered.
+   * @ref GlossPrimitive "primitive"
+   * shape functions, any degree of freedom is affected that belongs to a
+   * shape function where at least one of its nonzero components is affected
+   * by the component mask (see
+   * @ref GlossComponentMask).
+   * If this argument is omitted, all components of the finite element with
+   * degrees of freedom at the boundary will be considered.
    *
    * @ingroup constraints
    *
diff --git a/include/deal.II/dofs/function_map.h b/include/deal.II/dofs/function_map.h
index e8b489e4c3..c0c9eb0824 100644
--- a/include/deal.II/dofs/function_map.h
+++ b/include/deal.II/dofs/function_map.h
@@ -28,22 +28,22 @@ template <int spacedim, typename Number> class Function;
 /**
  * This class declares a local typedef that denotes a mapping between a
  * boundary indicator (see
- * @ref GlossBoundaryIndicator) that is used to describe what kind of boundary
- * condition holds on a particular piece of the boundary, and the function
- * describing the actual function that provides the boundary values on this
- * part of the boundary. This type is required in many functions in the
- * library where, for example, we need to know about the functions
- * $h_i(\mathbf x)$ used in boundary conditions @f{align*} \mathbf n \cdot
- * \nabla u = h_i \qquad \qquad \text{on}\ \Gamma_i\subset\partial\Omega. @f}
- * An example is the function KellyErrorEstimator::estimate() that allows us
- * to provide a set of functions $h_i$ for all those boundary indicators $i$
- * for which the boundary condition is supposed to be of Neumann type. Of
- * course, the same kind of principle can be applied to cases where we care
- * about Dirichlet values, where one needs to provide a map from boundary
- * indicator $i$ to Dirichlet function $h_i$ if the boundary conditions are
- * given as @f{align*} u = h_i \qquad \qquad \text{on}\
- * \Gamma_i\subset\partial\Omega. @f} This is, for example, the case for the
- * VectorTools::interpolate() functions.
+ * @ref GlossBoundaryIndicator)
+ * that is used to describe what kind of boundary condition holds on a
+ * particular piece of the boundary, and the function describing the actual
+ * function that provides the boundary values on this part of the boundary.
+ * This type is required in many functions in the library where, for example,
+ * we need to know about the functions $h_i(\mathbf x)$ used in boundary
+ * conditions @f{align*} \mathbf n \cdot \nabla u = h_i \qquad \qquad
+ * \text{on}\ \Gamma_i\subset\partial\Omega. @f} An example is the function
+ * KellyErrorEstimator::estimate() that allows us to provide a set of
+ * functions $h_i$ for all those boundary indicators $i$ for which the
+ * boundary condition is supposed to be of Neumann type. Of course, the same
+ * kind of principle can be applied to cases where we care about Dirichlet
+ * values, where one needs to provide a map from boundary indicator $i$ to
+ * Dirichlet function $h_i$ if the boundary conditions are given as @f{align*}
+ * u = h_i \qquad \qquad \text{on}\ \Gamma_i\subset\partial\Omega. @f} This
+ * is, for example, the case for the VectorTools::interpolate() functions.
  *
  * Tutorial programs step-6, step-7 and step-8 show examples of how to use
  * function arguments of this type in situations where we actually have an
diff --git a/include/deal.II/fe/block_mask.h b/include/deal.II/fe/block_mask.h
index 9b72e523bf..f85650d792 100644
--- a/include/deal.II/fe/block_mask.h
+++ b/include/deal.II/fe/block_mask.h
@@ -30,10 +30,10 @@ DEAL_II_NAMESPACE_OPEN
 /**
  * This class represents a mask that can be used to select individual vector
  * blocks of a finite element (see also
- * @ref GlossBlockMask "this glossary entry"). It will typically have as many
- * elements as the finite element has blocks, and one can use
- * <code>operator[]</code> to query whether a particular block has been
- * selected.
+ * @ref GlossBlockMask "this glossary entry").
+ * It will typically have as many elements as the finite element has blocks,
+ * and one can use <code>operator[]</code> to query whether a particular block
+ * has been selected.
  *
  * The semantics of this class are the same as the related ComponentMask
  * class, i.e., a default constructed mask represents all possible blocks. See
diff --git a/include/deal.II/fe/component_mask.h b/include/deal.II/fe/component_mask.h
index 0c48092a1e..64bf6ceee6 100644
--- a/include/deal.II/fe/component_mask.h
+++ b/include/deal.II/fe/component_mask.h
@@ -30,10 +30,10 @@ DEAL_II_NAMESPACE_OPEN
 /**
  * This class represents a mask that can be used to select individual vector
  * components of a finite element (see also
- * @ref GlossComponentMask "this glossary entry"). It will typically have as
- * many elements as the finite element has vector components, and one can use
- * <code>operator[]</code> to query whether a particular component has been
- * selected.
+ * @ref GlossComponentMask "this glossary entry").
+ * It will typically have as many elements as the finite element has vector
+ * components, and one can use <code>operator[]</code> to query whether a
+ * particular component has been selected.
  *
  * Objects of this kind are used in many places where one wants to restrict
  * operations to a certain subset of components, e.g. in
diff --git a/include/deal.II/fe/fe.h b/include/deal.II/fe/fe.h
index 4ac3c50189..65a2e653b8 100644
--- a/include/deal.II/fe/fe.h
+++ b/include/deal.II/fe/fe.h
@@ -76,20 +76,21 @@ namespace hp
  *
  * For vector valued elements shape functions may have nonzero entries in one
  * or several
- * @ref GlossComponent "components" of the vector valued function. If the
- * element is
- * @ref GlossPrimitive "primitive", there is indeed a single component with a
- * nonzero entry for each shape function. This component can be determined by
- * system_to_component_index(), the number of components is
- * FiniteElementData::n_components().
+ * @ref GlossComponent "components"
+ * of the vector valued function. If the element is
+ * @ref GlossPrimitive "primitive",
+ * there is indeed a single component with a nonzero entry for each shape
+ * function. This component can be determined by system_to_component_index(),
+ * the number of components is FiniteElementData::n_components().
  *
  * Furthermore, you may want to split your linear system into
- * @ref GlossBlock "blocks" for the use in BlockVector, BlockSparseMatrix,
- * BlockMatrixArray and so on. If you use non-primitive elements, you cannot
- * determine the block number by system_to_component_index(). Instead, you can
- * use system_to_block_index(), which will automatically take care of the
- * additional components occupied by vector valued elements. The number of
- * generated blocks can be determined by FiniteElementData::n_blocks().
+ * @ref GlossBlock "blocks"
+ * for the use in BlockVector, BlockSparseMatrix, BlockMatrixArray and so on.
+ * If you use non-primitive elements, you cannot determine the block number by
+ * system_to_component_index(). Instead, you can use system_to_block_index(),
+ * which will automatically take care of the additional components occupied by
+ * vector valued elements. The number of generated blocks can be determined by
+ * FiniteElementData::n_blocks().
  *
  * If you decide to operate by base element and multiplicity, the function
  * first_block_of_base() will be helpful.
@@ -98,10 +99,11 @@ namespace hp
  *
  * Since a FiniteElement does not have information on the actual grid cell, it
  * can only provide
- * @ref GlossSupport "support points" on the unit cell. Support points on the
- * actual grid cell must be computed by mapping these points. The class used
- * for this kind of operation is FEValues. In most cases, code of the
- * following type will serve to provide the mapped support points.
+ * @ref GlossSupport "support points"
+ * on the unit cell. Support points on the actual grid cell must be computed
+ * by mapping these points. The class used for this kind of operation is
+ * FEValues. In most cases, code of the following type will serve to provide
+ * the mapped support points.
  *
  * @code
  * Quadrature<dim> dummy_quadrature (fe.get_unit_support_points());
@@ -268,12 +270,13 @@ namespace hp
  *
  * First, already the basis of the shape function space may be difficult to
  * implement for arbitrary order and dimension. On the other hand, if the
- * @ref GlossNodes "node values" are given, then the duality relation between
- * node functionals and basis functions defines the basis. As a result, the
- * shape function space may be defined with arbitrary "raw" basis functions,
- * such that the actual finite element basis is computed from linear
- * combinations of them. The coefficients of these combinations are determined
- * by the duality of node values.
+ * @ref GlossNodes "node values"
+ * are given, then the duality relation between node functionals and basis
+ * functions defines the basis. As a result, the shape function space may be
+ * defined with arbitrary "raw" basis functions, such that the actual finite
+ * element basis is computed from linear combinations of them. The
+ * coefficients of these combinations are determined by the duality of node
+ * values.
  *
  * Using this matrix allows the construction of the basis of shape functions
  * in two steps.
@@ -897,8 +900,10 @@ public:
    * #system_to_base_table field and the system_to_base_index() function.
    *
    * The use of this function is explained extensively in the step-8 and
-   * @ref step_20 "step-20" tutorial programs as well as in the
-   * @ref vector_valued module.
+   * @ref step_20 "step-20"
+   * tutorial programs as well as in the
+   * @ref vector_valued
+   * module.
    */
   std::pair<unsigned int, unsigned int>
   system_to_component_index (const unsigned int index) const;
@@ -1177,7 +1182,8 @@ public:
    * Return a component mask with as many elements as this object has vector
    * components and of which exactly the one component is true that
    * corresponds to the given argument. See
-   * @ref GlossComponentMask "the glossary" for more information.
+   * @ref GlossComponentMask "the glossary"
+   * for more information.
    *
    * @param scalar An object that represents a single scalar vector component
    * of this finite element.
@@ -1191,7 +1197,8 @@ public:
    * Return a component mask with as many elements as this object has vector
    * components and of which exactly the <code>dim</code> components are true
    * that correspond to the given argument. See
-   * @ref GlossComponentMask "the glossary" for more information.
+   * @ref GlossComponentMask "the glossary"
+   * for more information.
    *
    * @param vector An object that represents dim vector components of this
    * finite element.
@@ -1205,7 +1212,8 @@ public:
    * Return a component mask with as many elements as this object has vector
    * components and of which exactly the <code>dim*(dim+1)/2</code> components
    * are true that correspond to the given argument. See
-   * @ref GlossComponentMask "the glossary" for more information.
+   * @ref GlossComponentMask "the glossary"
+   * for more information.
    *
    * @param sym_tensor An object that represents dim*(dim+1)/2 components of
    * this finite element that are jointly to be interpreted as forming a
@@ -1218,11 +1226,12 @@ public:
 
   /**
    * Given a block mask (see
-   * @ref GlossBlockMask "this glossary entry"), produce a component mask (see
-   * @ref GlossComponentMask "this glossary entry") that represents the
-   * components that correspond to the blocks selected in the input argument.
-   * This is essentially a conversion operator from BlockMask to
-   * ComponentMask.
+   * @ref GlossBlockMask "this glossary entry"),
+   * produce a component mask (see
+   * @ref GlossComponentMask "this glossary entry")
+   * that represents the components that correspond to the blocks selected in
+   * the input argument. This is essentially a conversion operator from
+   * BlockMask to ComponentMask.
    *
    * @param block_mask The mask that selects individual blocks of the finite
    * element
@@ -1236,7 +1245,8 @@ public:
    * Return a block mask with as many elements as this object has blocks and
    * of which exactly the one component is true that corresponds to the given
    * argument. See
-   * @ref GlossBlockMask "the glossary" for more information.
+   * @ref GlossBlockMask "the glossary"
+   * for more information.
    *
    * @note This function will only succeed if the scalar referenced by the
    * argument encompasses a complete block. In other words, if, for example,
@@ -1258,7 +1268,8 @@ public:
    * Return a component mask with as many elements as this object has vector
    * components and of which exactly the <code>dim</code> components are true
    * that correspond to the given argument. See
-   * @ref GlossBlockMask "the glossary" for more information.
+   * @ref GlossBlockMask "the glossary"
+   * for more information.
    *
    * @note The same caveat applies as to the version of the function above:
    * The extractor object passed as argument must be so that it corresponds to
@@ -1276,7 +1287,8 @@ public:
    * Return a component mask with as many elements as this object has vector
    * components and of which exactly the <code>dim*(dim+1)/2</code> components
    * are true that correspond to the given argument. See
-   * @ref GlossBlockMask "the glossary" for more information.
+   * @ref GlossBlockMask "the glossary"
+   * for more information.
    *
    * @note The same caveat applies as to the version of the function above:
    * The extractor object passed as argument must be so that it corresponds to
@@ -1293,10 +1305,12 @@ public:
 
   /**
    * Given a component mask (see
-   * @ref GlossComponentMask "this glossary entry"), produce a block mask (see
-   * @ref GlossBlockMask "this glossary entry") that represents the blocks
-   * that correspond to the components selected in the input argument. This is
-   * essentially a conversion operator from ComponentMask to BlockMask.
+   * @ref GlossComponentMask "this glossary entry"),
+   * produce a block mask (see
+   * @ref GlossBlockMask "this glossary entry")
+   * that represents the blocks that correspond to the components selected in
+   * the input argument. This is essentially a conversion operator from
+   * ComponentMask to BlockMask.
    *
    * @note This function will only succeed if the components referenced by the
    * argument encompasses complete blocks. In other words, if, for example,
@@ -1458,7 +1472,8 @@ public:
    * Return a support point vector for generalized interpolation.
    *
    * See the
-   * @ref GlossGeneralizedSupport "glossary entry on generalized points" for more information.
+   * @ref GlossGeneralizedSupport "glossary entry on generalized points"
+   * for more information.
    */
   const std::vector<Point<dim> > &
   get_generalized_support_points () const;
@@ -1468,7 +1483,8 @@ public:
    * get_unit_support_points() or get_generalized_support_points().
    *
    * See the
-   * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+   * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+   * for more information.
    */
   bool has_generalized_support_points () const;
 
diff --git a/include/deal.II/fe/fe_abf.h b/include/deal.II/fe/fe_abf.h
index 80d52095f6..2dd123b770 100644
--- a/include/deal.II/fe/fe_abf.h
+++ b/include/deal.II/fe/fe_abf.h
@@ -61,21 +61,21 @@ template <int dim, int spacedim> class MappingQ;
  * <h3>Interpolation</h3>
  *
  * The
- * @ref GlossInterpolation "interpolation" operators associated with the RT
- * element are constructed such that interpolation and computing the
- * divergence are commuting operations. We require this from interpolating
- * arbitrary functions as well as the #restriction matrices.  It can be
- * achieved by two interpolation schemes, the simplified one in
- * FE_RaviartThomasNodal and the original one here:
+ * @ref GlossInterpolation "interpolation"
+ * operators associated with the RT element are constructed such that
+ * interpolation and computing the divergence are commuting operations. We
+ * require this from interpolating arbitrary functions as well as the
+ * #restriction matrices.  It can be achieved by two interpolation schemes,
+ * the simplified one in FE_RaviartThomasNodal and the original one here:
  *
  * <h4>Node values on edges/faces</h4>
  *
  * On edges or faces, the
- * @ref GlossNodes "node values" are the moments of the normal component of
- * the interpolated function with respect to the traces of the RT polynomials.
- * Since the normal trace of the RT space of degree <i>k</i> on an edge/face
- * is the space <i>Q<sub>k</sub></i>, the moments are taken with respect to
- * this space.
+ * @ref GlossNodes "node values"
+ * are the moments of the normal component of the interpolated function with
+ * respect to the traces of the RT polynomials. Since the normal trace of the
+ * RT space of degree <i>k</i> on an edge/face is the space
+ * <i>Q<sub>k</sub></i>, the moments are taken with respect to this space.
  *
  * <h4>Interior node values</h4>
  *
@@ -159,7 +159,8 @@ private:
    * and #interior_weights). Called from the constructor.
    *
    * See the
-   * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+   * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+   * for more information.
    */
   void initialize_support_points (const unsigned int rt_degree);
 
diff --git a/include/deal.II/fe/fe_base.h b/include/deal.II/fe/fe_base.h
index 7640014c1d..e0fc80d606 100644
--- a/include/deal.II/fe/fe_base.h
+++ b/include/deal.II/fe/fe_base.h
@@ -56,11 +56,12 @@ namespace FiniteElementDomination
    * function that is used in the context of hp finite element methods when
    * determining what to do at faces where two different finite elements meet
    * (see the
-   * @ref hp_paper "hp paper" for a more detailed description of the
-   * following). In that case, the degrees of freedom of one side need to be
-   * constrained to those on the other side. The determination which side is
-   * which is based on the outcome of a comparison for mutual domination: the
-   * dominated side is constrained to the dominating one.
+   * @ref hp_paper "hp paper"
+   * for a more detailed description of the following). In that case, the
+   * degrees of freedom of one side need to be constrained to those on the
+   * other side. The determination which side is which is based on the outcome
+   * of a comparison for mutual domination: the dominated side is constrained
+   * to the dominating one.
    *
    * A similar situation happens in 3d, where we have to consider different
    * elements meeting at only an edge, not an entire face. Such comparisons
@@ -68,11 +69,12 @@ namespace FiniteElementDomination
    * function.
    *
    * Note that there are situations where neither side dominates. The
-   * @ref hp_paper "hp paper" lists two case, with the simpler one being that
-   * a $Q_2\times Q_1$ vector-valued element (i.e. a
-   * <code>FESystem(FE_Q(2),1,FE_Q(1),1)</code>) meets a $Q_1\times Q_2$
-   * element: here, for each of the two vector-components, we can define a
-   * domination relationship, but it is different for the two components.
+   * @ref hp_paper "hp paper"
+   * lists two case, with the simpler one being that a $Q_2\times Q_1$ vector-
+   * valued element (i.e. a <code>FESystem(FE_Q(2),1,FE_Q(1),1)</code>) meets
+   * a $Q_1\times Q_2$ element: here, for each of the two vector-components,
+   * we can define a domination relationship, but it is different for the two
+   * components.
    *
    * It is clear that the concept of domination doesn't matter for
    * discontinuous elements. However, discontinuous elements may be part of
@@ -376,13 +378,15 @@ public:
 
   /**
    * Number of components. See
-   * @ref GlossComponent "the glossary" for more information.
+   * @ref GlossComponent "the glossary"
+   * for more information.
    */
   unsigned int n_components () const;
 
   /**
    * Number of blocks. See
-   * @ref GlossBlock "the glossary" for more information.
+   * @ref GlossBlock "the glossary"
+   * for more information.
    */
   unsigned int n_blocks () const;
 
@@ -427,7 +431,8 @@ protected:
   /**
    * Set the primitivity of the element. This is usually done by the
    * constructor of a derived class.  See
-   * @ref GlossPrimitive "primitive" for details.
+   * @ref GlossPrimitive "primitive"
+   * for details.
    */
   void set_primitivity(const bool value);
 
diff --git a/include/deal.II/fe/fe_bdm.h b/include/deal.II/fe/fe_bdm.h
index 529e85f472..0de57b4c26 100644
--- a/include/deal.II/fe/fe_bdm.h
+++ b/include/deal.II/fe/fe_bdm.h
@@ -99,7 +99,8 @@ private:
    * Initialize the FiniteElement<dim>::generalized_support_points and
    * FiniteElement<dim>::generalized_face_support_points fields. Called from
    * the constructor. See the
-   * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+   * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+   * for more information.
    */
   void initialize_support_points (const unsigned int rt_degree);
   /**
diff --git a/include/deal.II/fe/fe_dg_vector.h b/include/deal.II/fe/fe_dg_vector.h
index 5e59433035..306651448a 100644
--- a/include/deal.II/fe/fe_dg_vector.h
+++ b/include/deal.II/fe/fe_dg_vector.h
@@ -109,7 +109,8 @@ private:
    * constructor.
    *
    * See the
-   * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+   * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+   * for more information.
    */
   void initialize_support_points (const unsigned int degree);
 
diff --git a/include/deal.II/fe/fe_nedelec.h b/include/deal.II/fe/fe_nedelec.h
index 1360c36392..9793360b07 100644
--- a/include/deal.II/fe/fe_nedelec.h
+++ b/include/deal.II/fe/fe_nedelec.h
@@ -120,17 +120,17 @@ template <int dim, int spacedim> class MappingQ;
  * <h3>Interpolation</h3>
  *
  * The
- * @ref GlossInterpolation "interpolation" operators associated with the
- * N&eacute;d&eacute;lec element are constructed such that interpolation and
- * computing the curl are commuting operations on rectangular mesh cells. We
- * require this from interpolating arbitrary functions as well as the
- * #restriction matrices.
+ * @ref GlossInterpolation "interpolation"
+ * operators associated with the N&eacute;d&eacute;lec element are constructed
+ * such that interpolation and computing the curl are commuting operations on
+ * rectangular mesh cells. We require this from interpolating arbitrary
+ * functions as well as the #restriction matrices.
  *
  * <h4>Node values</h4>
  *
  * The
- * @ref GlossNodes "node values" for an element of degree <i>k</i> on the
- * reference cell are:
+ * @ref GlossNodes "node values"
+ * for an element of degree <i>k</i> on the reference cell are:
  * <ol>
  * <li> On edges: the moments of the tangential component with respect to
  * polynomials of degree <i>k</i>.
@@ -383,7 +383,8 @@ private:
    * #generalized_face_support_points when computing the integration.
    *
    * See the
-   * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+   * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+   * for more information.
    */
   Table<2, double> boundary_weights;
 
diff --git a/include/deal.II/fe/fe_raviart_thomas.h b/include/deal.II/fe/fe_raviart_thomas.h
index 6d2ca819e8..6cd75e990a 100644
--- a/include/deal.II/fe/fe_raviart_thomas.h
+++ b/include/deal.II/fe/fe_raviart_thomas.h
@@ -67,21 +67,21 @@ template <int dim, int spacedim> class MappingQ;
  * <h3>Interpolation</h3>
  *
  * The
- * @ref GlossInterpolation "interpolation" operators associated with the RT
- * element are constructed such that interpolation and computing the
- * divergence are commuting operations. We require this from interpolating
- * arbitrary functions as well as the #restriction matrices.  It can be
- * achieved by two interpolation schemes, the simplified one in
- * FE_RaviartThomasNodal and the original one here:
+ * @ref GlossInterpolation "interpolation"
+ * operators associated with the RT element are constructed such that
+ * interpolation and computing the divergence are commuting operations. We
+ * require this from interpolating arbitrary functions as well as the
+ * #restriction matrices.  It can be achieved by two interpolation schemes,
+ * the simplified one in FE_RaviartThomasNodal and the original one here:
  *
  * <h4>Node values on edges/faces</h4>
  *
  * On edges or faces, the
- * @ref GlossNodes "node values" are the moments of the normal component of
- * the interpolated function with respect to the traces of the RT polynomials.
- * Since the normal trace of the RT space of degree <i>k</i> on an edge/face
- * is the space <i>Q<sub>k</sub></i>, the moments are taken with respect to
- * this space.
+ * @ref GlossNodes "node values"
+ * are the moments of the normal component of the interpolated function with
+ * respect to the traces of the RT polynomials. Since the normal trace of the
+ * RT space of degree <i>k</i> on an edge/face is the space
+ * <i>Q<sub>k</sub></i>, the moments are taken with respect to this space.
  *
  * <h4>Interior node values</h4>
  *
@@ -216,7 +216,8 @@ private:
    * point and one column for each degree of freedom on the face.
    *
    * See the
-   * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+   * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+   * for more information.
    */
   Table<2, double> boundary_weights;
   /**
@@ -356,7 +357,8 @@ private:
    * the constructor.
    *
    * See the
-   * @ref GlossGeneralizedSupport "glossary entry on generalized support points" for more information.
+   * @ref GlossGeneralizedSupport "glossary entry on generalized support points"
+   * for more information.
    */
   void initialize_support_points (const unsigned int rt_degree);
 };
diff --git a/include/deal.II/fe/fe_system.h b/include/deal.II/fe/fe_system.h
index 4316e65daa..4a6be4b77e 100644
--- a/include/deal.II/fe/fe_system.h
+++ b/include/deal.II/fe/fe_system.h
@@ -36,7 +36,8 @@ DEAL_II_NAMESPACE_OPEN
  * finite element. %Vector valued elements are discussed in a number of
  * tutorial programs, for example step-8, step-20, step-21, and in particular
  * in the
- * @ref vector_valued module.
+ * @ref vector_valued
+ * module.
  *
  * <h3>FESystem, components and blocks</h3>
  *
@@ -57,12 +58,13 @@ DEAL_II_NAMESPACE_OPEN
  * partial differential equation, the finite element side looks a bit
  * different Since not only FESystem, but also vector-valued elements like
  * FE_RaviartThomas, have several components. The concept needed here is a
- * @ref GlossBlock "block". Each block encompasses the set of degrees of
- * freedom associated with a single base element of an FESystem, where base
- * elements with multiplicities count multiple times. These blocks are usually
- * addressed using the information in DoFHandler::block_info(). The number of
- * blocks of a FESystem object is simply the sum of all multiplicities of base
- * elements and is given by n_blocks().
+ * @ref GlossBlock "block".
+ * Each block encompasses the set of degrees of freedom associated with a
+ * single base element of an FESystem, where base elements with multiplicities
+ * count multiple times. These blocks are usually addressed using the
+ * information in DoFHandler::block_info(). The number of blocks of a FESystem
+ * object is simply the sum of all multiplicities of base elements and is
+ * given by n_blocks().
  *
  * For example, the FESystem for the Taylor-Hood element for the three-
  * dimensional Stokes problem can be built using the code
diff --git a/include/deal.II/fe/fe_tools.h b/include/deal.II/fe/fe_tools.h
index 60718ec33a..66f18854ba 100644
--- a/include/deal.II/fe/fe_tools.h
+++ b/include/deal.II/fe/fe_tools.h
@@ -919,9 +919,9 @@ namespace FETools
    * Note also that this table exists once for each space dimension. If you
    * have a program that works with finite elements in different space
    * dimensions (for example,
-   * @ref step_4 "step-4" does something like this), then you should call this
-   * function for each space dimension for which you want your finite element
-   * added to the map.
+   * @ref step_4 "step-4"
+   * does something like this), then you should call this function for each
+   * space dimension for which you want your finite element added to the map.
    */
   template <int dim, int spacedim>
   void add_fe_name (const std::string &name,
diff --git a/include/deal.II/fe/fe_values.h b/include/deal.II/fe/fe_values.h
index 6561ee9b89..02f265a483 100644
--- a/include/deal.II/fe/fe_values.h
+++ b/include/deal.II/fe/fe_values.h
@@ -121,8 +121,8 @@ namespace internal
  * elements
  *
  * See the description of the
- * @ref vector_valued module for examples how to use the features of this
- * namespace.
+ * @ref vector_valued
+ * module for examples how to use the features of this namespace.
  *
  * @ingroup feaccess vector_valued
  */
@@ -131,7 +131,8 @@ namespace FEValuesViews
   /**
    * A class representing a view to a single scalar component of a possibly
    * vector-valued finite element. Views are discussed in the
-   * @ref vector_valued module.
+   * @ref vector_valued
+   * module.
    *
    * You get an object of this type if you apply a FEValuesExtractors::Scalar
    * to an FEValues, FEFaceValues or FESubfaceValues object.
@@ -343,7 +344,8 @@ namespace FEValuesViews
    * A class representing a view to a set of <code>spacedim</code> components
    * forming a vector part of a vector-valued finite element. Views are
    * discussed in the
-   * @ref vector_valued module.
+   * @ref vector_valued
+   * module.
    *
    * Note that in the current context, a vector is meant in the sense physics
    * uses it: it has <code>spacedim</code> components that behave in specific
@@ -734,7 +736,8 @@ namespace FEValuesViews
    * A class representing a view to a set of <code>(dim*dim + dim)/2</code>
    * components forming a symmetric second-order tensor from a vector-valued
    * finite element. Views are discussed in the
-   * @ref vector_valued module.
+   * @ref vector_valued
+   * module.
    *
    * This class allows to query the value and divergence of (components of)
    * shape functions and solutions representing symmetric tensors. The
@@ -939,7 +942,8 @@ namespace FEValuesViews
    * A class representing a view to a set of <code>dim*dim</code> components
    * forming a second-order tensor from a vector-valued finite element. Views
    * are discussed in the
-   * @ref vector_valued module.
+   * @ref vector_valued
+   * module.
    *
    * This class allows to query the value and divergence of (components of)
    * shape functions and solutions representing tensors. The divergence of a
@@ -2257,7 +2261,8 @@ public:
    * scalar component of the possibly vector-valued finite element. The
    * concept of views is explained in the documentation of the namespace
    * FEValuesViews and in particular in the
-   * @ref vector_valued module.
+   * @ref vector_valued
+   * module.
    */
   const FEValuesViews::Scalar<dim,spacedim> &
   operator[] (const FEValuesExtractors::Scalar &scalar) const;
@@ -2267,7 +2272,8 @@ public:
    * <code>dim</code> scalar components (i.e. a vector) of the vector-valued
    * finite element. The concept of views is explained in the documentation of
    * the namespace FEValuesViews and in particular in the
-   * @ref vector_valued module.
+   * @ref vector_valued
+   * module.
    */
   const FEValuesViews::Vector<dim,spacedim> &
   operator[] (const FEValuesExtractors::Vector &vector) const;
@@ -2278,7 +2284,8 @@ public:
    * order tensor) of the vector-valued finite element. The concept of views
    * is explained in the documentation of the namespace FEValuesViews and in
    * particular in the
-   * @ref vector_valued module.
+   * @ref vector_valued
+   * module.
    */
   const FEValuesViews::SymmetricTensor<2,dim,spacedim> &
   operator[] (const FEValuesExtractors::SymmetricTensor<2> &tensor) const;
@@ -2289,7 +2296,8 @@ public:
    * <code>(dim*dim)</code> scalar components (i.e. a 2nd order tensor) of the
    * vector-valued finite element. The concept of views is explained in the
    * documentation of the namespace FEValuesViews and in particular in the
-   * @ref vector_valued module.
+   * @ref vector_valued
+   * module.
    */
   const FEValuesViews::Tensor<2,dim,spacedim> &
   operator[] (const FEValuesExtractors::Tensor<2> &tensor) const;
diff --git a/include/deal.II/fe/fe_values_extractors.h b/include/deal.II/fe/fe_values_extractors.h
index 8450c4f133..bda6023ee7 100644
--- a/include/deal.II/fe/fe_values_extractors.h
+++ b/include/deal.II/fe/fe_values_extractors.h
@@ -33,8 +33,8 @@ DEAL_II_NAMESPACE_OPEN
  * <code>(dim*dim + dim)/2</code> components
  *
  * See the description of the
- * @ref vector_valued module for examples how to use the features of this
- * namespace.
+ * @ref vector_valued
+ * module for examples how to use the features of this namespace.
  *
  * @ingroup feaccess vector_valued
  */
@@ -46,7 +46,8 @@ namespace FEValuesExtractors
    * FESubfaceValues object is of type FEValuesViews::Scalar. The concept of
    * extractors is defined in the documentation of the namespace
    * FEValuesExtractors and in the
-   * @ref vector_valued module.
+   * @ref vector_valued
+   * module.
    *
    * @ingroup feaccess vector_valued
    */
@@ -82,7 +83,8 @@ namespace FEValuesExtractors
    *
    * The concept of extractors is defined in the documentation of the
    * namespace FEValuesExtractors and in the
-   * @ref vector_valued module.
+   * @ref vector_valued
+   * module.
    *
    * Note that in the current context, a vector is meant in the sense physics
    * uses it: it has <code>spacedim</code> components that behave in specific
@@ -133,7 +135,8 @@ namespace FEValuesExtractors
    *
    * The concept of extractors is defined in the documentation of the
    * namespace FEValuesExtractors and in the
-   * @ref vector_valued module.
+   * @ref vector_valued
+   * module.
    *
    * @ingroup feaccess vector_valued
    *
@@ -175,7 +178,8 @@ namespace FEValuesExtractors
    *
    * The concept of extractors is defined in the documentation of the
    * namespace FEValuesExtractors and in the
-   * @ref vector_valued module.
+   * @ref vector_valued
+   * module.
    *
    * @ingroup feaccess vector_valued
    *
diff --git a/include/deal.II/fe/mapping.h b/include/deal.II/fe/mapping.h
index 8446751c01..92e7e76f91 100644
--- a/include/deal.II/fe/mapping.h
+++ b/include/deal.II/fe/mapping.h
@@ -695,11 +695,12 @@ private:
   /**
    * Performs the same as @p fill_fe_values on a face. Additionally, @p
    * boundary_form (see
-   * @ref GlossBoundaryForm ) and @p normal_vectors can be computed on
-   * surfaces. Since the boundary form already contains the determinant of the
-   * Jacobian of the transformation, it is sometimes more economic to use the
-   * boundary form instead of the product of the unit normal and the
-   * transformed quadrature weight.
+   * @ref GlossBoundaryForm
+   * ) and @p normal_vectors can be computed on surfaces. Since the boundary
+   * form already contains the determinant of the Jacobian of the
+   * transformation, it is sometimes more economic to use the boundary form
+   * instead of the product of the unit normal and the transformed quadrature
+   * weight.
    */
   virtual void
   fill_fe_face_values (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
diff --git a/include/deal.II/grid/filtered_iterator.h b/include/deal.II/grid/filtered_iterator.h
index 04768ef9f1..db3344c678 100644
--- a/include/deal.II/grid/filtered_iterator.h
+++ b/include/deal.II/grid/filtered_iterator.h
@@ -62,7 +62,8 @@ namespace IteratorFilters
   /**
    * Filter that evaluates to true if either the iterator points to an object
    * for which the user flag is set or an iterator past the end. See
-   * @ref GlossUserFlags for information about user flags.
+   * @ref GlossUserFlags
+   * for information about user flags.
    *
    * @ingroup Iterators
    */
@@ -170,7 +171,8 @@ namespace IteratorFilters
    * @ref GlossLocallyOwnedCell "locally owned cell".
    *
    * This class is used in step-32, in connection with the methods of the
-   * @ref distributed module.
+   * @ref distributed
+   * module.
    *
    * @ingroup Iterators
    */
diff --git a/include/deal.II/grid/grid_generator.h b/include/deal.II/grid/grid_generator.h
index 595333f279..64afc54f75 100644
--- a/include/deal.II/grid/grid_generator.h
+++ b/include/deal.II/grid/grid_generator.h
@@ -38,9 +38,9 @@ template <typename number> class SparseMatrix;
  *
  * Some of these functions receive a flag @p colorize. If this is set, parts
  * of the boundary receive different boundary indicators (
- * @ref GlossBoundaryIndicator), allowing them to be distinguished for the
- * purpose of attaching geometry objects and evaluating different boundary
- * conditions.
+ * @ref GlossBoundaryIndicator),
+ * allowing them to be distinguished for the purpose of attaching geometry
+ * objects and evaluating different boundary conditions.
  *
  * This namespace also provides a function
  * GridGenerator::laplace_transformation that smoothly transforms a domain
@@ -816,14 +816,15 @@ namespace GridGenerator
    *
    * @tparam Container A type that satisfies the requirements of a mesh
    * container (see
-   * @ref GlossMeshAsAContainer). The map that is returned will be between
-   * cell iterators pointing into the container describing the surface mesh
-   * and face iterators of the volume mesh container. If the Container
-   * argument is DoFHandler of hp::DoFHandler, then the function will re-build
-   * the triangulation underlying the second argument and return a map between
-   * appropriate iterators into the Container arguments. However, the function
-   * will not actually distribute degrees of freedom on this newly created
-   * surface mesh.
+   * @ref GlossMeshAsAContainer).
+   * The map that is returned will be between cell iterators pointing into the
+   * container describing the surface mesh and face iterators of the volume
+   * mesh container. If the Container argument is DoFHandler of
+   * hp::DoFHandler, then the function will re-build the triangulation
+   * underlying the second argument and return a map between appropriate
+   * iterators into the Container arguments. However, the function will not
+   * actually distribute degrees of freedom on this newly created surface
+   * mesh.
    *
    * @note The algorithm outlined above assumes that all faces on higher
    * refinement levels always have exactly the same boundary indicator as
diff --git a/include/deal.II/grid/grid_in.h b/include/deal.II/grid/grid_in.h
index f645cc833b..b6c3b28ddb 100644
--- a/include/deal.II/grid/grid_in.h
+++ b/include/deal.II/grid/grid_in.h
@@ -290,13 +290,14 @@ struct SubCellData;
  * distortion here means that the Jacobian of the mapping from the reference
  * cell to the real cell has a non-positive determinant, i.e. the cell is
  * pinched or twisted; see the entry on
- * @ref GlossDistorted "distorted cells" in the glossary). If it finds any
- * such cells, it throws an exception. This exception is not caught in the
- * grid reader functions of the current class, and so will propagate through
- * to the function that called it. There, you can catch and ignore the
- * exception if you are certain that there is no harm in dealing with such
- * cells. If you were not aware that your mesh had such cells, your results
- * will likely be of dubious quality at best if you ignore the exception.
+ * @ref GlossDistorted "distorted cells"
+ * in the glossary). If it finds any such cells, it throws an exception. This
+ * exception is not caught in the grid reader functions of the current class,
+ * and so will propagate through to the function that called it. There, you
+ * can catch and ignore the exception if you are certain that there is no harm
+ * in dealing with such cells. If you were not aware that your mesh had such
+ * cells, your results will likely be of dubious quality at best if you ignore
+ * the exception.
  *
  *
  * @ingroup grid
diff --git a/include/deal.II/grid/grid_out.h b/include/deal.II/grid/grid_out.h
index ca2fa08b5b..4c5d363550 100644
--- a/include/deal.II/grid/grid_out.h
+++ b/include/deal.II/grid/grid_out.h
@@ -312,7 +312,8 @@ namespace GridOutFlags
     /**
      * Should lines with a set @p user_flag be drawn in a different color
      * (red)?  See
-     * @ref GlossUserFlags for information about user flags.
+     * @ref GlossUserFlags
+     * for information about user flags.
      */
     bool color_lines_on_user_flag;
 
diff --git a/include/deal.II/grid/grid_tools.h b/include/deal.II/grid/grid_tools.h
index aa7a372540..7f83820c19 100644
--- a/include/deal.II/grid/grid_tools.h
+++ b/include/deal.II/grid/grid_tools.h
@@ -406,10 +406,12 @@ namespace GridTools
    * @note When applied to a triangulation or DoF handler object based on a
    * parallel::distributed::Triangulation object, the cell returned may in
    * fact be a ghost or artificial cell (see
-   * @ref GlossArtificialCell and
-   * @ref GlossGhostCell). If so, many of the operations one may want to do on
-   * this cell (e.g., evaluating the solution) may not be possible and you
-   * will have to decide what to do in that case.
+   * @ref GlossArtificialCell
+   * and
+   * @ref GlossGhostCell).
+   * If so, many of the operations one may want to do on this cell (e.g.,
+   * evaluating the solution) may not be possible and you will have to decide
+   * what to do in that case.
    */
   template <int dim, template <int,int> class Container, int spacedim>
 #ifndef _MSC_VER
@@ -459,10 +461,12 @@ namespace GridTools
    * @note When applied to a triangulation or DoF handler object based on a
    * parallel::distributed::Triangulation object, the cell returned may in
    * fact be a ghost or artificial cell (see
-   * @ref GlossArtificialCell and
-   * @ref GlossGhostCell). If so, many of the operations one may want to do on
-   * this cell (e.g., evaluating the solution) may not be possible and you
-   * will have to decide what to do in that case.
+   * @ref GlossArtificialCell
+   * and
+   * @ref GlossGhostCell).
+   * If so, many of the operations one may want to do on this cell (e.g.,
+   * evaluating the solution) may not be possible and you will have to decide
+   * what to do in that case.
    */
   template <int dim, template<int, int> class Container, int spacedim>
 #ifndef _MSC_VER
@@ -488,10 +492,12 @@ namespace GridTools
    * @note When applied to a triangulation or DoF handler object based on a
    * parallel::distributed::Triangulation object, the cell returned may in
    * fact be a ghost or artificial cell (see
-   * @ref GlossArtificialCell and
-   * @ref GlossGhostCell). If so, many of the operations one may want to do on
-   * this cell (e.g., evaluating the solution) may not be possible and you
-   * will have to decide what to do in that case.
+   * @ref GlossArtificialCell
+   * and
+   * @ref GlossGhostCell).
+   * If so, many of the operations one may want to do on this cell (e.g.,
+   * evaluating the solution) may not be possible and you will have to decide
+   * what to do in that case.
    */
   template <int dim, int spacedim>
   std::pair<typename hp::DoFHandler<dim, spacedim>::active_cell_iterator, Point<dim> >
@@ -664,15 +670,17 @@ namespace GridTools
    * For a triangulation, return a mask that represents which of its vertices
    * are "owned" by the current process in the same way as we talk about
    * locally owned cells or degrees of freedom (see
-   * @ref GlossLocallyOwnedCell and
-   * @ref GlossLocallyOwnedDof). For the purpose of this function, we define a
-   * locally owned vertex as follows: a vertex is owned by that processor with
-   * the smallest subdomain id (which equals the MPI rank of that processor)
-   * among all owners of cells adjacent to this vertex. In other words,
-   * vertices that are in the interior of a partition of the triangulation are
-   * owned by the owner of this partition; for vertices that lie on the
-   * boundary between two or more partitions, the owner is the processor with
-   * the least subdomain_id among all adjacent subdomains.
+   * @ref GlossLocallyOwnedCell
+   * and
+   * @ref GlossLocallyOwnedDof).
+   * For the purpose of this function, we define a locally owned vertex as
+   * follows: a vertex is owned by that processor with the smallest subdomain
+   * id (which equals the MPI rank of that processor) among all owners of
+   * cells adjacent to this vertex. In other words, vertices that are in the
+   * interior of a partition of the triangulation are owned by the owner of
+   * this partition; for vertices that lie on the boundary between two or more
+   * partitions, the owner is the processor with the least subdomain_id among
+   * all adjacent subdomains.
    *
    * For sequential triangulations (as opposed to, for example,
    * parallel::distributed::Triangulation), every user vertex is of course
@@ -786,9 +794,10 @@ namespace GridTools
    * a subset of the input argument.
    *
    * For a definition of the concept of distorted cells, see the
-   * @ref GlossDistorted "glossary entry". The first argument passed to the
-   * current function is typically the exception thrown by the
-   * Triangulation::execute_coarsening_and_refinement function.
+   * @ref GlossDistorted "glossary entry".
+   * The first argument passed to the current function is typically the
+   * exception thrown by the Triangulation::execute_coarsening_and_refinement
+   * function.
    */
   template <int dim, int spacedim>
   typename Triangulation<dim,spacedim>::DistortedCellList
@@ -820,9 +829,10 @@ namespace GridTools
    *
    * @tparam Container A type that satisfies the requirements of a mesh
    * container (see
-   * @ref GlossMeshAsAContainer). In C++, the compiler can not determine the
-   * type of <code>Container</code> from the function call. You need to
-   * specify it as an explicit template argument following the function name.
+   * @ref GlossMeshAsAContainer).
+   * In C++, the compiler can not determine the type of <code>Container</code>
+   * from the function call. You need to specify it as an explicit template
+   * argument following the function name.
    * @param[in] cell An iterator pointing to a cell of the mesh container.
    * @return A list of active cells that form the patch around the given cell
    *
@@ -999,7 +1009,8 @@ namespace GridTools
    *
    * and any combination of that... More information on the topic can be found
    * in the
-   * @ref GlossFaceOrientation "glossary" article.
+   * @ref GlossFaceOrientation "glossary"
+   * article.
    *
    * @author Matthias Maier, 2012
    */
diff --git a/include/deal.II/grid/tria.h b/include/deal.II/grid/tria.h
index 051d6c2bec..ad344e9d73 100644
--- a/include/deal.II/grid/tria.h
+++ b/include/deal.II/grid/tria.h
@@ -1404,8 +1404,8 @@ public:
 
   /**
    * A typedef that is used to to identify
-   * @ref GlossActive "active cell iterators". The concept of iterators is
-   * discussed at length in the
+   * @ref GlossActive "active cell iterators".
+   * The concept of iterators is discussed at length in the
    * @ref Iterators "iterators documentation module".
    *
    * The current typedef identifies active cells in a triangulation. The
@@ -1528,7 +1528,8 @@ public:
    * A structure that is used as an exception object by the
    * create_triangulation() function to indicate which cells among the coarse
    * mesh cells are inverted or severely distorted (see the entry on
-   * @ref GlossDistorted "distorted cells" in the glossary).
+   * @ref GlossDistorted "distorted cells"
+   * in the glossary).
    *
    * Objects of this kind are thrown by the create_triangulation() and
    * execute_coarsening_and_refinement() functions, and they can be caught in
@@ -1580,8 +1581,9 @@ public:
    * should check whether any of the cells that are created by
    * create_triangulation() or execute_coarsening_and_refinement() are
    * distorted (see
-   * @ref GlossDistorted "distorted cells"). If set, these two functions may
-   * throw an exception if they encounter distorted cells.
+   * @ref GlossDistorted "distorted cells").
+   * If set, these two functions may throw an exception if they encounter
+   * distorted cells.
    */
   Triangulation (const MeshSmoothing smooth_grid = none,
                  const bool check_for_distorted_cells = false);
@@ -1814,10 +1816,10 @@ public:
    * creation of this object, at the very end of its operation, the current
    * function walks over all cells and verifies that none of the cells is
    * deformed (see the entry on
-   * @ref GlossDistorted "distorted cells" in the glossary), where we call a
-   * cell deformed if the determinant of the Jacobian of the mapping from
-   * reference cell to real cell is negative at least at one of the vertices
-   * (this computation is done using the
+   * @ref GlossDistorted "distorted cells"
+   * in the glossary), where we call a cell deformed if the determinant of the
+   * Jacobian of the mapping from reference cell to real cell is negative at
+   * least at one of the vertices (this computation is done using the
    * GeometryInfo::jacobian_determinants_at_vertices function). If there are
    * deformed cells, this function throws an exception of kind
    * DistortedCellList. Since this happens after all data structures have been
@@ -3138,9 +3140,9 @@ private:
    *
    * The function returns a list of cells that have produced children that
    * satisfy the criteria of
-   * @ref GlossDistorted "distorted cells" if the
-   * <code>check_for_distorted_cells</code> flag was specified upon creation
-   * of this object, at
+   * @ref GlossDistorted "distorted cells"
+   * if the <code>check_for_distorted_cells</code> flag was specified upon
+   * creation of this object, at
    */
   DistortedCellList execute_refinement ();
 
diff --git a/include/deal.II/grid/tria_accessor.h b/include/deal.II/grid/tria_accessor.h
index 102f0de28b..bad0f149e1 100644
--- a/include/deal.II/grid/tria_accessor.h
+++ b/include/deal.II/grid/tria_accessor.h
@@ -131,9 +131,10 @@ namespace TriaAccessorExceptions
   DeclException0 (ExcCellNotUsed);
   /**
    * The cell is not an
-   * @ref GlossActive "active" cell, but it already has children. Some
-   * operations, like setting refinement flags or accessing degrees of freedom
-   * are only possible on active cells.
+   * @ref GlossActive "active"
+   * cell, but it already has children. Some operations, like setting
+   * refinement flags or accessing degrees of freedom are only possible on
+   * active cells.
    *
    * @ingroup Exceptions
    */
@@ -669,15 +670,16 @@ public:
    * parallel::distributed::Triangulation object. There, refining a mesh
    * always involves a re-partitioning. In other words, vertices of locally
    * owned cells (see
-   * @ref GlossLocallyOwnedCell "this glossary entry") that you may have moved
-   * to a different location on one processor may be moved to a different
-   * processor upon mesh refinement (even if these particular cells were not
-   * refined) which will re-create their position based on the position of the
-   * coarse cells they previously had, not based on the position these
-   * vertices had on the processor that previously owned them. In other words,
-   * in parallel computations, you will probably have to move nodes explicitly
-   * after every mesh refinement because vertex positions may or may not be
-   * preserved across the re-partitioning that accompanies mesh refinement.
+   * @ref GlossLocallyOwnedCell "this glossary entry")
+   * that you may have moved to a different location on one processor may be
+   * moved to a different processor upon mesh refinement (even if these
+   * particular cells were not refined) which will re-create their position
+   * based on the position of the coarse cells they previously had, not based
+   * on the position these vertices had on the processor that previously owned
+   * them. In other words, in parallel computations, you will probably have to
+   * move nodes explicitly after every mesh refinement because vertex
+   * positions may or may not be preserved across the re-partitioning that
+   * accompanies mesh refinement.
    */
   Point<spacedim> &vertex (const unsigned int i) const;
 
@@ -1034,37 +1036,43 @@ public:
    */
   /**
    * Read the user flag. See
-   * @ref GlossUserFlags for more information.
+   * @ref GlossUserFlags
+   * for more information.
    */
   bool user_flag_set () const;
 
   /**
    * Set the user flag. See
-   * @ref GlossUserFlags for more information.
+   * @ref GlossUserFlags
+   * for more information.
    */
   void set_user_flag () const;
 
   /**
    * Clear the user flag. See
-   * @ref GlossUserFlags for more information.
+   * @ref GlossUserFlags
+   * for more information.
    */
   void clear_user_flag () const;
 
   /**
    * Set the user flag for this and all descendants. See
-   * @ref GlossUserFlags for more information.
+   * @ref GlossUserFlags
+   * for more information.
    */
   void recursively_set_user_flag () const;
 
   /**
    * Clear the user flag for this and all descendants. See
-   * @ref GlossUserFlags for more information.
+   * @ref GlossUserFlags
+   * for more information.
    */
   void recursively_clear_user_flag () const;
 
   /**
    * Reset the user data to zero, independent if pointer or index. See
-   * @ref GlossUserData for more information.
+   * @ref GlossUserData
+   * for more information.
    */
   void clear_user_data () const;
 
@@ -1076,13 +1084,15 @@ public:
    * Triangulation::clear_user_data() in between.
    *
    * See
-   * @ref GlossUserData for more information.
+   * @ref GlossUserData
+   * for more information.
    */
   void set_user_pointer (void *p) const;
 
   /**
    * Reset the user pointer to a @p NULL pointer. See
-   * @ref GlossUserData for more information.
+   * @ref GlossUserData
+   * for more information.
    */
   void clear_user_pointer () const;
 
@@ -1097,7 +1107,8 @@ public:
    * *a=static_cast<A*>(cell->user_pointer());</tt>.
    *
    * See
-   * @ref GlossUserData for more information.
+   * @ref GlossUserData
+   * for more information.
    */
   void *user_pointer () const;
 
@@ -1119,14 +1130,16 @@ public:
    * Triangulation::clear_user_data() in between.
    *
    * See
-   * @ref GlossUserData for more information.
+   * @ref GlossUserData
+   * for more information.
    */
   void recursively_set_user_pointer (void *p) const;
 
   /**
    * Clear the user pointer of this object and all of its descendants. The
    * same holds as said for the recursively_set_user_pointer() function. See
-   * @ref GlossUserData for more information.
+   * @ref GlossUserData
+   * for more information.
    */
   void recursively_clear_user_pointer () const;
 
@@ -1136,13 +1149,15 @@ public:
    * @note User pointers and user indices are mutually exclusive. Therefore,
    * you can only use one of them, unless you call
    * Triangulation::clear_user_data() in between. See
-   * @ref GlossUserData for more information.
+   * @ref GlossUserData
+   * for more information.
    */
   void set_user_index (const unsigned int p) const;
 
   /**
    * Reset the user index to 0. See
-   * @ref GlossUserData for more information.
+   * @ref GlossUserData
+   * for more information.
    */
   void clear_user_index () const;
 
@@ -1154,7 +1169,8 @@ public:
    * Triangulation::clear_user_data() in between.
    *
    * See
-   * @ref GlossUserData for more information.
+   * @ref GlossUserData
+   * for more information.
    */
   unsigned int user_index () const;
 
@@ -1172,7 +1188,8 @@ public:
    * Triangulation::clear_user_data() in between.
    *
    * See
-   * @ref GlossUserData for more information.
+   * @ref GlossUserData
+   * for more information.
    */
   void recursively_set_user_index (const unsigned int p) const;
 
@@ -1181,7 +1198,8 @@ public:
    * holds as said for the recursively_set_user_index() function.
    *
    * See
-   * @ref GlossUserData for more information.
+   * @ref GlossUserData
+   * for more information.
    */
   void recursively_clear_user_index () const;
   /**
@@ -2247,10 +2265,12 @@ public:
    * Return the material id of this cell.
    *
    * For a typical use of this function, see the
-   * @ref step_28 "step-28" tutorial program.
+   * @ref step_28 "step-28"
+   * tutorial program.
    *
    * See the
-   * @ref GlossMaterialId "glossary" for more information.
+   * @ref GlossMaterialId "glossary"
+   * for more information.
    */
   types::material_id material_id () const;
 
@@ -2258,10 +2278,12 @@ public:
    * Set the material id of this cell.
    *
    * For a typical use of this function, see the
-   * @ref step_28 "step-28" tutorial program.
+   * @ref step_28 "step-28"
+   * tutorial program.
    *
    * See the
-   * @ref GlossMaterialId "glossary" for more information.
+   * @ref GlossMaterialId "glossary"
+   * for more information.
    */
   void set_material_id (const types::material_id new_material_id) const;
 
@@ -2270,7 +2292,8 @@ public:
    * children, and so on) to the given value.
    *
    * See the
-   * @ref GlossMaterialId "glossary" for more information.
+   * @ref GlossMaterialId "glossary"
+   * for more information.
    */
   void recursively_set_material_id (const types::material_id new_material_id) const;
   /**
@@ -2288,7 +2311,8 @@ public:
    * Return the subdomain id of this cell.
    *
    * See the
-   * @ref GlossSubdomainId "glossary" for more information.
+   * @ref GlossSubdomainId "glossary"
+   * for more information.
    *
    * @note The subdomain of a cell is a property only defined for active
    * cells, i.e., cells that are not further refined. Consequently, you can
@@ -2303,9 +2327,9 @@ public:
    * Set the subdomain id of this cell.
    *
    * See the
-   * @ref GlossSubdomainId "glossary" for more information. This function
-   * should not be called if you use a parallel::distributed::Triangulation
-   * object.
+   * @ref GlossSubdomainId "glossary"
+   * for more information. This function should not be called if you use a
+   * parallel::distributed::Triangulation object.
    *
    * @note The subdomain of a cell is a property only defined for active
    * cells, i.e., cells that are not further refined. Consequently, you can
@@ -2339,10 +2363,10 @@ public:
    * intermediate child cells.
    *
    * See the
-   * @ref GlossSubdomainId "glossary" for more information. This function
-   * should not be called if you use a parallel::distributed::Triangulation
-   * object since there the subdomain id is implicitly defined by which
-   * processor you're on.
+   * @ref GlossSubdomainId "glossary"
+   * for more information. This function should not be called if you use a
+   * parallel::distributed::Triangulation object since there the subdomain id
+   * is implicitly defined by which processor you're on.
    */
   void recursively_set_subdomain_id (const types::subdomain_id new_subdomain_id) const;
   /**
@@ -2397,7 +2421,8 @@ public:
    * a cell).
    *
    * See the
-   * @ref GlossActive "glossary" for more information.
+   * @ref GlossActive "glossary"
+   * for more information.
    */
   bool active () const;
 
@@ -2408,8 +2433,10 @@ public:
    * triangulation is of type parallel::distributed::Triangulation.
    *
    * See the
-   * @ref GlossGhostCell "glossary" and the
-   * @ref distributed module for more information.
+   * @ref GlossGhostCell "glossary"
+   * and the
+   * @ref distributed
+   * module for more information.
    *
    * @post The returned value is equal to <code>!is_ghost() &&
    * !is_artificial()</code>.
@@ -2437,8 +2464,10 @@ public:
    * value is always false.
    *
    * See the
-   * @ref GlossGhostCell "glossary" and the
-   * @ref distributed module for more information.
+   * @ref GlossGhostCell "glossary"
+   * and the
+   * @ref distributed
+   * module for more information.
    *
    * @post The returned value is equal to <code>!is_locally_owned() &&
    * !is_artificial()</code>.
@@ -2463,8 +2492,10 @@ public:
    * value is always false.
    *
    * See the
-   * @ref GlossArtificialCell "glossary" and the
-   * @ref distributed module for more information.
+   * @ref GlossArtificialCell "glossary"
+   * and the
+   * @ref distributed
+   * module for more information.
    *
    * @post The returned value is equal to <code>!is_ghost() &&
    * !is_locally_owned()</code>.
diff --git a/include/deal.II/grid/tria_iterator_selector.h b/include/deal.II/grid/tria_iterator_selector.h
index 444dea7180..df566bc945 100644
--- a/include/deal.II/grid/tria_iterator_selector.h
+++ b/include/deal.II/grid/tria_iterator_selector.h
@@ -40,7 +40,8 @@ namespace internal
     /**
      * This class implements some types which differ between the dimensions.
      * These are the declararions for the 1D case only. See the
-     * @ref Iterators module for more information.
+     * @ref Iterators
+     * module for more information.
      *
      * A @p line_iterator is typdef'd to an iterator operating on the @p lines
      * member variable of a <tt>Triangulation<1></tt> object. An @p
@@ -89,7 +90,8 @@ namespace internal
     /**
      * This class implements some types which differ between the dimensions.
      * These are the declararions for the 2D case only. See the
-     * @ref Iterators module for more information.
+     * @ref Iterators
+     * module for more information.
      *
      * A @p line_iterator is typdef'd to an iterator operating on the @p lines
      * member variable of a <tt>Triangulation<2></tt> object. An @p
@@ -143,7 +145,8 @@ namespace internal
     /**
      * This class implements some types which differ between the dimensions.
      * These are the declararions for the 3D case only. See the
-     * @ref Iterators module for more information.
+     * @ref Iterators
+     * module for more information.
      *
      * For the declarations of the data types, more or less the same holds as
      * for lower dimensions (see <tt>Iterators<[12]></tt>). The dimension
diff --git a/include/deal.II/hp/dof_handler.h b/include/deal.II/hp/dof_handler.h
index 406e5f733e..32bd48cf35 100644
--- a/include/deal.II/hp/dof_handler.h
+++ b/include/deal.II/hp/dof_handler.h
@@ -134,8 +134,8 @@ namespace hp
 
     /**
      * A typedef that is used to to identify
-     * @ref GlossActive "active cell iterators". The concept of iterators is
-     * discussed at length in the
+     * @ref GlossActive "active cell iterators".
+     * The concept of iterators is discussed at length in the
      * @ref Iterators "iterators documentation module".
      *
      * The current typedef identifies active cells in a hp::DoFHandler object.
@@ -163,11 +163,11 @@ namespace hp
      *
      * The current typedef identifies cells in a DoFHandler object. Some of
      * these cells may in fact be active (see
-     * @ref GlossActive "active cell iterators" ) in which case they can in
-     * fact be asked for the degrees of freedom that live on them. On the
-     * other hand, if the cell is not active, any such query will result in an
-     * error. Note that this is what distinguishes this typedef from the
-     * level_cell_iterator typedef.
+     * @ref GlossActive "active cell iterators"
+     * ) in which case they can in fact be asked for the degrees of freedom
+     * that live on them. On the other hand, if the cell is not active, any
+     * such query will result in an error. Note that this is what
+     * distinguishes this typedef from the level_cell_iterator typedef.
      *
      * While the actual data type of the typedef is hidden behind a few layers
      * of (unfortunately necessary) indirections, it is in essence
diff --git a/include/deal.II/hp/fe_collection.h b/include/deal.II/hp/fe_collection.h
index 8dd65b3797..7d19ec97fb 100644
--- a/include/deal.II/hp/fe_collection.h
+++ b/include/deal.II/hp/fe_collection.h
@@ -33,7 +33,8 @@ namespace hp
    * a ::DoFHandler.
    *
    * It implements the concepts stated in the
-   * @ref hpcollection module described in the doxygen documentation.
+   * @ref hpcollection
+   * module described in the doxygen documentation.
    *
    * In addition to offering access to the elements of the collection, this
    * class provides access to the maximal number of degrees of freedom per
@@ -102,7 +103,8 @@ namespace hp
      * collection.
      *
      * This function calls FiniteElement::n_components.  See
-     * @ref GlossComponent "the glossary" for more information.
+     * @ref GlossComponent "the glossary"
+     * for more information.
      */
     unsigned int n_components () const;
 
@@ -112,14 +114,15 @@ namespace hp
      * have the same number of vector components, there is no such guarantees
      * for the number of blocks each element is made up of (an element may
      * have fewer blocks than vector components; see
-     * @ref GlossBlock "the glossary" for more information). For example, you
-     * may have an FECollection object that stores one copy of an FESystem
-     * with <code>dim</code> FE_Q objects and one copy of an FE_RaviartThomas
-     * element. Both have <code>dim</code> vector components but while the
-     * former has <code>dim</code> blocks the latter has only one.
-     * Consequently, this function will throw an assertion if the number of
-     * blocks is not the same for all elements. If they are the same, this
-     * function returns the result of FiniteElement::n_blocks().
+     * @ref GlossBlock "the glossary"
+     * for more information). For example, you may have an FECollection object
+     * that stores one copy of an FESystem with <code>dim</code> FE_Q objects
+     * and one copy of an FE_RaviartThomas element. Both have <code>dim</code>
+     * vector components but while the former has <code>dim</code> blocks the
+     * latter has only one. Consequently, this function will throw an
+     * assertion if the number of blocks is not the same for all elements. If
+     * they are the same, this function returns the result of
+     * FiniteElement::n_blocks().
      */
     unsigned int n_blocks () const;
 
@@ -244,12 +247,12 @@ namespace hp
 
     /**
      * Given a block mask (see
-     * @ref GlossBlockMask "this glossary entry" ), produce a component mask
-     * (see
-     * @ref GlossComponentMask "this glossary entry" ) that represents the
-     * components that correspond to the blocks selected in the input
-     * argument. This is essentially a conversion operator from BlockMask to
-     * ComponentMask.
+     * @ref GlossBlockMask "this glossary entry"
+     * ), produce a component mask (see
+     * @ref GlossComponentMask "this glossary entry"
+     * ) that represents the components that correspond to the blocks selected
+     * in the input argument. This is essentially a conversion operator from
+     * BlockMask to ComponentMask.
      *
      * @note This function is the equivalent of
      * FiniteElement::component_mask() with the same arguments. It verifies
@@ -269,7 +272,8 @@ namespace hp
      * Return a block mask with as many elements as this object has blocks and
      * of which exactly the one component is true that corresponds to the
      * given argument. See
-     * @ref GlossBlockMask "the glossary" for more information.
+     * @ref GlossBlockMask "the glossary"
+     * for more information.
      *
      * @note This function will only succeed if the scalar referenced by the
      * argument encompasses a complete block. In other words, if, for example,
@@ -297,7 +301,8 @@ namespace hp
      * Return a component mask with as many elements as this object has vector
      * components and of which exactly the <code>dim</code> components are
      * true that correspond to the given argument. See
-     * @ref GlossBlockMask "the glossary" for more information.
+     * @ref GlossBlockMask "the glossary"
+     * for more information.
      *
      * @note This function is the equivalent of
      * FiniteElement::component_mask() with the same arguments. It verifies
@@ -321,7 +326,8 @@ namespace hp
      * Return a component mask with as many elements as this object has vector
      * components and of which exactly the <code>dim*(dim+1)/2</code>
      * components are true that correspond to the given argument. See
-     * @ref GlossBlockMask "the glossary" for more information.
+     * @ref GlossBlockMask "the glossary"
+     * for more information.
      *
      * @note The same caveat applies as to the version of the function above:
      * The extractor object passed as argument must be so that it corresponds
@@ -344,11 +350,12 @@ namespace hp
 
     /**
      * Given a component mask (see
-     * @ref GlossComponentMask "this glossary entry" ), produce a block mask
-     * (see
-     * @ref GlossBlockMask "this glossary entry" ) that represents the blocks
-     * that correspond to the components selected in the input argument. This
-     * is essentially a conversion operator from ComponentMask to BlockMask.
+     * @ref GlossComponentMask "this glossary entry"
+     * ), produce a block mask (see
+     * @ref GlossBlockMask "this glossary entry"
+     * ) that represents the blocks that correspond to the components selected
+     * in the input argument. This is essentially a conversion operator from
+     * ComponentMask to BlockMask.
      *
      * @note This function will only succeed if the components referenced by
      * the argument encompasses complete blocks. In other words, if, for
diff --git a/include/deal.II/hp/mapping_collection.h b/include/deal.II/hp/mapping_collection.h
index 20387b0d71..d493ec6719 100644
--- a/include/deal.II/hp/mapping_collection.h
+++ b/include/deal.II/hp/mapping_collection.h
@@ -33,7 +33,8 @@ namespace hp
    * the hp::FECollection implements a collection of finite element classes.
    *
    * It implements the concepts stated in the
-   * @ref hpcollection module described in the doxygen documentation.
+   * @ref hpcollection
+   * module described in the doxygen documentation.
    *
    * Although it is recommended to supply an appropriate mapping for each
    * finite element kind used in a hp-computation, the MappingCollection class
diff --git a/include/deal.II/hp/q_collection.h b/include/deal.II/hp/q_collection.h
index d18ee03ad5..a3ee34aade 100644
--- a/include/deal.II/hp/q_collection.h
+++ b/include/deal.II/hp/q_collection.h
@@ -35,7 +35,8 @@ namespace hp
    * classes.
    *
    * It implements the concepts stated in the
-   * @ref hpcollection module described in the doxygen documentation.
+   * @ref hpcollection
+   * module described in the doxygen documentation.
    *
    * @ingroup hp hpcollection
    *
diff --git a/include/deal.II/lac/block_matrix_base.h b/include/deal.II/lac/block_matrix_base.h
index 660f647341..88cad408db 100644
--- a/include/deal.II/lac/block_matrix_base.h
+++ b/include/deal.II/lac/block_matrix_base.h
@@ -330,7 +330,8 @@ namespace BlockMatrixIterators
  * @note Instantiations for this template are provided for <tt>@<float@> and
  * @<double@></tt>; others can be generated in application programs (see the
  * section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @see
  * @ref GlossBlockLA "Block (linear algebra)"
@@ -622,8 +623,8 @@ public:
    *
    *
    * See
-   * @ref GlossCompress "Compressing distributed objects" for more
-   * information.
+   * @ref GlossCompress "Compressing distributed objects"
+   * for more information.
    */
   void compress (::dealii::VectorOperation::values operation);
 
diff --git a/include/deal.II/lac/block_sparsity_pattern.h b/include/deal.II/lac/block_sparsity_pattern.h
index ec3fde6926..d8b29227ef 100644
--- a/include/deal.II/lac/block_sparsity_pattern.h
+++ b/include/deal.II/lac/block_sparsity_pattern.h
@@ -485,8 +485,8 @@ public:
  * @ref Sparsity.
  *
  * <b>Note:</b> There are several, exchangeable variations of this class, see
- * @ref Sparsity, section 'Dynamic block sparsity patterns' for more
- * information.
+ * @ref Sparsity,
+ * section 'Dynamic block sparsity patterns' for more information.
  *
  * <b>Note:</b> This class used to be called CompressedBlockSparsityPattern.
  * However, since it's a block wrapper around the CompressedSparsityPattern
@@ -604,8 +604,8 @@ typedef BlockCompressedSparsityPattern CompressedBlockSparsityPattern DEAL_II_DE
  * @ref Sparsity.
  *
  * @note There are several, exchangeable variations of this class, see
- * @ref Sparsity, section 'Dynamic block sparsity patterns' for more
- * information.
+ * @ref Sparsity,
+ * section 'Dynamic block sparsity patterns' for more information.
  *
  * @author Wolfgang Bangerth, 2007
  */
@@ -684,8 +684,8 @@ public:
  * @ref Sparsity.
  *
  * @note There are several, exchangeable variations of this class, see
- * @ref Sparsity, section 'Dynamic block sparsity patterns' for more
- * information.
+ * @ref Sparsity,
+ * section 'Dynamic block sparsity patterns' for more information.
  *
  * This class is used in step-22 and step-31.
  *
@@ -774,10 +774,11 @@ public:
  * See the documentation of the BlockSparsityPattern for examples.
  *
  * This class is has properties of the "dynamic" type of
- * @ref Sparsity (in the sense that it can extend the memory if too little
- * elements were allocated), but otherwise is more like the basic deal.II
- * SparsityPattern (in the sense that the method compress() needs to be called
- * before the pattern can be used).
+ * @ref Sparsity
+ * (in the sense that it can extend the memory if too little elements were
+ * allocated), but otherwise is more like the basic deal.II SparsityPattern
+ * (in the sense that the method compress() needs to be called before the
+ * pattern can be used).
  *
  * This class is used in step-32.
  *
diff --git a/include/deal.II/lac/block_vector.h b/include/deal.II/lac/block_vector.h
index 6a0a143d85..c9ab2bb5c8 100644
--- a/include/deal.II/lac/block_vector.h
+++ b/include/deal.II/lac/block_vector.h
@@ -52,7 +52,8 @@ namespace TrilinosWrappers
  * @note Instantiations for this template are provided for <tt>@<float@> and
  * @<double@></tt>; others can be generated in application programs (see the
  * section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @see
  * @ref GlossBlockLA "Block (linear algebra)"
@@ -169,8 +170,8 @@ public:
    * exists in other objects for compatibility.
    *
    * See
-   * @ref GlossCompress "Compressing distributed objects" for more
-   * information.
+   * @ref GlossCompress "Compressing distributed objects"
+   * for more information.
    */
   void compress (::dealii::VectorOperation::values operation
                  =::dealii::VectorOperation::unknown);
diff --git a/include/deal.II/lac/block_vector_base.h b/include/deal.II/lac/block_vector_base.h
index c2373f9a99..9b15eab2bc 100644
--- a/include/deal.II/lac/block_vector_base.h
+++ b/include/deal.II/lac/block_vector_base.h
@@ -624,8 +624,8 @@ public:
    * exists in other objects for compatibility.
    *
    * See
-   * @ref GlossCompress "Compressing distributed objects" for more
-   * information.
+   * @ref GlossCompress "Compressing distributed objects"
+   * for more information.
    */
   void compress (::dealii::VectorOperation::values operation);
 
diff --git a/include/deal.II/lac/chunk_sparse_matrix.h b/include/deal.II/lac/chunk_sparse_matrix.h
index 02fd702515..e2b7a96f3b 100644
--- a/include/deal.II/lac/chunk_sparse_matrix.h
+++ b/include/deal.II/lac/chunk_sparse_matrix.h
@@ -400,7 +400,8 @@ namespace ChunkSparseMatrixIterators
  * @note Instantiations for this template are provided for <tt>@<float@> and
  * @<double@></tt>; others can be generated in application programs (see the
  * section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @author Wolfgang Bangerth, 2008
  */
@@ -831,10 +832,11 @@ public:
    *
    * Note that while this function can operate on all vectors that offer
    * iterator classes, it is only really effective for objects of type
-   * @ref Vector. For all classes for which iterating over elements, or random
-   * member access is expensive, this function is not efficient. In
-   * particular, if you want to multiply with BlockVector objects, you should
-   * consider using a BlockChunkSparseMatrix as well.
+   * @ref Vector.
+   * For all classes for which iterating over elements, or random member
+   * access is expensive, this function is not efficient. In particular, if
+   * you want to multiply with BlockVector objects, you should consider using
+   * a BlockChunkSparseMatrix as well.
    *
    * Source and destination must not be the same vector.
    */
@@ -849,10 +851,11 @@ public:
    *
    * Note that while this function can operate on all vectors that offer
    * iterator classes, it is only really effective for objects of type
-   * @ref Vector. For all classes for which iterating over elements, or random
-   * member access is expensive, this function is not efficient. In
-   * particular, if you want to multiply with BlockVector objects, you should
-   * consider using a BlockChunkSparseMatrix as well.
+   * @ref Vector.
+   * For all classes for which iterating over elements, or random member
+   * access is expensive, this function is not efficient. In particular, if
+   * you want to multiply with BlockVector objects, you should consider using
+   * a BlockChunkSparseMatrix as well.
    *
    * Source and destination must not be the same vector.
    */
@@ -866,10 +869,11 @@ public:
    *
    * Note that while this function can operate on all vectors that offer
    * iterator classes, it is only really effective for objects of type
-   * @ref Vector. For all classes for which iterating over elements, or random
-   * member access is expensive, this function is not efficient. In
-   * particular, if you want to multiply with BlockVector objects, you should
-   * consider using a BlockChunkSparseMatrix as well.
+   * @ref Vector.
+   * For all classes for which iterating over elements, or random member
+   * access is expensive, this function is not efficient. In particular, if
+   * you want to multiply with BlockVector objects, you should consider using
+   * a BlockChunkSparseMatrix as well.
    *
    * Source and destination must not be the same vector.
    */
@@ -884,10 +888,11 @@ public:
    *
    * Note that while this function can operate on all vectors that offer
    * iterator classes, it is only really effective for objects of type
-   * @ref Vector. For all classes for which iterating over elements, or random
-   * member access is expensive, this function is not efficient. In
-   * particular, if you want to multiply with BlockVector objects, you should
-   * consider using a BlockChunkSparseMatrix as well.
+   * @ref Vector.
+   * For all classes for which iterating over elements, or random member
+   * access is expensive, this function is not efficient. In particular, if
+   * you want to multiply with BlockVector objects, you should consider using
+   * a BlockChunkSparseMatrix as well.
    *
    * Source and destination must not be the same vector.
    */
diff --git a/include/deal.II/lac/chunk_sparsity_pattern.h b/include/deal.II/lac/chunk_sparsity_pattern.h
index 2732ee36da..b57b6f3fbb 100644
--- a/include/deal.II/lac/chunk_sparsity_pattern.h
+++ b/include/deal.II/lac/chunk_sparsity_pattern.h
@@ -216,8 +216,8 @@ namespace ChunkSparsityPatternIterators
 /**
  * Structure representing the sparsity pattern of a sparse matrix. This class
  * is an example of the "static" type of
- * @ref Sparsity. It uses the compressed row storage (CSR) format to store
- * data.
+ * @ref Sparsity.
+ * It uses the compressed row storage (CSR) format to store data.
  *
  * The use of this class is demonstrated in step-51.
  *
diff --git a/include/deal.II/lac/compressed_set_sparsity_pattern.h b/include/deal.II/lac/compressed_set_sparsity_pattern.h
index 3e4c20cbd5..379fd72480 100644
--- a/include/deal.II/lac/compressed_set_sparsity_pattern.h
+++ b/include/deal.II/lac/compressed_set_sparsity_pattern.h
@@ -49,11 +49,14 @@ template <typename number> class SparseMatrix;
  * Another viewpoint is that this class does not need up front allocation of a
  * certain amount of memory, but grows as necessary.  An extensive description
  * of sparsity patterns can be found in the documentation of the
- * @ref Sparsity module.
+ * @ref Sparsity
+ * module.
  *
  * This class is an example of the "dynamic" type of
- * @ref Sparsity. It is discussed in the step-27 and
- * @ref step_22 "step-22" tutorial programs.
+ * @ref Sparsity.
+ * It is discussed in the step-27 and
+ * @ref step_22 "step-22"
+ * tutorial programs.
  *
  * <h3>Interface</h3>
  *
@@ -83,8 +86,7 @@ template <typename number> class SparseMatrix;
  *
  * There are several, exchangeable variations of this class, see
  * @ref Sparsity,
- * section '"Dynamic" or "compressed" sparsity patterns' for
- * more information.
+ * section '"Dynamic" or "compressed" sparsity patterns' for more information.
  *
  * This class is a variation of the CompressedSparsityPattern class. Instead
  * of using sorted vectors together with a caching algorithm for storing the
@@ -93,12 +95,13 @@ template <typename number> class SparseMatrix;
  * better than the CompressedSparsityPattern in the context of hp-adaptivity
  * (see for example step-27), or generally when there are many nonzero entries
  * in each row of a matrix (see
- * @ref step_22 "step-22"). On the other hand, a benchmark where nonzero
- * entries were randomly inserted into the sparsity pattern revealed that this
- * class is slower by a factor 4-6 in this situation. Hence, currently the
- * suggestion is to carefully analyze which of the CompressedSparsityPattern
- * classes works best in a certain setting. An algorithm which performs
- * equally well in all situations still has to be found.
+ * @ref step_22 "step-22").
+ * On the other hand, a benchmark where nonzero entries were randomly inserted
+ * into the sparsity pattern revealed that this class is slower by a factor
+ * 4-6 in this situation. Hence, currently the suggestion is to carefully
+ * analyze which of the CompressedSparsityPattern classes works best in a
+ * certain setting. An algorithm which performs equally well in all situations
+ * still has to be found.
  *
  *
  * @author Oliver Kayser-Herold, 2007
diff --git a/include/deal.II/lac/compressed_simple_sparsity_pattern.h b/include/deal.II/lac/compressed_simple_sparsity_pattern.h
index ea1a3bc67c..222c933977 100644
--- a/include/deal.II/lac/compressed_simple_sparsity_pattern.h
+++ b/include/deal.II/lac/compressed_simple_sparsity_pattern.h
@@ -52,7 +52,8 @@ template <typename number> class SparseMatrix;
  * Another viewpoint is that this class does not need up front allocation of a
  * certain amount of memory, but grows as necessary.  An extensive description
  * of sparsity patterns can be found in the documentation of the
- * @ref Sparsity module.
+ * @ref Sparsity
+ * module.
  *
  * This class is an example of the "dynamic" type of
  * @ref Sparsity.
@@ -83,8 +84,7 @@ template <typename number> class SparseMatrix;
  *
  * There are several, exchangeable variations of this class, see
  * @ref Sparsity,
- * section '"Dynamic" or "compressed" sparsity patterns' for
- * more information.
+ * section '"Dynamic" or "compressed" sparsity patterns' for more information.
  *
  * @author Timo Heister, 2008
  */
diff --git a/include/deal.II/lac/compressed_sparsity_pattern.h b/include/deal.II/lac/compressed_sparsity_pattern.h
index 10451ce762..b4024a7d29 100644
--- a/include/deal.II/lac/compressed_sparsity_pattern.h
+++ b/include/deal.II/lac/compressed_sparsity_pattern.h
@@ -54,7 +54,8 @@ template <typename number> class SparseMatrix;
  * Another viewpoint is that this class does not need up front allocation of a
  * certain amount of memory, but grows as necessary.  An extensive description
  * of sparsity patterns can be found in the documentation of the
- * @ref Sparsity module.
+ * @ref Sparsity
+ * module.
  *
  * This class is an example of the "dynamic" type of
  * @ref Sparsity.
@@ -86,8 +87,7 @@ template <typename number> class SparseMatrix;
  *
  * There are several, exchangeable variations of this class, see
  * @ref Sparsity,
- * section '"Dynamic" or "compressed" sparsity patterns' for
- * more information.
+ * section '"Dynamic" or "compressed" sparsity patterns' for more information.
  *
  * @author Wolfgang Bangerth, 2001
  */
diff --git a/include/deal.II/lac/constraint_matrix.h b/include/deal.II/lac/constraint_matrix.h
index be9621938d..74c3713cc8 100644
--- a/include/deal.II/lac/constraint_matrix.h
+++ b/include/deal.II/lac/constraint_matrix.h
@@ -71,19 +71,21 @@ namespace internals
  * This class implements dealing with linear (possibly inhomogeneous)
  * constraints on degrees of freedom. The concept and origin of such
  * constraints is extensively described in the
- * @ref constraints module. The class is meant to deal with a limited number
- * of constraints relative to the total number of degrees of freedom, for
- * example a few per cent up to maybe 30 per cent; and with a linear
- * combination of <i>M</i> other degrees of freedom where <i>M</i> is also
- * relatively small (no larger than at most around the average number of
- * entries per row of a linear system). It is <em>not</em> meant to describe
- * full rank linear systems.
+ * @ref constraints
+ * module. The class is meant to deal with a limited number of constraints
+ * relative to the total number of degrees of freedom, for example a few per
+ * cent up to maybe 30 per cent; and with a linear combination of <i>M</i>
+ * other degrees of freedom where <i>M</i> is also relatively small (no larger
+ * than at most around the average number of entries per row of a linear
+ * system). It is <em>not</em> meant to describe full rank linear systems.
  *
  * The algorithms used in the implementation of this class are described in
  * some detail in the
- * @ref hp_paper "hp paper". There is also a significant amount of
- * documentation on how to use this class in the
- * @ref constraints module.
+ * @ref hp_paper "hp paper".
+ * There is also a significant amount of documentation on how to use this
+ * class in the
+ * @ref constraints
+ * module.
  *
  *
  * <h3>Description of constraints</h3>
@@ -128,12 +130,13 @@ namespace internals
  * and sorts the entries.
  *
  * @note Many of the algorithms this class implements are discussed in the
- * @ref hp_paper. The algorithms are also related to those shown in <i>M. S.
- * Shephard: Linear multipoint constraints applied via transformation as part
- * of a direct stiffness assembly process. Int. J. Numer. Meth. Engrg., vol.
- * 20 (1984), pp. 2107-2112.</i>, with the difference that the algorithms
- * shown there completely eliminated constrained degrees of freedom, whereas
- * we usually keep them as part of the linear system.
+ * @ref hp_paper.
+ * The algorithms are also related to those shown in <i>M. S. Shephard: Linear
+ * multipoint constraints applied via transformation as part of a direct
+ * stiffness assembly process. Int. J. Numer. Meth. Engrg., vol. 20 (1984),
+ * pp. 2107-2112.</i>, with the difference that the algorithms shown there
+ * completely eliminated constrained degrees of freedom, whereas we usually
+ * keep them as part of the linear system.
  *
  * @ingroup dofs
  * @ingroup constraints
@@ -560,8 +563,8 @@ public:
    * elements per row (for example for vector-valued problems or hp finite
    * elements). In this case, it is advisable to use the
    * CompressedSetSparsityPattern class instead, see for example
-   * @ref step_27 "step-27", or to use the CompressedSimpleSparsityPattern
-   * class, see for example
+   * @ref step_27 "step-27",
+   * or to use the CompressedSimpleSparsityPattern class, see for example
    * @ref step_31 "step-31".
    */
   void condense (CompressedSparsityPattern &sparsity) const;
@@ -589,7 +592,8 @@ public:
    * nonzero elements per row (for example for vector-valued problems or hp
    * finite elements). In this case, it is advisable to use the
    * BlockCompressedSetSparsityPattern class instead, see for example
-   * @ref step_27 "step-27" and
+   * @ref step_27 "step-27"
+   * and
    * @ref step_31 "step-31".
    */
   void condense (BlockCompressedSparsityPattern &sparsity) const;
@@ -943,7 +947,8 @@ public:
    * according to the constraints specified by the calling ConstraintMatrix.
    * This function can correctly handle inhomogeneous constraints as well. For
    * the parameter use_inhomogeneities_for_rhs see the documentation in
-   * @ref constraints module.
+   * @ref constraints
+   * module.
    *
    * @note This function in itself is thread-safe, i.e., it works properly
    * also when several threads call it simultaneously. However, the function
@@ -969,13 +974,14 @@ public:
    * sparsity pattern entries.
    *
    * As explained in the
-   * @ref hp_paper "hp paper" and in step-27, first allocating a sparsity
-   * pattern and later coming back and allocating additional entries for those
-   * matrix entries that will be written to due to the elimination of
-   * constrained degrees of freedom (using ConstraintMatrix::condense() ), can
-   * be a very expensive procedure. It is cheaper to allocate these entries
-   * right away without having to do a second pass over the sparsity pattern
-   * object. This function does exactly that.
+   * @ref hp_paper "hp paper"
+   * and in step-27, first allocating a sparsity pattern and later coming back
+   * and allocating additional entries for those matrix entries that will be
+   * written to due to the elimination of constrained degrees of freedom
+   * (using ConstraintMatrix::condense() ), can be a very expensive procedure.
+   * It is cheaper to allocate these entries right away without having to do a
+   * second pass over the sparsity pattern object. This function does exactly
+   * that.
    *
    * Because the function only allocates entries in a sparsity pattern, all it
    * needs to know are the degrees of freedom that couple to each other.
diff --git a/include/deal.II/lac/full_matrix.h b/include/deal.II/lac/full_matrix.h
index 2ce8f31096..16e3ae9c73 100644
--- a/include/deal.II/lac/full_matrix.h
+++ b/include/deal.II/lac/full_matrix.h
@@ -55,7 +55,8 @@ template <typename number> class LAPACKFullMatrix;
  * @<double@>, @<long double@>, @<std::complex@<float@>@>,
  * @<std::complex@<double@>@>, @<std::complex@<long double@>@></tt>; others
  * can be generated in application programs (see the section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @author Guido Kanschat, Franz-Theo Suttmeier, Wolfgang Bangerth, 1993-2004
  */
diff --git a/include/deal.II/lac/householder.h b/include/deal.II/lac/householder.h
index 09276f4bbe..a2786d8c0b 100644
--- a/include/deal.II/lac/householder.h
+++ b/include/deal.II/lac/householder.h
@@ -47,7 +47,8 @@ template<typename number> class Vector;
  * @note Instantiations for this template are provided for <tt>@<float@> and
  * @<double@></tt>; others can be generated in application programs (see the
  * section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @author Guido Kanschat, 2005
  */
diff --git a/include/deal.II/lac/matrix_lib.h b/include/deal.II/lac/matrix_lib.h
index 3691101c17..c8546e3d18 100644
--- a/include/deal.II/lac/matrix_lib.h
+++ b/include/deal.II/lac/matrix_lib.h
@@ -404,7 +404,8 @@ private:
  * @note Instantiations for this template are provided for <tt>@<float@> and
  * @<double@></tt>; others can be generated in application programs (see the
  * section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @author Guido Kanschat, 2005
  */
diff --git a/include/deal.II/lac/parallel_block_vector.h b/include/deal.II/lac/parallel_block_vector.h
index 7d1f5440ce..2bb2f7a48d 100644
--- a/include/deal.II/lac/parallel_block_vector.h
+++ b/include/deal.II/lac/parallel_block_vector.h
@@ -52,7 +52,8 @@ namespace parallel
      * @note Instantiations for this template are provided for <tt>@<float@>
      * and @<double@></tt>; others can be generated in application programs
      * (see the section on
-     * @ref Instantiations in the manual).
+     * @ref Instantiations
+     * in the manual).
      *
      * @see
      * @ref GlossBlockLA "Block (linear algebra)"
@@ -259,8 +260,8 @@ namespace parallel
        * This function copies the data that has accumulated in the data buffer
        * for ghost indices to the owning processor. For the meaning of the
        * argument @p operation, see the entry on
-       * @ref GlossCompress "Compressing distributed vectors and matrices" in
-       * the glossary.
+       * @ref GlossCompress "Compressing distributed vectors and matrices"
+       * in the glossary.
        *
        * There are two variants for this function. If called with argument @p
        * VectorOperation::add adds all the data accumulated in ghost elements
diff --git a/include/deal.II/lac/parallel_vector.h b/include/deal.II/lac/parallel_vector.h
index 7fba3db664..a633a89ded 100644
--- a/include/deal.II/lac/parallel_vector.h
+++ b/include/deal.II/lac/parallel_vector.h
@@ -98,15 +98,15 @@ namespace parallel
      * @p insert mode of @p compress() does not set the elements included in
      * ghost entries but simply discards them, assuming that the owning
      * processor has set them to the desired value already (See also the
-     * @ref GlossCompress "glossary entry on compress"). The
-     * <code>update_ghost_values()</code> function imports the data from the
-     * owning processor to the ghost indices in order to provide read access
-     * to the data associated with ghosts. - It is possible to split the above
-     * functions into two phases, where the first initiates the communication
-     * and the second one finishes it. These functions can be used to overlap
-     * communication with computations in other parts of the code. - Of
-     * course, reduction operations (like norms) make use of collective all-
-     * to-all MPI communications.
+     * @ref GlossCompress "glossary entry on compress").
+     * The <code>update_ghost_values()</code> function imports the data from
+     * the owning processor to the ghost indices in order to provide read
+     * access to the data associated with ghosts. - It is possible to split
+     * the above functions into two phases, where the first initiates the
+     * communication and the second one finishes it. These functions can be
+     * used to overlap communication with computations in other parts of the
+     * code. - Of course, reduction operations (like norms) make use of
+     * collective all- to-all MPI communications.
      *
      * This vector can take two different states with respect to ghost
      * elements: - After creation and whenever zero_out_ghosts() is called (or
@@ -350,8 +350,8 @@ namespace parallel
        * This function copies the data that has accumulated in the data buffer
        * for ghost indices to the owning processor. For the meaning of the
        * argument @p operation, see the entry on
-       * @ref GlossCompress "Compressing distributed vectors and matrices" in
-       * the glossary.
+       * @ref GlossCompress "Compressing distributed vectors and matrices"
+       * in the glossary.
        *
        * There are two variants for this function. If called with argument @p
        * VectorOperation::add adds all the data accumulated in ghost elements
diff --git a/include/deal.II/lac/petsc_block_sparse_matrix.h b/include/deal.II/lac/petsc_block_sparse_matrix.h
index d1910090d5..42a3a2cae3 100644
--- a/include/deal.II/lac/petsc_block_sparse_matrix.h
+++ b/include/deal.II/lac/petsc_block_sparse_matrix.h
@@ -59,8 +59,7 @@ namespace PETScWrappers
    * function, for much the same reason as is documented with the
    * BlockSparsityPattern class.
    *
-   * @ingroup Matrix1
-   * @see
+   * @ingroup Matrix1 @see
    * @ref GlossBlockLA "Block (linear algebra)"
    * @author Wolfgang Bangerth, 2004
    */
diff --git a/include/deal.II/lac/petsc_matrix_base.h b/include/deal.II/lac/petsc_matrix_base.h
index 14f6fca1fc..53a5b18dfc 100644
--- a/include/deal.II/lac/petsc_matrix_base.h
+++ b/include/deal.II/lac/petsc_matrix_base.h
@@ -524,8 +524,8 @@ namespace PETScWrappers
      * function must therefore be called once you have assembled the matrix.
      *
      * See
-     * @ref GlossCompress "Compressing distributed objects" for more
-     * information.
+     * @ref GlossCompress "Compressing distributed objects"
+     * for more information.
      */
     void compress (::dealii::VectorOperation::values operation);
 
diff --git a/include/deal.II/lac/petsc_parallel_block_sparse_matrix.h b/include/deal.II/lac/petsc_parallel_block_sparse_matrix.h
index 7f09c734a6..70024ebc8c 100644
--- a/include/deal.II/lac/petsc_parallel_block_sparse_matrix.h
+++ b/include/deal.II/lac/petsc_parallel_block_sparse_matrix.h
@@ -61,8 +61,7 @@ namespace PETScWrappers
      * collect_sizes() function, for much the same reason as is documented
      * with the BlockSparsityPattern class.
      *
-     * @ingroup Matrix1
-     * @see
+     * @ingroup Matrix1 @see
      * @ref GlossBlockLA "Block (linear algebra)"
      * @author Wolfgang Bangerth, 2004
      */
diff --git a/include/deal.II/lac/petsc_precondition.h b/include/deal.II/lac/petsc_precondition.h
index f9ccd3f67e..ccee308aae 100644
--- a/include/deal.II/lac/petsc_precondition.h
+++ b/include/deal.II/lac/petsc_precondition.h
@@ -115,7 +115,8 @@ namespace PETScWrappers
    * preconditioner.
    *
    * See the comment in the base class
-   * @ref PreconditionerBase for when this preconditioner may or may not work.
+   * @ref PreconditionerBase
+   * for when this preconditioner may or may not work.
    *
    * @ingroup PETScWrappers
    * @author Wolfgang Bangerth, Timo Heister, 2004, 2011
@@ -174,7 +175,8 @@ namespace PETScWrappers
    * the relevant section of the PETSc manual, but is not implemented here.
    *
    * See the comment in the base class
-   * @ref PreconditionerBase for when this preconditioner may or may not work.
+   * @ref PreconditionerBase
+   * for when this preconditioner may or may not work.
    *
    * @ingroup PETScWrappers
    * @author Wolfgang Bangerth, Timo Heister, 2004, 2011
@@ -225,7 +227,8 @@ namespace PETScWrappers
    * preconditioner.
    *
    * See the comment in the base class
-   * @ref PreconditionerBase for when this preconditioner may or may not work.
+   * @ref PreconditionerBase
+   * for when this preconditioner may or may not work.
    *
    * @ingroup PETScWrappers
    * @author Wolfgang Bangerth, Timo Heister, 2004, 2011
@@ -286,7 +289,8 @@ namespace PETScWrappers
    * preconditioner.
    *
    * See the comment in the base class
-   * @ref PreconditionerBase for when this preconditioner may or may not work.
+   * @ref PreconditionerBase
+   * for when this preconditioner may or may not work.
    *
    * @ingroup PETScWrappers
    * @author Wolfgang Bangerth, Timo Heister, 2004, 2011
@@ -347,7 +351,8 @@ namespace PETScWrappers
    * preconditioner.
    *
    * See the comment in the base class
-   * @ref PreconditionerBase for when this preconditioner may or may not work.
+   * @ref PreconditionerBase
+   * for when this preconditioner may or may not work.
    *
    * @ingroup PETScWrappers
    * @author Wolfgang Bangerth, Timo Heister, 2004, 2011
@@ -408,7 +413,8 @@ namespace PETScWrappers
    * Cholesky preconditioner.
    *
    * See the comment in the base class
-   * @ref PreconditionerBase for when this preconditioner may or may not work.
+   * @ref PreconditionerBase
+   * for when this preconditioner may or may not work.
    *
    * @ingroup PETScWrappers
    * @author Wolfgang Bangerth, Timo Heister, 2004, 2011
@@ -469,7 +475,8 @@ namespace PETScWrappers
    * preconditioner.
    *
    * See the comment in the base class
-   * @ref PreconditionerBase for when this preconditioner may or may not work.
+   * @ref PreconditionerBase
+   * for when this preconditioner may or may not work.
    *
    * @ingroup PETScWrappers
    * @author Wolfgang Bangerth, Timo Heister, 2004, 2011
@@ -531,7 +538,8 @@ namespace PETScWrappers
    * It should provide a convenient interface to another direct solver.
    *
    * See the comment in the base class
-   * @ref PreconditionerBase for when this preconditioner may or may not work.
+   * @ref PreconditionerBase
+   * for when this preconditioner may or may not work.
    *
    * @ingroup PETScWrappers
    * @author Oliver Kayser-Herold, 2004
diff --git a/include/deal.II/lac/petsc_vector_base.h b/include/deal.II/lac/petsc_vector_base.h
index e62738ff18..a6f3392a24 100644
--- a/include/deal.II/lac/petsc_vector_base.h
+++ b/include/deal.II/lac/petsc_vector_base.h
@@ -267,8 +267,8 @@ namespace PETScWrappers
      * anything else can be done on it.
      *
      * See
-     * @ref GlossCompress "Compressing distributed objects" for more
-     * information.
+     * @ref GlossCompress "Compressing distributed objects"
+     * for more information.
      */
     void compress (::dealii::VectorOperation::values operation);
 
diff --git a/include/deal.II/lac/precondition_block.h b/include/deal.II/lac/precondition_block.h
index 422b1e61b8..4496c7ab2e 100644
--- a/include/deal.II/lac/precondition_block.h
+++ b/include/deal.II/lac/precondition_block.h
@@ -371,7 +371,8 @@ protected:
  * @note Instantiations for this template are provided for <tt>@<float@> and
  * @<double@></tt>; others can be generated in application programs (see the
  * section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2003
  */
@@ -638,7 +639,8 @@ private:
  * @note Instantiations for this template are provided for <tt>@<float@> and
  * @<double@></tt>; others can be generated in application programs (see the
  * section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2001, 2002, 2003
  */
@@ -794,7 +796,8 @@ protected:
  * @note Instantiations for this template are provided for <tt>@<float@> and
  * @<double@></tt>; others can be generated in application programs (see the
  * section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @author Ralf Hartmann, Guido Kanschat, 1999, 2000
  */
diff --git a/include/deal.II/lac/sparse_direct.h b/include/deal.II/lac/sparse_direct.h
index bc18544db3..d485b273fe 100644
--- a/include/deal.II/lac/sparse_direct.h
+++ b/include/deal.II/lac/sparse_direct.h
@@ -42,8 +42,10 @@ DEAL_II_NAMESPACE_OPEN
  * sparse LU factorization. Matrices may have symmetric or unsymmetrix
  * sparsity patterns, and may have unsymmetric entries. The use of this class
  * is explained in the
- * @ref step_22 "step-22" and
- * @ref step_29 "step-29" tutorial programs.
+ * @ref step_22 "step-22"
+ * and
+ * @ref step_29 "step-29"
+ * tutorial programs.
  *
  * This matrix class implements the usual interface of preconditioners, that
  * is a function initialize(const SparseMatrix<double>&matrix,const
diff --git a/include/deal.II/lac/sparse_ilu.h b/include/deal.II/lac/sparse_ilu.h
index dd8df2eec5..fb72d42d69 100644
--- a/include/deal.II/lac/sparse_ilu.h
+++ b/include/deal.II/lac/sparse_ilu.h
@@ -45,12 +45,14 @@ DEAL_II_NAMESPACE_OPEN
  *
  * Refer to SparseLUDecomposition documentation for suggested usage and state
  * management. This class is used in the
- * @ref step_22 "step-22" tutorial program.
+ * @ref step_22 "step-22"
+ * tutorial program.
  *
  * @note Instantiations for this template are provided for <tt>@<float@> and
  * @<double@></tt>; others can be generated in application programs (see the
  * section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @author Wolfgang Bangerth, 2008, 2009; unified interface: Ralf Hartmann
  */
diff --git a/include/deal.II/lac/sparse_matrix.h b/include/deal.II/lac/sparse_matrix.h
index 6b9e9d36c9..d8bd4762d7 100644
--- a/include/deal.II/lac/sparse_matrix.h
+++ b/include/deal.II/lac/sparse_matrix.h
@@ -481,7 +481,8 @@ namespace SparseMatrixIterators
  * @note Instantiations for this template are provided for <tt>@<float@> and
  * @<double@></tt>; others can be generated in application programs (see the
  * section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @ingroup Matrix1
  * @author Essentially everyone who has ever worked on deal.II
@@ -1068,10 +1069,11 @@ public:
    *
    * Note that while this function can operate on all vectors that offer
    * iterator classes, it is only really effective for objects of type
-   * @ref Vector. For all classes for which iterating over elements, or random
-   * member access is expensive, this function is not efficient. In
-   * particular, if you want to multiply with BlockVector objects, you should
-   * consider using a BlockSparseMatrix as well.
+   * @ref Vector.
+   * For all classes for which iterating over elements, or random member
+   * access is expensive, this function is not efficient. In particular, if
+   * you want to multiply with BlockVector objects, you should consider using
+   * a BlockSparseMatrix as well.
    *
    * Source and destination must not be the same vector.
    *
@@ -1088,10 +1090,11 @@ public:
    *
    * Note that while this function can operate on all vectors that offer
    * iterator classes, it is only really effective for objects of type
-   * @ref Vector. For all classes for which iterating over elements, or random
-   * member access is expensive, this function is not efficient. In
-   * particular, if you want to multiply with BlockVector objects, you should
-   * consider using a BlockSparseMatrix as well.
+   * @ref Vector.
+   * For all classes for which iterating over elements, or random member
+   * access is expensive, this function is not efficient. In particular, if
+   * you want to multiply with BlockVector objects, you should consider using
+   * a BlockSparseMatrix as well.
    *
    * Source and destination must not be the same vector.
    */
@@ -1105,10 +1108,11 @@ public:
    *
    * Note that while this function can operate on all vectors that offer
    * iterator classes, it is only really effective for objects of type
-   * @ref Vector. For all classes for which iterating over elements, or random
-   * member access is expensive, this function is not efficient. In
-   * particular, if you want to multiply with BlockVector objects, you should
-   * consider using a BlockSparseMatrix as well.
+   * @ref Vector.
+   * For all classes for which iterating over elements, or random member
+   * access is expensive, this function is not efficient. In particular, if
+   * you want to multiply with BlockVector objects, you should consider using
+   * a BlockSparseMatrix as well.
    *
    * Source and destination must not be the same vector.
    *
@@ -1125,10 +1129,11 @@ public:
    *
    * Note that while this function can operate on all vectors that offer
    * iterator classes, it is only really effective for objects of type
-   * @ref Vector. For all classes for which iterating over elements, or random
-   * member access is expensive, this function is not efficient. In
-   * particular, if you want to multiply with BlockVector objects, you should
-   * consider using a BlockSparseMatrix as well.
+   * @ref Vector.
+   * For all classes for which iterating over elements, or random member
+   * access is expensive, this function is not efficient. In particular, if
+   * you want to multiply with BlockVector objects, you should consider using
+   * a BlockSparseMatrix as well.
    *
    * Source and destination must not be the same vector.
    */
diff --git a/include/deal.II/lac/sparse_vanka.h b/include/deal.II/lac/sparse_vanka.h
index b25030ccc8..2fb44cf8ae 100644
--- a/include/deal.II/lac/sparse_vanka.h
+++ b/include/deal.II/lac/sparse_vanka.h
@@ -123,7 +123,8 @@ template <typename number> class SparseBlockVanka;
  * @note Instantiations for this template are provided for <tt>@<float@> and
  * @<double@></tt>; others can be generated in application programs (see the
  * section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @author Guido Kanschat, Wolfgang Bangerth; 1999, 2000
  */
diff --git a/include/deal.II/lac/sparsity_pattern.h b/include/deal.II/lac/sparsity_pattern.h
index bfd261eb78..da162197f3 100644
--- a/include/deal.II/lac/sparsity_pattern.h
+++ b/include/deal.II/lac/sparsity_pattern.h
@@ -323,8 +323,8 @@ namespace SparsityPatternIterators
 /**
  * Structure representing the sparsity pattern of a sparse matrix. This class
  * is an example of the "static" type of
- * @ref Sparsity. It uses the compressed row storage (CSR) format to store
- * data.
+ * @ref Sparsity.
+ * It uses the compressed row storage (CSR) format to store data.
  *
  * The elements of a SparsityPattern, corresponding to the places where
  * SparseMatrix objects can store nonzero entries, are stored row-by-row.
diff --git a/include/deal.II/lac/swappable_vector.h b/include/deal.II/lac/swappable_vector.h
index 291a6e11d5..bd2734ac1d 100644
--- a/include/deal.II/lac/swappable_vector.h
+++ b/include/deal.II/lac/swappable_vector.h
@@ -47,7 +47,8 @@ DEAL_II_NAMESPACE_OPEN
  * @note Instantiations for this template are provided for <tt>@<float@> and
  * @<double@></tt>; others can be generated in application programs (see the
  * section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @author Wolfgang Bangerth, 1999, 2000
  */
diff --git a/include/deal.II/lac/trilinos_block_sparse_matrix.h b/include/deal.II/lac/trilinos_block_sparse_matrix.h
index 6139035e23..026682cbc5 100644
--- a/include/deal.II/lac/trilinos_block_sparse_matrix.h
+++ b/include/deal.II/lac/trilinos_block_sparse_matrix.h
@@ -69,8 +69,7 @@ namespace TrilinosWrappers
    * function, for much the same reason as is documented with the
    * BlockSparsityPattern class.
    *
-   * @ingroup Matrix1
-   * @see
+   * @ingroup Matrix1 @see
    * @ref GlossBlockLA "Block (linear algebra)"
    * @author Martin Kronbichler, Wolfgang Bangerth, 2008
    */
diff --git a/include/deal.II/lac/trilinos_block_vector.h b/include/deal.II/lac/trilinos_block_vector.h
index ff3cb48095..a063d40a78 100644
--- a/include/deal.II/lac/trilinos_block_vector.h
+++ b/include/deal.II/lac/trilinos_block_vector.h
@@ -160,8 +160,8 @@ namespace TrilinosWrappers
      * @deprecated
      *
      * See
-     * @ref GlossCompress "Compressing distributed objects" for more
-     * information.
+     * @ref GlossCompress "Compressing distributed objects"
+     * for more information.
      */
     void compress (const Epetra_CombineMode last_action) DEAL_II_DEPRECATED;
 
diff --git a/include/deal.II/lac/trilinos_parallel_block_vector.h b/include/deal.II/lac/trilinos_parallel_block_vector.h
index 8c932dab7b..a0291b5c50 100644
--- a/include/deal.II/lac/trilinos_parallel_block_vector.h
+++ b/include/deal.II/lac/trilinos_parallel_block_vector.h
@@ -269,8 +269,8 @@ namespace TrilinosWrappers
        * @deprecated
        *
        * See
-       * @ref GlossCompress "Compressing distributed objects" for more
-       * information.
+       * @ref GlossCompress "Compressing distributed objects"
+       * for more information.
        */
       void compress (const Epetra_CombineMode last_action) DEAL_II_DEPRECATED;
 
diff --git a/include/deal.II/lac/trilinos_sparse_matrix.h b/include/deal.II/lac/trilinos_sparse_matrix.h
index 9935e28db6..52e3518408 100644
--- a/include/deal.II/lac/trilinos_sparse_matrix.h
+++ b/include/deal.II/lac/trilinos_sparse_matrix.h
@@ -1083,8 +1083,8 @@ namespace TrilinosWrappers
      * run on all processors when used in %parallel.
      *
      * See
-     * @ref GlossCompress "Compressing distributed objects" for more
-     * information.
+     * @ref GlossCompress "Compressing distributed objects"
+     * for more information.
      */
     void compress (::dealii::VectorOperation::values operation);
 
diff --git a/include/deal.II/lac/trilinos_vector.h b/include/deal.II/lac/trilinos_vector.h
index 98e30056df..c57d0929a4 100644
--- a/include/deal.II/lac/trilinos_vector.h
+++ b/include/deal.II/lac/trilinos_vector.h
@@ -200,14 +200,14 @@ namespace TrilinosWrappers
      * above.
      *
      * What we call a 'ghosted' vector (see
-     * @ref GlossGhostedVector "vectors with ghost elements" ) is simply a
-     * view of the parallel vector where the element distributions overlap.
-     * The 'ghosted' Trilinos vector in itself has no idea of which entries
-     * are ghosted and which are locally owned. In fact, a ghosted vector may
-     * not even store all of the elements a non- ghosted vector would store on
-     * the current processor.  Consequently, for Trilinos vectors, there is no
-     * notion of an 'owner' of vector elements in the way we have it in the
-     * the non-ghost case view.
+     * @ref GlossGhostedVector "vectors with ghost elements"
+     * ) is simply a view of the parallel vector where the element
+     * distributions overlap. The 'ghosted' Trilinos vector in itself has no
+     * idea of which entries are ghosted and which are locally owned. In fact,
+     * a ghosted vector may not even store all of the elements a non- ghosted
+     * vector would store on the current processor.  Consequently, for
+     * Trilinos vectors, there is no notion of an 'owner' of vector elements
+     * in the way we have it in the the non-ghost case view.
      *
      * This explains why we do not allow writing into ghosted vectors on the
      * Trilinos side: Who would be responsible for taking care of the
diff --git a/include/deal.II/lac/trilinos_vector_base.h b/include/deal.II/lac/trilinos_vector_base.h
index 5ee3ccde57..9235eec0de 100644
--- a/include/deal.II/lac/trilinos_vector_base.h
+++ b/include/deal.II/lac/trilinos_vector_base.h
@@ -277,8 +277,8 @@ namespace TrilinosWrappers
      * the last time compress() was called.
      *
      * See
-     * @ref GlossCompress "Compressing distributed objects" for more
-     * information.
+     * @ref GlossCompress "Compressing distributed objects"
+     * for more information.
      */
     void compress (::dealii::VectorOperation::values operation);
 
diff --git a/include/deal.II/lac/vector.h b/include/deal.II/lac/vector.h
index c0287497e3..176a752464 100644
--- a/include/deal.II/lac/vector.h
+++ b/include/deal.II/lac/vector.h
@@ -76,7 +76,8 @@ template <typename> class VectorView;
  * codes for compatibility and are empty there.
  *
  * See
- * @ref GlossCompress "Compressing distributed objects" for more information.
+ * @ref GlossCompress "Compressing distributed objects"
+ * for more information.
  */
 struct VectorOperation
 {
@@ -99,7 +100,8 @@ struct VectorOperation
  * @<double@>, @<long double@>, @<std::complex@<float@>@>,
  * @<std::complex@<double@>@>, @<std::complex@<long double@>@></tt>; others
  * can be generated in application programs (see the section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @author Guido Kanschat, Franz-Theo Suttmeier, Wolfgang Bangerth
  */
diff --git a/include/deal.II/lac/vector_view.h b/include/deal.II/lac/vector_view.h
index 8433c58d4f..8321d41124 100644
--- a/include/deal.II/lac/vector_view.h
+++ b/include/deal.II/lac/vector_view.h
@@ -123,7 +123,8 @@ DEAL_II_NAMESPACE_OPEN
  * @<double@>, @<long double@>, @<std::complex@<float@>@>,
  * @<std::complex@<double@>@>, @<std::complex@<long double@>@></tt>; others
  * can be generated in application programs (see the section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @author Luca Heltai, 2009
  */
diff --git a/include/deal.II/meshworker/assembler.h b/include/deal.II/meshworker/assembler.h
index 6b6aff0964..344ba2c864 100644
--- a/include/deal.II/meshworker/assembler.h
+++ b/include/deal.II/meshworker/assembler.h
@@ -94,8 +94,9 @@ namespace MeshWorker
      *
      * In the block model, each of the blocks of the local vectors corresponds
      * to the restriction of a single block of the system to this cell (
-     * @ref GlossBlock). Thus, the size of this local block is the number of
-     * degrees of freedom of the corresponding base element of the FESystem.
+     * @ref GlossBlock).
+     * Thus, the size of this local block is the number of degrees of freedom
+     * of the corresponding base element of the FESystem.
      *
      * @todo Comprehensive model currently not implemented.
      *
diff --git a/include/deal.II/multigrid/mg_base.h b/include/deal.II/multigrid/mg_base.h
index 241b7d361b..c1a3e9a5ff 100644
--- a/include/deal.II/multigrid/mg_base.h
+++ b/include/deal.II/multigrid/mg_base.h
@@ -127,14 +127,15 @@ public:
  *
  * @note For the following, it is important to realize the difference between
  * a solution
- * @ref GlossComponent "component" and a solution
- * @ref GlossBlock "block". The distinction only applies if vector valued
- * elements are used, but is quite important then. This is reflected in the
- * fact that it is not possible right now to use transfer classes based on
- * MGTransferComponentBase for genuine vector valued elements, but descendants
- * of MGTransferBlockBase would have to be applied. In the following text, we
- * will use the term <em>block</em>, but remark that it might refer to
- * components as well.
+ * @ref GlossComponent "component"
+ * and a solution
+ * @ref GlossBlock "block".
+ * The distinction only applies if vector valued elements are used, but is
+ * quite important then. This is reflected in the fact that it is not possible
+ * right now to use transfer classes based on MGTransferComponentBase for
+ * genuine vector valued elements, but descendants of MGTransferBlockBase
+ * would have to be applied. In the following text, we will use the term
+ * <em>block</em>, but remark that it might refer to components as well.
  *
  * @todo update the following documentation, since it does not reflect the
  * latest changes in structure.
diff --git a/include/deal.II/multigrid/mg_dof_iterator_selector.h b/include/deal.II/multigrid/mg_dof_iterator_selector.h
index a325dc12b0..cf39a9c26d 100644
--- a/include/deal.II/multigrid/mg_dof_iterator_selector.h
+++ b/include/deal.II/multigrid/mg_dof_iterator_selector.h
@@ -41,7 +41,8 @@ namespace internal
 
     /**
      * Iterators for MGDofHandler in one dimension. See the
-     * @ref Iterators module for more information.
+     * @ref Iterators
+     * module for more information.
      */
     template <int spacedim>
     class Iterators<1,spacedim>
@@ -75,7 +76,8 @@ namespace internal
 
     /**
      * Iterators for MGDofHandler in two dimensions. See the
-     * @ref Iterators module for more information.
+     * @ref Iterators
+     * module for more information.
      */
     template <int spacedim>
     class Iterators<2,spacedim>
@@ -109,7 +111,8 @@ namespace internal
 
     /**
      * Iterators for MGDofHandler in three dimensions. See the
-     * @ref Iterators module for more information.
+     * @ref Iterators
+     * module for more information.
      */
     template <int spacedim>
     class Iterators<3,spacedim>
diff --git a/include/deal.II/multigrid/mg_tools.h b/include/deal.II/multigrid/mg_tools.h
index d00459f61f..b02ecd5d95 100644
--- a/include/deal.II/multigrid/mg_tools.h
+++ b/include/deal.II/multigrid/mg_tools.h
@@ -90,7 +90,8 @@ namespace MGTools
   /**
    * Make a sparsity pattern including fluxes of discontinuous Galerkin
    * methods. @see
-   * @ref make_sparsity_pattern and
+   * @ref make_sparsity_pattern
+   * and
    * @ref DoFTools
    */
   template <int dim, class SparsityPattern, int spacedim>
diff --git a/include/deal.II/multigrid/mg_transfer_block.h b/include/deal.II/multigrid/mg_transfer_block.h
index 2b26d56844..13e37c8813 100644
--- a/include/deal.II/multigrid/mg_transfer_block.h
+++ b/include/deal.II/multigrid/mg_transfer_block.h
@@ -52,8 +52,8 @@ template <int dim, int spacedim> class DoFHandler;
  *
  * This is the base class for MGTransfer objects for systems of equations
  * where multigrid is applied only to one ore some blocks, where a
- * @ref GlossBlock comprises all degrees of freedom generated by one base
- * element.
+ * @ref GlossBlock
+ * comprises all degrees of freedom generated by one base element.
  *
  * @author Guido Kanschat, 2001-2003
  */
diff --git a/include/deal.II/numerics/data_out_dof_data.h b/include/deal.II/numerics/data_out_dof_data.h
index 0a4d59660c..d7131cadde 100644
--- a/include/deal.II/numerics/data_out_dof_data.h
+++ b/include/deal.II/numerics/data_out_dof_data.h
@@ -321,7 +321,8 @@ namespace internal
  * independent scalar field, or whether some of them together form logically a
  * vector-field (see the
  * DataComponentInterpretation::DataComponentInterpretation enum, and the
- * @ref step_22 "step-22" tutorial program).
+ * @ref step_22 "step-22"
+ * tutorial program).
  *
  * It should be noted that this class does not copy the vector given to it
  * through the add_data_vector() functions, for memory consumption reasons. It
diff --git a/include/deal.II/numerics/data_out_rotation.h b/include/deal.II/numerics/data_out_rotation.h
index 5beeaa5f19..8256eeb45e 100644
--- a/include/deal.II/numerics/data_out_rotation.h
+++ b/include/deal.II/numerics/data_out_rotation.h
@@ -155,8 +155,8 @@ public:
   /**
    * Return the first cell which we want output for. The default
    * implementation returns the first
-   * @ref GlossActive "active cell", but you might want to return other cells
-   * in a derived class.
+   * @ref GlossActive "active cell",
+   * but you might want to return other cells in a derived class.
    */
   virtual cell_iterator first_cell ();
 
@@ -170,7 +170,7 @@ public:
    * guaranteed as long as @p first_cell is also used from the default
    * implementation. Overloading only one of the two functions might not be a
    * good idea.
-  */
+   */
   virtual cell_iterator next_cell (const cell_iterator &cell);
 
   /**
diff --git a/include/deal.II/numerics/error_estimator.h b/include/deal.II/numerics/error_estimator.h
index 5af290fa5e..fee55c4c78 100644
--- a/include/deal.II/numerics/error_estimator.h
+++ b/include/deal.II/numerics/error_estimator.h
@@ -237,10 +237,10 @@ public:
    * finite element used by the DoFHandler object is vector-valued. You then
    * have to set those entries to true in the bit-vector @p component_mask
    * (see
-   * @ref GlossComponentMask ) for which the respective component is to be
-   * used in the error estimator. The default is to use all components, which
-   * is done by either providing a bit-vector with all-set entries, or an
-   * empty bit-vector.
+   * @ref GlossComponentMask
+   * ) for which the respective component is to be used in the error
+   * estimator. The default is to use all components, which is done by either
+   * providing a bit-vector with all-set entries, or an empty bit-vector.
    *
    * The @p subdomain_id parameter indicates whether we shall compute
    * indicators for all cells (in case its value is the default,
diff --git a/include/deal.II/numerics/fe_field_function.h b/include/deal.II/numerics/fe_field_function.h
index 8ee9f68940..c70472d80c 100644
--- a/include/deal.II/numerics/fe_field_function.h
+++ b/include/deal.II/numerics/fe_field_function.h
@@ -111,17 +111,19 @@ namespace Functions
    * will own the cell at which the solution is evaluated. Rather, it may be
    * that the cell in which this point is found is in fact a ghost or
    * artificial cell (see
-   * @ref GlossArtificialCell and
-   * @ref GlossGhostCell). If the cell is artificial, we have no access to the
-   * solution there and functions that evaluate the solution at such a point
-   * will trigger an exception of type
-   * FEFieldFunction::ExcPointNotAvailableHere. The same kind of exception
-   * will also be produced if the cell is a ghost cell: On such cells, one
-   * could in principle evaluate the solution, but it becomes easier if we do
-   * not allow to do so because then there is exactly one processor in a
-   * parallel distributed computation that can indeed evaluate the solution.
-   * Consequently, it is clear which processor is responsible for producing
-   * output if the point evaluation is done as a postprocessing step.
+   * @ref GlossArtificialCell
+   * and
+   * @ref GlossGhostCell).
+   * If the cell is artificial, we have no access to the solution there and
+   * functions that evaluate the solution at such a point will trigger an
+   * exception of type FEFieldFunction::ExcPointNotAvailableHere. The same
+   * kind of exception will also be produced if the cell is a ghost cell: On
+   * such cells, one could in principle evaluate the solution, but it becomes
+   * easier if we do not allow to do so because then there is exactly one
+   * processor in a parallel distributed computation that can indeed evaluate
+   * the solution. Consequently, it is clear which processor is responsible
+   * for producing output if the point evaluation is done as a postprocessing
+   * step.
    *
    * To deal with this situation, you will want to use code as follows when,
    * for example, evaluating the solution at the origin (here using a parallel
@@ -192,8 +194,9 @@ namespace Functions
      * parallel::distributed::Triangulation you may get an exception when
      * trying to evaluate the solution at a point that does not lie in a
      * locally owned cell (see
-     * @ref GlossLocallyOwnedCell). See the section in the general
-     * documentation of this class for more information.
+     * @ref GlossLocallyOwnedCell).
+     * See the section in the general documentation of this class for more
+     * information.
      */
     virtual void vector_value (const Point<dim> &p,
                                Vector<double>   &values) const;
@@ -211,8 +214,9 @@ namespace Functions
      * parallel::distributed::Triangulation you may get an exception when
      * trying to evaluate the solution at a point that does not lie in a
      * locally owned cell (see
-     * @ref GlossLocallyOwnedCell). See the section in the general
-     * documentation of this class for more information.
+     * @ref GlossLocallyOwnedCell).
+     * See the section in the general documentation of this class for more
+     * information.
      */
     virtual double value (const Point< dim >     &p,
                           const unsigned int  component = 0)    const;
@@ -228,8 +232,9 @@ namespace Functions
      * parallel::distributed::Triangulation you may get an exception when
      * trying to evaluate the solution at a point that does not lie in a
      * locally owned cell (see
-     * @ref GlossLocallyOwnedCell). See the section in the general
-     * documentation of this class for more information.
+     * @ref GlossLocallyOwnedCell).
+     * See the section in the general documentation of this class for more
+     * information.
      */
     virtual void value_list (const std::vector<Point< dim > >     &points,
                              std::vector< double > &values,
@@ -247,8 +252,9 @@ namespace Functions
      * parallel::distributed::Triangulation you may get an exception when
      * trying to evaluate the solution at a point that does not lie in a
      * locally owned cell (see
-     * @ref GlossLocallyOwnedCell). See the section in the general
-     * documentation of this class for more information.
+     * @ref GlossLocallyOwnedCell).
+     * See the section in the general documentation of this class for more
+     * information.
      */
     virtual void vector_value_list (const std::vector<Point< dim > >     &points,
                                     std::vector< Vector<double> > &values) const;
@@ -264,8 +270,9 @@ namespace Functions
      * parallel::distributed::Triangulation you may get an exception when
      * trying to evaluate the solution at a point that does not lie in a
      * locally owned cell (see
-     * @ref GlossLocallyOwnedCell). See the section in the general
-     * documentation of this class for more information.
+     * @ref GlossLocallyOwnedCell).
+     * See the section in the general documentation of this class for more
+     * information.
      */
     virtual void
     vector_gradient (const Point< dim > &p,
@@ -282,8 +289,9 @@ namespace Functions
      * parallel::distributed::Triangulation you may get an exception when
      * trying to evaluate the solution at a point that does not lie in a
      * locally owned cell (see
-     * @ref GlossLocallyOwnedCell). See the section in the general
-     * documentation of this class for more information.
+     * @ref GlossLocallyOwnedCell).
+     * See the section in the general documentation of this class for more
+     * information.
      */
     virtual Tensor<1,dim> gradient(const Point< dim > &p,
                                    const unsigned int component = 0)const;
@@ -297,8 +305,9 @@ namespace Functions
      * parallel::distributed::Triangulation you may get an exception when
      * trying to evaluate the solution at a point that does not lie in a
      * locally owned cell (see
-     * @ref GlossLocallyOwnedCell). See the section in the general
-     * documentation of this class for more information.
+     * @ref GlossLocallyOwnedCell).
+     * See the section in the general documentation of this class for more
+     * information.
      */
     virtual void
     vector_gradient_list (const std::vector< Point< dim > > &p,
@@ -314,8 +323,9 @@ namespace Functions
      * parallel::distributed::Triangulation you may get an exception when
      * trying to evaluate the solution at a point that does not lie in a
      * locally owned cell (see
-     * @ref GlossLocallyOwnedCell). See the section in the general
-     * documentation of this class for more information.
+     * @ref GlossLocallyOwnedCell).
+     * See the section in the general documentation of this class for more
+     * information.
      */
     virtual void
     gradient_list (const std::vector< Point< dim > > &p,
@@ -330,8 +340,9 @@ namespace Functions
      * parallel::distributed::Triangulation you may get an exception when
      * trying to evaluate the solution at a point that does not lie in a
      * locally owned cell (see
-     * @ref GlossLocallyOwnedCell). See the section in the general
-     * documentation of this class for more information.
+     * @ref GlossLocallyOwnedCell).
+     * See the section in the general documentation of this class for more
+     * information.
      */
     virtual double
     laplacian (const Point<dim>   &p,
@@ -345,8 +356,9 @@ namespace Functions
      * parallel::distributed::Triangulation you may get an exception when
      * trying to evaluate the solution at a point that does not lie in a
      * locally owned cell (see
-     * @ref GlossLocallyOwnedCell). See the section in the general
-     * documentation of this class for more information.
+     * @ref GlossLocallyOwnedCell).
+     * See the section in the general documentation of this class for more
+     * information.
      */
     virtual void
     vector_laplacian (const Point<dim>   &p,
@@ -359,8 +371,9 @@ namespace Functions
      * parallel::distributed::Triangulation you may get an exception when
      * trying to evaluate the solution at a point that does not lie in a
      * locally owned cell (see
-     * @ref GlossLocallyOwnedCell). See the section in the general
-     * documentation of this class for more information.
+     * @ref GlossLocallyOwnedCell).
+     * See the section in the general documentation of this class for more
+     * information.
      */
     virtual void
     laplacian_list (const std::vector<Point<dim> > &points,
@@ -374,8 +387,9 @@ namespace Functions
      * parallel::distributed::Triangulation you may get an exception when
      * trying to evaluate the solution at a point that does not lie in a
      * locally owned cell (see
-     * @ref GlossLocallyOwnedCell). See the section in the general
-     * documentation of this class for more information.
+     * @ref GlossLocallyOwnedCell).
+     * See the section in the general documentation of this class for more
+     * information.
      */
     virtual void
     vector_laplacian_list (const std::vector<Point<dim> > &points,
diff --git a/include/deal.II/numerics/point_value_history.h b/include/deal.II/numerics/point_value_history.h
index a40e3e2ac5..f698a997e1 100644
--- a/include/deal.II/numerics/point_value_history.h
+++ b/include/deal.II/numerics/point_value_history.h
@@ -102,20 +102,20 @@ namespace internal
  * <ol>
  * <li>Firstly, the @p evaluate_field version that does not take a @p
  * DataPostprocessor object selects the nearest support point (see
- * @ref GlossSupport "this entry in the glossary" ) to a given point to
- * extract data from. This makes the code that needs to be run at each time
- * step very short, since looping over the mesh to extract the needed
- * dof_index can be done just once at the start. However, this method is not
- * suitable for FiniteElement objects that do not assign dofs to actual mesh
- * locations (i.e. FEs without
- * @ref GlossSupport "support points" ) or if adaptive mesh refinement is
- * used. The reason for the latter restriction is that the location of the
- * closest support point to a given point may change upon mesh refinement. The
- * class will throw an exception if any change to the triangulation is made
- * (Although the nearest support point could be re- computed upon mesh
- * refinement, the location of the support point will most likely change
- * slightly, making the interpretation of the data difficult, hence this is
- * not implemented currently.)
+ * @ref GlossSupport "this entry in the glossary"
+ * ) to a given point to extract data from. This makes the code that needs to
+ * be run at each time step very short, since looping over the mesh to extract
+ * the needed dof_index can be done just once at the start. However, this
+ * method is not suitable for FiniteElement objects that do not assign dofs to
+ * actual mesh locations (i.e. FEs without
+ * @ref GlossSupport "support points"
+ * ) or if adaptive mesh refinement is used. The reason for the latter
+ * restriction is that the location of the closest support point to a given
+ * point may change upon mesh refinement. The class will throw an exception if
+ * any change to the triangulation is made (Although the nearest support point
+ * could be re- computed upon mesh refinement, the location of the support
+ * point will most likely change slightly, making the interpretation of the
+ * data difficult, hence this is not implemented currently.)
  *
  * <li> Secondly, @p evaluate_field_at_requested_location calls @p
  * VectorTools::point_value to compute values at the specific point requested.
@@ -152,17 +152,19 @@ namespace internal
  *
  * When recording a new mnemonic name, the user must supply a component_mask
  * (see
- * @ref GlossComponentMask "this glossary entry" ) to indicate the
- * @ref GlossComponent "(vector) components" to be extracted from the given
- * input. If the user simply wants to extract all the components, the mask
- * need not be explicitly supplied to the @p add_field_name method and the
- * default value of the parameter is sufficient. If the @p evaluate_field with
- * a @p DataPostprocessor object is used, the component_mask is interpreted as
- * the mask of the @p DataPostprocessor return vector. The size of this mask
- * can be different to that of the FE space, but must be provided when the @p
- * add_field_name method is called. One variant of the @p add_field_name
- * method allows an unsigned int input to construct a suitable mask, if all
- * values from the @p DataPostprocessor are desired.
+ * @ref GlossComponentMask "this glossary entry"
+ * ) to indicate the
+ * @ref GlossComponent "(vector) components"
+ * to be extracted from the given input. If the user simply wants to extract
+ * all the components, the mask need not be explicitly supplied to the @p
+ * add_field_name method and the default value of the parameter is sufficient.
+ * If the @p evaluate_field with a @p DataPostprocessor object is used, the
+ * component_mask is interpreted as the mask of the @p DataPostprocessor
+ * return vector. The size of this mask can be different to that of the FE
+ * space, but must be provided when the @p add_field_name method is called.
+ * One variant of the @p add_field_name method allows an unsigned int input to
+ * construct a suitable mask, if all values from the @p DataPostprocessor are
+ * desired.
  *
  * The class automatically generates names for the data stored based on the
  * mnemonics supplied. The methods @p add_component_names and @p
diff --git a/include/deal.II/numerics/vector_tools.h b/include/deal.II/numerics/vector_tools.h
index c14a4d1ed6..e136140243 100644
--- a/include/deal.II/numerics/vector_tools.h
+++ b/include/deal.II/numerics/vector_tools.h
@@ -312,7 +312,8 @@ class ConstraintMatrix;
  * in particular <code>Vector&lt;float&gt;, Vector&lt;double&gt;,
  * BlockVector&lt;float&gt;, BlockVector&lt;double&gt;</code>; others can be
  * generated in application code (see the section on
- * @ref Instantiations in the manual).
+ * @ref Instantiations
+ * in the manual).
  *
  * @ingroup numerics
  * @author Wolfgang Bangerth, Ralf Hartmann, Guido Kanschat, 1998, 1999, 2000,
@@ -444,7 +445,8 @@ namespace VectorTools
    * functions onto the finite element space given by the DoFHandler argument
    * where the determination which function to use is made based on the
    * material id (see
-   * @ref GlossMaterialId) of each cell.
+   * @ref GlossMaterialId)
+   * of each cell.
    *
    * @param mapping        - The mapping to use to determine the location of
    * support points at which the functions are to be evaluated.
@@ -663,10 +665,11 @@ namespace VectorTools
    * in the boundary functions and the finite element, and those components in
    * the given boundary function will be used for which the respective flag
    * was set in the component mask. See also
-   * @ref GlossComponentMask. As an example, assume that you are solving the
-   * Stokes equations in 2d, with variables $(u,v,p)$ and that you only want
-   * to interpolate boundary values for the pressure, then the component mask
-   * should correspond to <code>(true,true,false)</code>.
+   * @ref GlossComponentMask.
+   * As an example, assume that you are solving the Stokes equations in 2d,
+   * with variables $(u,v,p)$ and that you only want to interpolate boundary
+   * values for the pressure, then the component mask should correspond to
+   * <code>(true,true,false)</code>.
    *
    * @note Whether a component mask has been specified or not, the number of
    * components of the functions in @p function_map must match that of the
@@ -791,10 +794,11 @@ namespace VectorTools
    * in the boundary functions and the finite element, and those components in
    * the given boundary function will be used for which the respective flag
    * was set in the component mask. See also
-   * @ref GlossComponentMask. As an example, assume that you are solving the
-   * Stokes equations in 2d, with variables $(u,v,p)$ and that you only want
-   * to interpolate boundary values for the pressure, then the component mask
-   * should correspond to <code>(true,true,false)</code>.
+   * @ref GlossComponentMask.
+   * As an example, assume that you are solving the Stokes equations in 2d,
+   * with variables $(u,v,p)$ and that you only want to interpolate boundary
+   * values for the pressure, then the component mask should correspond to
+   * <code>(true,true,false)</code>.
    *
    * @note Whether a component mask has been specified or not, the number of
    * components of the functions in @p function_map must match that of the
@@ -906,9 +910,9 @@ namespace VectorTools
    * @param boundary_functions A map from boundary indicators to pointers to
    * functions that describe the desired values on those parts of the boundary
    * marked with this boundary indicator (see
-   * @ref GlossBoundaryIndicator "Boundary indicator"). The projection happens
-   * on only those parts of the boundary whose indicators are represented in
-   * this map.
+   * @ref GlossBoundaryIndicator "Boundary indicator").
+   * The projection happens on only those parts of the boundary whose
+   * indicators are represented in this map.
    * @param q The face quadrature used in the integration necessary to compute
    * the mass matrix and right hand side of the projection.
    * @param boundary_values The result of this function. It is a map
@@ -1721,16 +1725,18 @@ namespace VectorTools
    * there are active cells of the triangulation object of the current
    * processor. However, not all active cells are in fact locally owned: some
    * may be ghost or artificial cells (see
-   * @ref GlossGhostCell "here" and
-   * @ref GlossArtificialCell "here"). The vector computed will, in the case
-   * of a distributed triangulation, contain zeros for cells that are not
-   * locally owned. As a consequence, in order to compute the <i>global</i>
-   * $L_2$ error (for example), the errors from different processors need to
-   * be combined, but this is simple because every processor only computes
-   * contributions for those cells of the global triangulation it locally owns
-   * (and these sets are, by definition, mutually disjoint). Consequently, the
-   * following piece of code computes the global $L_2$ error across multiple
-   * processors sharing a parallel::distribute::Triangulation:
+   * @ref GlossGhostCell "here"
+   * and
+   * @ref GlossArtificialCell "here").
+   * The vector computed will, in the case of a distributed triangulation,
+   * contain zeros for cells that are not locally owned. As a consequence, in
+   * order to compute the <i>global</i> $L_2$ error (for example), the errors
+   * from different processors need to be combined, but this is simple because
+   * every processor only computes contributions for those cells of the global
+   * triangulation it locally owns (and these sets are, by definition,
+   * mutually disjoint). Consequently, the following piece of code computes
+   * the global $L_2$ error across multiple processors sharing a
+   * parallel::distribute::Triangulation:
    * @code
    *    Vector<double> local_errors (tria.n_active_cells());
    *    VectorTools::integrate_difference (mapping, dof,
@@ -2008,10 +2014,10 @@ namespace VectorTools
    * correspond to the pressure, and avoid touching all other components of
    * the vector, such as the velocity components. (Note, however, that the
    * mask is not a
-   * @ref GlossComponentMask operating on the vector components of the finite
-   * element the solution vector @p v may be associated with; rather, it is a
-   * mask on the entire vector, without reference to what the vector elements
-   * mean.)
+   * @ref GlossComponentMask
+   * operating on the vector components of the finite element the solution
+   * vector @p v may be associated with; rather, it is a mask on the entire
+   * vector, without reference to what the vector elements mean.)
    *
    * The boolean mask @p p_select has an empty vector as default value, which
    * will be interpreted as selecting all vector elements, hence, subtracting