Fix some minor typos

diff --git a/doc/doxygen/tutorial/tutorial.h.in b/doc/doxygen/tutorial/tutorial.h.in
index 76376d9b82446864aa83713c049e2b04d5087b04..666b9d17a459025c653a77c043a2def59bad776e 100644 (file)
--- a/doc/doxygen/tutorial/tutorial.h.in
+++ b/doc/doxygen/tutorial/tutorial.h.in
@@ -299,7 +299,8 @@
  *   <tr valign="top">
  *       <td>step-23</td>
  *       <td> Finally a "real" time dependent problem, the wave equation.
- *       Fractional time stepping (explicit, fully implicit and Crank-Nicholson
+ *       Fractional time stepping (explicit, fully implicit and
+ *       [Crank](https://en.wikipedia.org/wiki/John_Crank)-[Nicolson](https://en.wikipedia.org/wiki/Phyllis_Nicolson)
  *       method).
  *       <br/> Keywords: MatrixCreator, VectorTools::project()
  *       </td></tr>
@@ -925,6 +926,7 @@
  *     </td>
  *     <td>
  *       step-12,
+ *       step-12b,
  *       step-21,
  *       step-39,
  *       step-46,

diff --git a/examples/step-12/doc/intro.dox b/examples/step-12/doc/intro.dox
index d15593e9c5b5c7b81e8bffc98424b3c048cbf9aa..a55ebe281a5a443928342ef4ed4244b158c33549 100644 (file)
--- a/examples/step-12/doc/intro.dox
+++ b/examples/step-12/doc/intro.dox
@@ -54,7 +54,7 @@ On each cell $T$, we multiply by a test function $v_h$ from the left and integra
 to get:
 @f[
   \left( v_h, \nabla \cdot (\beta u_h) \right)_T
-= -(\nabla v_h, \beta u_h) + \int_\Gamma v_h u_h \beta \cdot n
+= -(\nabla v_h, \beta u_h) + \int_{\partial T} v_h u_h \beta \cdot n
 @f]
 When summing this expression over all cells $T$, the boundary integral is done over
 all internal and external faces and as such there are three cases:

diff --git a/examples/step-21/step-21.cc b/examples/step-21/step-21.cc
index 8fadaf8b5f9a8ebdcbf77caaf7ebcbf9fa7512c4..07308b72322e64fbd6731309b306cb63148d2e8a 100644 (file)
--- a/examples/step-21/step-21.cc
+++ b/examples/step-21/step-21.cc
@@ -615,10 +615,8 @@ namespace Step21
     std::vector<double>         boundary_values(n_face_q_points);
     std::vector<Tensor<2, dim>> k_inverse_values(n_q_points);
 
-    std::vector<Vector<double>>              old_solution_values(n_q_points,
+    std::vector<Vector<double>> old_solution_values(n_q_points,
                                                     Vector<double>(dim + 2));
-    std::vector<std::vector<Tensor<1, dim>>> old_solution_grads(
-      n_q_points, std::vector<Tensor<1, dim>>(dim + 2));
 
     const FEValuesExtractors::Vector velocities(0);
     const FEValuesExtractors::Scalar pressure(dim);

diff --git a/examples/step-22/doc/intro.dox b/examples/step-22/doc/intro.dox
index 0fdabb98fc085885b18bead242308339e69e1c61..ec07c2bd89732e19b4a8c6d02ea04a5ba7b8ec8e 100644 (file)
--- a/examples/step-22/doc/intro.dox
+++ b/examples/step-22/doc/intro.dox
@@ -857,11 +857,11 @@ This functions obviates, by the way, also the call to the
 
 <h4>Performance optimizations</h4>
 
-The program developed below has seen a lot of TLC. We have run it over and
-over under profiling tools (mainly <a
+The program developed below has seen a lot of tender loving care.
+We have run it over and over under profiling tools (mainly <a
 href="http://www.valgrind.org/">valgrind</a>'s cachegrind and callgrind
 tools, as well as the KDE <a
-href="http://kcachegrind.sourceforge.net/">KCachegrind</a> program for
+href="http://kcachegrind.github.io/">KCachegrind</a> program for
 visualization) to see where the bottlenecks are. This has paid off: through
 this effort, the program has become about four times as fast when
 considering the runtime of the refinement cycles zero through three,

diff --git a/examples/step-31/doc/intro.dox b/examples/step-31/doc/intro.dox
index 3b4c95cde85f01d502411c545921b251496c29ae..cd3b7d74c60a4b0e877fdd604668987e0b503267 100644 (file)
--- a/examples/step-31/doc/intro.dox
+++ b/examples/step-31/doc/intro.dox
@@ -509,7 +509,7 @@ by using the approximation $\frac 12 T^{n-1}+\frac 12 T^{n-2}$, which means
 that we calculate the nonlinear viscosity as a function of this
 intermediate temperature, $\nu_\alpha =
 \nu_\alpha\left(\frac 12 T^{n-1}+\frac 12 T^{n-2}\right)$. Note that this
-evaluation of the residual is nothing else than a Crank-Nicholson scheme,
+evaluation of the residual is nothing else than a Crank-Nicolson scheme,
 so we can be sure that now everything is alright. One might wonder whether
 it is a problem that the numerical viscosity now is not evaluated at
 time $n$ (as opposed to the rest of the equation). However, this offset

diff --git a/examples/step-33/step-33.cc b/examples/step-33/step-33.cc
index 5a28eb6aa392ef6ddd303d0b355f5cfd91bb97a7..f430c1c18cd7a6641866f0867724f9b72208745d 100644 (file)
--- a/examples/step-33/step-33.cc
+++ b/examples/step-33/step-33.cc
@@ -2368,7 +2368,6 @@ namespace Step33
       grid_in.read_ucd(input_file);
     }
 
-    dof_handler.clear();
     dof_handler.distribute_dofs(fe);
 
     // Size all of the fields.

diff --git a/examples/step-6/doc/intro.dox b/examples/step-6/doc/intro.dox
index c3a17dba2670c72accdab48f023a10b7eff4317e..efc48d091e452a4ed4c14d9bfea8055bfc9dfde5 100644 (file)
--- a/examples/step-6/doc/intro.dox
+++ b/examples/step-6/doc/intro.dox
@@ -101,7 +101,7 @@ that a cell can be only refined once more than its neighbors), but that we end
 up with these “hanging nodes” if we do this.
 
 
-<h3> Why adapatively refined meshes? </h3>
+<h3> Why adaptively refined meshes? </h3>
 
 Now that you have seen what these adaptively refined meshes look like,
 you should ask <i>why</i> we would want to do this. After all, we know from

diff --git a/include/deal.II/algorithms/theta_timestepping.h b/include/deal.II/algorithms/theta_timestepping.h
index fb3c441ab5ff9ed3be756a77e4d888e3ecb355ef..de02d56c445945b56ccd6e791cde430f6c902409 100644 (file)
--- a/include/deal.II/algorithms/theta_timestepping.h
+++ b/include/deal.II/algorithms/theta_timestepping.h
@@ -54,16 +54,16 @@ namespace Algorithms
    * Application class performing the theta timestepping scheme.
    *
    * The theta scheme is an abstraction of implicit and explicit Euler
-   * schemes, the Crank-Nicholson scheme and linear combinations of those. The
+   * schemes, the Crank-Nicolson scheme and linear combinations of those. The
    * choice of the actual scheme is controlled by the parameter #theta as
    * follows.
    * <ul>
    * <li> #theta=0: explicit Euler scheme
    * <li> #theta=1: implicit Euler scheme
-   * <li> #theta=½: Crank-Nicholson scheme
+   * <li> #theta=½: Crank-Nicolson scheme
    * </ul>
    *
-   * For fixed #theta, the Crank-Nicholson scheme is the only second order
+   * For fixed #theta, the Crank-Nicolson scheme is the only second order
    * scheme. Nevertheless, further stability may be achieved by choosing
    * #theta larger than ½, thereby introducing a first order error term. In
    * order to avoid a loss of convergence order, the adaptive theta scheme can

diff --git a/include/deal.II/base/parameter_acceptor.h b/include/deal.II/base/parameter_acceptor.h
index de965147be73c6e68da23dfd1693785a42e3d238..f629debdba517e6dbc69c4236811cc8d84bc8fb3 100644 (file)
--- a/include/deal.II/base/parameter_acceptor.h
+++ b/include/deal.II/base/parameter_acceptor.h
@@ -177,7 +177,7 @@ DEAL_II_NAMESPACE_OPEN
  *   , my_subclass("Forcing term")
  * {}
  *
- * void MyClass::declare_parmeters(ParameterHandler &prm)
+ * void MyClass::declare_parameters(ParameterHandler &prm)
  * {
  *   // many add_parameter(...);
  * }

diff --git a/include/deal.II/grid/grid_out.h b/include/deal.II/grid/grid_out.h
index 41bbb40519d6eaec0921e0b2bb8fb65b8b9dea3a..4ba0d5e0d1637ba4f7be5eb2b40546fa30580343 100644 (file)
--- a/include/deal.II/grid/grid_out.h
+++ b/include/deal.II/grid/grid_out.h
@@ -931,7 +931,7 @@ namespace GridOutFlags
  * if you know which format you want to have, or if you want the format to be
  * a runtime parameter, you can write
  * @code
- *   GridOut::OutputFormat grid_format =
+ *   GridOut::OutputFormat output_format =
  *     GridOut::parse_output_format(get_format_name_from_somewhere());
  *   std::ofstream output_file("some_filename"
  *                             + GridOut::default_suffix(output_format));