Update documentation of step-10.

We do not need to enclose class names in <code>....</code> any more (doxygen
already does that correctly). Also update the description of MappingQ1.

diff --git a/examples/step-10/step-10.cc b/examples/step-10/step-10.cc
index 06e31a81a38529eee9148a827d733d7d11fb5e35..9e4edf920ef5fa5a083cb9f8822dc42c2ec498f9 100644 (file)
--- a/examples/step-10/step-10.cc
+++ b/examples/step-10/step-10.cc
@@ -1,6 +1,6 @@
 /* ---------------------------------------------------------------------
  *
- * Copyright (C) 2001 - 2015 by the deal.II authors
+ * Copyright (C) 2001 - 2016 by the deal.II authors
  *
  * This file is part of the deal.II library.
  *
@@ -33,7 +33,7 @@
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_values.h>
 
-// This is the only new one: in it, we declare the <code>MappingQ</code> class
+// This is the only new one: in it, we declare the MappingQ class
 // which we will use for polynomial mappings of arbitrary order:
 #include <deal.II/fe/mapping_q.h>
 
@@ -113,20 +113,19 @@ namespace Step10
             std::cout << "Degree = " << degree << std::endl;
 
             // For this, first set up an object describing the mapping. This
-            // is done using the <code>MappingQ</code> class, which takes as
+            // is done using the MappingQ class, which takes as
             // argument to the constructor the polynomial degree which it
             // shall use.
             const MappingQ<dim> mapping (degree);
-            // We note one interesting fact: if you want a piecewise linear
-            // mapping, then you could give a value of <code>1</code> to the
-            // constructor. However, for linear mappings, so many things can
-            // be generated simpler that there is another class, called
-            // <code>MappingQ1</code> which does exactly the same is if you
-            // gave an degree of <code>1</code> to the <code>MappingQ</code>
-            // class, but does so significantly faster. <code>MappingQ1</code>
-            // is also the class that is implicitly used throughout the
-            // library in many functions and classes if you do not specify
-            // another mapping explicitly.
+            // As a side note, for a piecewise linear mapping, you
+            // could give a value of <code>1</code> to the constructor
+            // of MappingQ, but there is also a class MappingQ1 that
+            // achieves the same effect. Historically, it did a lot of
+            // things in a simpler way than MappingQ but is today just
+            // a wrapper around the latter. It is, however, still the
+            // class that is used implicitly in many places of the
+            // library if you do not specify another mapping
+            // explicitly.
 
 
             // In degree to actually write out the present grid with this
@@ -156,7 +155,7 @@ namespace Step10
             // Then write out the triangulation to this file. The last
             // argument of the function is a pointer to a mapping object. This
             // argument has a default value, and if no value is given a simple
-            // <code>MappingQ1</code> object is taken, which we briefly
+            // MappingQ1 object is taken, which we briefly
             // described above. This would then result in a piecewise linear
             // approximation of the true boundary in the output.
             grid_out.write_gnuplot (triangulation, gnuplot_file, &mapping);
@@ -178,8 +177,8 @@ namespace Step10
   // $x_i$. The integrals on each cell are approximated by numerical
   // quadrature, hence the only additional ingredient we need is to set up a
   // FEValues object that provides the corresponding `JxW' values of each
-  // cell. (Note that `JxW' is meant to abbreviate <code>Jacobian determinant
-  // times weight</code>; since in numerical quadrature the two factors always
+  // cell. (Note that `JxW' is meant to abbreviate <i>Jacobian determinant
+  // times weight</i>; since in numerical quadrature the two factors always
   // occur at the same places, we only offer the combined quantity, rather
   // than two separate ones.) We note that here we won't use the FEValues
   // object in its original purpose, i.e. for the computation of values of