Some minor textual changes.

git-svn-id: https://svn.dealii.org/trunk@15912 0785d39b-7218-0410-832d-ea1e28bc413d

diff --git a/deal.II/examples/step-20/doc/intro.dox b/deal.II/examples/step-20/doc/intro.dox
index 412d9e18fe48428f78428de16d62ac9445614ad2..a35e1d24f2072f134f4f9e0b4daa51b3a7a13c34 100644 (file)
--- a/deal.II/examples/step-20/doc/intro.dox
+++ b/deal.II/examples/step-20/doc/intro.dox
@@ -249,7 +249,7 @@ functions, their gradients and divergences only once per outermost loop, and
 store the result, as this saves us a few otherwise repeated computations (it is
 possible to save even more repeated operations by calculating all relevant
 quantities in advance and then only inserting the results in the actual loop,
-see step-22 for a realization of that approach).
+see @ref step_22 "step-22" for a realization of that approach).
 The final result then looks like this, working in every space dimension:
 
 @code

diff --git a/deal.II/examples/step-22/doc/results.dox b/deal.II/examples/step-22/doc/results.dox
index b26b9e1f28be20540f822b16024b242e2f658f38..49ec193049b720306e32ed0a91c7cd8a50d318db 100644 (file)
--- a/deal.II/examples/step-22/doc/results.dox
+++ b/deal.II/examples/step-22/doc/results.dox
@@ -374,10 +374,10 @@ infeasible algorithm for the two last cycles in 3D with 1.2 and 4.6 million
 unknowns, respectively.
 
 <h4>Better preconditioner for the inner CG solver</h4>
-The first way to improve the situation would be to choose a preconditioner that 
-makes CG for the (0,0) matrix $A$ converge in a mesh-independent number of 
-iterations, say 10 to 30. We have seen such a canditate in 
-@ref step_16 "step-16": multigrid.
+Another idea to improve the situation even more would be to choose a 
+preconditioner that makes CG for the (0,0) matrix $A$ converge in a 
+mesh-independent number of iterations, say 10 to 30. We have seen such a
+canditate in @ref step_16 "step-16": multigrid.
 
 <h4>Block Schur complement preconditioner</h4>
 But even with a good preconditioner for $A$ at hand, there would still 

diff --git a/deal.II/examples/step-22/step-22.cc b/deal.II/examples/step-22/step-22.cc
index c5c70a1ec710eef3974a140a72f9e8b55ec3798e..acae5c53d7f29abd844ae6ef5bc3f4007ed90655 100644 (file)
--- a/deal.II/examples/step-22/step-22.cc
+++ b/deal.II/examples/step-22/step-22.cc
@@ -859,8 +859,8 @@ void StokesProblem<dim>::assemble_system ()
                                       // Note that in the above
                                       // computation of the local
                                       // matrix contribution we added
-                                      // the term <code> phi_i_p *
-                                      // phi_j_p </code>, yielding a
+                                      // the term <code> phi_p[i] *
+                                      // phi_p[j] </code>, yielding a
                                       // pressure mass matrix in the
                                       // $(1,1)$ block of the matrix
                                       // as discussed in the
@@ -868,8 +868,8 @@ void StokesProblem<dim>::assemble_system ()
                                       // only ends up in the $(1,1)$
                                       // block stems from the fact
                                       // that both of the factors in
-                                      // <code>phi_i_p *
-                                      // phi_j_p</code> are only
+                                      // <code>phi_p[i] *
+                                      // phi_p[j]</code> are only
                                       // non-zero when all the other
                                       // terms vanish (and the other
                                       // way around).
@@ -885,8 +885,9 @@ void StokesProblem<dim>::assemble_system ()
                                       // The final step is, as usual, the
                                       // transfer of the local contributions
                                       // to the global system matrix. This
-                                      // works also in the case of block
-                                      // vectors and matrices, and also the
+                                      // works in the case of block
+                                      // vectors and matrices just the way
+                                      // we are used it to be, and also the
                                       // terms constituting the pressure mass
                                       // matrix are written into the correct
                                       // position without any further
@@ -894,12 +895,12 @@ void StokesProblem<dim>::assemble_system ()
                                       // about one thing, though. We have
                                       // only build up half of the local
                                       // matrix because of symmetry, but
-                                      // we have to save the full system
+                                      // we're going to save the full system
                                       // matrix in order to use the standard
-                                      // functions for the solution. Hence,
-                                      // we use the element below the 
-                                      // diagonal if we happen to look
-                                      // above it.
+                                      // functions for solution. This is 
+                                      // done by flipping the indices in
+                                      // case we are pointing into the
+                                      // empty part of the local matrix.
       cell->get_dof_indices (local_dof_indices);
 
       for (unsigned int i=0; i<dofs_per_cell; ++i)