]> https://gitweb.dealii.org/ - dealii.git/commitdiff
rewrap comments (phew)
authorTimo Heister <timo.heister@gmail.com>
Tue, 19 Nov 2013 15:14:30 +0000 (15:14 +0000)
committerTimo Heister <timo.heister@gmail.com>
Tue, 19 Nov 2013 15:14:30 +0000 (15:14 +0000)
git-svn-id: https://svn.dealii.org/trunk@31709 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/include/deal.II/fe/fe_values.h

index f1791659bf666fd1512b142c05929cfe24b91c92..994f7885f255afd4e9cb75618625ef6fe795fcf6 100644 (file)
@@ -60,19 +60,15 @@ template <typename Number> class BlockVector;
 namespace internal
 {
   /**
-   * A class whose specialization is
-   * used to define what type the
-   * curl of a vector valued function
-   * corresponds to.
+   * A class whose specialization is used to define what type the curl of a
+   * vector valued function corresponds to.
    */
   template <int dim>
   struct CurlType;
 
   /**
-   * A class whose specialization is
-   * used to define what type the
-   * curl of a vector valued function
-   * corresponds to.
+   * A class whose specialization is used to define what type the curl of a
+   * vector valued function corresponds to.
    *
    * In 1d, the curl is a scalar.
    */
@@ -83,10 +79,8 @@ namespace internal
   };
 
   /**
-   * A class whose specialization is
-   * used to define what type the
-   * curl of a vector valued function
-   * corresponds to.
+   * A class whose specialization is used to define what type the curl of a
+   * vector valued function corresponds to.
    *
    * In 2d, the curl is a scalar.
    */
@@ -97,10 +91,8 @@ namespace internal
   };
 
   /**
-   * A class whose specialization is
-   * used to define what type the
-   * curl of a vector valued function
-   * corresponds to.
+   * A class whose specialization is used to define what type the curl of a
+   * vector valued function corresponds to.
    *
    * In 3d, the curl is a vector.
    */
@@ -124,10 +116,10 @@ namespace internal
  * FEValuesExtractors objects to a FEValues, FEFaceValues or FESubfaceValues
  * objects using the square bracket operator.
  *
- * There are classes that present views for single scalar components,
- * vector components consisting of <code>dim</code> elements, and
- * symmetric second order tensor components
- * consisting of <code>(dim*dim + dim)/2</code> elements
+ * There are classes that present views for single scalar components, vector
+ * components consisting of <code>dim</code> elements, and symmetric second
+ * order tensor components consisting of <code>(dim*dim + dim)/2</code>
+ * elements
  *
  * See the description of the @ref vector_valued module for examples how to
  * use the features of this namespace.
@@ -137,16 +129,12 @@ namespace internal
 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.
+   * 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.
    *
-   * You get an object of this type if you
-   * apply a FEValuesExtractors::Scalar to an
-   * FEValues, FEFaceValues or
-   * FESubfaceValues object.
+   * You get an object of this type if you apply a FEValuesExtractors::Scalar
+   * to an FEValues, FEFaceValues or FESubfaceValues object.
    *
    * @ingroup feaccess vector_valued
    */
@@ -155,131 +143,93 @@ namespace FEValuesViews
   {
   public:
     /**
-     * A typedef for the data type of
-     * values of the view this class
-     * represents. Since we deal with a
-     * single components, the value type is
-     * a scalar double.
+     * A typedef for the data type of values of the view this class
+     * represents. Since we deal with a single components, the value type is a
+     * scalar double.
      */
     typedef double        value_type;
 
     /**
-     * A typedef for the type of gradients
-     * of the view this class
-     * represents. Here, for a scalar
-     * component of the finite element, the
-     * gradient is a
-     * <code>Tensor@<1,dim@></code>.
+     * A typedef for the type of gradients of the view this class
+     * represents. Here, for a scalar component of the finite element, the
+     * gradient is a <code>Tensor@<1,dim@></code>.
      */
     typedef dealii::Tensor<1,spacedim> gradient_type;
 
     /**
-     * A typedef for the type of second
-     * derivatives of the view this class
-     * represents. Here, for a scalar
-     * component of the finite element, the
-     * Hessian is a
-     * <code>Tensor@<2,dim@></code>.
+     * A typedef for the type of second derivatives of the view this class
+     * represents. Here, for a scalar component of the finite element, the
+     * Hessian is a <code>Tensor@<2,dim@></code>.
      */
     typedef dealii::Tensor<2,spacedim> hessian_type;
 
     /**
-     * A structure where for each shape
-     * function we pre-compute a bunch of
-     * data that will make later accesses
-     * much cheaper.
+     * A structure where for each shape function we pre-compute a bunch of
+     * data that will make later accesses much cheaper.
      */
     struct ShapeFunctionData
     {
       /**
-       * For each shape function, store
-       * whether the selected vector
-       * component may be nonzero. For
-       * primitive shape functions we
-       * know for sure whether a certain
-       * scalar component of a given
-       * shape function is nonzero,
-       * whereas for non-primitive shape
-       * functions this may not be
-       * entirely clear (e.g. for RT
-       * elements it depends on the shape
-       * of a cell).
+       * For each shape function, store whether the selected vector component
+       * may be nonzero. For primitive shape functions we know for sure
+       * whether a certain scalar component of a given shape function is
+       * nonzero, whereas for non-primitive shape functions this may not be
+       * entirely clear (e.g. for RT elements it depends on the shape of a
+       * cell).
        */
       bool is_nonzero_shape_function_component;
 
       /**
-       * For each shape function, store
-       * the row index within the
-       * shape_values, shape_gradients,
-       * and shape_hessians tables (the
-       * column index is the quadrature
-       * point index). If the shape
-       * function is primitive, then we
-       * can get this information from
-       * the shape_function_to_row_table
-       * of the FEValues object;
-       * otherwise, we have to work a bit
-       * harder to compute this
-       * information.
+       * For each shape function, store the row index within the shape_values,
+       * shape_gradients, and shape_hessians tables (the column index is the
+       * quadrature point index). If the shape function is primitive, then we
+       * can get this information from the shape_function_to_row_table of the
+       * FEValues object; otherwise, we have to work a bit harder to compute
+       * this information.
        */
       unsigned int row_index;
     };
 
     /**
-     * Default constructor. Creates an
-     * invalid object.
+     * Default constructor. Creates an invalid object.
      */
     Scalar ();
 
     /**
-     * Constructor for an object that
-     * represents a single scalar component
-     * of a FEValuesBase object (or of one
-     * of the classes derived from
+     * Constructor for an object that represents a single scalar component of
+     * a FEValuesBase object (or of one of the classes derived from
      * FEValuesBase).
      */
     Scalar (const FEValuesBase<dim,spacedim> &fe_values_base,
             const unsigned int       component);
 
     /**
-     * Copy operator. This is not a
-     * lightweight object so we don't allow
-     * copying and generate an exception if
-     * this function is called.
+     * Copy operator. This is not a lightweight object so we don't allow
+     * copying and generate an exception if this function is called.
      */
     Scalar &operator= (const Scalar<dim,spacedim> &);
 
     /**
-     * Return the value of the vector
-     * component selected by this view, for
-     * the shape function and quadrature
-     * point selected by the arguments.
+     * Return the value of the vector component selected by this view, for the
+     * shape function and quadrature point selected by the arguments.
      *
-     * @param shape_function Number
-     * of the shape function to be
-     * evaluated. Note that this
-     * number runs from zero to
-     * dofs_per_cell, even in the
-     * case of an FEFaceValues or
-     * FESubfaceValues object.
+     * @param shape_function Number of the shape function to be
+     * evaluated. Note that this number runs from zero to dofs_per_cell, even
+     * in the case of an FEFaceValues or FESubfaceValues object.
      *
-     * @param q_point Number of
-     * the quadrature point at which
-     * function is to be evaluated
+     * @param q_point Number of the quadrature point at which function is to
+     * be evaluated
      */
     value_type
     value (const unsigned int shape_function,
            const unsigned int q_point) const;
 
     /**
-     * Return the gradient (a tensor of
-     * rank 1) of the vector component
-     * selected by this view, for the shape
-     * function and quadrature point
+     * Return the gradient (a tensor of rank 1) of the vector component
+     * selected by this view, for the shape function and quadrature point
      * selected by the arguments.
      *
-     * @note The meaning of the arguments
-     * is as documented for the value()
+     * @note The meaning of the arguments is as documented for the value()
      * function.
      */
     gradient_type
@@ -287,15 +237,11 @@ namespace FEValuesViews
               const unsigned int q_point) const;
 
     /**
-     * Return the Hessian (the tensor of
-     * rank 2 of all second derivatives) of
-     * the vector component selected by
-     * this view, for the shape function
-     * and quadrature point selected by the
-     * arguments.
+     * Return the Hessian (the tensor of rank 2 of all second derivatives) of
+     * the vector component selected by this view, for the shape function and
+     * quadrature point selected by the arguments.
      *
-     * @note The meaning of the arguments
-     * is as documented for the value()
+     * @note The meaning of the arguments is as documented for the value()
      * function.
      */
     hessian_type
@@ -303,19 +249,13 @@ namespace FEValuesViews
              const unsigned int q_point) const;
 
     /**
-     * Return the values of the selected
-     * scalar component of the finite
-     * element function characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the cell, face
-     * or subface selected the last time
-     * the <tt>reinit</tt> function of the
-     * FEValues object was called.
+     * Return the values of the selected scalar component of the finite
+     * element function characterized by <tt>fe_function</tt> at the
+     * quadrature points of the cell, face or subface selected the last time
+     * the <tt>reinit</tt> function of the FEValues object was called.
      *
-     * This function is the equivalent of
-     * the
-     * FEValuesBase::get_function_values
-     * function but it only works on the
+     * This function is the equivalent of the
+     * FEValuesBase::get_function_values function but it only works on the
      * selected scalar component.
      */
     template <class InputVector>
@@ -323,19 +263,13 @@ namespace FEValuesViews
                               std::vector<value_type> &values) const;
 
     /**
-     * Return the gradients of the selected
-     * scalar component of the finite
-     * element function characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the cell, face
-     * or subface selected the last time
-     * the <tt>reinit</tt> function of the
-     * FEValues object was called.
+     * Return the gradients of the selected scalar component of the finite
+     * element function characterized by <tt>fe_function</tt> at the
+     * quadrature points of the cell, face or subface selected the last time
+     * the <tt>reinit</tt> function of the FEValues object was called.
      *
-     * This function is the equivalent of
-     * the
-     * FEValuesBase::get_function_gradients
-     * function but it only works on the
+     * This function is the equivalent of the
+     * FEValuesBase::get_function_gradients function but it only works on the
      * selected scalar component.
      */
     template <class InputVector>
@@ -343,19 +277,13 @@ namespace FEValuesViews
                                  std::vector<gradient_type> &gradients) const;
 
     /**
-     * Return the Hessians of the selected
-     * scalar component of the finite
-     * element function characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the cell, face
-     * or subface selected the last time
-     * the <tt>reinit</tt> function of the
-     * FEValues object was called.
+     * Return the Hessians of the selected scalar component of the finite
+     * element function characterized by <tt>fe_function</tt> at the
+     * quadrature points of the cell, face or subface selected the last time
+     * the <tt>reinit</tt> function of the FEValues object was called.
      *
-     * This function is the equivalent of
-     * the
-     * FEValuesBase::get_function_hessians
-     * function but it only works on the
+     * This function is the equivalent of the
+     * FEValuesBase::get_function_hessians function but it only works on the
      * selected scalar component.
      */
     template <class InputVector>
@@ -363,25 +291,15 @@ namespace FEValuesViews
                                 std::vector<hessian_type> &hessians) const;
 
     /**
-     * Return the Laplacians of the
-     * selected scalar component of
-     * the finite element function
-     * characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the
-     * cell, face or subface
-     * selected the last time the
-     * <tt>reinit</tt> function of
-     * the FEValues object was
-     * called. The Laplacians are
-     * the trace of the Hessians.
+     * Return the Laplacians of the selected scalar component of the finite
+     * element function characterized by <tt>fe_function</tt> at the
+     * quadrature points of the cell, face or subface selected the last time
+     * the <tt>reinit</tt> function of the FEValues object was called. The
+     * Laplacians are the trace of the Hessians.
      *
-     * This function is the
-     * equivalent of the
-     * FEValuesBase::get_function_laplacians
-     * function but it only works
-     * on the selected scalar
-     * component.
+     * This function is the equivalent of the
+     * FEValuesBase::get_function_laplacians function but it only works on the
+     * selected scalar component.
      */
     template <class InputVector>
     void get_function_laplacians (const InputVector &fe_function,
@@ -389,21 +307,18 @@ namespace FEValuesViews
 
   private:
     /**
-     * A reference to the FEValuesBase object
-     * we operate on.
+     * A reference to the FEValuesBase object we operate on.
      */
     const FEValuesBase<dim,spacedim> &fe_values;
 
     /**
-     * The single scalar component this
-     * view represents of the FEValuesBase
+     * The single scalar component this view represents of the FEValuesBase
      * object.
      */
     const unsigned int component;
 
     /**
-     * Store the data about shape
-     * functions.
+     * Store the data about shape functions.
      */
     std::vector<ShapeFunctionData> shape_function_data;
   };
@@ -411,50 +326,29 @@ 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.
+   * 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.
    *
-   * 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 ways
-   * under coordinate system
-   * transformations. Examples include
-   * velocity or displacement fields. This is
-   * opposed to how mathematics uses the word
-   * "vector" (and how we use this word in
-   * other contexts in the library, for
-   * example in the Vector class), where it
-   * really stands for a collection of
-   * numbers. An example of this latter use
-   * of the word could be the set of
-   * concentrations of chemical species in a
-   * flame; however, these are really just a
-   * collection of scalar variables, since
-   * they do not change if the coordinate
-   * system is rotated, unlike the components
-   * of a velocity vector, and consequently,
-   * this class should not be used for this
-   * context.
+   * 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
+   * ways under coordinate system transformations. Examples include velocity
+   * or displacement fields. This is opposed to how mathematics uses the word
+   * "vector" (and how we use this word in other contexts in the library, for
+   * example in the Vector class), where it really stands for a collection of
+   * numbers. An example of this latter use of the word could be the set of
+   * concentrations of chemical species in a flame; however, these are really
+   * just a collection of scalar variables, since they do not change if the
+   * coordinate system is rotated, unlike the components of a velocity vector,
+   * and consequently, this class should not be used for this context.
    *
-   * This class allows to query the
-   * value, gradient and divergence of
-   * (components of) shape functions
-   * and solutions representing
-   * vectors. The
-   * gradient of a vector
-   * $d_{k}, 0\le k<\text{dim}$ is
-   * defined as
-   * $S_{ij} = \frac{\partial d_{i}}{\partial x_j},
-   * 0\le i,j<\text{dim}$.
+   * This class allows to query the value, gradient and divergence of
+   * (components of) shape functions and solutions representing vectors. The
+   * gradient of a vector $d_{k}, 0\le k<\text{dim}$ is defined as $S_{ij} =
+   * \frac{\partial d_{i}}{\partial x_j}, 0\le i,j<\text{dim}$.
    *
-   * You get an object of this type if you
-   * apply a FEValuesExtractors::Vector to an
-   * FEValues, FEFaceValues or
-   * FESubfaceValues object.
+   * You get an object of this type if you apply a FEValuesExtractors::Vector
+   * to an FEValues, FEFaceValues or FESubfaceValues object.
    *
    * @ingroup feaccess vector_valued
    */
@@ -463,209 +357,144 @@ namespace FEValuesViews
   {
   public:
     /**
-     * A typedef for the data type of
-     * values of the view this class
-     * represents. Since we deal with a set
-     * of <code>dim</code> components, the
-     * value type is a Tensor<1,spacedim>.
+     * A typedef for the data type of values of the view this class
+     * represents. Since we deal with a set of <code>dim</code> components,
+     * the value type is a Tensor<1,spacedim>.
      */
     typedef dealii::Tensor<1,spacedim>          value_type;
 
     /**
-     * A typedef for the type of gradients
-     * of the view this class
-     * represents. Here, for a set of
-     * <code>dim</code> components of the
-     * finite element, the gradient is a
-     * <code>Tensor@<2,spacedim@></code>.
+     * A typedef for the type of gradients of the view this class
+     * represents. Here, for a set of <code>dim</code> components of the
+     * finite element, the gradient is a <code>Tensor@<2,spacedim@></code>.
      *
-     * See the general documentation of this class for how exactly
-     * the gradient of a vector is defined.
+     * See the general documentation of this class for how exactly the
+     * gradient of a vector is defined.
      */
     typedef dealii::Tensor<2,spacedim>          gradient_type;
 
     /**
-     * A typedef for the type of
-     * symmetrized gradients of the view
-     * this class represents. Here, for a
-     * set of <code>dim</code> components
-     * of the finite element, the
-     * symmetrized gradient is a
+     * A typedef for the type of symmetrized gradients of the view this class
+     * represents. Here, for a set of <code>dim</code> components of the
+     * finite element, the symmetrized gradient is a
      * <code>SymmetricTensor@<2,spacedim@></code>.
      *
-     * The symmetric gradient of a vector
-     * field $\mathbf v$ is defined as
-     * $\varepsilon(\mathbf v)=\frac 12
-     * (\nabla \mathbf v + \nabla \mathbf
+     * The symmetric gradient of a vector field $\mathbf v$ is defined as
+     * $\varepsilon(\mathbf v)=\frac 12 (\nabla \mathbf v + \nabla \mathbf
      * v^T)$.
      */
     typedef dealii::SymmetricTensor<2,spacedim> symmetric_gradient_type;
 
     /**
-     * A typedef for the type of the
-     * divergence of the view this class
-     * represents. Here, for a set of
-     * <code>dim</code> components of the
-     * finite element, the divergence of
-     * course is a scalar.
+     * A typedef for the type of the divergence of the view this class
+     * represents. Here, for a set of <code>dim</code> components of the
+     * finite element, the divergence of course is a scalar.
      */
     typedef double                 divergence_type;
 
     /**
-     * A typedef for the type of the
-     * curl of the view this class
-     * represents. Here, for a set of
-     * <code>spacedim=2</code> components
-     * of the finite element, the curl is
-     * a <code>Tensor@<1, 1@></code>. For
-     * <code>spacedim=3</code> it is a
-     * <code>Tensor@<1, dim@></code>.
+     * A typedef for the type of the curl of the view this class
+     * represents. Here, for a set of <code>spacedim=2</code> components of
+     * the finite element, the curl is a <code>Tensor@<1, 1@></code>. For
+     * <code>spacedim=3</code> it is a <code>Tensor@<1, dim@></code>.
      */
     typedef typename dealii::internal::CurlType<spacedim>::type   curl_type;
 
     /**
-     * A typedef for the type of second
-     * derivatives of the view this class
-     * represents. Here, for a set of
-     * <code>dim</code> components of the
-     * finite element, the Hessian is a
-     * <code>Tensor@<3,dim@></code>.
+     * A typedef for the type of second derivatives of the view this class
+     * represents. Here, for a set of <code>dim</code> components of the
+     * finite element, the Hessian is a <code>Tensor@<3,dim@></code>.
      */
     typedef dealii::Tensor<3,spacedim>          hessian_type;
 
     /**
-     * A structure where for each shape
-     * function we pre-compute a bunch of
-     * data that will make later accesses
-     * much cheaper.
+     * A structure where for each shape function we pre-compute a bunch of
+     * data that will make later accesses much cheaper.
      */
     struct ShapeFunctionData
     {
       /**
-       * For each pair (shape
-       * function,component within
-       * vector), store whether the
-       * selected vector component may be
-       * nonzero. For primitive shape
-       * functions we know for sure
-       * whether a certain scalar
-       * component of a given shape
-       * function is nonzero, whereas for
-       * non-primitive shape functions
-       * this may not be entirely clear
-       * (e.g. for RT elements it depends
-       * on the shape of a cell).
+       * For each pair (shape function,component within vector), store whether
+       * the selected vector component may be nonzero. For primitive shape
+       * functions we know for sure whether a certain scalar component of a
+       * given shape function is nonzero, whereas for non-primitive shape
+       * functions this may not be entirely clear (e.g. for RT elements it
+       * depends on the shape of a cell).
        */
       bool is_nonzero_shape_function_component[spacedim];
 
       /**
-       * For each pair (shape function,
-       * component within vector), store
-       * the row index within the
-       * shape_values, shape_gradients,
-       * and shape_hessians tables (the
-       * column index is the quadrature
-       * point index). If the shape
-       * function is primitive, then we
-       * can get this information from
-       * the shape_function_to_row_table
-       * of the FEValues object;
-       * otherwise, we have to work a bit
-       * harder to compute this
+       * For each pair (shape function, component within vector), store the
+       * row index within the shape_values, shape_gradients, and
+       * shape_hessians tables (the column index is the quadrature point
+       * index). If the shape function is primitive, then we can get this
+       * information from the shape_function_to_row_table of the FEValues
+       * object; otherwise, we have to work a bit harder to compute this
        * information.
        */
       unsigned int row_index[spacedim];
 
       /**
-       * For each shape function say the
-       * following: if only a single
-       * entry in
-       * is_nonzero_shape_function_component
-       * for this shape function is
-       * nonzero, then store the
-       * corresponding value of row_index
-       * and
-       * single_nonzero_component_index
-       * represents the index between 0
-       * and dim for which it is
-       * attained. If multiple components
-       * are nonzero, then store -1. If
-       * no components are nonzero then
-       * store -2.
+       * For each shape function say the following: if only a single entry in
+       * is_nonzero_shape_function_component for this shape function is
+       * nonzero, then store the corresponding value of row_index and
+       * single_nonzero_component_index represents the index between 0 and dim
+       * for which it is attained. If multiple components are nonzero, then
+       * store -1. If no components are nonzero then store -2.
        */
       int          single_nonzero_component;
       unsigned int single_nonzero_component_index;
     };
 
     /**
-     * Default constructor. Creates an
-     * invalid object.
+     * Default constructor. Creates an invalid object.
      */
     Vector ();
 
     /**
-     * Constructor for an object that
-     * represents dim components of a
-     * FEValuesBase object (or of one of
-     * the classes derived from
-     * FEValuesBase), representing a
-     * vector-valued variable.
+     * Constructor for an object that represents dim components of a
+     * FEValuesBase object (or of one of the classes derived from
+     * FEValuesBase), representing a vector-valued variable.
      *
-     * The second argument denotes the
-     * index of the first component of the
+     * The second argument denotes the index of the first component of the
      * selected vector.
      */
     Vector (const FEValuesBase<dim,spacedim> &fe_values_base,
             const unsigned int first_vector_component);
 
     /**
-     * Copy operator. This is not a
-     * lightweight object so we don't allow
-     * copying and generate an exception if
-     * this function is called.
+     * Copy operator. This is not a lightweight object so we don't allow
+     * copying and generate an exception if this function is called.
      */
     Vector &operator= (const Vector<dim,spacedim> &);
 
     /**
-     * Return the value of the vector
-     * components selected by this view,
-     * for the shape function and
-     * quadrature point selected by the
-     * arguments. Here, since the view
-     * represents a vector-valued part of
-     * the FEValues object with
-     * <code>dim</code> components, the
-     * return type is a tensor of rank 1
-     * with <code>dim</code> components.
+     * Return the value of the vector components selected by this view, for
+     * the shape function and quadrature point selected by the
+     * arguments. Here, since the view represents a vector-valued part of the
+     * FEValues object with <code>dim</code> components, the return type is a
+     * tensor of rank 1 with <code>dim</code> components.
      *
-     * @param shape_function Number
-     * of the shape function to be
-     * evaluated. Note that this
-     * number runs from zero to
-     * dofs_per_cell, even in the
-     * case of an FEFaceValues or
-     * FESubfaceValues object.
+     * @param shape_function Number of the shape function to be
+     * evaluated. Note that this number runs from zero to dofs_per_cell, even
+     * in the case of an FEFaceValues or FESubfaceValues object.
      *
-     * @param q_point Number of
-     * the quadrature point at which
-     * function is to be evaluated
+     * @param q_point Number of the quadrature point at which function is to
+     * be evaluated
      */
     value_type
     value (const unsigned int shape_function,
            const unsigned int q_point) const;
 
     /**
-     * Return the gradient (a tensor of
-     * rank 2) of the vector component
-     * selected by this view, for the shape
-     * function and quadrature point
+     * Return the gradient (a tensor of rank 2) of the vector component
+     * selected by this view, for the shape function and quadrature point
      * selected by the arguments.
      *
-     * See the general documentation of this class for how exactly
-     * the gradient of a vector is defined.
+     * See the general documentation of this class for how exactly the
+     * gradient of a vector is defined.
      *
-     * @note The meaning of the arguments
-     * is as documented for the value()
+     * @note The meaning of the arguments is as documented for the value()
      * function.
      */
     gradient_type
@@ -673,24 +502,16 @@ namespace FEValuesViews
               const unsigned int q_point) const;
 
     /**
-     * Return the symmetric gradient (a
-     * symmetric tensor of rank 2) of the
-     * vector component selected by this
-     * view, for the shape function and
-     * quadrature point selected by the
-     * arguments.
+     * Return the symmetric gradient (a symmetric tensor of rank 2) of the
+     * vector component selected by this view, for the shape function and
+     * quadrature point selected by the arguments.
      *
-     * The symmetric gradient is defined as
-     * $\frac 12 [(\nabla \phi_i(x_q)) +
-     * (\nabla \phi_i(x_q))^T]$, where
-     * $\phi_i$ represents the
-     * <code>dim</code> components selected
-     * from the FEValuesBase object, and
-     * $x_q$ is the location of the $q$-th
-     * quadrature point.
+     * The symmetric gradient is defined as $\frac 12 [(\nabla \phi_i(x_q)) +
+     * (\nabla \phi_i(x_q))^T]$, where $\phi_i$ represents the
+     * <code>dim</code> components selected from the FEValuesBase object, and
+     * $x_q$ is the location of the $q$-th quadrature point.
      *
-     * @note The meaning of the arguments
-     * is as documented for the value()
+     * @note The meaning of the arguments is as documented for the value()
      * function.
      */
     symmetric_gradient_type
@@ -698,14 +519,11 @@ namespace FEValuesViews
                         const unsigned int q_point) const;
 
     /**
-     * Return the scalar divergence of
-     * the vector components selected by
-     * this view, for the shape function
-     * and quadrature point selected by the
+     * Return the scalar divergence of the vector components selected by this
+     * view, for the shape function and quadrature point selected by the
      * arguments.
      *
-     * @note The meaning of the arguments
-     * is as documented for the value()
+     * @note The meaning of the arguments is as documented for the value()
      * function.
      */
     divergence_type
@@ -713,31 +531,17 @@ namespace FEValuesViews
                 const unsigned int q_point) const;
 
     /**
-     * Return the vector curl of
-     * the vector components selected by
-     * this view, for the shape function
-     * and quadrature point selected by the
-     * arguments. For 1d this function does
-     * not make any sense. Thus it is not
-     * implemented for <code>spacedim=1</code>.
-     * In 2d the curl is defined as
-     * @f{equation*}
-     * \operatorname{curl}(u):=\frac{du_2}{dx}
-     * -\frac{du_1}{dy},
-     * @f}
-     * whereas in 3d it is given by
-     * @f{equation*}
-     * \operatorname{curl}(u):=\left(
-     * \begin{array}{c}
-     * \frac{du_3}{dy}-\frac{du_2}{dz}\\
-     * \frac{du_1}{dz}-\frac{du_3}{dx}\\
-     * \frac{du_2}{dx}-\frac{du_1}{dy}
-     * \end{array}
-     * \right).
-     * @f}
+     * Return the vector curl of the vector components selected by this view,
+     * for the shape function and quadrature point selected by the
+     * arguments. For 1d this function does not make any sense. Thus it is not
+     * implemented for <code>spacedim=1</code>.  In 2d the curl is defined as
+     * @f{equation*} \operatorname{curl}(u):=\frac{du_2}{dx} -\frac{du_1}{dy},
+     * @f} whereas in 3d it is given by @f{equation*}
+     * \operatorname{curl}(u):=\left( \begin{array}{c}
+     * \frac{du_3}{dy}-\frac{du_2}{dz}\\ \frac{du_1}{dz}-\frac{du_3}{dx}\\
+     * \frac{du_2}{dx}-\frac{du_1}{dy} \end{array} \right).  @f}
      *
-     * @note The meaning of the arguments
-     * is as documented for the value()
+     * @note The meaning of the arguments is as documented for the value()
      * function.
      */
     curl_type
@@ -745,15 +549,11 @@ namespace FEValuesViews
           const unsigned int q_point) const;
 
     /**
-     * Return the Hessian (the tensor of
-     * rank 2 of all second derivatives) of
-     * the vector components selected by
-     * this view, for the shape function
-     * and quadrature point selected by the
-     * arguments.
+     * Return the Hessian (the tensor of rank 2 of all second derivatives) of
+     * the vector components selected by this view, for the shape function and
+     * quadrature point selected by the arguments.
      *
-     * @note The meaning of the arguments
-     * is as documented for the value()
+     * @note The meaning of the arguments is as documented for the value()
      * function.
      */
     hessian_type
@@ -761,19 +561,13 @@ namespace FEValuesViews
              const unsigned int q_point) const;
 
     /**
-     * Return the values of the selected
-     * vector components of the finite
-     * element function characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the cell, face
-     * or subface selected the last time
-     * the <tt>reinit</tt> function of the
-     * FEValues object was called.
+     * Return the values of the selected vector components of the finite
+     * element function characterized by <tt>fe_function</tt> at the
+     * quadrature points of the cell, face or subface selected the last time
+     * the <tt>reinit</tt> function of the FEValues object was called.
      *
-     * This function is the equivalent of
-     * the
-     * FEValuesBase::get_function_values
-     * function but it only works on the
+     * This function is the equivalent of the
+     * FEValuesBase::get_function_values function but it only works on the
      * selected vector components.
      */
     template <class InputVector>
@@ -781,19 +575,13 @@ namespace FEValuesViews
                               std::vector<value_type> &values) const;
 
     /**
-     * Return the gradients of the selected
-     * vector components of the finite
-     * element function characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the cell, face
-     * or subface selected the last time
-     * the <tt>reinit</tt> function of the
-     * FEValues object was called.
+     * Return the gradients of the selected vector components of the finite
+     * element function characterized by <tt>fe_function</tt> at the
+     * quadrature points of the cell, face or subface selected the last time
+     * the <tt>reinit</tt> function of the FEValues object was called.
      *
-     * This function is the equivalent of
-     * the
-     * FEValuesBase::get_function_gradients
-     * function but it only works on the
+     * This function is the equivalent of the
+     * FEValuesBase::get_function_gradients function but it only works on the
      * selected vector components.
      */
     template <class InputVector>
@@ -801,29 +589,19 @@ namespace FEValuesViews
                                  std::vector<gradient_type> &gradients) const;
 
     /**
-     * Return the symmetrized gradients of
-     * the selected vector components of
-     * the finite element function
-     * characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the cell, face
-     * or subface selected the last time
-     * the <tt>reinit</tt> function of the
-     * FEValues object was called.
+     * Return the symmetrized gradients of the selected vector components of
+     * the finite element function characterized by <tt>fe_function</tt> at
+     * the quadrature points of the cell, face or subface selected the last
+     * time the <tt>reinit</tt> function of the FEValues object was called.
      *
-     * The symmetric gradient of a vector
-     * field $\mathbf v$ is defined as
-     * $\varepsilon(\mathbf v)=\frac 12
-     * (\nabla \mathbf v + \nabla \mathbf
+     * The symmetric gradient of a vector field $\mathbf v$ is defined as
+     * $\varepsilon(\mathbf v)=\frac 12 (\nabla \mathbf v + \nabla \mathbf
      * v^T)$.
      *
-     * @note There is no equivalent
-     * function such as
-     * FEValuesBase::get_function_symmetric_gradients
-     * in the FEValues classes but the
-     * information can be obtained from
-     * FEValuesBase::get_function_gradients,
-     * of course.
+     * @note There is no equivalent function such as
+     * FEValuesBase::get_function_symmetric_gradients in the FEValues classes
+     * but the information can be obtained from
+     * FEValuesBase::get_function_gradients, of course.
      */
     template <class InputVector>
     void
@@ -831,21 +609,14 @@ namespace FEValuesViews
                                       std::vector<symmetric_gradient_type> &symmetric_gradients) const;
 
     /**
-     * Return the divergence of the selected
-     * vector components of the finite
-     * element function characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the cell, face
-     * or subface selected the last time
-     * the <tt>reinit</tt> function of the
-     * FEValues object was called.
+     * Return the divergence of the selected vector components of the finite
+     * element function characterized by <tt>fe_function</tt> at the
+     * quadrature points of the cell, face or subface selected the last time
+     * the <tt>reinit</tt> function of the FEValues object was called.
      *
-     * There is no equivalent function such
-     * as
-     * FEValuesBase::get_function_divergences
-     * in the FEValues classes but the
-     * information can be obtained from
-     * FEValuesBase::get_function_gradients,
+     * There is no equivalent function such as
+     * FEValuesBase::get_function_divergences in the FEValues classes but the
+     * information can be obtained from FEValuesBase::get_function_gradients,
      * of course.
      */
     template <class InputVector>
@@ -853,21 +624,14 @@ namespace FEValuesViews
                                    std::vector<divergence_type> &divergences) const;
 
     /**
-     * Return the curl of the selected
-     * vector components of the finite
-     * element function characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the cell, face
-     * or subface selected the last time
-     * the <tt>reinit</tt> function of the
-     * FEValues object was called.
+     * Return the curl of the selected vector components of the finite element
+     * function characterized by <tt>fe_function</tt> at the quadrature points
+     * of the cell, face or subface selected the last time the <tt>reinit</tt>
+     * function of the FEValues object was called.
      *
-     * There is no equivalent function such
-     * as
-     * FEValuesBase::get_function_curls
-     * in the FEValues classes but the
-     * information can be obtained from
-     * FEValuesBase::get_function_gradients,
+     * There is no equivalent function such as
+     * FEValuesBase::get_function_curls in the FEValues classes but the
+     * information can be obtained from FEValuesBase::get_function_gradients,
      * of course.
      */
     template <class InputVector>
@@ -875,19 +639,13 @@ namespace FEValuesViews
                              std::vector<curl_type> &curls) const;
 
     /**
-     * Return the Hessians of the selected
-     * vector components of the finite
-     * element function characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the cell, face
-     * or subface selected the last time
-     * the <tt>reinit</tt> function of the
-     * FEValues object was called.
+     * Return the Hessians of the selected vector components of the finite
+     * element function characterized by <tt>fe_function</tt> at the
+     * quadrature points of the cell, face or subface selected the last time
+     * the <tt>reinit</tt> function of the FEValues object was called.
      *
-     * This function is the equivalent of
-     * the
-     * FEValuesBase::get_function_hessians
-     * function but it only works on the
+     * This function is the equivalent of the
+     * FEValuesBase::get_function_hessians function but it only works on the
      * selected vector components.
      */
     template <class InputVector>
@@ -895,25 +653,15 @@ namespace FEValuesViews
                                 std::vector<hessian_type> &hessians) const;
 
     /**
-     * Return the Laplacians of the
-     * selected vector components
-     * of the finite element
-     * function characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the
-     * cell, face or subface
-     * selected the last time the
-     * <tt>reinit</tt> function of
-     * the FEValues object was
-     * called. The Laplacians are
-     * the trace of the Hessians.
+     * Return the Laplacians of the selected vector components of the finite
+     * element function characterized by <tt>fe_function</tt> at the
+     * quadrature points of the cell, face or subface selected the last time
+     * the <tt>reinit</tt> function of the FEValues object was called. The
+     * Laplacians are the trace of the Hessians.
      *
-     * This function is the
-     * equivalent of the
-     * FEValuesBase::get_function_laplacians
-     * function but it only works
-     * on the selected vector
-     * components.
+     * This function is the equivalent of the
+     * FEValuesBase::get_function_laplacians function but it only works on the
+     * selected vector components.
      */
     template <class InputVector>
     void get_function_laplacians (const InputVector &fe_function,
@@ -921,21 +669,18 @@ namespace FEValuesViews
 
   private:
     /**
-     * A reference to the FEValuesBase object
-     * we operate on.
+     * A reference to the FEValuesBase object we operate on.
      */
     const FEValuesBase<dim,spacedim> &fe_values;
 
     /**
-     * The first component of the vector
-     * this view represents of the
+     * The first component of the vector this view represents of the
      * FEValuesBase object.
      */
     const unsigned int first_vector_component;
 
     /**
-     * Store the data about shape
-     * functions.
+     * Store the data about shape functions.
      */
     std::vector<ShapeFunctionData> shape_function_data;
   };
@@ -945,34 +690,21 @@ namespace FEValuesViews
   class SymmetricTensor;
 
   /**
-   * 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.
+   * 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.
    *
-   * This class allows to query the
-   * value and divergence of
-   * (components of) shape functions
-   * and solutions representing
-   * symmetric tensors. The
-   * divergence of a symmetric tensor
-   * $S_{ij}, 0\le i,j<\text{dim}$ is
-   * defined as
-   * $d_i = \sum_j \frac{\partial S_{ij}}{\partial x_j},
-   * 0\le i<\text{dim}$,
-   * which due to the symmetry of the tensor is also
-   * $d_i = \sum_j \frac{\partial S_{ji}}{\partial x_j}$.
-   * In other words, it due to the symmetry
-   * of $S$ it does not matter whether
-   * we apply the nabla operator by row
-   * or by column to get the divergence.
+   * This class allows to query the value and divergence of (components of)
+   * shape functions and solutions representing symmetric tensors. The
+   * divergence of a symmetric tensor $S_{ij}, 0\le i,j<\text{dim}$ is defined
+   * as $d_i = \sum_j \frac{\partial S_{ij}}{\partial x_j}, 0\le
+   * i<\text{dim}$, which due to the symmetry of the tensor is also $d_i =
+   * \sum_j \frac{\partial S_{ji}}{\partial x_j}$.  In other words, it due to
+   * the symmetry of $S$ it does not matter whether we apply the nabla
+   * operator by row or by column to get the divergence.
    *
-   * You get an object of this type if you
-   * apply a
-   * FEValuesExtractors::SymmetricTensor to
-   * an FEValues, FEFaceValues or
+   * You get an object of this type if you apply a
+   * FEValuesExtractors::SymmetricTensor to an FEValues, FEFaceValues or
    * FESubfaceValues object.
    *
    * @ingroup feaccess vector_valued
@@ -984,149 +716,100 @@ namespace FEValuesViews
   {
   public:
     /**
-     * A typedef for the data type of
-     * values of the view this class
-     * represents. Since we deal with a set
-     * of <code>(dim*dim + dim)/2</code> components
-     * (i.e. the unique components of a symmetric second-order
+     * A typedef for the data type of values of the view this class
+     * represents. Since we deal with a set of <code>(dim*dim + dim)/2</code>
+     * components (i.e. the unique components of a symmetric second-order
      * tensor), the value type is a SymmetricTensor<2,spacedim>.
      */
     typedef dealii::SymmetricTensor<2, spacedim> value_type;
 
     /**
-     * A typedef for the type of the
-     * divergence of the view this class
-     * represents. Here, for a set of
-     * of <code>(dim*dim + dim)/2</code> unique components
-     * of the finite element representing a symmetric second-order
-     * tensor, the divergence of
-     * course is a * <code>Tensor@<1,dim@></code>.
+     * A typedef for the type of the divergence of the view this class
+     * represents. Here, for a set of of <code>(dim*dim + dim)/2</code> unique
+     * components of the finite element representing a symmetric second-order
+     * tensor, the divergence of course is a * <code>Tensor@<1,dim@></code>.
      *
-     * See the general discussion
-     * of this class for a
-     * definition of the
+     * See the general discussion of this class for a definition of the
      * divergence.
      */
     typedef dealii::Tensor<1, spacedim> divergence_type;
 
     /**
-     * A structure where for each shape
-     * function we pre-compute a bunch of
-     * data that will make later accesses
-     * much cheaper.
+     * A structure where for each shape function we pre-compute a bunch of
+     * data that will make later accesses much cheaper.
      */
     struct ShapeFunctionData
     {
       /**
-       * For each pair (shape
-       * function,component within
-       * vector), store whether the
-       * selected vector component may be
-       * nonzero. For primitive shape
-       * functions we know for sure
-       * whether a certain scalar
-       * component of a given shape
-       * function is nonzero, whereas for
-       * non-primitive shape functions
-       * this may not be entirely clear
-       * (e.g. for RT elements it depends
-       * on the shape of a cell).
+       * For each pair (shape function,component within vector), store whether
+       * the selected vector component may be nonzero. For primitive shape
+       * functions we know for sure whether a certain scalar component of a
+       * given shape function is nonzero, whereas for non-primitive shape
+       * functions this may not be entirely clear (e.g. for RT elements it
+       * depends on the shape of a cell).
        */
       bool is_nonzero_shape_function_component[value_type::n_independent_components];
 
       /**
-       * For each pair (shape function,
-       * component within vector), store
-       * the row index within the
-       * shape_values, shape_gradients,
-       * and shape_hessians tables (the
-       * column index is the quadrature
-       * point index). If the shape
-       * function is primitive, then we
-       * can get this information from
-       * the shape_function_to_row_table
-       * of the FEValues object;
-       * otherwise, we have to work a bit
-       * harder to compute this
+       * For each pair (shape function, component within vector), store the
+       * row index within the shape_values, shape_gradients, and
+       * shape_hessians tables (the column index is the quadrature point
+       * index). If the shape function is primitive, then we can get this
+       * information from the shape_function_to_row_table of the FEValues
+       * object; otherwise, we have to work a bit harder to compute this
        * information.
        */
       unsigned int row_index[value_type::n_independent_components];
 
       /**
-       * For each shape function say the
-       * following: if only a single
-       * entry in
-       * is_nonzero_shape_function_component
-       * for this shape function is
-       * nonzero, then store the
-       * corresponding value of row_index
-       * and
-       * single_nonzero_component_index
-       * represents the index between 0
-       * and (dim^2 + dim)/2 for which it is
-       * attained. If multiple components
-       * are nonzero, then store -1. If
-       * no components are nonzero then
-       * store -2.
+       * For each shape function say the following: if only a single entry in
+       * is_nonzero_shape_function_component for this shape function is
+       * nonzero, then store the corresponding value of row_index and
+       * single_nonzero_component_index represents the index between 0 and
+       * (dim^2 + dim)/2 for which it is attained. If multiple components are
+       * nonzero, then store -1. If no components are nonzero then store -2.
        */
       int single_nonzero_component;
       unsigned int single_nonzero_component_index;
     };
 
     /**
-     * Default constructor. Creates an
-     * invalid object.
+     * Default constructor. Creates an invalid object.
      */
     SymmetricTensor();
 
     /**
-     * Constructor for an object that
-     * represents <code>(dim*dim + dim)/2</code>
-     * components of a
-     * FEValuesBase object (or of one of
-     * the classes derived from
-     * FEValuesBase), representing the unique
-     * components comprising a symmetric second-
-     * order tensor valued variable.
+     * Constructor for an object that represents <code>(dim*dim +
+     * dim)/2</code> components of a FEValuesBase object (or of one of the
+     * classes derived from FEValuesBase), representing the unique components
+     * comprising a symmetric second- order tensor valued variable.
      *
-     * The second argument denotes the
-     * index of the first component of the
+     * The second argument denotes the index of the first component of the
      * selected symmetric second order tensor.
      */
     SymmetricTensor(const FEValuesBase<dim, spacedim> &fe_values_base,
                     const unsigned int first_tensor_component);
 
     /**
-     * Copy operator. This is not a
-     * lightweight object so we don't allow
-     * copying and generate an exception if
-     * this function is called.
+     * Copy operator. This is not a lightweight object so we don't allow
+     * copying and generate an exception if this function is called.
      */
     SymmetricTensor &operator=(const SymmetricTensor<2, dim, spacedim> &);
 
     /**
-     * Return the value of the vector
-     * components selected by this view,
-     * for the shape function and
-     * quadrature point selected by the
-     * arguments. Here, since the view
-     * represents a vector-valued part of
-     * the FEValues object with
-     * <code>(dim*dim + dim)/2</code> components
-     * (the unique components of a symmetric second-order tensor),
-     * the return type is a symmetric tensor of rank 2.
+     * Return the value of the vector components selected by this view, for
+     * the shape function and quadrature point selected by the
+     * arguments. Here, since the view represents a vector-valued part of the
+     * FEValues object with <code>(dim*dim + dim)/2</code> components (the
+     * unique components of a symmetric second-order tensor), the return type
+     * is a symmetric tensor of rank 2.
      *
-     * @param shape_function Number
-     * of the shape function to be
-     * evaluated. Note that this
-     * number runs from zero to
-     * dofs_per_cell, even in the
-     * case of an FEFaceValues or
-     * FESubfaceValues object.
+     * @param shape_function Number of the shape function to be
+     * evaluated. Note that this number runs from zero to dofs_per_cell, even
+     * in the case of an FEFaceValues or FESubfaceValues object.
      *
-     * @param q_point Number of
-     * the quadrature point at which
-     * function is to be evaluated
+     * @param q_point Number of the quadrature point at which function is to
+     * be evaluated
      */
     value_type
     value (const unsigned int shape_function,
@@ -1134,19 +817,14 @@ namespace FEValuesViews
 
 
     /**
-     * Return the vector divergence of
-     * the vector components selected by
-     * this view, for the shape function
-     * and quadrature point selected by the
+     * Return the vector divergence of the vector components selected by this
+     * view, for the shape function and quadrature point selected by the
      * arguments.
      *
-     * See the general discussion
-     * of this class for a
-     * definition of the
+     * See the general discussion of this class for a definition of the
      * divergence.
      *
-     * @note The meaning of the arguments
-     * is as documented for the value()
+     * @note The meaning of the arguments is as documented for the value()
      * function.
      */
     divergence_type
@@ -1154,19 +832,13 @@ namespace FEValuesViews
                 const unsigned int q_point) const;
 
     /**
-     * Return the values of the selected
-     * vector components of the finite
-     * element function characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the cell, face
-     * or subface selected the last time
-     * the <tt>reinit</tt> function of the
-     * FEValues object was called.
+     * Return the values of the selected vector components of the finite
+     * element function characterized by <tt>fe_function</tt> at the
+     * quadrature points of the cell, face or subface selected the last time
+     * the <tt>reinit</tt> function of the FEValues object was called.
      *
-     * This function is the equivalent of
-     * the
-     * FEValuesBase::get_function_values
-     * function but it only works on the
+     * This function is the equivalent of the
+     * FEValuesBase::get_function_values function but it only works on the
      * selected vector components.
      */
     template <class InputVector>
@@ -1174,26 +846,17 @@ namespace FEValuesViews
                               std::vector<value_type> &values) const;
 
     /**
-     * Return the divergence of the selected
-     * vector components of the finite
-     * element function characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the cell, face
-     * or subface selected the last time
-     * the <tt>reinit</tt> function of the
-     * FEValues object was called.
+     * Return the divergence of the selected vector components of the finite
+     * element function characterized by <tt>fe_function</tt> at the
+     * quadrature points of the cell, face or subface selected the last time
+     * the <tt>reinit</tt> function of the FEValues object was called.
      *
-     * There is no equivalent function such
-     * as
-     * FEValuesBase::get_function_divergences
-     * in the FEValues classes but the
-     * information can be obtained from
-     * FEValuesBase::get_function_gradients,
+     * There is no equivalent function such as
+     * FEValuesBase::get_function_divergences in the FEValues classes but the
+     * information can be obtained from FEValuesBase::get_function_gradients,
      * of course.
      *
-     * See the general discussion
-     * of this class for a
-     * definition of the
+     * See the general discussion of this class for a definition of the
      * divergence.
      */
     template <class InputVector>
@@ -1202,21 +865,18 @@ namespace FEValuesViews
 
   private:
     /**
-     * A reference to the FEValuesBase object
-     * we operate on.
+     * A reference to the FEValuesBase object we operate on.
      */
     const FEValuesBase<dim, spacedim> &fe_values;
 
     /**
-     * The first component of the vector
-     * this view represents of the
+     * The first component of the vector this view represents of the
      * FEValuesBase object.
      */
     const unsigned int first_tensor_component;
 
     /**
-     * Store the data about shape
-     * functions.
+     * Store the data about shape functions.
      */
     std::vector<ShapeFunctionData> shape_function_data;
   };
@@ -1226,29 +886,17 @@ namespace FEValuesViews
   class Tensor;
 
   /**
-   * 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.
+   * 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.
    *
-   * This class allows to query the
-   * value and divergence of
-   * (components of) shape functions
-   * and solutions representing
-   * tensors. The
-   * divergence of a tensor
-   * $T_{ij}, 0\le i,j<\text{dim}$ is
-   * defined as
-   * $d_i = \sum_j \frac{\partial T_{ji}}{\partial x_j},
-   * 0\le i<\text{dim}$.
+   * This class allows to query the value and divergence of (components of)
+   * shape functions and solutions representing tensors. The divergence of a
+   * tensor $T_{ij}, 0\le i,j<\text{dim}$ is defined as $d_i = \sum_j
+   * \frac{\partial T_{ji}}{\partial x_j}, 0\le i<\text{dim}$.
    *
-   * You get an object of this type if you
-   * apply a
-   * FEValuesExtractors::Tensor to
-   * an FEValues, FEFaceValues or
-   * FESubfaceValues object.
+   * You get an object of this type if you apply a FEValuesExtractors::Tensor
+   * to an FEValues, FEFaceValues or FESubfaceValues object.
    *
    * @ingroup feaccess vector_valued
    *
@@ -1260,8 +908,8 @@ namespace FEValuesViews
   public:
 
     /**
-     * Data type for what you get when you apply an extractor
-     * of this kind to a vector-valued finite element.
+     * Data type for what you get when you apply an extractor of this kind to
+     * a vector-valued finite element.
      */
     typedef dealii::Tensor<2, spacedim> value_type;
 
@@ -1271,88 +919,57 @@ namespace FEValuesViews
     typedef dealii::Tensor<1, spacedim> divergence_type;
 
     /**
-     * A structure where for each shape
-     * function we pre-compute a bunch of
-     * data that will make later accesses
-     * much cheaper.
+     * A structure where for each shape function we pre-compute a bunch of
+     * data that will make later accesses much cheaper.
      */
     struct ShapeFunctionData
     {
       /**
-       * For each pair (shape
-       * function,component within
-       * vector), store whether the
-       * selected vector component may be
-       * nonzero. For primitive shape
-       * functions we know for sure
-       * whether a certain scalar
-       * component of a given shape
-       * function is nonzero, whereas for
-       * non-primitive shape functions
-       * this may not be entirely clear
-       * (e.g. for RT elements it depends
-       * on the shape of a cell).
+       * For each pair (shape function,component within vector), store whether
+       * the selected vector component may be nonzero. For primitive shape
+       * functions we know for sure whether a certain scalar component of a
+       * given shape function is nonzero, whereas for non-primitive shape
+       * functions this may not be entirely clear (e.g. for RT elements it
+       * depends on the shape of a cell).
        */
       bool is_nonzero_shape_function_component[value_type::n_independent_components];
 
       /**
-       * For each pair (shape function,
-       * component within vector), store
-       * the row index within the
-       * shape_values, shape_gradients,
-       * and shape_hessians tables (the
-       * column index is the quadrature
-       * point index). If the shape
-       * function is primitive, then we
-       * can get this information from
-       * the shape_function_to_row_table
-       * of the FEValues object;
-       * otherwise, we have to work a bit
-       * harder to compute this
+       * For each pair (shape function, component within vector), store the
+       * row index within the shape_values, shape_gradients, and
+       * shape_hessians tables (the column index is the quadrature point
+       * index). If the shape function is primitive, then we can get this
+       * information from the shape_function_to_row_table of the FEValues
+       * object; otherwise, we have to work a bit harder to compute this
        * information.
        */
       unsigned int row_index[value_type::n_independent_components];
 
       /**
-       * For each shape function say the
-       * following: if only a single
-       * entry in
-       * is_nonzero_shape_function_component
-       * for this shape function is
-       * nonzero, then store the
-       * corresponding value of row_index
-       * and
-       * single_nonzero_component_index
-       * represents the index between 0
-       * and (dim^2) for which it is
-       * attained. If multiple components
-       * are nonzero, then store -1. If
-       * no components are nonzero then
-       * store -2.
+       * For each shape function say the following: if only a single entry in
+       * is_nonzero_shape_function_component for this shape function is
+       * nonzero, then store the corresponding value of row_index and
+       * single_nonzero_component_index represents the index between 0 and
+       * (dim^2) for which it is attained. If multiple components are nonzero,
+       * then store -1. If no components are nonzero then store -2.
        */
       int single_nonzero_component;
       unsigned int single_nonzero_component_index;
     };
 
     /**
-     * Default constructor. Creates an
-     * invalid object.
+     * Default constructor. Creates an invalid object.
      */
     Tensor();
 
 
     /**
-     * Constructor for an object that
-     * represents <code>(dim*dim)</code>
-     * components of a
-     * FEValuesBase object (or of one of
-     * the classes derived from
-     * FEValuesBase), representing the unique
-     * components comprising a second-order
-     * tensor valued variable.
+     * Constructor for an object that represents <code>(dim*dim)</code>
+     * components of a FEValuesBase object (or of one of the classes derived
+     * from FEValuesBase), representing the unique components comprising a
+     * second-order tensor valued variable.
      *
-     * The second argument denotes the
-     * index of the first component of the
+     * The second argument denotes the index of the first component of the
      * selected symmetric second order tensor.
      */
     Tensor(const FEValuesBase<dim, spacedim> &fe_values_base,
@@ -1360,55 +977,39 @@ namespace FEValuesViews
 
 
     /**
-     * Copy operator. This is not a
-     * lightweight object so we don't allow
-     * copying and generate an exception if
-     * this function is called.
+     * Copy operator. This is not a lightweight object so we don't allow
+     * copying and generate an exception if this function is called.
      */
     Tensor &operator=(const Tensor<2, dim, spacedim> &);
 
     /**
-     * Return the value of the vector
-     * components selected by this view,
-     * for the shape function and
-     * quadrature point selected by the
-     * arguments. Here, since the view
-     * represents a vector-valued part of
-     * the FEValues object with
-     * <code>(dim*dim)</code> components
-     * (the unique components of a second-order tensor),
-     * the return type is a tensor of rank 2.
+     * Return the value of the vector components selected by this view, for
+     * the shape function and quadrature point selected by the
+     * arguments. Here, since the view represents a vector-valued part of the
+     * FEValues object with <code>(dim*dim)</code> components (the unique
+     * components of a second-order tensor), the return type is a tensor of
+     * rank 2.
      *
-     * @param shape_function Number
-     * of the shape function to be
-     * evaluated. Note that this
-     * number runs from zero to
-     * dofs_per_cell, even in the
-     * case of an FEFaceValues or
-     * FESubfaceValues object.
+     * @param shape_function Number of the shape function to be
+     * evaluated. Note that this number runs from zero to dofs_per_cell, even
+     * in the case of an FEFaceValues or FESubfaceValues object.
      *
-     * @param q_point Number of
-     * the quadrature point at which
-     * function is to be evaluated
+     * @param q_point Number of the quadrature point at which function is to
+     * be evaluated
      */
     value_type
     value (const unsigned int shape_function,
            const unsigned int q_point) const;
 
     /**
-     * Return the vector divergence of
-     * the vector components selected by
-     * this view, for the shape function
-     * and quadrature point selected by the
+     * Return the vector divergence of the vector components selected by this
+     * view, for the shape function and quadrature point selected by the
      * arguments.
      *
-     * See the general discussion
-     * of this class for a
-     * definition of the
+     * See the general discussion of this class for a definition of the
      * divergence.
      *
-     * @note The meaning of the arguments
-     * is as documented for the value()
+     * @note The meaning of the arguments is as documented for the value()
      * function.
      */
     divergence_type
@@ -1416,19 +1017,13 @@ namespace FEValuesViews
                 const unsigned int q_point) const;
 
     /**
-     * Return the values of the selected
-     * vector components of the finite
-     * element function characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the cell, face
-     * or subface selected the last time
-     * the <tt>reinit</tt> function of the
-     * FEValues object was called.
+     * Return the values of the selected vector components of the finite
+     * element function characterized by <tt>fe_function</tt> at the
+     * quadrature points of the cell, face or subface selected the last time
+     * the <tt>reinit</tt> function of the FEValues object was called.
      *
-     * This function is the equivalent of
-     * the
-     * FEValuesBase::get_function_values
-     * function but it only works on the
+     * This function is the equivalent of the
+     * FEValuesBase::get_function_values function but it only works on the
      * selected vector components.
      */
     template <class InputVector>
@@ -1437,26 +1032,17 @@ namespace FEValuesViews
 
 
     /**
-     * Return the divergence of the selected
-     * vector components of the finite
-     * element function characterized by
-     * <tt>fe_function</tt> at the
-     * quadrature points of the cell, face
-     * or subface selected the last time
-     * the <tt>reinit</tt> function of the
-     * FEValues object was called.
+     * Return the divergence of the selected vector components of the finite
+     * element function characterized by <tt>fe_function</tt> at the
+     * quadrature points of the cell, face or subface selected the last time
+     * the <tt>reinit</tt> function of the FEValues object was called.
      *
-     * There is no equivalent function such
-     * as
-     * FEValuesBase::get_function_divergences
-     * in the FEValues classes but the
-     * information can be obtained from
-     * FEValuesBase::get_function_gradients,
+     * There is no equivalent function such as
+     * FEValuesBase::get_function_divergences in the FEValues classes but the
+     * information can be obtained from FEValuesBase::get_function_gradients,
      * of course.
      *
-     * See the general discussion
-     * of this class for a
-     * definition of the
+     * See the general discussion of this class for a definition of the
      * divergence.
      */
     template <class InputVector>
@@ -1465,21 +1051,18 @@ namespace FEValuesViews
 
   private:
     /**
-     * A reference to the FEValuesBase object
-     * we operate on.
+     * A reference to the FEValuesBase object we operate on.
      */
     const FEValuesBase<dim, spacedim> &fe_values;
 
     /**
-     * The first component of the vector
-     * this view represents of the
+     * The first component of the vector this view represents of the
      * FEValuesBase object.
      */
     const unsigned int first_tensor_component;
 
     /**
-     * Store the data about shape
-     * functions.
+     * Store the data about shape functions.
      */
     std::vector<ShapeFunctionData> shape_function_data;
   };
@@ -1492,24 +1075,18 @@ namespace internal
   namespace FEValuesViews
   {
     /**
-     * A class objects of which store a
-     * collection of FEValuesViews::Scalar,
-     * FEValuesViews::Vector, etc object. The
-     * FEValuesBase class uses it to generate
-     * all possible Views classes upon
-     * construction time; we do this at
-     * construction time since the Views
-     * classes cache some information and are
-     * therefore relatively expensive to
-     * create.
+     * A class objects of which store a collection of FEValuesViews::Scalar,
+     * FEValuesViews::Vector, etc object. The FEValuesBase class uses it to
+     * generate all possible Views classes upon construction time; we do this
+     * at construction time since the Views classes cache some information and
+     * are therefore relatively expensive to create.
      */
     template <int dim, int spacedim>
     struct Cache
     {
       /**
-       * Caches for scalar and
-       * vector, and symmetric second-order
-       * tensor valued views.
+       * Caches for scalar and vector, and symmetric second-order tensor
+       * valued views.
        */
       std::vector<dealii::FEValuesViews::Scalar<dim,spacedim> > scalars;
       std::vector<dealii::FEValuesViews::Vector<dim,spacedim> > vectors;
@@ -1532,16 +1109,15 @@ namespace internal
 //TODO: Several FEValuesBase of a system should share Mapping
 
 /**
- * Contains all data vectors for FEValues.
- * This class has been extracted from FEValuesBase to be handed
- * over to the fill functions of Mapping and
+ * Contains all data vectors for FEValues.  This class has been extracted from
+ * FEValuesBase to be handed over to the fill functions of Mapping and
  * FiniteElement.
  *
- * @note All data fields are public, but this is not
- * critical, because access to this object is private in FEValues.
+ * @note All data fields are public, but this is not critical, because access
+ * to this object is private in FEValues.
  *
- * The purpose of this class is discussed
- * on the page on @ref UpdateFlagsEssay.
+ * The purpose of this class is discussed on the page on @ref
+ * UpdateFlagsEssay.
  *
  * @ingroup feaccess
  * @author Guido Kanschat
@@ -1552,179 +1128,118 @@ class FEValuesData
 {
 public:
   /**
-   * Initialize all vectors to
-   * correct size.
+   * Initialize all vectors to correct size.
    */
   void initialize (const unsigned int        n_quadrature_points,
                    const FiniteElement<dim,spacedim> &fe,
                    const UpdateFlags         flags);
 
   /**
-   * Storage type for shape
-   * values. Each row in the matrix
-   * denotes the values of a single
-   * shape function at the
-   * different points, columns are
-   * for a single point with the
-   * different shape functions.
+   * Storage type for shape values. Each row in the matrix denotes the values
+   * of a single shape function at the different points, columns are for a
+   * single point with the different shape functions.
    *
-   * If a shape function has more
-   * than one non-zero component
-   * (in deal.II diction: it is
-   * non-primitive), then we
-   * allocate one row per non-zero
-   * component, and shift
-   * subsequent rows backward.
-   * Lookup of the correct row for
-   * a shape function is thus
-   * simple in case the entire
-   * finite element is primitive
-   * (i.e. all shape functions are
-   * primitive), since then the
-   * shape function number equals
-   * the row number. Otherwise, use
-   * the
-   * #shape_function_to_row_table
-   * array to get at the first row
-   * that belongs to this
-   * particular shape function, and
-   * navigate among all the rows
-   * for this shape function using
-   * the
-   * FiniteElement::get_nonzero_components()
-   * function which tells us which
-   * components are non-zero and
-   * thus have a row in the array
-   * presently under discussion.
+   * If a shape function has more than one non-zero component (in deal.II
+   * diction: it is non-primitive), then we allocate one row per non-zero
+   * component, and shift subsequent rows backward.  Lookup of the correct row
+   * for a shape function is thus simple in case the entire finite element is
+   * primitive (i.e. all shape functions are primitive), since then the shape
+   * function number equals the row number. Otherwise, use the
+   * #shape_function_to_row_table array to get at the first row that belongs
+   * to this particular shape function, and navigate among all the rows for
+   * this shape function using the FiniteElement::get_nonzero_components()
+   * function which tells us which components are non-zero and thus have a row
+   * in the array presently under discussion.
    */
   typedef Table<2,double> ShapeVector;
 
   /**
-   * Storage type for
-   * gradients. The layout of data
-   * is the same as for the
+   * Storage type for gradients. The layout of data is the same as for the
    * #ShapeVector data type.
    */
   typedef std::vector<std::vector<Tensor<1,spacedim> > > GradientVector;
 
   /**
-   * Likewise for second order
-   * derivatives.
+   * Likewise for second order derivatives.
    */
   typedef std::vector<std::vector<Tensor<2,spacedim> > > HessianVector;
 
   /**
-   * Store the values of the shape
-   * functions at the quadrature
-   * points. See the description of
-   * the data type for the layout
-   * of the data in this field.
+   * Store the values of the shape functions at the quadrature points. See the
+   * description of the data type for the layout of the data in this field.
    */
   ShapeVector shape_values;
 
   /**
-   * Store the gradients of the
-   * shape functions at the
-   * quadrature points. See the
-   * description of the data type
-   * for the layout of the data in
-   * this field.
+   * Store the gradients of the shape functions at the quadrature points. See
+   * the description of the data type for the layout of the data in this
+   * field.
    */
   GradientVector shape_gradients;
 
   /**
-   * Store the 2nd derivatives of
-   * the shape functions at the
-   * quadrature points.  See the
-   * description of the data type
-   * for the layout of the data in
-   * this field.
+   * Store the 2nd derivatives of the shape functions at the quadrature
+   * points.  See the description of the data type for the layout of the data
+   * in this field.
    */
   HessianVector shape_hessians;
 
   /**
-   * Store an array of weights
-   * times the Jacobi determinant
-   * at the quadrature points. This
-   * function is reset each time
-   * reinit() is called. The
-   * Jacobi determinant is actually
-   * the reciprocal value of the
-   * Jacobi matrices stored in this
-   * class, see the general
-   * documentation of this class
-   * for more information.
+   * Store an array of weights times the Jacobi determinant at the quadrature
+   * points. This function is reset each time reinit() is called. The Jacobi
+   * determinant is actually the reciprocal value of the Jacobi matrices
+   * stored in this class, see the general documentation of this class for
+   * more information.
    *
-   * However, if this object refers
-   * to an FEFaceValues or
-   * FESubfaceValues object, then
-   * the JxW_values correspond to
-   * the Jacobian of the
-   * transformation of the face,
-   * not the cell, i.e. the
-   * dimensionality is that of a
-   * surface measure, not of a
-   * volume measure. In this case,
-   * it is computed from the
-   * boundary forms, rather than
-   * the Jacobian matrix.
+   * However, if this object refers to an FEFaceValues or FESubfaceValues
+   * object, then the JxW_values correspond to the Jacobian of the
+   * transformation of the face, not the cell, i.e. the dimensionality is that
+   * of a surface measure, not of a volume measure. In this case, it is
+   * computed from the boundary forms, rather than the Jacobian matrix.
    */
   std::vector<double>       JxW_values;
 
   /**
-   * Array of the Jacobian matrices at the
-   * quadrature points.
+   * Array of the Jacobian matrices at the quadrature points.
    */
   std::vector< DerivativeForm<1,dim,spacedim> > jacobians;
 
   /**
-   * Array of the derivatives of the Jacobian
-   * matrices at the quadrature points.
+   * Array of the derivatives of the Jacobian matrices at the quadrature
+   * points.
    */
   std::vector<DerivativeForm<2,dim,spacedim> >  jacobian_grads;
 
   /**
-   * Array of the inverse Jacobian matrices
-   * at the quadrature points.
+   * Array of the inverse Jacobian matrices at the quadrature points.
    */
   std::vector<DerivativeForm<1,spacedim,dim> > inverse_jacobians;
 
   /**
-   * Array of quadrature points. This array
-   * is set up upon calling reinit() and
-   * contains the quadrature points on the
-   * real element, rather than on the
-   * reference element.
+   * Array of quadrature points. This array is set up upon calling reinit()
+   * and contains the quadrature points on the real element, rather than on
+   * the reference element.
    */
   std::vector<Point<spacedim> >  quadrature_points;
 
   /**
-   * List of outward normal vectors at the
-   * quadrature points. This field is filled
-   * in by the finite element class.
+   * List of outward normal vectors at the quadrature points. This field is
+   * filled in by the finite element class.
    */
   std::vector<Point<spacedim> >  normal_vectors;
 
   /**
-   * List of boundary forms at the
-   * quadrature points. This field is filled
-   * in by the finite element class.
+   * List of boundary forms at the quadrature points. This field is filled in
+   * by the finite element class.
    */
   std::vector<Tensor<1,spacedim> >  boundary_forms;
 
   /**
-  * When asked for the value (or
-  * gradient, or Hessian) of shape
-  * function i's c-th vector
-  * component, we need to look it
-  * up in the #shape_values,
-  * #shape_gradients and
-  * #shape_hessians arrays.  The
-  * question is where in this
-  * array does the data for shape
-  * function i, component c
-  * reside. This is what this
-  * table answers.
+  * When asked for the value (or gradient, or Hessian) of shape function i's
+  * c-th vector component, we need to look it up in the #shape_values,
+  * #shape_gradients and #shape_hessians arrays.  The question is where in
+  * this array does the data for shape function i, component c reside. This is
+  * what this table answers.
   *
   * The format of the table is as
   * follows:
@@ -1740,43 +1255,24 @@ public:
   *   corresponding datum is stored
   *   for all the quadrature points.
   *
-  * In the general, vector-valued
-  * context, the number of
-  * components is larger than one,
-  * but for a given shape
-  * function, not all vector
-  * components may be nonzero
-  * (e.g., if a shape function is
-  * primitive, then exactly one
-  * vector component is non-zero,
-  * while the others are all
-  * zero). For such zero
-  * components, #shape_values and
-  * friends do not have a
-  * row. Consequently, for vector
-  * components for which shape
-  * function i is zero, the entry
-  * in the current table is
-  * numbers::invalid_unsigned_int.
+  * In the general, vector-valued context, the number of components is larger
+  * than one, but for a given shape function, not all vector components may be
+  * nonzero (e.g., if a shape function is primitive, then exactly one vector
+  * component is non-zero, while the others are all zero). For such zero
+  * components, #shape_values and friends do not have a row. Consequently, for
+  * vector components for which shape function i is zero, the entry in the
+  * current table is numbers::invalid_unsigned_int.
   *
-  * On the other hand, the table
-  * is guaranteed to have at least
-  * one valid index for each shape
-  * function. In particular, for a
-  * primitive finite element, each
-  * shape function has exactly one
-  * nonzero component and so for
-  * each i, there is exactly one
-  * valid index within the range
-  * <code>[i*n_components,
-  * (i+1)*n_components)</code>.
+  * On the other hand, the table is guaranteed to have at least one valid
+  * index for each shape function. In particular, for a primitive finite
+  * element, each shape function has exactly one nonzero component and so for
+  * each i, there is exactly one valid index within the range
+  * <code>[i*n_components, (i+1)*n_components)</code>.
    */
   std::vector<unsigned int> shape_function_to_row_table;
 
   /**
-   * Original update flags handed
-   * to the constructor of
-   * FEValues.
+   * Original update flags handed to the constructor of FEValues.
    */
   UpdateFlags          update_flags;
 };
@@ -1878,19 +1374,18 @@ public:
  *
  * <h3>UpdateFlags</h3>
  *
- * The UpdateFlags object handed to the constructor is used to
- * determine which of the data fields to compute. This way, it is
- * possible to avoid expensive computations of useless derivatives.
- * In the beginning, these flags are processed through the functions
- * Mapping::update_once(), Mapping::update_each(),
- * FiniteElement::update_once() FiniteElement::update_each(). All the
- * results are bit-wise or'd and determine the fields actually
- * computed. This enables Mapping and FiniteElement to schedule
- * auxiliary data fields for updating. Still, it is recommended to
- * give <b>all</b> needed update flags to FEValues.
+ * The UpdateFlags object handed to the constructor is used to determine which
+ * of the data fields to compute. This way, it is possible to avoid expensive
+ * computations of useless derivatives.  In the beginning, these flags are
+ * processed through the functions Mapping::update_once(),
+ * Mapping::update_each(), FiniteElement::update_once()
+ * FiniteElement::update_each(). All the results are bit-wise or'd and
+ * determine the fields actually computed. This enables Mapping and
+ * FiniteElement to schedule auxiliary data fields for updating. Still, it is
+ * recommended to give <b>all</b> needed update flags to FEValues.
  *
- * The mechanisms by which this class works is also discussed
- * on the page on @ref UpdateFlagsEssay.
+ * The mechanisms by which this class works is also discussed on the page on
+ * @ref UpdateFlagsEssay.
  *
  * @ingroup feaccess
  * @author Wolfgang Bangerth, 1998, 2003, Guido Kanschat, 2001
@@ -1901,14 +1396,12 @@ class FEValuesBase : protected FEValuesData<dim,spacedim>,
 {
 public:
   /**
-   * Dimension in which this object
-   * operates.
+   * Dimension in which this object operates.
    */
   static const unsigned int dimension = dim;
 
   /**
-   * Dimension of the space in
-   * which this object operates.
+   * Dimension of the space in which this object operates.
    */
   static const unsigned int space_dimension = spacedim;
 
@@ -1918,30 +1411,19 @@ public:
   const unsigned int n_quadrature_points;
 
   /**
-   * Number of shape functions per
-   * cell. If we use this base
-   * class to evaluate a finite
-   * element on faces of cells,
-   * this is still the number of
-   * degrees of freedom per cell,
-   * not per face.
+   * Number of shape functions per cell. If we use this base class to evaluate
+   * a finite element on faces of cells, this is still the number of degrees
+   * of freedom per cell, not per face.
    */
   const unsigned int dofs_per_cell;
 
 
   /**
-   * Constructor. Set up the array
-   * sizes with <tt>n_q_points</tt>
-   * quadrature points, <tt>dofs_per_cell</tt>
-   * trial functions per cell and
-   * with the given pattern to
-   * update the fields when the
-   * <tt>reinit</tt> function of the
-   * derived classes is called. The
-   * fields themselves are not set
-   * up, this must happen in the
-   * constructor of the derived
-   * class.
+   * Constructor. Set up the array sizes with <tt>n_q_points</tt> quadrature
+   * points, <tt>dofs_per_cell</tt> trial functions per cell and with the
+   * given pattern to update the fields when the <tt>reinit</tt> function of
+   * the derived classes is called. The fields themselves are not set up, this
+   * must happen in the constructor of the derived class.
    */
   FEValuesBase (const unsigned int n_q_points,
                 const unsigned int dofs_per_cell,
@@ -1958,71 +1440,42 @@ public:
   //@{
 
   /**
-   * Value of a shape function at a
-   * quadrature point on the cell,
-   * face or subface selected the
-   * last time the <tt>reinit</tt>
-   * function of the derived class
-   * was called.
+   * Value of a shape function at a quadrature point on the cell, face or
+   * subface selected the last time the <tt>reinit</tt> function of the
+   * derived class was called.
    *
-   * If the shape function is
-   * vector-valued, then this
-   * returns the only non-zero
-   * component. If the shape
-   * function has more than one
-   * non-zero component (i.e. it is
-   * not primitive), then throw an
-   * exception of type
-   * ExcShapeFunctionNotPrimitive. In
-   * that case, use the
-   * shape_value_component()
-   * function.
+   * If the shape function is vector-valued, then this returns the only
+   * non-zero component. If the shape function has more than one non-zero
+   * component (i.e. it is not primitive), then throw an exception of type
+   * ExcShapeFunctionNotPrimitive. In that case, use the
+   * shape_value_component() function.
    *
-   * @param function_no Number
-   * of the shape function to be
-   * evaluated. Note that this
-   * number runs from zero to
-   * dofs_per_cell, even in the
-   * case of an FEFaceValues or
-   * FESubfaceValues object.
+   * @param function_no Number of the shape function to be evaluated. Note
+   * that this number runs from zero to dofs_per_cell, even in the case of an
+   * FEFaceValues or FESubfaceValues object.
    *
-   * @param point_no Number of
-   * the quadrature point at which
-   * function is to be evaluated
+   * @param point_no Number of the quadrature point at which function is to be
+   * evaluated
    */
   const double &shape_value (const unsigned int function_no,
                              const unsigned int point_no) const;
 
   /**
-   * Compute one vector component of
-   * the value of a shape function
-   * at a quadrature point. If the
-   * finite element is scalar, then
-   * only component zero is allowed
-   * and the return value equals
-   * that of the shape_value()
-   * function. If the finite
-   * element is vector valued but
-   * all shape functions are
-   * primitive (i.e. they are
-   * non-zero in only one
-   * component), then the value
-   * returned by shape_value()
-   * equals that of this function
-   * for exactly one
-   * component. This function is
-   * therefore only of greater
-   * interest if the shape function
-   * is not primitive, but then it
-   * is necessary since the other
+   * Compute one vector component of the value of a shape function at a
+   * quadrature point. If the finite element is scalar, then only component
+   * zero is allowed and the return value equals that of the shape_value()
+   * function. If the finite element is vector valued but all shape functions
+   * are primitive (i.e. they are non-zero in only one component), then the
+   * value returned by shape_value() equals that of this function for exactly
+   * one component. This function is therefore only of greater interest if the
+   * shape function is not primitive, but then it is necessary since the other
    * function cannot be used.
    *
-   * @param function_no Number
-   * of the shape function to be
+   * @param function_no Number of the shape function to be evaluated
+   *
+   * @param point_no Number of the quadrature point at which function is to be
    * evaluated
-   * @param point_no Number of
-   * the quadrature point at which
-   * function is to be evaluated
+   *
    * @param component vector component to be evaluated
    */
   double shape_value_component (const unsigned int function_no,
@@ -2030,37 +1483,21 @@ public:
                                 const unsigned int component) const;
 
   /**
-   * Compute the gradient of the
-   * <tt>function_no</tt>th shape function at the
-   * <tt>quadrature_point</tt>th quadrature point with
-   * respect to real cell
-   * coordinates.  If you want to
-   * get the derivative in one of
-   * the coordinate directions, use
-   * the appropriate function of
-   * the Tensor class to
-   * extract one component of the Tensor returned by this
-   * function. Since
-   * only a reference to the
-   * gradient's value is returned,
-   * there should be no major
+   * Compute the gradient of the <tt>function_no</tt>th shape function at the
+   * <tt>quadrature_point</tt>th quadrature point with respect to real cell
+   * coordinates.  If you want to get the derivative in one of the coordinate
+   * directions, use the appropriate function of the Tensor class to extract
+   * one component of the Tensor returned by this function. Since only a
+   * reference to the gradient's value is returned, there should be no major
    * performance drawback.
    *
-   * If the shape function is
-   * vector-valued, then this
-   * returns the only non-zero
-   * component. If the shape
-   * function has more than one
-   * non-zero component (i.e. it is
-   * not primitive), then it will throw an
-   * exception of type
-   * ExcShapeFunctionNotPrimitive. In
-   * that case, use the
-   * shape_grad_component()
-   * function.
+   * If the shape function is vector-valued, then this returns the only
+   * non-zero component. If the shape function has more than one non-zero
+   * component (i.e. it is not primitive), then it will throw an exception of
+   * type ExcShapeFunctionNotPrimitive. In that case, use the
+   * shape_grad_component() function.
    *
-   * The same holds for the arguments
-   * of this function as for the
+   * The same holds for the arguments of this function as for the
    * shape_value() function.
    */
   const Tensor<1,spacedim> &
@@ -2068,31 +1505,17 @@ public:
               const unsigned int quadrature_point) const;
 
   /**
-   * Return one vector component of
-   * the gradient of a shape function
-   * at a quadrature point. If the
-   * finite element is scalar, then
-   * only component zero is allowed
-   * and the return value equals
-   * that of the shape_grad()
-   * function. If the finite
-   * element is vector valued but
-   * all shape functions are
-   * primitive (i.e. they are
-   * non-zero in only one
-   * component), then the value
-   * returned by shape_grad()
-   * equals that of this function
-   * for exactly one
-   * component. This function is
-   * therefore only of greater
-   * interest if the shape function
-   * is not primitive, but then it
-   * is necessary since the other
+   * Return one vector component of the gradient of a shape function at a
+   * quadrature point. If the finite element is scalar, then only component
+   * zero is allowed and the return value equals that of the shape_grad()
+   * function. If the finite element is vector valued but all shape functions
+   * are primitive (i.e. they are non-zero in only one component), then the
+   * value returned by shape_grad() equals that of this function for exactly
+   * one component. This function is therefore only of greater interest if the
+   * shape function is not primitive, but then it is necessary since the other
    * function cannot be used.
    *
-   * The same holds for the arguments
-   * of this function as for the
+   * The same holds for the arguments of this function as for the
    * shape_value_component() function.
    */
   Tensor<1,spacedim>
@@ -2101,36 +1524,20 @@ public:
                         const unsigned int component) const;
 
   /**
-   * Second derivatives of
-   * the <tt>function_no</tt>th shape function at
-   * the <tt>point_no</tt>th quadrature point
-   * with respect to real cell
-   * coordinates. If you want to
-   * get the derivatives in one of
-   * the coordinate directions, use
-   * the appropriate function of
-   * the Tensor class to
-   * extract one component. Since
-   * only a reference to the
-   * derivative values is returned,
-   * there should be no major
-   * performance drawback.
+   * Second derivatives of the <tt>function_no</tt>th shape function at the
+   * <tt>point_no</tt>th quadrature point with respect to real cell
+   * coordinates. If you want to get the derivatives in one of the coordinate
+   * directions, use the appropriate function of the Tensor class to extract
+   * one component. Since only a reference to the derivative values is
+   * returned, there should be no major performance drawback.
    *
-   * If the shape function is
-   * vector-valued, then this
-   * returns the only non-zero
-   * component. If the shape
-   * function has more than one
-   * non-zero component (i.e. it is
-   * not primitive), then throw an
-   * exception of type
-   * ExcShapeFunctionNotPrimitive. In
-   * that case, use the
-   * shape_grad_grad_component()
-   * function.
+   * If the shape function is vector-valued, then this returns the only
+   * non-zero component. If the shape function has more than one non-zero
+   * component (i.e. it is not primitive), then throw an exception of type
+   * ExcShapeFunctionNotPrimitive. In that case, use the
+   * shape_grad_grad_component() function.
    *
-   * The same holds for the arguments
-   * of this function as for the
+   * The same holds for the arguments of this function as for the
    * shape_value() function.
    */
   const Tensor<2,spacedim> &
@@ -2146,33 +1553,17 @@ public:
 
 
   /**
-   * Return one vector component of
-   * the gradient of a shape
-   * function at a quadrature
-   * point. If the finite element
-   * is scalar, then only component
-   * zero is allowed and the return
-   * value equals that of the
-   * shape_hessian()
-   * function. If the finite
-   * element is vector valued but
-   * all shape functions are
-   * primitive (i.e. they are
-   * non-zero in only one
-   * component), then the value
-   * returned by
-   * shape_hessian()
-   * equals that of this function
-   * for exactly one
-   * component. This function is
-   * therefore only of greater
-   * interest if the shape function
-   * is not primitive, but then it
-   * is necessary since the other
-   * function cannot be used.
+   * Return one vector component of the gradient of a shape function at a
+   * quadrature point. If the finite element is scalar, then only component
+   * zero is allowed and the return value equals that of the shape_hessian()
+   * function. If the finite element is vector valued but all shape functions
+   * are primitive (i.e. they are non-zero in only one component), then the
+   * value returned by shape_hessian() equals that of this function for
+   * exactly one component. This function is therefore only of greater
+   * interest if the shape function is not primitive, but then it is necessary
+   * since the other function cannot be used.
    *
-   * The same holds for the arguments
-   * of this function as for the
+   * The same holds for the arguments of this function as for the
    * shape_value_component() function.
    */
   Tensor<2,spacedim>
@@ -2194,131 +1585,71 @@ public:
   //@{
 
   /**
-   * Returns the values of a finite
-   * element function restricted to
-   * the current cell, face or
-   * subface selected the last time
-   * the <tt>reinit</tt> function
-   * of the derived class was
-   * called, at the quadrature
-   * points.
+   * Returns the values of a finite element function restricted to the current
+   * cell, face or subface selected the last time the <tt>reinit</tt> function
+   * of the derived class was called, at the quadrature points.
    *
-   * If the present cell is not
-   * active then values are
-   * interpolated to the current
-   * cell and point values are
-   * computed from that.
+   * If the present cell is not active then values are interpolated to the
+   * current cell and point values are computed from that.
    *
-   * This function may only be used
-   * if the finite element in use
-   * is a scalar one, i.e. has only
-   * one vector component.  To get
-   * values of multi-component
-   * elements, there is another
-   * get_function_values() below,
-   * returning a vector of vectors
-   * of results.
+   * This function may only be used if the finite element in use is a scalar
+   * one, i.e. has only one vector component.  To get values of
+   * multi-component elements, there is another get_function_values() below,
+   * returning a vector of vectors of results.
    *
-   * @param[in] fe_function A
-   * vector of values that
-   * describes (globally) the
-   * finite element function that
-   * this function should evaluate
-   * at the quadrature points of
-   * the current cell.
+   * @param[in] fe_function A vector of values that describes (globally) the
+   * finite element function that this function should evaluate at the
+   * quadrature points of the current cell.
    *
-   * @param[out] values The values
-   * of the function specified by
-   * fe_function at the quadrature
-   * points of the current cell.
-   * The object is assume to
+   * @param[out] values The values of the function specified by fe_function at
+   * the quadrature points of the current cell.  The object is assume to
    * already have the correct size.
    *
-   * @post <code>values[q]</code>
-   * will contain the value of the
-   * field described by fe_function
-   * at the $q$th quadrature point.
+   * @post <code>values[q]</code> will contain the value of the field
+   * described by fe_function at the $q$th quadrature point.
    *
-   * @note The actual data type of the
-   * input vector may be either a
-   * Vector&lt;T&gt;,
-   * BlockVector&lt;T&gt;, or one
-   * of the sequential PETSc or
-   * Trilinos vector wrapper
-   * classes. It represents a
-   * global vector of DoF values
-   * associated with the DofHandler
-   * object with which this
-   * FEValues object was last
-   * initialized. Alternatively,
-   * if the vector argument is of
-   * type IndexSet, then the function
-   * is represented as one that
-   * is either zero or one, depending
-   * on whether a DoF index is in
-   * the set or not.
+   * @note The actual data type of the input vector may be either a
+   * Vector&lt;T&gt;, BlockVector&lt;T&gt;, or one of the sequential PETSc or
+   * Trilinos vector wrapper classes. It represents a global vector of DoF
+   * values associated with the DofHandler object with which this FEValues
+   * object was last initialized. Alternatively, if the vector argument is of
+   * type IndexSet, then the function is represented as one that is either
+   * zero or one, depending on whether a DoF index is in the set or not.
    */
   template <class InputVector, typename number>
   void get_function_values (const InputVector &fe_function,
                             std::vector<number> &values) const;
 
   /**
-   * This function does the same as
-   * the other
-   * get_function_values(), but
-   * applied to multi-component
-   * (vector-valued) elements. The
-   * meaning of the arguments is as
-   * explained there.
+   * This function does the same as the other get_function_values(), but
+   * applied to multi-component (vector-valued) elements. The meaning of the
+   * arguments is as explained there.
    *
-   * @post <code>values[q]</code>
-   * is a vector of values of the
-   * field described by fe_function
-   * at the $q$th quadrature
-   * point. The size of the vector
-   * accessed by
-   * <code>values[q]</code> equals
-   * the number of components of
-   * the finite element,
-   * i.e. <code>values[q](c)</code>
-   * returns the value of the $c$th
-   * vector component at the $q$th
-   * quadrature point.
+   * @post <code>values[q]</code> is a vector of values of the field described
+   * by fe_function at the $q$th quadrature point. The size of the vector
+   * accessed by <code>values[q]</code> equals the number of components of the
+   * finite element, i.e. <code>values[q](c)</code> returns the value of the
+   * $c$th vector component at the $q$th quadrature point.
    */
   template <class InputVector, typename number>
   void get_function_values (const InputVector       &fe_function,
                             std::vector<Vector<number> > &values) const;
 
   /**
-   * Generate function values from
-   * an arbitrary vector.
+   * Generate function values from an arbitrary vector.
    *
-   * This function offers the
-   * possibility to extract
-   * function values in quadrature
-   * points from vectors not
-   * corresponding to a whole
+   * This function offers the possibility to extract function values in
+   * quadrature points from vectors not corresponding to a whole
    * discretization.
    *
-   * The vector <tt>indices</tt>
-   * corresponds to the degrees of
-   * freedom on a single cell. Its
-   * length may even be a multiple
-   * of the number of dofs per
-   * cell. Then, the vectors in
-   * <tt>value</tt> should allow
-   * for the same multiple of the
-   * components of the finite
-   * element.
+   * The vector <tt>indices</tt> corresponds to the degrees of freedom on a
+   * single cell. Its length may even be a multiple of the number of dofs per
+   * cell. Then, the vectors in <tt>value</tt> should allow for the same
+   * multiple of the components of the finite element.
    *
-   * You may want to use this
-   * function, if you want to
-   * access just a single block
-   * from a BlockVector, if you
-   * have a multi-level vector or
-   * if you already have a local
-   * representation of your finite
-   * element data.
+   * You may want to use this function, if you want to access just a single
+   * block from a BlockVector, if you have a multi-level vector or if you
+   * already have a local representation of your finite element data.
    */
   template <class InputVector, typename number>
   void get_function_values (const InputVector &fe_function,
@@ -2326,42 +1657,23 @@ public:
                             std::vector<number> &values) const;
 
   /**
-   * Generate vector function
-   * values from an arbitrary
-   * vector.
+   * Generate vector function values from an arbitrary vector.
    *
-   * This function offers the
-   * possibility to extract
-   * function values in quadrature
-   * points from vectors not
-   * corresponding to a whole
+   * This function offers the possibility to extract function values in
+   * quadrature points from vectors not corresponding to a whole
    * discretization.
    *
-   * The vector <tt>indices</tt>
-   * corresponds to the degrees of
-   * freedom on a single cell. Its
-   * length may even be a multiple
-   * of the number of dofs per
-   * cell. Then, the vectors in
-   * <tt>value</tt> should allow
-   * for the same multiple of the
-   * components of the finite
-   * element.
+   * The vector <tt>indices</tt> corresponds to the degrees of freedom on a
+   * single cell. Its length may even be a multiple of the number of dofs per
+   * cell. Then, the vectors in <tt>value</tt> should allow for the same
+   * multiple of the components of the finite element.
    *
-   * You may want to use this
-   * function, if you want to
-   * access just a single block
-   * from a BlockVector, if you
-   * have a multi-level vector or
-   * if you already have a local
-   * representation of your finite
-   * element data.
+   * You may want to use this function, if you want to access just a single
+   * block from a BlockVector, if you have a multi-level vector or if you
+   * already have a local representation of your finite element data.
    *
-   * Since this function allows for
-   * fairly general combinations of
-   * argument sizes, be aware that
-   * the checks on the arguments
-   * may not detect errors.
+   * Since this function allows for fairly general combinations of argument
+   * sizes, be aware that the checks on the arguments may not detect errors.
    */
   template <class InputVector, typename number>
   void get_function_values (const InputVector &fe_function,
@@ -2370,62 +1682,32 @@ public:
 
 
   /**
-   * Generate vector function
-   * values from an arbitrary
-   * vector.
+   * Generate vector function values from an arbitrary vector.
    *
-   * This function offers the
-   * possibility to extract
-   * function values in quadrature
-   * points from vectors not
-   * corresponding to a whole
+   * This function offers the possibility to extract function values in
+   * quadrature points from vectors not corresponding to a whole
    * discretization.
    *
-   * The vector <tt>indices</tt>
-   * corresponds to the degrees of
-   * freedom on a single cell. Its
-   * length may even be a multiple
-   * of the number of dofs per
-   * cell. Then, the vectors in
-   * <tt>value</tt> should allow
-   * for the same multiple of the
-   * components of the finite
-   * element.
+   * The vector <tt>indices</tt> corresponds to the degrees of freedom on a
+   * single cell. Its length may even be a multiple of the number of dofs per
+   * cell. Then, the vectors in <tt>value</tt> should allow for the same
+   * multiple of the components of the finite element.
    *
-   * Depending on the value of the last
-   * argument, the outer vector of
-   * <tt>values</tt> has either the
-   * length of the quadrature rule
-   * (<tt>quadrature_points_fastest
-   * == false</tt>) or the length
-   * of components to be filled
-   * <tt>quadrature_points_fastest
-   * == true</tt>. If <tt>p</tt> is
-   * the current quadrature point
-   * number and <tt>i</tt> is the
-   * vector component of the
-   * solution desired, the access
-   * to <tt>values</tt> is
-   * <tt>values[p][i]</tt> if
-   * <tt>quadrature_points_fastest
-   * == false</tt>, and
-   * <tt>values[i][p]</tt>
-   * otherwise.
+   * Depending on the value of the last argument, the outer vector of
+   * <tt>values</tt> has either the length of the quadrature rule
+   * (<tt>quadrature_points_fastest == false</tt>) or the length of components
+   * to be filled <tt>quadrature_points_fastest == true</tt>. If <tt>p</tt> is
+   * the current quadrature point number and <tt>i</tt> is the vector
+   * component of the solution desired, the access to <tt>values</tt> is
+   * <tt>values[p][i]</tt> if <tt>quadrature_points_fastest == false</tt>, and
+   * <tt>values[i][p]</tt> otherwise.
    *
-   * You may want to use this
-   * function, if you want to
-   * access just a single block
-   * from a BlockVector, if you
-   * have a multi-level vector or
-   * if you already have a local
-   * representation of your finite
-   * element data.
+   * You may want to use this function, if you want to access just a single
+   * block from a BlockVector, if you have a multi-level vector or if you
+   * already have a local representation of your finite element data.
    *
-   * Since this function allows for
-   * fairly general combinations of
-   * argument sizes, be aware that
-   * the checks on the arguments
-   * may not detect errors.
+   * Since this function allows for fairly general combinations of argument
+   * sizes, be aware that the checks on the arguments may not detect errors.
    */
   template <class InputVector>
   void get_function_values (const InputVector &fe_function,
@@ -2438,118 +1720,62 @@ public:
   //@{
 
   /**
-   * Compute the gradients of a
-   * finite element at the
-   * quadrature points of a
-   * cell. This function is the
-   * equivalent of the
-   * corresponding
-   * get_function_values() function
-   * (see there for more
-   * information) but evaluates the
-   * finite element field's
-   * gradient instead of its value.
+   * Compute the gradients of a finite element at the quadrature points of a
+   * cell. This function is the equivalent of the corresponding
+   * get_function_values() function (see there for more information) but
+   * evaluates the finite element field's gradient instead of its value.
    *
-   * This function may only be used
-   * if the finite element in use
-   * is a scalar one, i.e. has only
-   * one vector component. There is
-   * a corresponding function of
-   * the same name for
-   * vector-valued finite elements.
+   * This function may only be used if the finite element in use is a scalar
+   * one, i.e. has only one vector component. There is a corresponding
+   * function of the same name for vector-valued finite elements.
    *
-   * @param[in] fe_function A
-   * vector of values that
-   * describes (globally) the
-   * finite element function that
-   * this function should evaluate
-   * at the quadrature points of
-   * the current cell.
+   * @param[in] fe_function A vector of values that describes (globally) the
+   * finite element function that this function should evaluate at the
+   * quadrature points of the current cell.
    *
-   * @param[out] gradients The gradients
-   * of the function specified by
-   * fe_function at the quadrature
-   * points of the current cell.
-   * The gradients are computed
-   * in real space (as opposed to
-   * on the unit cell).
-   * The object is assume to
-   * already have the correct size.
+   * @param[out] gradients The gradients of the function specified by
+   * fe_function at the quadrature points of the current cell.  The gradients
+   * are computed in real space (as opposed to on the unit cell).  The object
+   * is assume to already have the correct size.
    *
-   * @post
-   * <code>gradients[q]</code> will
-   * contain the gradient of the
-   * field described by fe_function
-   * at the $q$th quadrature
-   * point. <code>gradients[q][d]</code>
-   * represents the derivative in
-   * coordinate direction $d$ at
-   * quadrature point $q$.
+   * @post <code>gradients[q]</code> will contain the gradient of the field
+   * described by fe_function at the $q$th quadrature
+   * point. <code>gradients[q][d]</code> represents the derivative in
+   * coordinate direction $d$ at quadrature point $q$.
    *
-   * @note The actual data type of the
-   * input vector may be either a
-   * Vector&lt;T&gt;,
-   * BlockVector&lt;T&gt;, or one
-   * of the sequential PETSc or
-   * Trilinos vector wrapper
-   * classes. It represents a
-   * global vector of DoF values
-   * associated with the DofHandler
-   * object with which this
-   * FEValues object was last
-   * initialized. Alternatively,
-   * if the vector argument is of
-   * type IndexSet, then the function
-   * is represented as one that
-   * is either zero or one, depending
-   * on whether a DoF index is in
-   * the set or not.
+   * @note The actual data type of the input vector may be either a
+   * Vector&lt;T&gt;, BlockVector&lt;T&gt;, or one of the sequential PETSc or
+   * Trilinos vector wrapper classes. It represents a global vector of DoF
+   * values associated with the DofHandler object with which this FEValues
+   * object was last initialized. Alternatively, if the vector argument is of
+   * type IndexSet, then the function is represented as one that is either
+   * zero or one, depending on whether a DoF index is in the set or not.
    */
   template <class InputVector>
   void get_function_gradients (const InputVector      &fe_function,
                                std::vector<Tensor<1,spacedim> > &gradients) const;
 
   /**
-   * This function does the same as
-   * the other
-   * get_function_gradients(), but
-   * applied to multi-component
-   * (vector-valued) elements. The
-   * meaning of the arguments is as
-   * explained there.
+   * This function does the same as the other get_function_gradients(), but
+   * applied to multi-component (vector-valued) elements. The meaning of the
+   * arguments is as explained there.
    *
-   * @post
-   * <code>gradients[q]</code> is a
-   * vector of gradients of the
-   * field described by fe_function
-   * at the $q$th quadrature
-   * point. The size of the vector
-   * accessed by
-   * <code>gradients[q]</code>
-   * equals the number of
-   * components of the finite
-   * element,
-   * i.e. <code>gradients[q][c]</code>
-   * returns the gradient of the
-   * $c$th vector component at the
-   * $q$th quadrature
-   * point. Consequently,
-   * <code>gradients[q][c][d]</code>
-   * is the derivative in
-   * coordinate direction $d$ of
-   * the $c$th vector component of
-   * the vector field at quadrature
-   * point $q$ of the current cell.
+   * @post <code>gradients[q]</code> is a vector of gradients of the field
+   * described by fe_function at the $q$th quadrature point. The size of the
+   * vector accessed by <code>gradients[q]</code> equals the number of
+   * components of the finite element, i.e. <code>gradients[q][c]</code>
+   * returns the gradient of the $c$th vector component at the $q$th
+   * quadrature point. Consequently, <code>gradients[q][c][d]</code> is the
+   * derivative in coordinate direction $d$ of the $c$th vector component of
+   * the vector field at quadrature point $q$ of the current cell.
    */
   template <class InputVector>
   void get_function_gradients (const InputVector               &fe_function,
                                std::vector<std::vector<Tensor<1,spacedim> > > &gradients) const;
 
   /**
-   * Function gradient access with
-   * more flexibility. see
-   * get_function_values() with
-   * corresponding arguments.
+   * Function gradient access with more flexibility. see get_function_values()
+   * with corresponding arguments.
    */
   template <class InputVector>
   void get_function_gradients (const InputVector &fe_function,
@@ -2557,10 +1783,8 @@ public:
                                std::vector<Tensor<1,spacedim> > &gradients) const;
 
   /**
-   * Function gradient access with
-   * more flexibility. see
-   * get_function_values() with
-   * corresponding arguments.
+   * Function gradient access with more flexibility. see get_function_values()
+   * with corresponding arguments.
    */
   template <class InputVector>
   void get_function_gradients (const InputVector &fe_function,
@@ -2569,24 +1793,21 @@ public:
                                bool quadrature_points_fastest = false) const;
 
   /**
-   * @deprecated Use
-   * get_function_gradients() instead.
+   * @deprecated Use get_function_gradients() instead.
    */
   template <class InputVector>
   void get_function_grads (const InputVector      &fe_function,
                            std::vector<Tensor<1,spacedim> > &gradients) const DEAL_II_DEPRECATED;
 
   /**
-   * @deprecated Use
-   * get_function_gradients() instead.
+   * @deprecated Use get_function_gradients() instead.
    */
   template <class InputVector>
   void get_function_grads (const InputVector               &fe_function,
                            std::vector<std::vector<Tensor<1,spacedim> > > &gradients) const DEAL_II_DEPRECATED;
 
   /**
-   * @deprecated Use
-   * get_function_gradients() instead.
+   * @deprecated Use get_function_gradients() instead.
    */
   template <class InputVector>
   void get_function_grads (const InputVector &fe_function,
@@ -2594,8 +1815,7 @@ public:
                            std::vector<Tensor<1,spacedim> > &gradients) const DEAL_II_DEPRECATED;
 
   /**
-   * @deprecated Use
-   * get_function_gradients() instead.
+   * @deprecated Use get_function_gradients() instead.
    */
   template <class InputVector>
   void get_function_grads (const InputVector &fe_function,
@@ -2608,74 +1828,37 @@ public:
   //@{
 
   /**
-   * Compute the tensor of second
-   * derivatives of a finite
-   * element at the quadrature
-   * points of a cell. This
-   * function is the equivalent of
-   * the corresponding
-   * get_function_values() function
-   * (see there for more
-   * information) but evaluates the
-   * finite element field's second
-   * derivatives instead of its
-   * value.
+   * Compute the tensor of second derivatives of a finite element at the
+   * quadrature points of a cell. This function is the equivalent of the
+   * corresponding get_function_values() function (see there for more
+   * information) but evaluates the finite element field's second derivatives
+   * instead of its value.
    *
-   * This function may only be used
-   * if the finite element in use
-   * is a scalar one, i.e. has only
-   * one vector component. There is
-   * a corresponding function of
-   * the same name for
-   * vector-valued finite elements.
+   * This function may only be used if the finite element in use is a scalar
+   * one, i.e. has only one vector component. There is a corresponding
+   * function of the same name for vector-valued finite elements.
    *
-   * @param[in] fe_function A
-   * vector of values that
-   * describes (globally) the
-   * finite element function that
-   * this function should evaluate
-   * at the quadrature points of
-   * the current cell.
+   * @param[in] fe_function A vector of values that describes (globally) the
+   * finite element function that this function should evaluate at the
+   * quadrature points of the current cell.
    *
-   * @param[out] hessians The Hessians
-   * of the function specified by
-   * fe_function at the quadrature
-   * points of the current cell.
-   * The Hessians are computed
-   * in real space (as opposed to
-   * on the unit cell).
-   * The object is assume to
-   * already have the correct size.
+   * @param[out] hessians The Hessians of the function specified by
+   * fe_function at the quadrature points of the current cell.  The Hessians
+   * are computed in real space (as opposed to on the unit cell).  The object
+   * is assume to already have the correct size.
    *
-   * @post <code>hessians[q]</code>
-   * will contain the Hessian of
-   * the field described by
-   * fe_function at the $q$th
-   * quadrature
-   * point. <code>gradients[q][i][j]</code>
-   * represents the $(i,j)$th
-   * component of the matrix of
-   * second derivatives at
-   * quadrature point $q$.
+   * @post <code>hessians[q]</code> will contain the Hessian of the field
+   * described by fe_function at the $q$th quadrature
+   * point. <code>gradients[q][i][j]</code> represents the $(i,j)$th component
+   * of the matrix of second derivatives at quadrature point $q$.
    *
-   * @note The actual data type of the
-   * input vector may be either a
-   * Vector&lt;T&gt;,
-   * BlockVector&lt;T&gt;, or one
-   * of the sequential PETSc or
-   * Trilinos vector wrapper
-   * classes. It represents a
-   * global vector of DoF values
-   * associated with the DofHandler
-   * object with which this
-   * FEValues object was last
-   * initialized. Alternatively,
-   * if the vector argument is of
-   * type IndexSet, then the function
-   * is represented as one that
-   * is either zero or one, depending
-   * on whether a DoF index is in
-   * the set or not.
+   * @note The actual data type of the input vector may be either a
+   * Vector&lt;T&gt;, BlockVector&lt;T&gt;, or one of the sequential PETSc or
+   * Trilinos vector wrapper classes. It represents a global vector of DoF
+   * values associated with the DofHandler object with which this FEValues
+   * object was last initialized. Alternatively, if the vector argument is of
+   * type IndexSet, then the function is represented as one that is either
+   * zero or one, depending on whether a DoF index is in the set or not.
    */
   template <class InputVector>
   void
@@ -2683,36 +1866,19 @@ public:
                          std::vector<Tensor<2,spacedim> > &hessians) const;
 
   /**
-   * This function does the same as
-   * the other
-   * get_function_hessians(), but
-   * applied to multi-component
-   * (vector-valued) elements. The
-   * meaning of the arguments is as
-   * explained there.
+   * This function does the same as the other get_function_hessians(), but
+   * applied to multi-component (vector-valued) elements. The meaning of the
+   * arguments is as explained there.
    *
-   * @post <code>hessians[q]</code>
-   * is a vector of Hessians of the
-   * field described by fe_function
-   * at the $q$th quadrature
-   * point. The size of the vector
-   * accessed by
-   * <code>hessians[q]</code>
-   * equals the number of
-   * components of the finite
-   * element,
-   * i.e. <code>hessians[q][c]</code>
-   * returns the Hessian of the
-   * $c$th vector component at the
-   * $q$th quadrature
-   * point. Consequently,
-   * <code>values[q][c][i][j]</code>
-   * is the $(i,j)$th component of
-   * the matrix of second
-   * derivatives of the $c$th
-   * vector component of the vector
-   * field at quadrature point $q$
-   * of the current cell.
+   * @post <code>hessians[q]</code> is a vector of Hessians of the field
+   * described by fe_function at the $q$th quadrature point. The size of the
+   * vector accessed by <code>hessians[q]</code> equals the number of
+   * components of the finite element, i.e. <code>hessians[q][c]</code>
+   * returns the Hessian of the $c$th vector component at the $q$th quadrature
+   * point. Consequently, <code>values[q][c][i][j]</code> is the $(i,j)$th
+   * component of the matrix of second derivatives of the $c$th vector
+   * component of the vector field at quadrature point $q$ of the current
+   * cell.
    */
   template <class InputVector>
   void
@@ -2721,11 +1887,8 @@ public:
                          bool quadrature_points_fastest = false) const;
 
   /**
-   * Access to the second
-   * derivatives of a function with
-   * more flexibility. see
-   * get_function_values() with
-   * corresponding arguments.
+   * Access to the second derivatives of a function with more flexibility. see
+   * get_function_values() with corresponding arguments.
    */
   template <class InputVector>
   void get_function_hessians (
@@ -2734,11 +1897,8 @@ public:
     std::vector<Tensor<2,spacedim> > &hessians) const;
 
   /**
-   * Access to the second
-   * derivatives of a function with
-   * more flexibility. see
-   * get_function_values() with
-   * corresponding arguments.
+   * Access to the second derivatives of a function with more flexibility. see
+   * get_function_values() with corresponding arguments.
    */
   template <class InputVector>
   void get_function_hessians (
@@ -2766,81 +1926,40 @@ public:
 
   /**
    * Compute the (scalar) Laplacian (i.e. the trace of the tensor of second
-   * derivatives) of a finite
-   * element at the quadrature
-   * points of a cell. This
-   * function is the equivalent of
-   * the corresponding
-   * get_function_values() function
-   * (see there for more
-   * information) but evaluates the
-   * finite element field's second
-   * derivatives instead of its
-   * value.
+   * derivatives) of a finite element at the quadrature points of a cell. This
+   * function is the equivalent of the corresponding get_function_values()
+   * function (see there for more information) but evaluates the finite
+   * element field's second derivatives instead of its value.
    *
-   * This function may only be used
-   * if the finite element in use
-   * is a scalar one, i.e. has only
-   * one vector component. There is
-   * a corresponding function of
-   * the same name for
-   * vector-valued finite elements.
+   * This function may only be used if the finite element in use is a scalar
+   * one, i.e. has only one vector component. There is a corresponding
+   * function of the same name for vector-valued finite elements.
    *
-   * @param[in] fe_function A
-   * vector of values that
-   * describes (globally) the
-   * finite element function that
-   * this function should evaluate
-   * at the quadrature points of
-   * the current cell.
+   * @param[in] fe_function A vector of values that describes (globally) the
+   * finite element function that this function should evaluate at the
+   * quadrature points of the current cell.
    *
-   * @param[out] laplacians The Laplacians
-   * of the function specified by
-   * fe_function at the quadrature
-   * points of the current cell.
-   * The Laplacians are computed
-   * in real space (as opposed to
-   * on the unit cell).
-   * The object is assume to
-   * already have the correct size.
+   * @param[out] laplacians The Laplacians of the function specified by
+   * fe_function at the quadrature points of the current cell.  The Laplacians
+   * are computed in real space (as opposed to on the unit cell).  The object
+   * is assume to already have the correct size.
    *
-   * @post <code>laplacians[q]</code>
-   * will contain the Laplacian of
-   * the field described by
-   * fe_function at the $q$th
-   * quadrature
-   * point. <code>gradients[q][i][j]</code>
-   * represents the $(i,j)$th
-   * component of the matrix of
-   * second derivatives at
-   * quadrature point $q$.
+   * @post <code>laplacians[q]</code> will contain the Laplacian of the field
+   * described by fe_function at the $q$th quadrature
+   * point. <code>gradients[q][i][j]</code> represents the $(i,j)$th component
+   * of the matrix of second derivatives at quadrature point $q$.
    *
-   * @post For each component of
-   * the output vector, there holds
-   * <code>laplacians[q]=trace(hessians[q])</code>,
-   * where <tt>hessians</tt> would
-   * be the output of the
-   * get_function_hessians()
-   * function.
+   * @post For each component of the output vector, there holds
+   * <code>laplacians[q]=trace(hessians[q])</code>, where <tt>hessians</tt>
+   * would be the output of the get_function_hessians() function.
    *
-   * @note The actual data type of the
-   * input vector may be either a
-   * Vector&lt;T&gt;,
-   * BlockVector&lt;T&gt;, or one
-   * of the sequential PETSc or
-   * Trilinos vector wrapper
-   * classes. It represents a
-   * global vector of DoF values
-   * associated with the DofHandler
-   * object with which this
-   * FEValues object was last
-   * initialized. Alternatively,
-   * if the vector argument is of
-   * type IndexSet, then the function
-   * is represented as one that
-   * is either zero or one, depending
-   * on whether a DoF index is in
-   * the set or not.
+   * @note The actual data type of the input vector may be either a
+   * Vector&lt;T&gt;, BlockVector&lt;T&gt;, or one of the sequential PETSc or
+   * Trilinos vector wrapper classes. It represents a global vector of DoF
+   * values associated with the DofHandler object with which this FEValues
+   * object was last initialized. Alternatively, if the vector argument is of
+   * type IndexSet, then the function is represented as one that is either
+   * zero or one, depending on whether a DoF index is in the set or not.
    */
   template <class InputVector, typename number>
   void
@@ -2848,36 +1967,20 @@ public:
                            std::vector<number> &laplacians) const;
 
   /**
-   * This function does the same as
-   * the other
-   * get_function_laplacians(), but
-   * applied to multi-component
-   * (vector-valued) elements. The
-   * meaning of the arguments is as
-   * explained there.
+   * This function does the same as the other get_function_laplacians(), but
+   * applied to multi-component (vector-valued) elements. The meaning of the
+   * arguments is as explained there.
    *
-   * @post <code>laplacians[q]</code>
-   * is a vector of Laplacians of the
-   * field described by fe_function
-   * at the $q$th quadrature
-   * point. The size of the vector
-   * accessed by
-   * <code>laplacians[q]</code>
-   * equals the number of
-   * components of the finite
-   * element,
-   * i.e. <code>laplacians[q][c]</code>
-   * returns the Laplacian of the
-   * $c$th vector component at the
-   * $q$th quadrature
-   * point.
+   * @post <code>laplacians[q]</code> is a vector of Laplacians of the field
+   * described by fe_function at the $q$th quadrature point. The size of the
+   * vector accessed by <code>laplacians[q]</code> equals the number of
+   * components of the finite element, i.e. <code>laplacians[q][c]</code>
+   * returns the Laplacian of the $c$th vector component at the $q$th
+   * quadrature point.
    *
-   * @post For each component of
-   * the output vector, there holds
-   * <code>laplacians[q][c]=trace(hessians[q][c])</code>,
-   * where <tt>hessians</tt> would
-   * be the output of the
-   * get_function_hessians()
+   * @post For each component of the output vector, there holds
+   * <code>laplacians[q][c]=trace(hessians[q][c])</code>, where
+   * <tt>hessians</tt> would be the output of the get_function_hessians()
    * function.
    */
   template <class InputVector, typename number>
@@ -2886,11 +1989,8 @@ public:
                            std::vector<Vector<number> > &laplacians) const;
 
   /**
-   * Access to the second
-   * derivatives of a function with
-   * more flexibility. see
-   * get_function_values() with
-   * corresponding arguments.
+   * Access to the second derivatives of a function with more flexibility. see
+   * get_function_values() with corresponding arguments.
    */
   template <class InputVector, typename number>
   void get_function_laplacians (
@@ -2899,11 +1999,8 @@ public:
     std::vector<number> &laplacians) const;
 
   /**
-   * Access to the second
-   * derivatives of a function with
-   * more flexibility. see
-   * get_function_values() with
-   * corresponding arguments.
+   * Access to the second derivatives of a function with more flexibility. see
+   * get_function_values() with corresponding arguments.
    */
   template <class InputVector, typename number>
   void get_function_laplacians (
@@ -2912,11 +2009,8 @@ public:
     std::vector<Vector<number> > &laplacians) const;
 
   /**
-   * Access to the second
-   * derivatives of a function with
-   * more flexibility. see
-   * get_function_values() with
-   * corresponding arguments.
+   * Access to the second derivatives of a function with more flexibility. see
+   * get_function_values() with corresponding arguments.
    */
   template <class InputVector, typename number>
   void get_function_laplacians (
@@ -2930,149 +2024,106 @@ public:
   //@{
 
   /**
-   * Position of the <tt>i</tt>th
-   * quadrature point in real space.
+   * Position of the <tt>i</tt>th quadrature point in real space.
    */
   const Point<spacedim> &quadrature_point (const unsigned int i) const;
 
   /**
-   * Return a pointer to the vector of
-   * quadrature points in real space.
+   * Return a pointer to the vector of quadrature points in real space.
    */
   const std::vector<Point<spacedim> > &get_quadrature_points () const;
 
   /**
-   * Mapped quadrature weight. If
-   * this object refers to a volume
-   * evaluation (i.e. the derived
-   * class is of type FEValues),
-   * then this is the Jacobi
-   * determinant times the weight
-   * of the *<tt>i</tt>th unit
-   * quadrature point.
+   * Mapped quadrature weight. If this object refers to a volume evaluation
+   * (i.e. the derived class is of type FEValues), then this is the Jacobi
+   * determinant times the weight of the *<tt>i</tt>th unit quadrature point.
    *
-   * For surface evaluations
-   * (i.e. classes FEFaceValues or
-   * FESubfaceValues), it is the
-   * mapped surface element times
-   * the weight of the quadrature
+   * For surface evaluations (i.e. classes FEFaceValues or FESubfaceValues),
+   * it is the mapped surface element times the weight of the quadrature
    * point.
    *
-   * You can think of the quantity returned
-   * by this function as the volume or
-   * surface element $dx, ds$ in the
-   * integral that we implement here by
+   * You can think of the quantity returned by this function as the volume or
+   * surface element $dx, ds$ in the integral that we implement here by
    * quadrature.
    */
   double JxW (const unsigned int quadrature_point) const;
 
   /**
-   * Pointer to the array holding
-   * the values returned by JxW().
+   * Pointer to the array holding the values returned by JxW().
    */
   const std::vector<double> &get_JxW_values () const;
 
   /**
-   * Return the Jacobian of the
-   * transformation at the specified
-   * quadrature point, i.e.
-   * $J_{ij}=dx_i/d\hat x_j$
+   * Return the Jacobian of the transformation at the specified quadrature
+   * point, i.e.  $J_{ij}=dx_i/d\hat x_j$
    */
   const DerivativeForm<1,dim,spacedim> &jacobian (const unsigned int quadrature_point) const;
 
   /**
-   * Pointer to the array holding
-   * the values returned by jacobian().
+   * Pointer to the array holding the values returned by jacobian().
    */
   const std::vector<DerivativeForm<1,dim,spacedim> > &get_jacobians () const;
 
   /**
-   * Return the second derivative of the
-   * transformation from unit to real cell,
-   * i.e. the first derivative of the
-   * Jacobian, at the specified quadrature
-   * point, i.e. $G_{ijk}=dJ_{jk}/d\hat x_i$.
+   * Return the second derivative of the transformation from unit to real
+   * cell, i.e. the first derivative of the Jacobian, at the specified
+   * quadrature point, i.e. $G_{ijk}=dJ_{jk}/d\hat x_i$.
    */
   const DerivativeForm<2,dim,spacedim> &jacobian_grad (const unsigned int quadrature_point) const;
 
   /**
-   * Pointer to the array holding
-   * the values returned by
-   * jacobian_grads().
+   * Pointer to the array holding the values returned by jacobian_grads().
    */
   const std::vector<DerivativeForm<2,dim,spacedim> > &get_jacobian_grads () const;
 
   /**
-   * Return the inverse Jacobian of the
-   * transformation at the specified
-   * quadrature point, i.e.
-   * $J_{ij}=d\hat x_i/dx_j$
+   * Return the inverse Jacobian of the transformation at the specified
+   * quadrature point, i.e.  $J_{ij}=d\hat x_i/dx_j$
    */
   const DerivativeForm<1,spacedim,dim> &inverse_jacobian (const unsigned int quadrature_point) const;
 
   /**
-   * Pointer to the array holding
-   * the values returned by
-   * inverse_jacobian().
+   * Pointer to the array holding the values returned by inverse_jacobian().
    */
   const std::vector<DerivativeForm<1,spacedim,dim> > &get_inverse_jacobians () const;
   /**
-   * For a face, return the outward
-   * normal vector to the cell at
-   * the <tt>i</tt>th quadrature
-   * point.
+   * For a face, return the outward normal vector to the cell at the
+   * <tt>i</tt>th quadrature point.
    *
-   * For a cell of codimension one,
-   * return the normal vector, as
-   * it is specified by the
-   * numbering of the vertices.
+   * For a cell of codimension one, return the normal vector, as it is
+   * specified by the numbering of the vertices.
    *
-   * The length of the vector
-   * is normalized to one.
+   * The length of the vector is normalized to one.
    */
   const Point<spacedim> &normal_vector (const unsigned int i) const;
 
   /**
-   * Return the normal vectors at
-   * the quadrature points. For a
-   * face, these are the outward
-   * normal vectors to the
-   * cell. For a cell of
-   * codimension one, the
-   * orientation is given by the
-   * numbering of vertices.
+   * Return the normal vectors at the quadrature points. For a face, these are
+   * the outward normal vectors to the cell. For a cell of codimension one,
+   * the orientation is given by the numbering of vertices.
    */
   const std::vector<Point<spacedim> > &get_normal_vectors () const;
 
   /**
-   * Transform a set of vectors,
-   * one for each quadrature
-   * point. The <tt>mapping</tt>
-   * can be any of the ones defined
-   * in MappingType.
+   * Transform a set of vectors, one for each quadrature point. The
+   * <tt>mapping</tt> can be any of the ones defined in MappingType.
    */
   void transform (std::vector<Tensor<1,spacedim> > &transformed,
                   const std::vector<Tensor<1,dim> > &original,
                   MappingType mapping) const;
 
   /**
-   * @deprecated Use
-   * normal_vector() instead.
+   * @deprecated Use normal_vector() instead.
    *
-   * Return the outward normal vector to
-   * the cell at the <tt>i</tt>th quadrature
-   * point. The length of the vector
-   * is normalized to one.
+   * Return the outward normal vector to the cell at the <tt>i</tt>th
+   * quadrature point. The length of the vector is normalized to one.
    */
   const Point<spacedim> &cell_normal_vector (const unsigned int i) const DEAL_II_DEPRECATED;
 
   /**
-   * @deprecated Use
-   * get_normal_vectors() instead.
+   * @deprecated Use get_normal_vectors() instead.
    *
-   * Returns the vectors normal to
-   * the cell in each of the
-   * quadrature points.
+   * Returns the vectors normal to the cell in each of the quadrature points.
    */
   const std::vector<Point<spacedim> > &get_cell_normal_vectors () const DEAL_II_DEPRECATED;
 
@@ -3082,56 +2133,41 @@ public:
   //@{
 
   /**
-   * Create a view of the current FEValues
-   * object that represents a particular
-   * 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.
+   * Create a view of the current FEValues object that represents a particular
+   * 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.
    */
   const FEValuesViews::Scalar<dim,spacedim> &
   operator[] (const FEValuesExtractors::Scalar &scalar) const;
 
   /**
-   * Create a view of the current FEValues
-   * object that represents a set of
-   * <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.
+   * Create a view of the current FEValues object that represents a set of
+   * <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.
    */
   const FEValuesViews::Vector<dim,spacedim> &
   operator[] (const FEValuesExtractors::Vector &vector) const;
 
   /**
-   * Create a view of the current FEValues
-   * object that represents a set of
-   * <code>(dim*dim + dim)/2</code> scalar components
-   * (i.e. a symmetric 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.
+   * Create a view of the current FEValues object that represents a set of
+   * <code>(dim*dim + dim)/2</code> scalar components (i.e. a symmetric 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.
    */
   const FEValuesViews::SymmetricTensor<2,dim,spacedim> &
   operator[] (const FEValuesExtractors::SymmetricTensor<2> &tensor) const;
 
 
   /**
-   * Create a view of the current FEValues
-   * object that represents a set of
-   * <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.
+   * Create a view of the current FEValues object that represents a set of
+   * <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.
    */
   const FEValuesViews::Tensor<2,dim,spacedim> &
   operator[] (const FEValuesExtractors::Tensor<2> &tensor) const;
@@ -3142,57 +2178,43 @@ public:
   //@{
 
   /**
-   * Constant reference to the
-   * selected mapping object.
+   * Constant reference to the selected mapping object.
    */
   const Mapping<dim,spacedim> &get_mapping () const;
 
   /**
-   * Constant reference to the
-   * selected finite element
-   * object.
+   * Constant reference to the selected finite element object.
    */
   const FiniteElement<dim,spacedim> &get_fe () const;
 
   /**
-   * Return the update flags set
-   * for this object.
+   * Return the update flags set for this object.
    */
   UpdateFlags get_update_flags () const;
 
   /**
-   * Return a triangulation
-   * iterator to the current cell.
+   * Return a triangulation iterator to the current cell.
    */
   const typename Triangulation<dim,spacedim>::cell_iterator get_cell () const;
 
   /**
-   * Return the relation of the current
-   * cell to the previous cell. This
-   * allows re-use of some cell data
-   * (like local matrices for equations
-   * with constant coefficients) if the
-   * result is
-   * <tt>CellSimilarity::translation</tt>.
+   * Return the relation of the current cell to the previous cell. This allows
+   * re-use of some cell data (like local matrices for equations with constant
+   * coefficients) if the result is <tt>CellSimilarity::translation</tt>.
    */
   CellSimilarity::Similarity get_cell_similarity () const;
 
   /**
-   * Determine an estimate for the
-   * memory consumption (in bytes)
-   * of this object.
+   * Determine an estimate for the memory consumption (in bytes) of this
+   * object.
    */
   std::size_t memory_consumption () const;
   //@}
 
 
   /**
-   * This exception is thrown if
-   * FEValuesBase is asked to
-   * return the value of a field
-   * which was not required by the
-   * UpdateFlags for this
-   * FEValuesBase.
+   * This exception is thrown if FEValuesBase is asked to return the value of
+   * a field which was not required by the UpdateFlags for this FEValuesBase.
    *
    * @ingroup Exceptions
    */
@@ -3237,110 +2259,73 @@ public:
 
 protected:
   /**
-   * Objects of the FEValues
-   * class need to store a pointer
-   * (i.e. an iterator) to the
-   * present cell in order to be
-   * able to extract the values of
-   * the degrees of freedom on this
-   * cell in the
-   * get_function_values() and
-   * assorted functions. On the
-   * other hand, this class should
-   * also work for different
-   * iterators, as long as they
-   * have the same interface to
-   * extract the DoF values (i.e.,
-   * for example, they need to have
-   * a @p get_interpolated_dof_values
-   * function).
+   * Objects of the FEValues class need to store a pointer (i.e. an iterator)
+   * to the present cell in order to be able to extract the values of the
+   * degrees of freedom on this cell in the get_function_values() and assorted
+   * functions. On the other hand, this class should also work for different
+   * iterators, as long as they have the same interface to extract the DoF
+   * values (i.e., for example, they need to have a @p
+   * get_interpolated_dof_values function).
    *
-   * This calls for a common base
-   * class of iterator classes, and
-   * making the functions we need
-   * here @p virtual. On the other
-   * hand, this is the only place
-   * in the library where we need
-   * this, and introducing a base
-   * class of iterators and making
-   * a function virtual penalizes
-   * <em>all</em> users of the
-   * iterators, which are basically
-   * intended as very fast accessor
-   * functions. So we do not want
-   * to do this. Rather, what we do
-   * here is making the functions
-   * we need virtual only for use
-   * with <em>this class</em>. The idea
-   * is the following: have a
-   * common base class which
-   * declares some pure virtual
-   * functions, and for each
-   * possible iterator type, we
-   * have a derived class which
-   * stores the iterator to the
-   * cell and implements these
-   * functions. Since the iterator
-   * classes have the same
-   * interface, we can make the
-   * derived classes a template,
-   * templatized on the iterator
-   * type.
+   * This calls for a common base class of iterator classes, and making the
+   * functions we need here @p virtual. On the other hand, this is the only
+   * place in the library where we need this, and introducing a base class of
+   * iterators and making a function virtual penalizes <em>all</em> users of
+   * the iterators, which are basically intended as very fast accessor
+   * functions. So we do not want to do this. Rather, what we do here is
+   * making the functions we need virtual only for use with <em>this
+   * class</em>. The idea is the following: have a common base class which
+   * declares some pure virtual functions, and for each possible iterator
+   * type, we have a derived class which stores the iterator to the cell and
+   * implements these functions. Since the iterator classes have the same
+   * interface, we can make the derived classes a template, templatized on the
+   * iterator type.
    *
-   * This way, the use of virtual
-   * functions is restricted to
-   * only this class, and other
-   * users of iterators do not have
-   * to bear the negative effects.
+   * This way, the use of virtual functions is restricted to only this class,
+   * and other users of iterators do not have to bear the negative effects.
    *
    * @author Wolfgang Bangerth, 2003
    */
   class CellIteratorBase;
 
   /**
-   * Forward declaration of classes derived
-   * from CellIteratorBase. Their
-   * definition and implementation is given
-   * in the .cc file.
+   * Forward declaration of classes derived from CellIteratorBase. Their
+   * definition and implementation is given in the .cc file.
    */
   template <typename CI> class CellIterator;
   class TriaCellIterator;
 
   /**
-   * Store the cell selected last time the
-   * reinit() function was called.  This is
-   * necessary for the
-   * <tt>get_function_*</tt> functions as
-   * well as the functions of same name in
-   * the extractor classes.
+   * Store the cell selected last time the reinit() function was called.  This
+   * is necessary for the <tt>get_function_*</tt> functions as well as the
+   * functions of same name in the extractor classes.
    */
   std::auto_ptr<const CellIteratorBase> present_cell;
 
   /**
    * A signal connection we use to ensure we get informed whenever the
-   * triangulation changes. We need to know about that because it
-   * invalidates all cell iterators and, as part of that, the
-   * 'present_cell' iterator we keep around between subsequent
-   * calls to reinit() in order to compute the cell similarity.
+   * triangulation changes. We need to know about that because it invalidates
+   * all cell iterators and, as part of that, the 'present_cell' iterator we
+   * keep around between subsequent calls to reinit() in order to compute the
+   * cell similarity.
    */
   boost::signals2::connection tria_listener;
 
   /**
-   * A function that is connected to the triangulation in
-   * order to reset the stored 'present_cell' iterator to an invalid
-   * one whenever the triangulation is changed and the iterator consequently
-   * becomes invalid.
+   * A function that is connected to the triangulation in order to reset the
+   * stored 'present_cell' iterator to an invalid one whenever the
+   * triangulation is changed and the iterator consequently becomes invalid.
    */
   void invalidate_present_cell ();
 
   /**
    * This function is called by the various reinit() functions in derived
-   * classes. Given the cell indicated by the argument, test whether
-   * we have to throw away the previously stored present_cell argument
-   * because it would require us to compare cells from different
-   * triangulations. In checking all this, also make sure that we have
-   * tria_listener connected to the triangulation to which we will set
-   * present_cell right after calling this function.
+   * classes. Given the cell indicated by the argument, test whether we have
+   * to throw away the previously stored present_cell argument because it
+   * would require us to compare cells from different triangulations. In
+   * checking all this, also make sure that we have tria_listener connected to
+   * the triangulation to which we will set present_cell right after calling
+   * this function.
    */
   void
   maybe_invalidate_previous_present_cell (const typename Triangulation<dim,spacedim>::cell_iterator &cell);
@@ -3367,72 +2352,50 @@ protected:
   SmartPointer<typename Mapping<dim,spacedim>::InternalDataBase,FEValuesBase<dim,spacedim> > fe_data;
 
   /**
-   * Initialize some update
-   * flags. Called from the
-   * @p initialize functions of
-   * derived classes, which are in
-   * turn called from their
-   * constructors.
+   * Initialize some update flags. Called from the @p initialize functions of
+   * derived classes, which are in turn called from their constructors.
    *
-   * Basically, this function finds
-   * out using the finite element
-   * and mapping object already
-   * stored which flags need to be
-   * set to compute everything the
-   * user wants, as expressed
-   * through the flags passed as
-   * argument.
+   * Basically, this function finds out using the finite element and mapping
+   * object already stored which flags need to be set to compute everything
+   * the user wants, as expressed through the flags passed as argument.
    */
   UpdateFlags compute_update_flags (const UpdateFlags update_flags) const;
 
   /**
-   * An enum variable that can store
-   * different states of the current cell
-   * in comparison to the previously
-   * visited cell. If wanted, additional
-   * states can be checked here and used
-   * in one of the methods used during
-   * reinit.
+   * An enum variable that can store different states of the current cell in
+   * comparison to the previously visited cell. If wanted, additional states
+   * can be checked here and used in one of the methods used during reinit.
    */
   CellSimilarity::Similarity cell_similarity;
 
   /**
-   * A function that checks whether the
-   * new cell is similar to the one
-   * previously used. Then, a significant
-   * amount of the data can be reused,
-   * e.g. the derivatives of the basis
-   * functions in real space, shape_grad.
+   * A function that checks whether the new cell is similar to the one
+   * previously used. Then, a significant amount of the data can be reused,
+   * e.g. the derivatives of the basis functions in real space, shape_grad.
    */
   void
   check_cell_similarity (const typename Triangulation<dim,spacedim>::cell_iterator &cell);
 
 private:
   /**
-   * Copy constructor. Since
-   * objects of this class are not
-   * copyable, we make it private,
-   * and also do not implement it.
+   * Copy constructor. Since objects of this class are not copyable, we make
+   * it private, and also do not implement it.
    */
   FEValuesBase (const FEValuesBase &);
 
   /**
-   * Copy operator. Since
-   * objects of this class are not
-   * copyable, we make it private,
-   * and also do not implement it.
+   * Copy operator. Since objects of this class are not copyable, we make it
+   * private, and also do not implement it.
    */
   FEValuesBase &operator= (const FEValuesBase &);
 
   /**
-   * A cache for all possible FEValuesViews
-   * objects.
+   * A cache for all possible FEValuesViews objects.
    */
   dealii::internal::FEValuesViews::Cache<dim,spacedim> fe_values_views_cache;
 
   /**
-   * Make the view classes friends of this
-   * class, since they access internal
+   * Make the view classes friends of this class, since they access internal
    * data.
    */
   template <int, int> friend class FEValuesViews::Scalar;
@@ -3446,9 +2409,9 @@ private:
 /**
  * Finite element evaluated in quadrature points of a cell.
  *
- * This function implements the initialization routines for
- * FEValuesBase, if values in quadrature points of a cell are
- * needed. For further documentation see this class.
+ * This function implements the initialization routines for FEValuesBase, if
+ * values in quadrature points of a cell are needed. For further documentation
+ * see this class.
  *
  * @ingroup feaccess
  * @author Wolfgang Bangerth, 1998, Guido Kanschat, 2001
@@ -3458,19 +2421,14 @@ class FEValues : public FEValuesBase<dim,spacedim>
 {
 public:
   /**
-   * Dimension of the object over
-   * which we integrate. For the
-   * present class, this is equal
-   * to <code>dim</code>.
+   * Dimension of the object over which we integrate. For the present class,
+   * this is equal to <code>dim</code>.
    */
   static const unsigned int integral_dimension = dim;
 
   /**
-   * Constructor. Gets cell
-   * independent data from mapping
-   * and finite element objects,
-   * matching the quadrature rule
-   * and update flags.
+   * Constructor. Gets cell independent data from mapping and finite element
+   * objects, matching the quadrature rule and update flags.
    */
   FEValues (const Mapping<dim,spacedim>       &mapping,
             const FiniteElement<dim,spacedim> &fe,
@@ -3478,129 +2436,87 @@ public:
             const UpdateFlags                  update_flags);
 
   /**
-   * Constructor. Uses MappingQ1
-   * implicitly.
+   * Constructor. Uses MappingQ1 implicitly.
    */
   FEValues (const FiniteElement<dim,spacedim> &fe,
             const Quadrature<dim>             &quadrature,
             const UpdateFlags                  update_flags);
 
   /**
-   * Reinitialize the gradients,
-   * Jacobi determinants, etc for
-   * the given cell of type
-   * "iterator into a DoFHandler
-   * object", and the finite
-   * element associated with this
-   * object. It is assumed that the
-   * finite element used by the
-   * given cell is also the one
-   * used by this FEValues
-   * object.
+   * Reinitialize the gradients, Jacobi determinants, etc for the given cell
+   * of type "iterator into a DoFHandler object", and the finite element
+   * associated with this object. It is assumed that the finite element used
+   * by the given cell is also the one used by this FEValues object.
    */
   template <class DH, bool level_dof_access>
   void reinit (const TriaIterator<DoFCellAccessor<DH,level_dof_access> > cell);
 
   /**
-   * Reinitialize the gradients,
-   * Jacobi determinants, etc for
-   * the given cell of type
-   * "iterator into a Triangulation
-   * object", and the given finite
-   * element. Since iterators into
-   * triangulation alone only
-   * convey information about the
-   * geometry of a cell, but not
-   * about degrees of freedom
-   * possibly associated with this
-   * cell, you will not be able to
-   * call some functions of this
-   * class if they need information
-   * about degrees of
-   * freedom. These functions are,
-   * above all, the
-   * <tt>get_function_value/gradients/hessians/laplacians</tt>
-   * functions. If you want to call
-   * these functions, you have to
-   * call the @p reinit variants
-   * that take iterators into
-   * DoFHandler or other DoF
-   * handler type objects.
+   * Reinitialize the gradients, Jacobi determinants, etc for the given cell
+   * of type "iterator into a Triangulation object", and the given finite
+   * element. Since iterators into triangulation alone only convey information
+   * about the geometry of a cell, but not about degrees of freedom possibly
+   * associated with this cell, you will not be able to call some functions of
+   * this class if they need information about degrees of freedom. These
+   * functions are, above all, the
+   * <tt>get_function_value/gradients/hessians/laplacians</tt> functions. If
+   * you want to call these functions, you have to call the @p reinit variants
+   * that take iterators into DoFHandler or other DoF handler type objects.
    */
   void reinit (const typename Triangulation<dim,spacedim>::cell_iterator &cell);
 
   /**
-   * Return a reference to the copy
-   * of the quadrature formula
-   * stored by this object.
+   * Return a reference to the copy of the quadrature formula stored by this
+   * object.
    */
   const Quadrature<dim> &get_quadrature () const;
 
   /**
-   * Determine an estimate for the
-   * memory consumption (in bytes)
-   * of this object.
+   * Determine an estimate for the memory consumption (in bytes) of this
+   * object.
    */
   std::size_t memory_consumption () const;
 
   /**
-   * Return a reference to this
-   * very object.
+   * Return a reference to this very object.
    *
-   * Though it seems that it is not very
-   * useful, this function is there to
-   * provide capability to the hpFEValues
-   * class, in which case it provides the
-   * FEValues object for the present cell
-   * (remember that for hp finite elements,
-   * the actual FE object used may change
-   * from cell to cell, so we also need
-   * different FEValues objects for
-   * different cells; once you reinitialize
-   * the hpFEValues object for a specific
-   * cell, it retrieves the FEValues object
-   * for the FE on that cell and returns it
-   * through a function of the same name as
-   * this one; this function here therefore
-   * only provides the same interface so
-   * that one can templatize on
-   * FEValues/hpFEValues).
+   * Though it seems that it is not very useful, this function is there to
+   * provide capability to the hpFEValues class, in which case it provides the
+   * FEValues object for the present cell (remember that for hp finite
+   * elements, the actual FE object used may change from cell to cell, so we
+   * also need different FEValues objects for different cells; once you
+   * reinitialize the hpFEValues object for a specific cell, it retrieves the
+   * FEValues object for the FE on that cell and returns it through a function
+   * of the same name as this one; this function here therefore only provides
+   * the same interface so that one can templatize on FEValues/hpFEValues).
    */
   const FEValues<dim,spacedim> &get_present_fe_values () const;
 
 private:
   /**
-   * Store a copy of the quadrature
-   * formula here.
+   * Store a copy of the quadrature formula here.
    */
   const Quadrature<dim> quadrature;
 
   /**
-   * Do work common to the two
-   * constructors.
+   * Do work common to the two constructors.
    */
   void initialize (const UpdateFlags update_flags);
 
   /**
-   * The reinit() functions do
-   * only that part of the work
-   * that requires knowledge of the
-   * type of iterator. After
-   * setting present_cell(),
-   * they pass on to this function,
-   * which does the real work, and
-   * which is independent of the
-   * actual type of the cell
-   * iterator.
+   * The reinit() functions do only that part of the work that requires
+   * knowledge of the type of iterator. After setting present_cell(), they
+   * pass on to this function, which does the real work, and which is
+   * independent of the actual type of the cell iterator.
    */
   void do_reinit ();
 };
 
 
 /**
- * Extend the interface of FEValuesBase to values that only make sense
- * when evaluating something on the surface of a cell. All the data
- * that is available in the interior of cells is also available here.
+ * Extend the interface of FEValuesBase to values that only make sense when
+ * evaluating something on the surface of a cell. All the data that is
+ * available in the interior of cells is also available here.
  *
  * See FEValuesBase
  *
@@ -3612,30 +2528,21 @@ class FEFaceValuesBase : public FEValuesBase<dim,spacedim>
 {
 public:
   /**
-   * Dimension of the object over
-   * which we integrate. For the
-   * present class, this is equal
-   * to <code>dim-1</code>.
+   * Dimension of the object over which we integrate. For the present class,
+   * this is equal to <code>dim-1</code>.
    */
   static const unsigned int integral_dimension = dim-1;
 
   /**
-   * Constructor. Call the constructor of
-   * the base class and set up the arrays
-   * of this class with the right sizes.
-   * Actually filling these arrays is a
-   * duty of the derived class's
-   * constructors.
+   * Constructor. Call the constructor of the base class and set up the arrays
+   * of this class with the right sizes.  Actually filling these arrays is a
+   * duty of the derived class's constructors.
    *
-   * @p n_faces_or_subfaces is the number
-   * of faces or subfaces that this object
-   * is to store. The actual number depends
-   * on the derived class, for
-   * FEFaceValues it is <tt>2*dim</tt>, while for
-   * the FESubfaceValues class it is
-   * <tt>2*dim*(1<<(dim-1))</tt>, i.e. the number
-   * of faces times the number of subfaces
-   * per face.
+   * @p n_faces_or_subfaces is the number of faces or subfaces that this
+   * object is to store. The actual number depends on the derived class, for
+   * FEFaceValues it is <tt>2*dim</tt>, while for the FESubfaceValues class it
+   * is <tt>2*dim*(1<<(dim-1))</tt>, i.e. the number of faces times the number
+   * of subfaces per face.
    */
   FEFaceValuesBase (const unsigned int                 n_q_points,
                     const unsigned int                 dofs_per_cell,
@@ -3645,54 +2552,45 @@ public:
                     const Quadrature<dim-1>&           quadrature);
 
   /**
-   * Boundary form of the
-   * transformation of the cell at
-   * the <tt>i</tt>th quadrature point.
-   * See @ref GlossBoundaryForm .
+   * Boundary form of the transformation of the cell at the <tt>i</tt>th
+   * quadrature point.  See @ref GlossBoundaryForm .
    */
   const Tensor<1,spacedim> &boundary_form (const unsigned int i) const;
 
   /**
-   * Return the list of outward
-   * normal vectors times the
-   * Jacobian of the surface
-   * mapping.
+   * Return the list of outward normal vectors times the Jacobian of the
+   * surface mapping.
    */
   const std::vector<Tensor<1,spacedim> > &get_boundary_forms () const;
 
   /**
-   * Return the index of the face
-   * selected the last time the
-   * reinit() function was called.
+   * Return the index of the face selected the last time the reinit() function
+   * was called.
    */
   unsigned int get_face_index() const;
 
   /**
-   * Return a reference to the copy
-   * of the quadrature formula
-   * stored by this object.
+   * Return a reference to the copy of the quadrature formula stored by this
+   * object.
    */
   const Quadrature<dim-1> & get_quadrature () const;
 
   /**
-   * Determine an estimate for the
-   * memory consumption (in bytes)
-   * of this object.
+   * Determine an estimate for the memory consumption (in bytes) of this
+   * object.
    */
   std::size_t memory_consumption () const;
 
 protected:
 
   /**
-   * Index of the face selected the
-   * last time the reinit()
-   * function was called.
+   * Index of the face selected the last time the reinit() function was
+   * called.
    */
   unsigned int present_face_index;
 
   /**
-   * Store a copy of the quadrature
-   * formula here.
+   * Store a copy of the quadrature formula here.
    */
   const Quadrature<dim-1> quadrature;
 };
@@ -3702,13 +2600,13 @@ protected:
 /**
  * Finite element evaluated in quadrature points on a face.
  *
- * This class adds the functionality of FEFaceValuesBase to
- * FEValues; see there for more documentation.
+ * This class adds the functionality of FEFaceValuesBase to FEValues; see
+ * there for more documentation.
  *
- * Since finite element functions and their derivatives may be
- * discontinuous at cell boundaries, there is no restriction of this
- * function to a mesh face. But, there are limits of these values
- * approaching the face from either of the neighboring cells.
+ * Since finite element functions and their derivatives may be discontinuous
+ * at cell boundaries, there is no restriction of this function to a mesh
+ * face. But, there are limits of these values approaching the face from
+ * either of the neighboring cells.
  *
  * @ingroup feaccess
  * @author Wolfgang Bangerth, 1998, Guido Kanschat, 2000, 2001
@@ -3718,8 +2616,7 @@ class FEFaceValues : public FEFaceValuesBase<dim,spacedim>
 {
 public:
   /**
-   * Dimension in which this object
-   * operates.
+   * Dimension in which this object operates.
    */
 
   static const unsigned int dimension = dim;
@@ -3727,19 +2624,14 @@ public:
   static const unsigned int space_dimension = spacedim;
 
   /**
-   * Dimension of the object over
-   * which we integrate. For the
-   * present class, this is equal
-   * to <code>dim-1</code>.
+   * Dimension of the object over which we integrate. For the present class,
+   * this is equal to <code>dim-1</code>.
    */
   static const unsigned int integral_dimension = dim-1;
 
   /**
-   * Constructor. Gets cell
-   * independent data from mapping
-   * and finite element objects,
-   * matching the quadrature rule
-   * and update flags.
+   * Constructor. Gets cell independent data from mapping and finite element
+   * objects, matching the quadrature rule and update flags.
    */
   FEFaceValues (const Mapping<dim,spacedim>       &mapping,
                 const FiniteElement<dim,spacedim> &fe,
@@ -3747,95 +2639,61 @@ public:
                 const UpdateFlags                  update_flags);
 
   /**
-   * Constructor. Uses MappingQ1
-   * implicitly.
+   * Constructor. Uses MappingQ1 implicitly.
    */
   FEFaceValues (const FiniteElement<dim,spacedim> &fe,
                 const Quadrature<dim-1>           &quadrature,
                 const UpdateFlags                  update_flags);
 
   /**
-   * Reinitialize the gradients, Jacobi
-   * determinants, etc for the face with
-   * number @p face_no of @p cell
-   * and the given finite element.
+   * Reinitialize the gradients, Jacobi determinants, etc for the face with
+   * number @p face_no of @p cell and the given finite element.
    */
   template <class DH, bool level_dof_access>
   void reinit (const TriaIterator<DoFCellAccessor<DH,level_dof_access> > cell,
                const unsigned int face_no);
 
   /**
-   * Reinitialize the gradients,
-   * Jacobi determinants, etc for
-   * the given face on given cell
-   * of type "iterator into a
-   * Triangulation object", and the
-   * given finite element. Since
-   * iterators into triangulation
-   * alone only convey information
-   * about the geometry of a cell,
-   * but not about degrees of
-   * freedom possibly associated
-   * with this cell, you will not
-   * be able to call some functions
-   * of this class if they need
-   * information about degrees of
-   * freedom. These functions are,
-   * above all, the
-   * <tt>get_function_value/gradients/hessians</tt>
-   * functions. If you want to call
-   * these functions, you have to
-   * call the @p reinit variants
-   * that take iterators into
-   * DoFHandler or other DoF
-   * handler type objects.
+   * Reinitialize the gradients, Jacobi determinants, etc for the given face
+   * on given cell of type "iterator into a Triangulation object", and the
+   * given finite element. Since iterators into triangulation alone only
+   * convey information about the geometry of a cell, but not about degrees of
+   * freedom possibly associated with this cell, you will not be able to call
+   * some functions of this class if they need information about degrees of
+   * freedom. These functions are, above all, the
+   * <tt>get_function_value/gradients/hessians</tt> functions. If you want to
+   * call these functions, you have to call the @p reinit variants that take
+   * iterators into DoFHandler or other DoF handler type objects.
    */
   void reinit (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
                const unsigned int                                         face_no);
 
   /**
-   * Return a reference to this
-   * very object.
+   * Return a reference to this very object.
    *
-   * Though it seems that it is not very
-   * useful, this function is there to
-   * provide capability to the hpFEValues
-   * class, in which case it provides the
-   * FEValues object for the present cell
-   * (remember that for hp finite elements,
-   * the actual FE object used may change
-   * from cell to cell, so we also need
-   * different FEValues objects for
-   * different cells; once you reinitialize
-   * the hpFEValues object for a specific
-   * cell, it retrieves the FEValues object
-   * for the FE on that cell and returns it
-   * through a function of the same name as
-   * this one; this function here therefore
-   * only provides the same interface so
-   * that one can templatize on
-   * FEValues/hpFEValues).
+   * Though it seems that it is not very useful, this function is there to
+   * provide capability to the hpFEValues class, in which case it provides the
+   * FEValues object for the present cell (remember that for hp finite
+   * elements, the actual FE object used may change from cell to cell, so we
+   * also need different FEValues objects for different cells; once you
+   * reinitialize the hpFEValues object for a specific cell, it retrieves the
+   * FEValues object for the FE on that cell and returns it through a function
+   * of the same name as this one; this function here therefore only provides
+   * the same interface so that one can templatize on FEValues/hpFEValues).
    */
   const FEFaceValues<dim,spacedim> &get_present_fe_values () const;
 private:
 
   /**
-   * Do work common to the two
-   * constructors.
+   * Do work common to the two constructors.
    */
   void initialize (const UpdateFlags update_flags);
 
   /**
-   * The reinit() functions do
-   * only that part of the work
-   * that requires knowledge of the
-   * type of iterator. After
-   * setting present_cell(),
-   * they pass on to this function,
-   * which does the real work, and
-   * which is independent of the
-   * actual type of the cell
-   * iterator.
+   * The reinit() functions do only that part of the work that requires
+   * knowledge of the type of iterator. After setting present_cell(), they
+   * pass on to this function, which does the real work, and which is
+   * independent of the actual type of the cell iterator.
    */
   void do_reinit (const unsigned int face_no);
 };
@@ -3844,17 +2702,16 @@ private:
 /**
  * Finite element evaluated in quadrature points on a face.
  *
- * This class adds the functionality of FEFaceValuesBase to
- * FEValues; see there for more documentation.
+ * This class adds the functionality of FEFaceValuesBase to FEValues; see
+ * there for more documentation.
  *
- * This class is used for faces lying on a refinement edge. In this
- * case, the neighboring cell is refined. To be able to compute
- * differences between interior and exterior function values, the
- * refinement of the neighboring cell must be simulated on this
- * cell. This is achieved by applying a quadrature rule that simulates
- * the refinement. The resulting data fields are split up to reflect
- * the refinement structure of the neighbor: a subface number
- * corresponds to the number of the child of the neighboring face.
+ * This class is used for faces lying on a refinement edge. In this case, the
+ * neighboring cell is refined. To be able to compute differences between
+ * interior and exterior function values, the refinement of the neighboring
+ * cell must be simulated on this cell. This is achieved by applying a
+ * quadrature rule that simulates the refinement. The resulting data fields
+ * are split up to reflect the refinement structure of the neighbor: a subface
+ * number corresponds to the number of the child of the neighboring face.
  *
  * @ingroup feaccess
  * @author Wolfgang Bangerth, 1998, Guido Kanschat, 2000, 2001
@@ -3864,31 +2721,24 @@ class FESubfaceValues : public FEFaceValuesBase<dim,spacedim>
 {
 public:
   /**
-   * Dimension in which this object
-   * operates.
+   * Dimension in which this object operates.
    */
   static const unsigned int dimension = dim;
 
   /**
-   * Dimension of the space in
-   * which this object operates.
+   * Dimension of the space in which this object operates.
    */
   static const unsigned int space_dimension = spacedim;
 
   /**
-   * Dimension of the object over
-   * which we integrate. For the
-   * present class, this is equal
-   * to <code>dim-1</code>.
+   * Dimension of the object over which we integrate. For the present class,
+   * this is equal to <code>dim-1</code>.
    */
   static const unsigned int integral_dimension = dim-1;
 
   /**
-   * Constructor. Gets cell
-   * independent data from mapping
-   * and finite element objects,
-   * matching the quadrature rule
-   * and update flags.
+   * Constructor. Gets cell independent data from mapping and finite element
+   * objects, matching the quadrature rule and update flags.
    */
   FESubfaceValues (const Mapping<dim,spacedim>       &mapping,
                    const FiniteElement<dim,spacedim> &fe,
@@ -3896,25 +2746,17 @@ public:
                    const UpdateFlags         update_flags);
 
   /**
-   * Constructor. Uses MappingQ1
-   * implicitly.
+   * Constructor. Uses MappingQ1 implicitly.
    */
   FESubfaceValues (const FiniteElement<dim,spacedim> &fe,
                    const Quadrature<dim-1>  &face_quadrature,
                    const UpdateFlags         update_flags);
 
   /**
-   * Reinitialize the gradients,
-   * Jacobi determinants, etc for
-   * the given cell of type
-   * "iterator into a DoFHandler
-   * object", and the finite
-   * element associated with this
-   * object. It is assumed that the
-   * finite element used by the
-   * given cell is also the one
-   * used by this
-   * FESubfaceValues object.
+   * Reinitialize the gradients, Jacobi determinants, etc for the given cell
+   * of type "iterator into a DoFHandler object", and the finite element
+   * associated with this object. It is assumed that the finite element used
+   * by the given cell is also the one used by this FESubfaceValues object.
    */
   template <class DH, bool level_dof_access>
   void reinit (const TriaIterator<DoFCellAccessor<DH,level_dof_access> > cell,
@@ -3922,57 +2764,33 @@ public:
                const unsigned int                    subface_no);
 
   /**
-   * Reinitialize the gradients,
-   * Jacobi determinants, etc for
-   * the given subface on given
-   * cell of type "iterator into a
-   * Triangulation object", and the
-   * given finite element. Since
-   * iterators into triangulation
-   * alone only convey information
-   * about the geometry of a cell,
-   * but not about degrees of
-   * freedom possibly associated
-   * with this cell, you will not
-   * be able to call some functions
-   * of this class if they need
-   * information about degrees of
-   * freedom. These functions are,
-   * above all, the
-   * <tt>get_function_value/gradients/hessians</tt>
-   * functions. If you want to call
-   * these functions, you have to
-   * call the @p reinit variants
-   * that take iterators into
-   * DoFHandler or other DoF
-   * handler type objects.
+   * Reinitialize the gradients, Jacobi determinants, etc for the given
+   * subface on given cell of type "iterator into a Triangulation object", and
+   * the given finite element. Since iterators into triangulation alone only
+   * convey information about the geometry of a cell, but not about degrees of
+   * freedom possibly associated with this cell, you will not be able to call
+   * some functions of this class if they need information about degrees of
+   * freedom. These functions are, above all, the
+   * <tt>get_function_value/gradients/hessians</tt> functions. If you want to
+   * call these functions, you have to call the @p reinit variants that take
+   * iterators into DoFHandler or other DoF handler type objects.
    */
   void reinit (const typename Triangulation<dim,spacedim>::cell_iterator &cell,
                const unsigned int                    face_no,
                const unsigned int                    subface_no);
 
   /**
-   * Return a reference to this
-   * very object.
+   * Return a reference to this very object.
    *
-   * Though it seems that it is not very
-   * useful, this function is there to
-   * provide capability to the hpFEValues
-   * class, in which case it provides the
-   * FEValues object for the present cell
-   * (remember that for hp finite elements,
-   * the actual FE object used may change
-   * from cell to cell, so we also need
-   * different FEValues objects for
-   * different cells; once you reinitialize
-   * the hpFEValues object for a specific
-   * cell, it retrieves the FEValues object
-   * for the FE on that cell and returns it
-   * through a function of the same name as
-   * this one; this function here therefore
-   * only provides the same interface so
-   * that one can templatize on
-   * FEValues/hpFEValues).
+   * Though it seems that it is not very useful, this function is there to
+   * provide capability to the hpFEValues class, in which case it provides the
+   * FEValues object for the present cell (remember that for hp finite
+   * elements, the actual FE object used may change from cell to cell, so we
+   * also need different FEValues objects for different cells; once you
+   * reinitialize the hpFEValues object for a specific cell, it retrieves the
+   * FEValues object for the FE on that cell and returns it through a function
+   * of the same name as this one; this function here therefore only provides
+   * the same interface so that one can templatize on FEValues/hpFEValues).
    */
   const FESubfaceValues<dim,spacedim> &get_present_fe_values () const;
 
@@ -3993,22 +2811,15 @@ public:
 private:
 
   /**
-   * Do work common to the two
-   * constructors.
+   * Do work common to the two constructors.
    */
   void initialize (const UpdateFlags update_flags);
 
   /**
-   * The reinit() functions do
-   * only that part of the work
-   * that requires knowledge of the
-   * type of iterator. After
-   * setting present_cell(),
-   * they pass on to this function,
-   * which does the real work, and
-   * which is independent of the
-   * actual type of the cell
-   * iterator.
+   * The reinit() functions do only that part of the work that requires
+   * knowledge of the type of iterator. After setting present_cell(), they
+   * pass on to this function, which does the real work, and which is
+   * independent of the actual type of the cell iterator.
    */
   void do_reinit (const unsigned int face_no,
                   const unsigned int subface_no);
@@ -4034,12 +2845,9 @@ namespace FEValuesViews
     Assert (fe_values.update_flags & update_values,
             typename FVB::ExcAccessToUninitializedField());
 
-    // an adaptation of the
-    // FEValuesBase::shape_value_component
-    // function except that here we know the
-    // component as fixed and we have
-    // pre-computed and cached a bunch of
-    // information. see the comments there
+    // an adaptation of the FEValuesBase::shape_value_component function
+    // except that here we know the component as fixed and we have
+    // pre-computed and cached a bunch of information. see the comments there
     if (shape_function_data[shape_function].is_nonzero_shape_function_component)
       return fe_values.shape_values(shape_function_data[shape_function]
                                     .row_index,

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.