From 3b19fa9191d7720256aa85600674ed2c68f97d2f Mon Sep 17 00:00:00 2001
From: David Wells <drwells@vt.edu>
Date: Tue, 14 Jul 2015 17:25:14 -0400
Subject: [PATCH] Fix a large number of typos. This should be a majority of the
 typos in the documentation.

---
 examples/step-39/step-39.cc                   |  2 +-
 examples/step-42/doc/intro.dox                |  4 +--
 examples/step-42/doc/results.dox              |  2 +-
 examples/step-42/step-42.cc                   |  4 +--
 examples/step-50/step-50.cc                   |  4 +--
 examples/step-51/doc/results.dox              |  2 +-
 examples/step-51/step-51.cc                   |  8 +++---
 examples/step-52/step-52.cc                   |  2 +-
 examples/step-53/doc/intro.dox                |  2 +-
 examples/step-53/step-53.cc                   |  4 +--
 examples/step-54/doc/intro.dox                | 10 +++----
 examples/step-54/step-54.cc                   |  2 +-
 include/deal.II/algorithms/any_data.h         |  4 +--
 .../deal.II/base/auto_derivative_function.h   |  2 +-
 include/deal.II/base/convergence_table.h      |  6 ++---
 include/deal.II/base/data_out_base.h          | 14 +++++-----
 include/deal.II/base/exceptions.h             |  2 +-
 include/deal.II/base/flow_function.h          |  2 +-
 include/deal.II/base/function.h               |  2 +-
 include/deal.II/base/logstream.h              | 12 ++++-----
 include/deal.II/base/memory_consumption.h     |  2 +-
 include/deal.II/base/parameter_handler.h      | 10 +++----
 include/deal.II/base/parsed_function.h        |  2 +-
 include/deal.II/base/polynomial.h             |  4 +--
 include/deal.II/base/polynomials_adini.h      | 12 ++++-----
 include/deal.II/base/quadrature_lib.h         |  4 +--
 include/deal.II/base/smartpointer.h           |  2 +-
 include/deal.II/base/subscriptor.h            |  2 +-
 include/deal.II/base/table.h                  |  2 +-
 include/deal.II/base/table_handler.h          |  2 +-
 include/deal.II/base/tensor.h                 |  4 +--
 include/deal.II/base/tensor_base.h            |  2 +-
 include/deal.II/base/thread_management.h      |  2 +-
 include/deal.II/base/time_stepping.h          |  2 +-
 include/deal.II/base/timer.h                  |  2 +-
 include/deal.II/base/types.h                  |  2 +-
 include/deal.II/base/utilities.h              |  6 ++---
 include/deal.II/base/vectorization.h          |  2 +-
 include/deal.II/base/work_stream.h            |  6 ++---
 .../deal.II/distributed/solution_transfer.h   |  4 +--
 include/deal.II/dofs/dof_accessor.templates.h |  2 +-
 include/deal.II/dofs/dof_faces.h              |  2 +-
 include/deal.II/dofs/dof_handler.h            |  4 +--
 include/deal.II/dofs/dof_tools.h              |  6 ++---
 include/deal.II/fe/block_mask.h               |  2 +-
 include/deal.II/fe/component_mask.h           |  2 +-
 include/deal.II/fe/fe.h                       |  6 ++---
 include/deal.II/fe/fe_base.h                  |  2 +-
 include/deal.II/fe/fe_dg_vector.templates.h   |  2 +-
 include/deal.II/fe/fe_dgp.h                   |  2 +-
 include/deal.II/fe/fe_dgp_monomial.h          |  2 +-
 include/deal.II/fe/fe_face.h                  |  4 +--
 include/deal.II/fe/fe_poly.h                  |  4 +--
 include/deal.II/fe/fe_poly_face.h             |  4 +--
 include/deal.II/fe/fe_q_hierarchical.h        |  2 +-
 include/deal.II/fe/fe_raviart_thomas.h        |  2 +-
 include/deal.II/fe/fe_tools.h                 |  6 ++---
 include/deal.II/fe/fe_update_flags.h          |  8 +++---
 include/deal.II/fe/fe_values.h                | 19 +++++++++++++-
 include/deal.II/fe/mapping.h                  |  4 +--
 include/deal.II/fe/mapping_q1.h               |  2 +-
 include/deal.II/fe/mapping_q_eulerian.h       |  6 ++---
 include/deal.II/grid/filtered_iterator.h      |  6 ++---
 include/deal.II/grid/grid_generator.h         |  4 +--
 include/deal.II/grid/grid_in.h                |  4 +--
 include/deal.II/grid/grid_out.h               |  6 ++---
 include/deal.II/grid/grid_reordering.h        | 14 +++++-----
 .../deal.II/grid/grid_reordering_internal.h   | 12 ++++-----
 include/deal.II/grid/grid_tools.h             | 12 ++++-----
 include/deal.II/grid/intergrid_map.h          |  2 +-
 include/deal.II/grid/manifold.h               | 11 ++++----
 include/deal.II/grid/manifold_lib.h           |  6 ++---
 include/deal.II/grid/tria.h                   | 14 +++++-----
 include/deal.II/grid/tria_accessor.h          | 24 ++++++++---------
 .../deal.II/grid/tria_accessor.templates.h    |  4 +--
 include/deal.II/grid/tria_boundary_lib.h      |  2 +-
 include/deal.II/grid/tria_iterator.h          | 10 +++----
 .../deal.II/grid/tria_iterator.templates.h    |  4 +--
 include/deal.II/grid/tria_iterator_selector.h |  2 +-
 include/deal.II/grid/tria_levels.h            |  8 +++---
 include/deal.II/grid/tria_objects.h           | 26 +++++++++----------
 include/deal.II/hp/dof_faces.h                |  2 +-
 include/deal.II/hp/dof_handler.h              |  2 +-
 include/deal.II/hp/q_collection.h             |  2 +-
 include/deal.II/lac/block_linear_operator.h   | 10 +++----
 include/deal.II/lac/block_matrix_base.h       |  6 ++---
 include/deal.II/lac/block_sparse_matrix.h     |  2 +-
 include/deal.II/lac/block_sparsity_pattern.h  |  6 ++---
 include/deal.II/lac/block_vector_base.h       |  4 +--
 include/deal.II/lac/chunk_sparse_matrix.h     |  6 ++---
 include/deal.II/lac/constraint_matrix.h       |  8 +++---
 .../deal.II/lac/constraint_matrix.templates.h |  4 +--
 include/deal.II/lac/filtered_matrix.h         |  6 ++---
 include/deal.II/lac/full_matrix.templates.h   |  2 +-
 include/deal.II/lac/householder.h             |  2 +-
 include/deal.II/lac/identity_matrix.h         |  2 +-
 include/deal.II/lac/iterative_inverse.h       |  2 +-
 include/deal.II/lac/matrix_block.h            | 10 +++----
 include/deal.II/lac/matrix_lib.h              |  4 +--
 include/deal.II/lac/packaged_operation.h      | 14 +++++-----
 include/deal.II/lac/parallel_block_vector.h   |  2 +-
 include/deal.II/lac/parallel_vector.h         |  2 +-
 .../deal.II/lac/petsc_block_sparse_matrix.h   |  2 +-
 include/deal.II/lac/petsc_matrix_base.h       |  4 +--
 .../lac/petsc_parallel_block_sparse_matrix.h  |  8 +++---
 include/deal.II/lac/petsc_parallel_vector.h   |  4 +--
 include/deal.II/lac/petsc_precondition.h      |  6 ++---
 include/deal.II/lac/petsc_sparse_matrix.h     |  2 +-
 include/deal.II/lac/petsc_vector_base.h       |  6 ++---
 include/deal.II/lac/precondition.h            |  5 ++--
 include/deal.II/lac/precondition_block.h      |  8 +++---
 .../lac/precondition_block.templates.h        | 12 ++++-----
 include/deal.II/lac/relaxation_block.h        |  4 +--
 include/deal.II/lac/slepc_solver.h            |  4 +--
 .../lac/slepc_spectral_transformation.h       |  8 +++---
 include/deal.II/lac/solver_control.h          |  4 +--
 include/deal.II/lac/solver_minres.h           |  4 +--
 include/deal.II/lac/solver_relaxation.h       |  2 +-
 include/deal.II/lac/sparse_direct.h           |  4 +--
 include/deal.II/lac/sparse_matrix.h           | 11 ++++----
 include/deal.II/lac/sparse_matrix_ez.h        |  4 +--
 .../deal.II/lac/sparse_matrix_ez.templates.h  |  2 +-
 include/deal.II/lac/sparse_vanka.h            |  6 ++---
 include/deal.II/lac/sparse_vanka.templates.h  |  2 +-
 include/deal.II/lac/sparsity_tools.h          |  2 +-
 include/deal.II/lac/swappable_vector.h        |  2 +-
 include/deal.II/lac/transpose_matrix.h        |  4 +--
 include/deal.II/lac/tridiagonal_matrix.h      |  2 +-
 .../lac/trilinos_block_sparse_matrix.h        |  2 +-
 include/deal.II/lac/trilinos_precondition.h   |  6 ++---
 include/deal.II/lac/trilinos_sparse_matrix.h  | 10 +++----
 .../deal.II/lac/trilinos_sparsity_pattern.h   | 16 ++++++------
 include/deal.II/lac/trilinos_vector.h         |  4 +--
 include/deal.II/lac/trilinos_vector_base.h    |  2 +-
 include/deal.II/lac/vector.h                  |  2 +-
 include/deal.II/lac/vector.templates.h        |  2 +-
 include/deal.II/lac/vector_view.h             |  8 +++---
 .../deal.II/matrix_free/dof_info.templates.h  |  2 +-
 include/deal.II/matrix_free/fe_evaluation.h   |  2 +-
 include/deal.II/meshworker/integration_info.h |  4 +--
 include/deal.II/multigrid/mg_base.h           |  4 +--
 include/deal.II/multigrid/mg_transfer_block.h |  2 +-
 .../mg_transfer_component.templates.h         |  6 ++---
 source/base/data_out_base.cc                  |  2 +-
 source/base/geometry_info.cc                  |  2 +-
 source/base/logstream.cc                      |  2 +-
 source/base/mpi.cc                            |  2 +-
 source/base/parameter_handler.cc              |  2 +-
 source/base/quadrature_lib.cc                 |  2 +-
 source/dofs/dof_handler.cc                    |  2 +-
 source/dofs/dof_tools_constraints.cc          |  2 +-
 source/fe/fe.cc                               |  4 +--
 source/fe/fe_abf.cc                           |  4 +--
 source/fe/fe_bdm.cc                           |  4 +--
 source/fe/fe_q_base.cc                        |  2 +-
 source/fe/fe_q_hierarchical.cc                |  4 +--
 source/fe/fe_raviart_thomas.cc                |  4 +--
 source/fe/fe_tools.cc                         |  2 +-
 source/fe/fe_tools_interpolate.cc             |  2 +-
 source/fe/fe_trace.cc                         |  2 +-
 source/fe/fe_values.cc                        |  2 +-
 source/fe/mapping_fe_field.cc                 |  6 ++---
 source/fe/mapping_q.cc                        |  2 +-
 source/fe/mapping_q1.cc                       |  4 +--
 source/fe/mapping_q_eulerian.cc               |  2 +-
 165 files changed, 399 insertions(+), 381 deletions(-)

diff --git a/examples/step-39/step-39.cc b/examples/step-39/step-39.cc
index 64fd4a2b6a..4c52e86a77 100644
--- a/examples/step-39/step-39.cc
+++ b/examples/step-39/step-39.cc
@@ -518,7 +518,7 @@ namespace Step39
     mg_matrix_dg_down.clear();
     // It is important to update the sparsity patterns after <tt>clear()</tt>
     // was called for the level matrices, since the matrices lock the sparsity
-    // pattern through the Smartpointer and Subscriptor mechanism.
+    // pattern through the SmartPointer and Subscriptor mechanism.
     mg_sparsity.resize(0, n_levels-1);
     mg_sparsity_dg_interface.resize(0, n_levels-1);
 
diff --git a/examples/step-42/doc/intro.dox b/examples/step-42/doc/intro.dox
index 993ce7ae19..0a2397871e 100644
--- a/examples/step-42/doc/intro.dox
+++ b/examples/step-42/doc/intro.dox
@@ -306,7 +306,7 @@ method for the contact. It works as follows:
  \f}
  with ${\hat R}\left({\mathbf u}\right)=\left(P_{Pi}(C\varepsilon(u)),\varepsilon(\varphi^{i}_p\right)$ with
  the exceptions of (i) elements $p\in\mathcal{A}_i$ where we set ${\hat R}\left({\mathbf u}\right)=0$,
- and (ii) elements that correpond to hanging nodes, which we eliminate in the usual manner.
+ and (ii) elements that correspond to hanging nodes, which we eliminate in the usual manner.
 
  <li> Define the new active and inactive sets by
  @f{gather*}\mathcal{A}_{i+1}:=\lbrace p\in\mathcal{S}:\Lambda^i_p +
@@ -409,7 +409,7 @@ Compared to step-41, the programs has a few new classes:
 Other than that, let us comment only on the following aspects:
 <ul>
 <li> The program allows you to select from two different coarse meshes
-  through the parameter file. These are eiter a cube $[0,1]^3$ or
+  through the parameter file. These are either a cube $[0,1]^3$ or
   a half sphere with the open side facing the positive $z$ direction.
   
 <li>In either case, we will assume the convention that the part of the
diff --git a/examples/step-42/doc/results.dox b/examples/step-42/doc/results.dox
index 73911f11fe..6f34deccbb 100644
--- a/examples/step-42/doc/results.dox
+++ b/examples/step-42/doc/results.dox
@@ -136,7 +136,7 @@ Contact force = 56.794
 The tables at the end of each cycle show information about computing time
 and the number of calls of different parts of the program like assembly or
 calculating the residual, for the most recent mesh refinement cycle. Some of
-the numbers above can be improved by transfering the solution from one mesh to
+the numbers above can be improved by transferring the solution from one mesh to
 the next, an option we have not exercised here. Of course, you can also make
 the program run faster, especially on the later refinement cycles, by just
 using more processors: the accompanying paper shows good scaling to at least
diff --git a/examples/step-42/step-42.cc b/examples/step-42/step-42.cc
index 9b276315d0..585b6498a8 100644
--- a/examples/step-42/step-42.cc
+++ b/examples/step-42/step-42.cc
@@ -1121,7 +1121,7 @@ namespace Step42
   // for the finite element are located. We achieve this by using a
   // QGaussLobatto quadrature formula here, along with initializing the finite
   // element with a set of interpolation points derived from the same quadrature
-  // formula. The remainder of the function is relatively straightfoward: we
+  // formula. The remainder of the function is relatively straightforward: we
   // put the resulting matrix into the given argument; because we know the
   // matrix is diagonal, it is sufficient to have a loop over only $i$ not
   // not over $j$. Strictly speaking, we could even avoid multiplying the
@@ -2069,7 +2069,7 @@ namespace Step42
   // residual (newton_rhs_uncondensed) and corresponding diagonal entry
   // of the mass matrix (diag_mass_matrix_vector). Because it is
   // not unlikely that hanging nodes show up in the contact area
-  // it is important to apply contraints_hanging_nodes.distribute
+  // it is important to apply constraints_hanging_nodes.distribute
   // to the distributed_lambda vector.
   template <int dim>
   void
diff --git a/examples/step-50/step-50.cc b/examples/step-50/step-50.cc
index bcbf3a63e0..f0d201e56c 100644
--- a/examples/step-50/step-50.cc
+++ b/examples/step-50/step-50.cc
@@ -599,9 +599,9 @@ namespace Step50
     // for each degree of freedom. Due to the way the ConstraintMatrix
     // stores its data, the function to add a constraint on a single
     // degree of freedom and force it to be zero is called
-    // Constraintmatrix::add_line(); doing so for several degrees of
+    // ConstraintMatrix::add_line(); doing so for several degrees of
     // freedom at once can be done using
-    // Constraintmatrix::add_lines():
+    // ConstraintMatrix::add_lines():
     std::vector<ConstraintMatrix> boundary_constraints (triangulation.n_global_levels());
     std::vector<ConstraintMatrix> boundary_interface_constraints (triangulation.n_global_levels());
     for (unsigned int level=0; level<triangulation.n_global_levels(); ++level)
diff --git a/examples/step-51/doc/results.dox b/examples/step-51/doc/results.dox
index b202132fa1..28300a4d9d 100644
--- a/examples/step-51/doc/results.dox
+++ b/examples/step-51/doc/results.dox
@@ -277,7 +277,7 @@ are linear. Put in other words, DG methods are often most efficient when used
 at relatively high order, despite their focus on a discontinuous (and hence,
 seemingly low accurate) representation of solutions.
 
-<h4>Resuls for 3D</h4>
+<h4>Results for 3D</h4>
 
 We now show the same figures in 3D: The first row shows the number of degrees
 of freedom and computing time versus the $L_2$ error in the scalar variable
diff --git a/examples/step-51/step-51.cc b/examples/step-51/step-51.cc
index c814c97314..3d578faa53 100644
--- a/examples/step-51/step-51.cc
+++ b/examples/step-51/step-51.cc
@@ -389,7 +389,7 @@ namespace Step51
     // The degrees of freedom corresponding to the skeleton strongly enforce
     // Dirichlet boundary conditions, just as in a continuous Galerkin finite
     // element method.  We can enforce the boundary conditions in an analogous
-    // manner through the use of <code>ConstrainMatrix</code> constructs. In
+    // manner through the use of <code>ConstraintMatrix</code> constructs. In
     // addition, hanging nodes are handled in the same way as for
     // continuous finite elements: For the face elements which
     // only define degrees of freedom on the face, this process sets the
@@ -486,7 +486,7 @@ namespace Step51
   // and matrix that are written into the global matrix, whereas the
   // ScratchData contains all data that we need for the local assembly. There
   // is one variable worth noting here, namely the boolean variable @p
-  // trace_reconstruct. As mentioned in the introdution, we solve the HDG
+  // trace_reconstruct. As mentioned in the introduction, we solve the HDG
   // system in two steps. First, we create a linear system for the skeleton
   // system where we condense the local part into it via the Schur complement
   // $D-CA^{-1}B$. Then, we solve for the local part using the skeleton
@@ -1172,7 +1172,7 @@ namespace Step51
   // @sect4{HDG::output_results}
   // We have 3 sets of results that we would like to output:  the local solution,
   // the post-processed local solution, and the skeleton solution.  The former 2
-  // both 'live' on element volumes, wheras the latter lives on codimention-1 surfaces
+  // both 'live' on element volumes, whereas the latter lives on codimension-1 surfaces
   // of the triangulation.  Our @p output_results function writes all local solutions
   // to the same vtk file, even though they correspond to different <code>DoFHandler</code>
   // objects.  The graphical output for the skeleton variable is done through
@@ -1232,7 +1232,7 @@ namespace Step51
     face_out += ".vtk";
     std::ofstream face_output (face_out.c_str());
 
-// The <code>DataOutFaces</code> class works analagously to the <code>DataOut</code>
+// The <code>DataOutFaces</code> class works analogously to the <code>DataOut</code>
 // class when we have a <code>DoFHandler</code> that defines the solution on
 // the skeleton of the triangulation.  We treat it as such here, and the code is
 // similar to that above.
diff --git a/examples/step-52/step-52.cc b/examples/step-52/step-52.cc
index 3ccda27310..27e8860b1e 100644
--- a/examples/step-52/step-52.cc
+++ b/examples/step-52/step-52.cc
@@ -532,7 +532,7 @@ namespace Step52
 
 
   // @sect4{<code>Diffusion::embedded_explicit_method</code>}
-  // This function is the driver for the embedded explict methods. It requires
+  // This function is the driver for the embedded explicit methods. It requires
   // more parameters:
   //   - coarsen_param: factor multiplying the current time step when the error
   //   is below the threshold.
diff --git a/examples/step-53/doc/intro.dox b/examples/step-53/doc/intro.dox
index bfcc8c1b16..93519dc785 100644
--- a/examples/step-53/doc/intro.dox
+++ b/examples/step-53/doc/intro.dox
@@ -26,7 +26,7 @@ these cases:
   case of ships, the domain is the water surrounding the ship with its rudders
   and propellers.
 - The other of the two big applications of the finite element method is
-  structural engineering in which the domains are bridges, airplane necelles
+  structural engineering in which the domains are bridges, airplane nacelles
   and wings, and other solid bodies of often complicated shapes.
 - Finite element modeling is also often used to describe the generation and
   propagation of earthquake waves. In these cases, one needs to accurately
diff --git a/examples/step-53/step-53.cc b/examples/step-53/step-53.cc
index 4a8c6ec4db..2b73c4273b 100644
--- a/examples/step-53/step-53.cc
+++ b/examples/step-53/step-53.cc
@@ -386,10 +386,10 @@ namespace Step53
 
     // The next step is to explain to the triangulation to use our geometry
     // object whenever a new point is needed upon refining the mesh. We do
-    // this by telling the triangulation to use our geometry for everythin
+    // this by telling the triangulation to use our geometry for everything
     // that has manifold indicator zero, and then proceed to mark all cells
     // and their bounding faces and edges with manifold indicator zero. This
-    // ensures that the triangulation consults our geometry object everytime
+    // ensures that the triangulation consults our geometry object every time
     // a new vertex is needed. Since manifold indicators are inherited from
     // mother to children, this also happens after several recursive
     // refinement steps.
diff --git a/examples/step-54/doc/intro.dox b/examples/step-54/doc/intro.dox
index ce738b3ff4..bcd257cf47 100644
--- a/examples/step-54/doc/intro.dox
+++ b/examples/step-54/doc/intro.dox
@@ -76,7 +76,7 @@ then automatically generated by projecting a midpoint of an existing object
 onto the specified geometry.
 
 Differently from a spherical or circular boundary, a boundary with a complex
-geometry poses proplems as to where it is best to place the new nodes created
+geometry poses problems as to where it is best to place the new nodes created
 upon refinement on the prescribed shape.  HyperBallBoundary first creates the
 new nodes on the face or edge to be refined by averaging the surrounding
 points in the same way as FlatManifold does. Then, it goes on to project such
@@ -99,7 +99,7 @@ vertices of the original edge.
 <img src="http://www.dealii.org/images/steps/developer/step-54.CurveSplit.png" alt="" width="500">
 
 
-A different projection stategy has been implemented in the
+A different projection strategy has been implemented in the
 OpenCASCADE::NormalProjectionBoundary class. The <code>TopoDS_Shape</code>
 assigned at construction time can be arbitrary (a collection of shapes, faces,
 edges or a single face or edge will all work). The new cell nodes are first
@@ -124,7 +124,7 @@ class is constructed assigning a <code>TopoDS_Shape</code> (containing at
 least a face) and a direction along which all the projections will be carried
 out. New points will be computed by first averaging the surrounding points (as
 in the FlatManifold case), and then taking the closest intersection between
-the topological shape and the line passing throught the resulting point, along
+the topological shape and the line passing through the resulting point, along
 the direction used at construction time.  In this way, the user will have a
 higher control on the projection direction to be enforced to ensure good mesh
 quality.
@@ -140,7 +140,7 @@ not found. To overcome these problems, the
 OpenCASCADE::NormalToMeshProjectionBoundary class implements a third
 projection algorithm. The OpenCASCADE::NormalToMeshProjectionBoundary class is
 built assigning a <code>TopoDS_Shape</code> (containing at least one face) to
-the contructor, and works exactly like a
+the constructor, and works exactly like a
 OpenCASCADE::DirectionalProjection. But, as the name of the class suggests,
 OpenCASCADE::NormalToMeshProjectionBoundary tries to come up with a suitable
 estimate of the direction normal to the mesh elements to be refined, and uses
@@ -150,7 +150,7 @@ to split it in order to give rise to two new cells of the same length. We here
 extended this concept in 3D, and project all new nodes in a direction that
 approximates the cell normal.
 
-In the next figure, which is inpired by the geometry considered in this
+In the next figure, which is inspired by the geometry considered in this
 tutorial, we make an attempt to compare the behavior of the three projectors
 considered. As can be seen on the left, given the original cell (in blue), the
 new point found with the normal projection is in a position which does not
diff --git a/examples/step-54/step-54.cc b/examples/step-54/step-54.cc
index 6c544b7a13..a76bef99a3 100644
--- a/examples/step-54/step-54.cc
+++ b/examples/step-54/step-54.cc
@@ -239,7 +239,7 @@ namespace Step54
     // The mesh imported has a single, two-dimensional cell located in
     // three-dimensional space. We now want to ensure that it is refined
     // according to the CAD geometry imported above. This this end, we get an
-    // iterator to that cell and assgin to it the manifold_id 1 (see
+    // iterator to that cell and assign to it the manifold_id 1 (see
     // @ref GlossManifoldIndicator "this glossary entry").
     // We also get an iterator to its four faces, and assign each of them
     // the manifold_id 2:
diff --git a/include/deal.II/algorithms/any_data.h b/include/deal.II/algorithms/any_data.h
index 4750af5ccf..7b31146f50 100644
--- a/include/deal.II/algorithms/any_data.h
+++ b/include/deal.II/algorithms/any_data.h
@@ -149,7 +149,7 @@ public:
   /**
    * @brief Find index of a named object
    *
-   * Try to find the objecty and return its index in the list. Throw an
+   * Try to find the object and return its index in the list. Throw an
    * exception if the object has not been found.
    */
   unsigned int find(const std::string &name) const;
@@ -157,7 +157,7 @@ public:
   /**
    * @brief Try to find index of a named object
    *
-   * Try to find the objecty and return its index in the list. returns
+   * Try to find the object and return its index in the list. returns
    * numbers::invalid_unsigned_int if the name was not found.
    */
   unsigned int try_find(const std::string &name) const;
diff --git a/include/deal.II/base/auto_derivative_function.h b/include/deal.II/base/auto_derivative_function.h
index f2974cefae..a8c3199176 100644
--- a/include/deal.II/base/auto_derivative_function.h
+++ b/include/deal.II/base/auto_derivative_function.h
@@ -62,7 +62,7 @@ DEAL_II_NAMESPACE_OPEN
  *
  * Furthermore note, that an object of this class does <b>not</b> represent
  * the derivative of a function, like FunctionDerivative, that gives a
- * directional derivate by calling the value() function. In fact, this class
+ * directional derivative by calling the value() function. In fact, this class
  * (the AutoDerivativeFunction class) can substitute the Function class as
  * base class for user defined classes. This class implements the gradient()
  * functions for automatic computation of numerical difference quotients and
diff --git a/include/deal.II/base/convergence_table.h b/include/deal.II/base/convergence_table.h
index 5524f9fc96..fbb041cf42 100644
--- a/include/deal.II/base/convergence_table.h
+++ b/include/deal.II/base/convergence_table.h
@@ -161,7 +161,7 @@ public:
    * the convergence rates of `all' columns (see the following two functions).
    *
    * The Column::flag==1 is reserved for omitting the column from convergence
-   * rate evalution.
+   * rate evaluation.
    */
   void
   omit_column_from_convergence_rate_evaluation(const std::string &key);
@@ -170,7 +170,7 @@ public:
    * Evaluates convergence rates due to the <tt>rate_mode</tt> in relation to
    * the reference column <tt>reference_column_key</tt>. This function
    * evaluates the rates of ALL columns except of the columns that are to be
-   * omitted (see previous function) and execpt of the columns that are
+   * omitted (see previous function) and except of the columns that are
    * previously evaluated rate columns.  This function allows to evaluate the
    * convergence rate for almost all columns of a table without calling
    * evaluate_convergence_rates() for each column separately.
@@ -187,7 +187,7 @@ public:
   /**
    * Evaluates convergence rates due to the <tt>rate_mode</tt>. This function
    * evaluates the rates of ALL columns except of the columns that are to be
-   * omitted (see previous function) and execpt of the columns that are
+   * omitted (see previous function) and except of the columns that are
    * previously evaluated rate columns.  This function allows to evaluate the
    * convergence rate for almost all columns of a table without calling
    * evaluate_convergence_rates() for each column separately.
diff --git a/include/deal.II/base/data_out_base.h b/include/deal.II/base/data_out_base.h
index 0d19b916a7..26252a5323 100644
--- a/include/deal.II/base/data_out_base.h
+++ b/include/deal.II/base/data_out_base.h
@@ -77,7 +77,7 @@ class XDMFEntry;
  * order, <i>x</i> running fastest, then <i>y</i> and <i>z</i>. Nodes are
  * stored in this order and cells as well. Each cell in 3D is stored such that
  * the front face is in the <i>xz</i>-plane. In order to enhance
- * intellegibility of this concept, the following two sections are kept from a
+ * intelligibility of this concept, the following two sections are kept from a
  * previous version of this documentation.
  *
  *
@@ -226,7 +226,7 @@ namespace DataOutBase
    *
    * See the general documentation of the DataOutBase class for more
    * information on its contents and purposes.  In the case of two dimensions,
-   * the next picture ist an example of <tt>n_subdivision</tt> = 4 because the
+   * the next picture is an example of <tt>n_subdivision</tt> = 4 because the
    * number of (sub)cells within each patch is equal to
    * <tt>2<sup>dim</sup></tt>.
    *
@@ -739,7 +739,7 @@ namespace DataOutBase
     /**
      * Default colorization function. This one does what one usually wants: It
      * shifts colors from black (lowest value) through blue, green and red to
-     * white (highest value). For the exact defition of the color scale refer
+     * white (highest value). For the exact definition of the color scale refer
      * to the implementation.
      *
      * This function was originally written by Stefan Nauber.
@@ -958,7 +958,7 @@ namespace DataOutBase
   struct Deal_II_IntermediateFlags : public OutputFlagsBase<Deal_II_IntermediateFlags>
   {
     /**
-     * An indicator of the currect file format version used to write
+     * An indicator of the current file format version used to write
      * intermediate format. We do not attempt to be backward compatible, so
      * this number is used only to verify that the format we are writing is
      * what the current readers and writers understand.
@@ -1357,7 +1357,7 @@ namespace DataOutBase
   /**
    * Write the given list of patches to the output stream in gnuplot format.
    * Visualization of two-dimensional data can then be achieved by starting
-   * <tt>gnuplot</tt> and endtering the commands
+   * <tt>gnuplot</tt> and entering the commands
    *
    * @verbatim
    * set data style lines
@@ -1450,7 +1450,7 @@ namespace DataOutBase
    * declared somewhere before the object data. This may be in an external
    * data file or at the beginning of the output file. Setting the
    * <tt>external_data</tt> flag to false, an standard camera, light and
-   * texture (scaled to fit the scene) is added to the outputfile. Set to true
+   * texture (scaled to fit the scene) is added to the output file. Set to true
    * an include file "data.inc" is included. This file is not generated by
    * deal and has to include camera, light and the texture definition Tex.
    *
@@ -1907,7 +1907,7 @@ namespace DataOutBase
  *
  * The functions offering the different output format names are, respectively,
  * <tt>default_suffix</tt>, <tt>parse_output_format</tt>, and
- * <tt>get_output_format_names</tt>. They make the selection of ouput formats
+ * <tt>get_output_format_names</tt>. They make the selection of output formats
  * in parameter files much easier, and especially independent of the formats
  * presently implemented. User programs need therefore not be changed whenever
  * a new format is implemented.
diff --git a/include/deal.II/base/exceptions.h b/include/deal.II/base/exceptions.h
index 7f38981c2c..e5213f456a 100644
--- a/include/deal.II/base/exceptions.h
+++ b/include/deal.II/base/exceptions.h
@@ -1002,7 +1002,7 @@ namespace StandardExceptions
                     "information.");
 
   /**
-   * Some of our numerical classes allow for setting alll entries to zero
+   * Some of our numerical classes allow for setting all entries to zero
    * using the assignment operator <tt>=</tt>.
    *
    * In many cases, this assignment operator makes sense <b>only</b> for the
diff --git a/include/deal.II/base/flow_function.h b/include/deal.II/base/flow_function.h
index be40e9e683..fe47d66194 100644
--- a/include/deal.II/base/flow_function.h
+++ b/include/deal.II/base/flow_function.h
@@ -215,7 +215,7 @@ namespace Functions
   class StokesLSingularity : public FlowFunction<2>
   {
   public:
-    /// Constructor setting upsome data.
+    /// Constructor setting up some data.
     StokesLSingularity();
 
     virtual void vector_values (const std::vector<Point<2> > &points,
diff --git a/include/deal.II/base/function.h b/include/deal.II/base/function.h
index feccc8f59c..b5310b0c5f 100644
--- a/include/deal.II/base/function.h
+++ b/include/deal.II/base/function.h
@@ -625,7 +625,7 @@ private:
  * here, the given function object is still a scalar function (i.e. it has a
  * single value at each space point) but that the Function object generated is
  * vector valued. The number of vector components is specified in the
- * constructor, where one also selectes a single one of these vector
+ * constructor, where one also selects a single one of these vector
  * components that should be filled by the passed object. The result is a
  * vector Function object that returns zero in each component except the
  * single selected one where it returns the value returned by the given as the
diff --git a/include/deal.II/base/logstream.h b/include/deal.II/base/logstream.h
index 9426454866..c8b971cd61 100644
--- a/include/deal.II/base/logstream.h
+++ b/include/deal.II/base/logstream.h
@@ -114,7 +114,7 @@ class LogStream : public Subscriptor
 {
 public:
   /**
-   * A subclass allowing for the safe generation and removal of prefices.
+   * A subclass allowing for the safe generation and removal of prefixes.
    *
    * Somewhere at the beginning of a block, create one of these objects, and
    * it will appear as a prefix in LogStream output like @p deallog. At the
@@ -260,7 +260,7 @@ public:
   /**
    * Maximum number of levels to be written to the log file. The functionality
    * is the same as <tt>depth_console</tt>, nevertheless, this function should
-   * be used with care, since it may spoile the value of a log file.
+   * be used with care, since it may spoil the value of a log file.
    *
    * The previous value of this parameter is returned.
    */
@@ -332,7 +332,7 @@ public:
 
   /**
    * set the precision for the underlying stream and returns the previous
-   * stream precision. This fuction mimics
+   * stream precision. This function mimics
    * http://www.cplusplus.com/reference/ios/ios_base/precision/
    */
   std::streamsize precision (const std::streamsize prec);
@@ -340,7 +340,7 @@ public:
 
   /**
    * set the width for the underlying stream and returns the previous stream
-   * width. This fuction mimics
+   * width. This function mimics
    * http://www.cplusplus.com/reference/ios/ios_base/width/
    */
   std::streamsize width (const std::streamsize wide);
@@ -348,7 +348,7 @@ public:
 
   /**
    * set the flags for the underlying stream and returns the previous stream
-   * flags. This fuction mimics
+   * flags. This function mimics
    * http://www.cplusplus.com/reference/ios/ios_base/flags/
    */
   std::ios::fmtflags flags(const std::ios::fmtflags f);
@@ -529,7 +529,7 @@ private:
 
   /**
    * Internal wrapper around "thread local" outstreams. This private function
-   * will return the correct internal ostringstream buffer for operater<<.
+   * will return the correct internal ostringstream buffer for operator<<.
    */
   std::ostringstream &get_stream();
 
diff --git a/include/deal.II/base/memory_consumption.h b/include/deal.II/base/memory_consumption.h
index cda727c9ff..5f4553be66 100644
--- a/include/deal.II/base/memory_consumption.h
+++ b/include/deal.II/base/memory_consumption.h
@@ -54,7 +54,7 @@ template <typename T> class VectorizedArray;
  * memory_consumption() will simply call the member function of same name. It
  * is up to the implementation of the data type to provide a good estimate of
  * the amount of memory used. Inside this function, the use of
- * MemoryConsumpton::memory_consumption() for compounds of the class helps to
+ * MemoryConsumption::memory_consumption() for compounds of the class helps to
  * obtain this estimate. Most classes in the deal.II library have such a
  * member function.
  *
diff --git a/include/deal.II/base/parameter_handler.h b/include/deal.II/base/parameter_handler.h
index e5fd8842d7..0496cf85cc 100644
--- a/include/deal.II/base/parameter_handler.h
+++ b/include/deal.II/base/parameter_handler.h
@@ -1007,8 +1007,8 @@ namespace Patterns
  *       set Nonlinear method = Gradient
  *       # this is a comment
  *       subsection Linear solver
- *         set Solver                        = CG
- *         set Maxmimum number of iterations = 30
+ *         set Solver                       = CG
+ *         set Maximum number of iterations = 30
  *       end
  *     end
  *     ...                       # other stuff
@@ -1140,7 +1140,7 @@ namespace Patterns
  * parameters at the beginning of a log file, since this way input and output
  * are together in one file which makes matching at a later time easier.
  * Additionally, the function also print those entries which have not been
- * modified in the input file und are thus set to default values; since
+ * modified in the input file and are thus set to default values; since
  * default values may change in the process of program development, you cannot
  * know the values of parameters not specified in the input file.
  *
@@ -1385,7 +1385,7 @@ namespace Patterns
  *
  * <h3>Representation of Parameters</h3>
  *
- * Here is some more internal information about the repesentation of
+ * Here is some more internal information about the representation of
  * parameters:
  *
  * Logically, parameters and the nested sections they are arranged in can be
@@ -2390,7 +2390,7 @@ private:
   /**
    * Traverse the section currently set by
    * enter_subsection()/leave_subsection() and see which of the entries are
-   * variante/array entries. Then fill the multiple_choices variable using
+   * variant or array entries. Then fill the multiple_choices variable using
    * this information.
    */
   void init_branches_current_section ();
diff --git a/include/deal.II/base/parsed_function.h b/include/deal.II/base/parsed_function.h
index bd4434a699..bd78213f25 100644
--- a/include/deal.II/base/parsed_function.h
+++ b/include/deal.II/base/parsed_function.h
@@ -112,7 +112,7 @@ namespace Functions
      * Parse parameters needed by this class.  If the number of components
      * which is parsed does not match the number of components of this object,
      * an assertion is thrown and the program is aborted.  In order for the
-     * class to function properly, we follow the same convenctions declared in
+     * class to function properly, we follow the same conventions declared in
      * the FunctionParser class (look there for a detailed description of the
      * syntax for function declarations).
      *
diff --git a/include/deal.II/base/polynomial.h b/include/deal.II/base/polynomial.h
index 412472885b..fa03f4b3d6 100644
--- a/include/deal.II/base/polynomial.h
+++ b/include/deal.II/base/polynomial.h
@@ -300,8 +300,8 @@ namespace Polynomials
   {
   public:
     /**
-     * Constructor. Takes the degree <tt>n</tt> of the Lagrangian polynom and
-     * the index <tt>support_point</tt> of the support point. Fills the
+     * Constructor. Takes the degree <tt>n</tt> of the Lagrangian polynomial
+     * and the index <tt>support_point</tt> of the support point. Fills the
      * <tt>coefficients</tt> of the base class Polynomial.
      */
     LagrangeEquidistant (const unsigned int n,
diff --git a/include/deal.II/base/polynomials_adini.h b/include/deal.II/base/polynomials_adini.h
index a688adf526..d02826ca02 100644
--- a/include/deal.II/base/polynomials_adini.h
+++ b/include/deal.II/base/polynomials_adini.h
@@ -93,35 +93,35 @@ public:
 
 private:
   /**
-   * Store the coefficients of the polynominals in the order
+   * Store the coefficients of the polynomials in the order
    * $1,x,y,x^2,y^2,xy,x^3,y^3,xy^2,x^2y,x^3y,xy^3$
    */
   Table<2, double> coef;
 
   /**
-   * Store the coefficients of the x-derivative of the polynominals in the
+   * Store the coefficients of the x-derivative of the polynomials in the
    * order $1,x,y,x^2,y^2,xy,x^3,y^3,xy^2,x^2y,x^3y,xy^3$
    */
 
   Table<2, double> dx;
   /**
-   * Store the coefficients of the y-derivative of the polynominals in the
+   * Store the coefficients of the y-derivative of the polynomials in the
    * order $1,x,y,x^2,y^2,xy,x^3,y^3,xy^2,x^2y,x^3y,xy^3$
    */
 
   Table<2, double> dy;
   /**
-   * Store the coefficients of the second x-derivative of the polynominals in
+   * Store the coefficients of the second x-derivative of the polynomials in
    * the order $1,x,y,x^2,y^2,xy,x^3,y^3,xy^2,x^2y,x^3y,xy^3$
    */
   Table<2, double> dxx;
   /**
-   * Store the coefficients of the second y-derivative of the polynominals in
+   * Store the coefficients of the second y-derivative of the polynomials in
    * the order $1,x,y,x^2,y^2,xy,x^3,y^3,xy^2,x^2y,x^3y,xy^3$
    */
   Table<2, double> dyy;
   /**
-   * Store the coefficients of the second mixed derivative of the polynominals
+   * Store the coefficients of the second mixed derivative of the polynomials
    * in the order $1,x,y,x^2,y^2,xy,x^3,y^3,xy^2,x^2y,x^3y,xy^3$
    */
   Table<2, double> dxy;
diff --git a/include/deal.II/base/quadrature_lib.h b/include/deal.II/base/quadrature_lib.h
index a7fbd90648..82df8966f1 100644
--- a/include/deal.II/base/quadrature_lib.h
+++ b/include/deal.II/base/quadrature_lib.h
@@ -267,7 +267,7 @@ protected:
  *
  * Which one of the two sets of weights is provided, can be selected by the @p
  * factor_out_singular_weight parameter. If it is false (the default), then
- * the $\bar{w}_i$ weigths are computed, and you should provide only the
+ * the $\bar{w}_i$ weights are computed, and you should provide only the
  * smooth function $f(x)$, since the singularity is included inside the
  * quadrature. If the parameter is set to true, then the singularity is
  * factored out of the quadrature formula, and you should provide a function
@@ -283,7 +283,7 @@ class QGaussLogR : public Quadrature<dim>
 {
 public:
   /**
-   * The constructor takes four arguments: the order of the gauss formula on
+   * The constructor takes four arguments: the order of the Gauss formula on
    * each of the segments $[0,x_0]$ and $[x_0,1]$, the actual location of the
    * singularity, the scale factor inside the logarithmic function and a flag
    * that decides whether the singularity is left inside the quadrature
diff --git a/include/deal.II/base/smartpointer.h b/include/deal.II/base/smartpointer.h
index b9627d79c9..c96ea3f1ae 100644
--- a/include/deal.II/base/smartpointer.h
+++ b/include/deal.II/base/smartpointer.h
@@ -180,7 +180,7 @@ public:
 
 private:
   /**
-   * Pointer to the object we want to subscribt to. Since it is often
+   * Pointer to the object we want to subscribe to. Since it is often
    * necessary to follow this pointer when debugging, we have deliberately
    * chosen a short name.
    */
diff --git a/include/deal.II/base/subscriptor.h b/include/deal.II/base/subscriptor.h
index 97266bc9f7..1abb9992ad 100644
--- a/include/deal.II/base/subscriptor.h
+++ b/include/deal.II/base/subscriptor.h
@@ -166,7 +166,7 @@ private:
   map_iterator;
 
   /**
-   * Store the number of objects which subscribed to this object. Initialally,
+   * Store the number of objects which subscribed to this object. Initially,
    * this number is zero, and upon destruction it shall be zero again (i.e.
    * all objects which subscribed should have unsubscribed again).
    *
diff --git a/include/deal.II/base/table.h b/include/deal.II/base/table.h
index 06d0dd65cd..6d2feee357 100644
--- a/include/deal.II/base/table.h
+++ b/include/deal.II/base/table.h
@@ -301,7 +301,7 @@ namespace internal
       iterator begin () const;
 
       /**
-       * Return an interator to the element past the end of this row.
+       * Return an iterator to the element past the end of this row.
        */
       iterator end () const;
 
diff --git a/include/deal.II/base/table_handler.h b/include/deal.II/base/table_handler.h
index 802a9d9733..34de941ea8 100644
--- a/include/deal.II/base/table_handler.h
+++ b/include/deal.II/base/table_handler.h
@@ -298,7 +298,7 @@ public:
    * - <code>simple_table_with_separate_column_description</code>: This format
    * is very similar to <code>table_with_separate_column_description</code>,
    * but it skips aligning the columns with additional white space. This
-   * increases the performance o fwrite_text() for large tables. Example
+   * increases the performance of write_text() for large tables. Example
    * output:
    *   @code
    *     # 1: key1
diff --git a/include/deal.II/base/tensor.h b/include/deal.II/base/tensor.h
index 55ce6337d9..e03b76da2b 100644
--- a/include/deal.II/base/tensor.h
+++ b/include/deal.II/base/tensor.h
@@ -1549,7 +1549,7 @@ void outer_product (Tensor<1,dim,Number>       &dst,
  * Cross-product in 2d. This is just a rotation by 90 degrees clockwise to
  * compute the outer normal from a tangential vector. This function is defined
  * for all space dimensions to allow for dimension independent programming
- * (e.g. within switches over the space dimenion), but may only be called if
+ * (e.g. within switches over the space dimension), but may only be called if
  * the actual dimension of the arguments is two (e.g. from the <tt>dim==2</tt>
  * case in the switch).
  *
@@ -1572,7 +1572,7 @@ cross_product (Tensor<1,dim,Number>       &dst,
 /**
  * Cross-product of 2 vectors in 3d. This function is defined for all space
  * dimensions to allow for dimension independent programming (e.g. within
- * switches over the space dimenion), but may only be called if the actual
+ * switches over the space dimension), but may only be called if the actual
  * dimension of the arguments is three (e.g. from the <tt>dim==3</tt> case in
  * the switch).
  *
diff --git a/include/deal.II/base/tensor_base.h b/include/deal.II/base/tensor_base.h
index c7ea73c2ac..7d9b35efe5 100644
--- a/include/deal.II/base/tensor_base.h
+++ b/include/deal.II/base/tensor_base.h
@@ -582,7 +582,7 @@ public:
 private:
   /**
    * Store the values in a simple array.  For <tt>dim==0</tt> store one
-   * element, because otherways the compiler would choke.  We catch this case
+   * element, because otherwise the compiler would choke.  We catch this case
    * in the constructor to disallow the creation of such an object.
    */
   Number values[(dim!=0) ? (dim) : (dim+1)];
diff --git a/include/deal.II/base/thread_management.h b/include/deal.II/base/thread_management.h
index 748df38afc..1abe251e5b 100644
--- a/include/deal.II/base/thread_management.h
+++ b/include/deal.II/base/thread_management.h
@@ -68,7 +68,7 @@ namespace Threads
    * management and synchronization classes instead when running in single-
    * thread mode. Specifically, the new_thread() functions only call the
    * function but wait for it to return instead of running in on another
-   * thread, and the mutices do nothing really. The only reason to provide
+   * thread, and the mutexes do nothing really. The only reason to provide
    * such a function is that the program can be compiled both in MT and non-MT
    * mode without difference.
    *
diff --git a/include/deal.II/base/time_stepping.h b/include/deal.II/base/time_stepping.h
index 146df7d833..d05db95b37 100644
--- a/include/deal.II/base/time_stepping.h
+++ b/include/deal.II/base/time_stepping.h
@@ -92,7 +92,7 @@ namespace TimeStepping
       VECTOR &y) = 0;
 
     /**
-     * Empty structure used to store informations.
+     * Empty structure used to store information.
      */
     struct Status {};
 
diff --git a/include/deal.II/base/timer.h b/include/deal.II/base/timer.h
index 5c8988c90d..1bdc54471e 100644
--- a/include/deal.II/base/timer.h
+++ b/include/deal.II/base/timer.h
@@ -283,7 +283,7 @@ private:
  * and reports how much time we spent there. Moreover, the class measures the
  * total time spent from start to termination of the TimerOutput object. In
  * this case, we did a lot of other stuff, so that the time proportions of the
- * functions we measured are far away from 100 precent.
+ * functions we measured are far away from 100 percent.
  *
  *
  * <h3>Using scoped timers</h3>
diff --git a/include/deal.II/base/types.h b/include/deal.II/base/types.h
index bc65b57477..a23bbe87ff 100644
--- a/include/deal.II/base/types.h
+++ b/include/deal.II/base/types.h
@@ -201,7 +201,7 @@ namespace numbers
   /**
    * Invalid manifold_id which we need in several places as a default value.
    * We assume that all valid manifold_ids lie in the range [0,
-   * invalid_maifold_id).
+   * invalid_manifold_id).
    *
    * @see
    * @ref GlossManifoldIndicator "Glossary entry on manifold indicators"
diff --git a/include/deal.II/base/utilities.h b/include/deal.II/base/utilities.h
index d4ecae5fb3..582eb6e0dc 100644
--- a/include/deal.II/base/utilities.h
+++ b/include/deal.II/base/utilities.h
@@ -84,7 +84,7 @@ namespace Utilities
    * deal.II classes, by default spacedim is equal to dimension, the above
    * string is usually contracted to "<dim>", instead of "<dim,spacedim>".
    * This function returns a string containing "dim" if dim is equal to
-   * spacedim, otherwhise it returns "dim,spacedim".
+   * spacedim, otherwise it returns "dim,spacedim".
    */
   std::string dim_string(const int dim, const int spacedim);
 
@@ -180,7 +180,7 @@ namespace Utilities
 
   /**
    * Read a (signed) integer starting at the position in @p name indicated by
-   * the second argument, and retun this integer as a pair together with how
+   * the second argument, and return this integer as a pair together with how
    * many characters it takes up in the string.
    *
    * If no integer can be read at the indicated position, return
@@ -651,7 +651,7 @@ namespace Utilities
                 // did len
                 // become==0
                 // somehow? that
-                // shouln't have
+                // shouldn't have
                 // happened
                 Assert (false, ExcInternalError());
               }
diff --git a/include/deal.II/base/vectorization.h b/include/deal.II/base/vectorization.h
index 009d392774..1a34d8bb41 100644
--- a/include/deal.II/base/vectorization.h
+++ b/include/deal.II/base/vectorization.h
@@ -366,7 +366,7 @@ vectorized_load_and_transpose(const unsigned int       n_entries,
  * undefined behavior.
  *
  * The argument @p add_into selects where the entries should only be written
- * into the output arrays or the result should be added into the exisiting
+ * into the output arrays or the result should be added into the existing
  * entries in the output. For <code>add_into == false</code>, the following
  * code is assumed:
  *
diff --git a/include/deal.II/base/work_stream.h b/include/deal.II/base/work_stream.h
index 0e7cb4d1ee..a924961244 100644
--- a/include/deal.II/base/work_stream.h
+++ b/include/deal.II/base/work_stream.h
@@ -123,7 +123,7 @@ DEAL_II_NAMESPACE_OPEN
  *
  * Once an item is processed by the copier, it is deleted and the ScratchData
  * and CopyData objects that were used in its computation are considered
- * unused and may be re-used for the next invokation of the worker function,
+ * unused and may be re-used for the next invocation of the worker function,
  * on this or another thread.
  *
  * The functions in this namespace only really work in parallel when
@@ -307,7 +307,7 @@ namespace WorkStream
         /**
          * Constructor. Take an iterator range, the size of a buffer that can
          * hold items, and the sample additional data object that will be
-         * passed to each worker and copier function invokation.
+         * passed to each worker and copier function invocation.
          */
         IteratorRangeToItemStream (const Iterator       &begin,
                                    const Iterator       &end,
@@ -677,7 +677,7 @@ namespace WorkStream
                 }
             }
 
-          // mark current item as useable again
+          // mark current item as usable again
           current_item->currently_in_use = false;
 
 
diff --git a/include/deal.II/distributed/solution_transfer.h b/include/deal.II/distributed/solution_transfer.h
index 9f21f51b5f..ffcc3c2f45 100644
--- a/include/deal.II/distributed/solution_transfer.h
+++ b/include/deal.II/distributed/solution_transfer.h
@@ -48,7 +48,7 @@ namespace parallel
      * interpolate() or deserialize() you need to supply distributed vectors
      * without ghost elements.
      *
-     * <h3>Transfering a solution</h3> Here VECTOR is your favorite vector
+     * <h3>Transferring a solution</h3> Here VECTOR is your favorite vector
      * type, e.g. PETScWrappers::MPI::Vector, TrilinosWrappers::MPI::Vector,
      * or corresponding blockvectors.
      * @code
@@ -130,7 +130,7 @@ namespace parallel
        * stores the dof indices of each cell and stores the dof values of the
        * vectors in @p all_in in each cell that'll be coarsened. @p all_in
        * includes all vectors that are to be interpolated onto the new
-       * (refined and/or coarsenend) grid.
+       * (refined and/or coarsened) grid.
        */
       void prepare_for_coarsening_and_refinement (const std::vector<const VECTOR *> &all_in);
 
diff --git a/include/deal.II/dofs/dof_accessor.templates.h b/include/deal.II/dofs/dof_accessor.templates.h
index 3883cc2b29..d405829cb2 100644
--- a/include/deal.II/dofs/dof_accessor.templates.h
+++ b/include/deal.II/dofs/dof_accessor.templates.h
@@ -3078,7 +3078,7 @@ namespace internal
 
 //TODO[WB/MK]: This function could me made more efficient because it
 //allocates memory, which could be avoided by passing in another
-//argument as a scratch array. Comment(GK) Do not bother and leva this
+//argument as a scratch array. Comment(GK) Do not bother and leave this
 //to ConstraintMatrix or MeshWorker::Assembler
 
         // get indices of dofs
diff --git a/include/deal.II/dofs/dof_faces.h b/include/deal.II/dofs/dof_faces.h
index 52885e69c5..f4ea6b48f3 100644
--- a/include/deal.II/dofs/dof_faces.h
+++ b/include/deal.II/dofs/dof_faces.h
@@ -77,7 +77,7 @@ namespace internal
 
     /**
      * Store the indices of degrees of freedom on faces in 1D. As these would
-     * be vertices, which are treted separately, don't do anything.
+     * be vertices, which are treated separately, don't do anything.
      *
      * @author Tobias Leicht, 2006
      */
diff --git a/include/deal.II/dofs/dof_handler.h b/include/deal.II/dofs/dof_handler.h
index 4cddb81326..ff474d374b 100644
--- a/include/deal.II/dofs/dof_handler.h
+++ b/include/deal.II/dofs/dof_handler.h
@@ -112,7 +112,7 @@ namespace internal
  * for dofs are given to the largest cells as well as their bounding lines and
  * vertices, with the dofs of more refined cells getting higher numbers.
  *
- * This numbering implies very large bandwiths of the resulting matrices and
+ * This numbering implies very large bandwidths of the resulting matrices and
  * is thus vastly suboptimal for some solution algorithms. For this reason,
  * the DoFRenumbering class offers several algorithms to reorder the dof
  * numbering according. See there for a discussion of the implemented
@@ -136,7 +136,7 @@ namespace internal
  * <h3>User defined renumbering schemes</h3>
  *
  * The DoFRenumbering class offers a number of renumbering schemes like the
- * Cuthill-McKey scheme. Basically, the function sets up an array in which for
+ * Cuthill-McKee scheme. Basically, the function sets up an array in which for
  * each degree of freedom we store the new index this DoF should have after
  * renumbering. Using this array, the renumber_dofs() function of the present
  * class is called, which actually performs the change from old DoF indices to
diff --git a/include/deal.II/dofs/dof_tools.h b/include/deal.II/dofs/dof_tools.h
index d8c492652f..90a3a0f8e0 100644
--- a/include/deal.II/dofs/dof_tools.h
+++ b/include/deal.II/dofs/dof_tools.h
@@ -452,8 +452,8 @@ namespace DoFTools
    * There is a complication if some or all of the shape functions of the
    * finite element in use are non-zero in more than one component (in deal.II
    * speak: they are non-primitive). In this case, the coupling element
-   * correspoding to the first non-zero component is taken and additional ones
-   * for this component are ignored.
+   * corresponding to the first non-zero component is taken and additional
+   * ones for this component are ignored.
    *
    * @todo Not implemented for hp::DoFHandler.
    *
@@ -597,7 +597,7 @@ namespace DoFTools
    * their associated components in the coefficient matrix.
    *
    * There is one matrix for couplings in a cell and one for the couplings
-   * occuring in fluxes.
+   * occurring in fluxes.
    *
    * @todo Not implemented for hp::DoFHandler.
    */
diff --git a/include/deal.II/fe/block_mask.h b/include/deal.II/fe/block_mask.h
index 702c02b87a..33b79728bf 100644
--- a/include/deal.II/fe/block_mask.h
+++ b/include/deal.II/fe/block_mask.h
@@ -128,7 +128,7 @@ public:
 
   /**
    * Return whether this block mask represents a mask with exactly
-   * <code>n</code> blocks. This is true if either it was initilized with a
+   * <code>n</code> blocks. This is true if either it was initialized with a
    * vector with exactly <code>n</code> entries of type <code>bool</code> (in
    * this case, @p n must equal the result of size()) or if it was initialized
    * with an empty vector (or using the default constructor) in which case it
diff --git a/include/deal.II/fe/component_mask.h b/include/deal.II/fe/component_mask.h
index c5eee66c3d..0254a9b704 100644
--- a/include/deal.II/fe/component_mask.h
+++ b/include/deal.II/fe/component_mask.h
@@ -129,7 +129,7 @@ public:
 
   /**
    * Return whether this component mask represents a mask with exactly
-   * <code>n</code> components. This is true if either it was initilized with
+   * <code>n</code> components. This is true if either it was initialized with
    * a vector with exactly <code>n</code> entries of type <code>bool</code>
    * (in this case, @p n must equal the result of size()) or if it was
    * initialized with an empty vector (or using the default constructor) in
diff --git a/include/deal.II/fe/fe.h b/include/deal.II/fe/fe.h
index 6e669fa7a0..189bb3f68b 100644
--- a/include/deal.II/fe/fe.h
+++ b/include/deal.II/fe/fe.h
@@ -1574,7 +1574,7 @@ public:
    *
    * @note This function is implemented in FiniteElement for the case that the
    * element has support points. In this case, the resulting coefficients are
-   * just the values in the suport points. All other elements must reimplement
+   * just the values in the support points. All other elements must reimplement
    * it.
    */
   virtual
@@ -1753,7 +1753,7 @@ protected:
 
   /**
    * Specify the constraints which the dofs on the two sides of a cell
-   * interface underly if the line connects two cells of which one is refined
+   * interface underlie if the line connects two cells of which one is refined
    * once.
    *
    * For further details see the general description of the derived class.
@@ -1805,7 +1805,7 @@ protected:
    * can be in (all combinations of the three bool flags face_orientation,
    * face_flip and face_rotation).
    *
-   * The standard implementation fills this with zeros, i.e. no permuatation
+   * The standard implementation fills this with zeros, i.e. no permutation
    * at all. Derived finite element classes have to fill this Table with the
    * correct values.
    */
diff --git a/include/deal.II/fe/fe_base.h b/include/deal.II/fe/fe_base.h
index 2f86444f3c..bcaf50b9ac 100644
--- a/include/deal.II/fe/fe_base.h
+++ b/include/deal.II/fe/fe_base.h
@@ -232,7 +232,7 @@ public:
 
   /**
    * Number of degrees of freedom in a hexahedron; not including the degrees
-   * of freedom on the quadrilaterals, lines and vertices of the hecahedron.
+   * of freedom on the quadrilaterals, lines and vertices of the hexahedron.
    */
   const unsigned int dofs_per_hex;
 
diff --git a/include/deal.II/fe/fe_dg_vector.templates.h b/include/deal.II/fe/fe_dg_vector.templates.h
index 4df9f6b6e7..b972a85af3 100644
--- a/include/deal.II/fe/fe_dg_vector.templates.h
+++ b/include/deal.II/fe/fe_dg_vector.templates.h
@@ -21,7 +21,7 @@
 DEAL_II_NAMESPACE_OPEN
 
 
-//TODO:[GK] deg+1 is wrong here and should bew fixed after FiniteElementData was cleaned up
+//TODO:[GK] deg+1 is wrong here and should be fixed after FiniteElementData was cleaned up
 
 template <class POLY, int dim, int spacedim>
 FE_DGVector<POLY,dim,spacedim>::FE_DGVector (
diff --git a/include/deal.II/fe/fe_dgp.h b/include/deal.II/fe/fe_dgp.h
index 1a9fae4f54..aa73c24e46 100644
--- a/include/deal.II/fe/fe_dgp.h
+++ b/include/deal.II/fe/fe_dgp.h
@@ -101,7 +101,7 @@ template <int dim, int spacedim> class MappingQ;
  * the expressions can be simplified to $t=y$ and
  * $\phi_1(x,y)=x,\phi_2(x,y)=y$. However, for all other cases, the functions
  * $\phi_1(x,y),\phi_2(x,y)$ are not linear any more, and neither is any
- * linear combincation of them. Consequently, the linear functions are not
+ * linear combination of them. Consequently, the linear functions are not
  * within the range of the mapped $P_1$ polynomials.
  *
  * <h3>Visualization of shape functions</h3> In 2d, the shape functions of
diff --git a/include/deal.II/fe/fe_dgp_monomial.h b/include/deal.II/fe/fe_dgp_monomial.h
index b8f222ee12..ccf7c518cc 100644
--- a/include/deal.II/fe/fe_dgp_monomial.h
+++ b/include/deal.II/fe/fe_dgp_monomial.h
@@ -76,7 +76,7 @@ template <int dim, int spacedim> class MappingQ;
  * the expressions can be simplified to $t=y$ and
  * $\phi_1(x,y)=x,\phi_2(x,y)=y$. However, for all other cases, the functions
  * $\phi_1(x,y),\phi_2(x,y)$ are not linear any more, and neither is any
- * linear combincation of them. Consequently, the linear functions are not
+ * linear combination of them. Consequently, the linear functions are not
  * within the range of the mapped $P_1$ polynomials.
  *
  *
diff --git a/include/deal.II/fe/fe_face.h b/include/deal.II/fe/fe_face.h
index 31fb8f1d3a..1daa1dc895 100644
--- a/include/deal.II/fe/fe_face.h
+++ b/include/deal.II/fe/fe_face.h
@@ -282,7 +282,7 @@ protected:
    * Determine the values that need to be computed on the unit cell to be able
    * to compute all values required by <tt>flags</tt>.
    *
-   * For the purpuse of this function, refer to the documentation in
+   * For the purpose of this function, refer to the documentation in
    * FiniteElement.
    *
    * This class assumes that shape functions of this FiniteElement do
@@ -298,7 +298,7 @@ protected:
    * Determine the values that need to be computed on every cell to be able to
    * compute all values required by <tt>flags</tt>.
    *
-   * For the purpuse of this function, refer to the documentation in
+   * For the purpose of this function, refer to the documentation in
    * FiniteElement.
    *
    * This class assumes that shape functions of this FiniteElement do
diff --git a/include/deal.II/fe/fe_poly.h b/include/deal.II/fe/fe_poly.h
index 4097495eec..22365a0d40 100644
--- a/include/deal.II/fe/fe_poly.h
+++ b/include/deal.II/fe/fe_poly.h
@@ -206,7 +206,7 @@ protected:
    * Determine the values that need to be computed on the unit cell to be able
    * to compute all values required by <tt>flags</tt>.
    *
-   * For the purpuse of this function, refer to the documentation in
+   * For the purpose of this function, refer to the documentation in
    * FiniteElement.
    *
    * This class assumes that shape functions of this FiniteElement do
@@ -222,7 +222,7 @@ protected:
    * Determine the values that need to be computed on every cell to be able to
    * compute all values required by <tt>flags</tt>.
    *
-   * For the purpuse of this function, refer to the documentation in
+   * For the purpose of this function, refer to the documentation in
    * FiniteElement.
    *
    * This class assumes that shape functions of this FiniteElement do
diff --git a/include/deal.II/fe/fe_poly_face.h b/include/deal.II/fe/fe_poly_face.h
index 28f9d23cdc..0a9070da96 100644
--- a/include/deal.II/fe/fe_poly_face.h
+++ b/include/deal.II/fe/fe_poly_face.h
@@ -194,7 +194,7 @@ protected:
    * Determine the values that need to be computed on the unit cell to be able
    * to compute all values required by <tt>flags</tt>.
    *
-   * For the purpuse of this function, refer to the documentation in
+   * For the purpose of this function, refer to the documentation in
    * FiniteElement.
    *
    * This class assumes that shape functions of this FiniteElement do
@@ -210,7 +210,7 @@ protected:
    * Determine the values that need to be computed on every cell to be able to
    * compute all values required by <tt>flags</tt>.
    *
-   * For the purpuse of this function, refer to the documentation in
+   * For the purpose of this function, refer to the documentation in
    * FiniteElement.
    *
    * This class assumes that shape functions of this FiniteElement do
diff --git a/include/deal.II/fe/fe_q_hierarchical.h b/include/deal.II/fe/fe_q_hierarchical.h
index 12916dd246..f3a78cc7be 100644
--- a/include/deal.II/fe/fe_q_hierarchical.h
+++ b/include/deal.II/fe/fe_q_hierarchical.h
@@ -751,7 +751,7 @@ private:
    * This function constructs a table which fe_q_hierarchical index each
    * degree of freedom in the hierarchic numbering would have.
    *
-   * This function is anologous to the
+   * This function is analogous to the
    * FETools::hierarchical_to_lexicographic_numbering() function. However, in
    * contrast to the fe_q_hierarchical numbering defined above, the
    * lexicographic numbering originates from the tensor products of
diff --git a/include/deal.II/fe/fe_raviart_thomas.h b/include/deal.II/fe/fe_raviart_thomas.h
index 81779e78ce..12caf0345f 100644
--- a/include/deal.II/fe/fe_raviart_thomas.h
+++ b/include/deal.II/fe/fe_raviart_thomas.h
@@ -95,7 +95,7 @@ template <int dim, int spacedim> class MappingQ;
  * The node values above rely on integrals, which will be computed by
  * quadrature rules themselves. The generalized support points are a set of
  * points such that this quadrature can be performed with sufficient accuracy.
- * The points needed are thode of QGauss<sub>k+1</sub> on each face as well as
+ * The points needed are those of QGauss<sub>k+1</sub> on each face as well as
  * QGauss<sub>k</sub> in the interior of the cell (or none for
  * RT<sub>0</sub>).
  *
diff --git a/include/deal.II/fe/fe_tools.h b/include/deal.II/fe/fe_tools.h
index 54a0f8bc49..20fe8a291e 100644
--- a/include/deal.II/fe/fe_tools.h
+++ b/include/deal.II/fe/fe_tools.h
@@ -474,8 +474,8 @@ namespace FETools
    * correspond to the number of columns of @p projection_matrix.  The size of
    * @p vector_of_tensors_at_nodes must correspond to the number of rows of @p
    * vector_of_tensors_at_nodes .  The projection matrix @p projection_matrix
-   * desribes the projection of scalar data from the quadrature points and can
-   * be obtained from the
+   * describes the projection of scalar data from the quadrature points and
+   * can be obtained from the
    * FETools::compute_projection_from_quadrature_points_matrix function.
    */
   template <int dim>
@@ -535,7 +535,7 @@ namespace FETools
    * The same is true if @p fe1 is a continuous and @p fe2 is a discontinuous
    * finite element. For the case that @p fe1 is a discontinuous and @p fe2 is
    * a continuous finite element there is no point interpolation defined at
-   * the discontinuities.  Therefore the meanvalue is taken at the DoF values
+   * the discontinuities.  Therefore the mean value is taken at the DoF values
    * on the discontinuities.
    *
    * Note that for continuous elements on grids with hanging nodes (i.e.
diff --git a/include/deal.II/fe/fe_update_flags.h b/include/deal.II/fe/fe_update_flags.h
index 4622f309a3..206abf8d1f 100644
--- a/include/deal.II/fe/fe_update_flags.h
+++ b/include/deal.II/fe/fe_update_flags.h
@@ -126,8 +126,8 @@ enum UpdateFlags
   //! Transformed quadrature weights
   /**
    * Compute the quadrature weights on the real cell, i.e. the weights of the
-   * quadrature rule multiplied with the determinant of the Jacoian of the
-   * transformation from reference to realcell.
+   * quadrature rule multiplied with the determinant of the Jacobian of the
+   * transformation from reference to real cell.
    */
   update_JxW_values = 0x0020,
   //! Normal vectors
@@ -153,7 +153,7 @@ enum UpdateFlags
   update_jacobians = 0x0080,
   //! Gradient of volume element
   /**
-   * Compute the dervatives of the Jacobian of the transformation.
+   * Compute the derivatives of the Jacobian of the transformation.
    */
   update_jacobian_grads = 0x0100,
   //! Volume element
@@ -331,7 +331,7 @@ operator &= (UpdateFlags &f1, UpdateFlags f2)
  * change if one cell is just a translation of the previous). Currently, this
  * variable does only recognize a translation and an inverted translation (if
  * dim<spacedim). However, this concept makes it easy to add additional
- * staties to be detected in FEValues/FEFaceValues for making use of these
+ * states to be detected in FEValues/FEFaceValues for making use of these
  * similarities as well.
  */
 namespace CellSimilarity
diff --git a/include/deal.II/fe/fe_values.h b/include/deal.II/fe/fe_values.h
index f65a767a3a..5257d51805 100644
--- a/include/deal.II/fe/fe_values.h
+++ b/include/deal.II/fe/fe_values.h
@@ -1248,6 +1248,23 @@ namespace internal
  * A class that contains all data vectors for FEValues, FEFaceValues, and
  * FESubfaceValues.
  *
+ * This class has been extracted from FEValuesBase to encapsulate in one
+ * place all of the data, independent of the functions that later
+ * access this data in the public interfaces of the FEValues and related
+ * classes. Consequently, this base class is protected in FEValuesBase.
+ *
+ * The second reason is because in FEValuesBase::reinit, we first need to
+ * call Mapping::fill_fe_values() to compute mapping related data, and later
+ * call FiniteElement::fill_fe_values() to compute shape function related
+ * data. In the first step, Mapping::fill_fe_values() gets a pointer to
+ * its own internal data structure and a pointer to the FEValuesData base
+ * object of FEValuesBase, and the mapping then places the computed data
+ * into the data fields that pertain to the mapping below. In the second
+ * step, the finite element receives a pointer to its own internal object,
+ * and to the current object, and from both of these computes the shape
+ * function related information and, again, places it into the current
+ * FEValuesData object.
+ *
  * More information can be found on the page on
  * @ref UpdateFlagsEssay.
  *
@@ -1750,7 +1767,7 @@ public:
    * @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
+   * 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.
diff --git a/include/deal.II/fe/mapping.h b/include/deal.II/fe/mapping.h
index b01c821757..68d388b0d8 100644
--- a/include/deal.II/fe/mapping.h
+++ b/include/deal.II/fe/mapping.h
@@ -176,7 +176,7 @@ enum MappingType
  * <h4>Mapping of vector fields, differential forms and gradients of vector
  * fields</h4>
  *
- * The transfomation of vector fields, differential forms
+ * The transformation of vector fields, differential forms
  * (gradients/jacobians) and gradients of vector fields between the reference
  * cell and the actual grid cell follows the general form
  *
@@ -196,7 +196,7 @@ enum MappingType
  *
  * <h3>Technical notes</h3>
  *
- * A hint to implementators: no function except the two functions @p
+ * A hint to implementors: no function except the two functions @p
  * update_once and @p update_each may add any flags.
  *
  * For more information about the <tt>spacedim</tt> template parameter check
diff --git a/include/deal.II/fe/mapping_q1.h b/include/deal.II/fe/mapping_q1.h
index 18f6fd190b..efd0ea8731 100644
--- a/include/deal.II/fe/mapping_q1.h
+++ b/include/deal.II/fe/mapping_q1.h
@@ -466,7 +466,7 @@ protected:
    * i-th column of Y is real_vertex[i].  If we split X=[A|b], the least
    * square approx is A x_hat+b  Classically  X = Y * (M^t (M M^t)^{-1})  Let
    * K = M^t * (M M^t)^{-1} = [KA Kb] this can be precomputed, and that is
-   * exactely what we do.  Finally A = Y*KA  and  b = Y*Kb.
+   * exactly what we do.  Finally A = Y*KA  and  b = Y*Kb.
    */
   Point<dim>
   transform_real_to_unit_cell_initial_guess (const std::vector<Point<spacedim> > &vertex,
diff --git a/include/deal.II/fe/mapping_q_eulerian.h b/include/deal.II/fe/mapping_q_eulerian.h
index 58cde27a77..e05763cb3e 100644
--- a/include/deal.II/fe/mapping_q_eulerian.h
+++ b/include/deal.II/fe/mapping_q_eulerian.h
@@ -82,7 +82,7 @@ DEAL_II_NAMESPACE_OPEN
  * parallel codes using the PETSc wrapper classes, the type of the vector can
  * be specified as template parameter <tt>EulerVectorType</tt> Not specifying
  * this template argument in applications using the PETSc vector classes leads
- * to the construction of a copy of the vector which is not acccessible
+ * to the construction of a copy of the vector which is not accessible
  * afterwards!
  *
  * @author Joshua White, 2008
@@ -94,14 +94,14 @@ public:
   /**
    * Constructor.
    *
-   * @param[in] degree The polynomical degree of the desired $Q_p$ mapping.
+   * @param[in] degree The polynomial degree of the desired $Q_p$ mapping.
    * @param[in] euler_dof_handler A DoFHandler object that defines a finite
    * element space. This space needs to have at least dim components and the
    * first dim components of the space will be considered displacements
    * relative to the original positions of the cells of the triangulation.
    * @param[in] euler_vector A finite element function in the space defined by
    * the second argument. The first dim components of this function will be
-   * interpreted as the displacement we use in definining the mapping,
+   * interpreted as the displacement we use in defining the mapping,
    * relative to the location of cells of the underlying triangulation.
    */
   MappingQEulerian (const unsigned int              degree,
diff --git a/include/deal.II/grid/filtered_iterator.h b/include/deal.II/grid/filtered_iterator.h
index 6bc5493fdb..7b4c804056 100644
--- a/include/deal.II/grid/filtered_iterator.h
+++ b/include/deal.II/grid/filtered_iterator.h
@@ -189,8 +189,8 @@ namespace IteratorFilters
 
 
   /**
-   * Filter for iterators that evaluates to true if th level subdomain id of a
-   * cell is equal to the current processor id.
+   * Filter for iterators that evaluates to true if the level subdomain id of
+   * a cell is equal to the current processor id.
    *
    * @ingroup Iterators
    */
@@ -216,7 +216,7 @@ namespace IteratorFilters
  * satisfies the predicate if operators ++ or -- are invoked. Intermediate
  * iterator values that lie in between but do not satisfy the predicate are
  * skipped. It is thus very simple to write loops over a certain class of
- * objects without the need to explicitely write down the condition they have
+ * objects without the need to explicitly write down the condition they have
  * to satisfy in each loop iteration. This in particular is helpful if
  * functions are called with a pair of iterators denoting a range on which
  * they shall act, by choosing a filtered iterator instead of usual ones.
diff --git a/include/deal.II/grid/grid_generator.h b/include/deal.II/grid/grid_generator.h
index 3073ffc5fe..da179985d9 100644
--- a/include/deal.II/grid/grid_generator.h
+++ b/include/deal.II/grid/grid_generator.h
@@ -269,7 +269,7 @@ namespace GridGenerator
    *
    * @note This function silently reorders the vertices on the cells to
    * lexicographic ordering (see <code>GridReordering::reorder_grid</code>).
-   * In other words, if reodering of the vertices does occur, the ordering of
+   * In other words, if reordering of the vertices does occur, the ordering of
    * vertices in the array of <code>corners</code> will no longer refer to the
    * same triangulation.
    *
@@ -859,7 +859,7 @@ namespace GridGenerator
    * this is not the case, you will encounter problems when using the
    * triangulation later on.
    *
-   * All informations about cell manifold_ids and material ids are copied from
+   * All information about cell manifold_ids and material ids are copied from
    * one triangulation to the other, and only the boundary manifold_ids and
    * boundary_ids are copied over from the faces of @p in_tria to the faces of
    * @p out_tria. If you need to specify manifold ids on interior faces, they
diff --git a/include/deal.II/grid/grid_in.h b/include/deal.II/grid/grid_in.h
index e5c3d9e648..ea27687105 100644
--- a/include/deal.II/grid/grid_in.h
+++ b/include/deal.II/grid/grid_in.h
@@ -241,7 +241,7 @@ struct SubCellData;
  *
  * In two dimensions, another difficulty occurs, which has to do with the
  * sense of a quadrilateral. A quad consists of four lines which have a
- * direction, which is per definitionem as follows:
+ * direction, which is by definition as follows:
  * @verbatim
  *   3-->--2
  *   |     |
@@ -277,7 +277,7 @@ struct SubCellData;
  * For this reason, the <tt>read_*</tt> functions of this class that read in
  * grids in various input formats call the GridReordering class to bring the
  * order of vertices that define the cells into an ordering that satisfies the
- * requiremenets of the Triangulation class. Be sure to read the documentation
+ * requirements of the Triangulation class. Be sure to read the documentation
  * of that class if you experience unexpected problems when reading grids
  * through this class.
  *
diff --git a/include/deal.II/grid/grid_out.h b/include/deal.II/grid/grid_out.h
index 05021a2b49..a4796b1b8d 100644
--- a/include/deal.II/grid/grid_out.h
+++ b/include/deal.II/grid/grid_out.h
@@ -237,7 +237,7 @@ namespace GridOutFlags
 
     /**
      * Based on the vertices of the face and #n_boundary_face_points
-     * additional points a tensor product mesh (tranformed to the real space)
+     * additional points a tensor product mesh (transformed to the real space)
      * of (#n_boundary_face_points+2)<sup>dim-1</sup> points is plotted on
      * each boundary face.
      */
@@ -318,7 +318,7 @@ namespace GridOutFlags
     bool color_lines_on_user_flag;
 
     /**
-     * This is the number of points on a boundary face, that are ploted
+     * This is the number of points on a boundary face, that are plotted
      * additionally to the vertices of the face.
      *
      * This is used if the mapping used is not the standard @p MappingQ1
@@ -1173,7 +1173,7 @@ public:
   static std::string default_suffix (const OutputFormat output_format);
 
   /**
-   * Default suffix for the default output format selected throuw
+   * Default suffix for the default output format selected through
    * ParameterHandler.
    */
   std::string default_suffix () const;
diff --git a/include/deal.II/grid/grid_reordering.h b/include/deal.II/grid/grid_reordering.h
index b92c508327..4f2458a507 100644
--- a/include/deal.II/grid/grid_reordering.h
+++ b/include/deal.II/grid/grid_reordering.h
@@ -292,7 +292,7 @@ DEAL_II_NAMESPACE_OPEN
  * From the examples above, it is obvious that if we encounter a cell that
  * cannot be added to the cells which have already been entered, we can not
  * usually point to a cell that is the culprit and that must be entered in a
- * different oreintation. Furthermore, even if we knew which cell, there might
+ * different orientation. Furthermore, even if we knew which cell, there might
  * be large number of cells that would then cease to fit into the grid and
  * which we would have to find a different orientation as well (in the second
  * example above, if we rotated cell 1, then we would have to rotate the cells
@@ -305,7 +305,7 @@ DEAL_II_NAMESPACE_OPEN
  * structure, where node N has as many children as there are possible
  * orientations of node N+1 (in two space dimensions, there are four
  * orientations in which each cell can be constructed from its four vertices;
- * for example, if the vertex indicaes are <tt>(0 1 2 3)</tt>, then the four
+ * for example, if the vertex indices are <tt>(0 1 2 3)</tt>, then the four
  * possibilities would be <tt>(0 1 2 3)</tt>, <tt>(1 2 3 0)</tt>, <tt>(2 3 0
  * 1)</tt>, and <tt>(3 0 1 2)</tt>). When adding one cell after the other, we
  * traverse this tree in a depth-first (pre-order) fashion. When we encounter
@@ -376,7 +376,7 @@ DEAL_II_NAMESPACE_OPEN
  * @endverbatim
  * First a cell is chosen ( (0,1,4,3) in this case). A single side of the cell
  * is oriented arbitrarily (3->4). This choice of orientation is then
- * propogated through the mesh, across sides and elements. (0->1), (6->7) and
+ * propagated through the mesh, across sides and elements. (0->1), (6->7) and
  * (9->10). The involves edge-hopping and face hopping, giving a path through
  * the mesh shown in dots.
  * @verbatim
@@ -501,7 +501,7 @@ DEAL_II_NAMESPACE_OPEN
  *
  * The first such method is based on the observation that if we fail to insert
  * one cell with number N, then this may not be due to cell N-1 unless N-1 is
- * a direct neighbor of N. The reason is abvious: the chosen orientation of
+ * a direct neighbor of N. The reason is obvious: the chosen orientation of
  * cell M could only affect the possibilities to add cell N if either it were
  * a direct neighbor or if there were a sequence of cells that were added
  * after M and that connected cells M and N. Clearly, for M=N-1, the latter
@@ -575,7 +575,7 @@ DEAL_II_NAMESPACE_OPEN
  * been added already. This would be cell 0. However, we know that the
  * orientation of cell 0 can't be important, so we conclude that there is no
  * possible way to orient all the lines of the given cells such that they
- * satisfy the requirements if deal.II triangulations. We know that this can't
+ * satisfy the requirements of deal.II triangulations. We know that this can't
  * be, so it results in an exception be thrown.
  *
  * The bottom line of this example is that when we looked at all possible
@@ -646,9 +646,9 @@ public:
    * positive measure/volume. In the former case, all cells are inverted. It
    * does nothing in 1d.
    *
-   * The invertion of cells might also work when only a subset of all cells
+   * The inversion of cells might also work when only a subset of all cells
    * have negative volume. However, grids consisting of a mixture of negative
-   * and positiv oriented cells are very likely to be broken. Therefore, an
+   * and positively oriented cells are very likely to be broken. Therefore, an
    * exception is thrown, in case cells are not uniformly oriented.
    *
    * Note, that this function should be called before reorder_cells().
diff --git a/include/deal.II/grid/grid_reordering_internal.h b/include/deal.II/grid/grid_reordering_internal.h
index b421d9c5bc..40cd8508f0 100644
--- a/include/deal.II/grid/grid_reordering_internal.h
+++ b/include/deal.II/grid/grid_reordering_internal.h
@@ -81,7 +81,7 @@ namespace internal
       static const int EdgeToNode[4][2];
 
       /**
-       * The edges comin into each node, in anti-clockwise order {
+       * The edges common to each node, in anti-clockwise order {
        * {3,0},{0,1},{1,2},{2,3} }
        */
       static const int NodeToEdge[4][2];
@@ -207,7 +207,7 @@ namespace internal
       void build_graph (const std::vector<CellData<2> > &inquads);
 
       /**
-       * Orient the internal data into deal.II format The orientation algorith
+       * Orient the internal data into deal.II format The orientation algorithm
        * is as follows
        *
        * 1) Find an unoriented quad (A)
@@ -218,7 +218,7 @@ namespace internal
        *
        * 4) if opposite side to (s) of (B) is unoriented orient it
        *
-       * 5) repeat 3) and 4) until side-hoppong fails (we've reached a
+       * 5) repeat 3) and 4) until side-hopping fails (we've reached a
        * boundary) or (s) has already been oriented (we've closed a loop or
        * unoriented sides).
        *
@@ -616,9 +616,9 @@ namespace internal
       bool orient_next_unoriented_edge ();
 
       /**
-       * Return whether the cell is consistenty oriented at present (i.e. only
-       * considering those edges that are already oriented. This is a sanity
-       * check that should be called from inside an assert macro.
+       * Return whether the cell is consistently oriented at present (i.e.
+       * only considering those edges that are already oriented. This is
+       * a sanity check that should be called from inside an assert macro.
        */
       bool cell_is_consistent (const unsigned int cell_num) const;
 
diff --git a/include/deal.II/grid/grid_tools.h b/include/deal.II/grid/grid_tools.h
index 46285086b0..ca335e2473 100644
--- a/include/deal.II/grid/grid_tools.h
+++ b/include/deal.II/grid/grid_tools.h
@@ -127,7 +127,7 @@ namespace GridTools
                  const Mapping<dim,spacedim> &mapping = (StaticMappingQ1<dim,spacedim>::mapping));
 
   /**
-   * Return the diamater of the smallest active cell of a triangulation. See
+   * Return the diameter of the smallest active cell of a triangulation. See
    * step-24 for an example of use of this function.
    */
   template <int dim, int spacedim>
@@ -135,7 +135,7 @@ namespace GridTools
   minimal_cell_diameter (const Triangulation<dim, spacedim> &triangulation);
 
   /**
-   * Return the diamater of the largest active cell of a triangulation.
+   * Return the diameter of the largest active cell of a triangulation.
    */
   template <int dim, int spacedim>
   double
@@ -1128,7 +1128,7 @@ namespace GridTools
    * DoFs of the first face should be modified prior to constraining to the
    * DoFs of the second face. If @p first_vector_components is non empty the
    * matrix is interpreted as a rotation matrix that is applied to all vector
-   * valued blocks listet in @p first_vector_components of the FESystem. For
+   * valued blocks listed in @p first_vector_components of the FESystem. For
    * more details see make_periodicity_constraints() and the glossary
    * @ref GlossPeriodicConstraints "glossary entry on periodic conditions".
    *
@@ -1169,7 +1169,7 @@ namespace GridTools
    * over. This is a function you'd typically call when there is only one
    * active level on your Triangulation.
    *
-   * The optional parameter @p reset_boundary_ids, indicates wether this
+   * The optional parameter @p reset_boundary_ids, indicates whether this
    * function should reset the boundary_ids of the Triangulation to its
    * default value 0 after copying its value to the manifold_id. By default,
    * boundary_ids are left untouched.
@@ -1190,7 +1190,7 @@ namespace GridTools
    * underlying manifold.
    *
    * When reading a Triangulation from a supported input format, typical
-   * informations that can be stored in a file are boundary conditions for
+   * information that can be stored in a file are boundary conditions for
    * boundary faces (which we store in the boundary_id of the faces), material
    * types for cells (which we store in the material_id of the cells) and in
    * some cases subdomain ids for cells (which we store in the subdomain_id of
@@ -1203,7 +1203,7 @@ namespace GridTools
    * Manifold objects for new points. This function iterates over active cells
    * and copies the material_ids to the manifold_ids.
    *
-   * The optional parameter @p compute_face_ids, indicates wether this
+   * The optional parameter @p compute_face_ids, indicates whether this
    * function should also set the manifold_ids of the faces (both for internal
    * faces and for faces on the boundary). If set to true, then each face will
    * get a manifold_id equal to the minimum of the surrounding manifold_ids,
diff --git a/include/deal.II/grid/intergrid_map.h b/include/deal.II/grid/intergrid_map.h
index d28e03e058..c7f67c79df 100644
--- a/include/deal.II/grid/intergrid_map.h
+++ b/include/deal.II/grid/intergrid_map.h
@@ -74,7 +74,7 @@ DEAL_II_NAMESPACE_OPEN
  * Note that this class could in principle be based on the C++
  * <tt>std::map<Key,Value></tt> data type. Instead, it uses another data
  * format which is more effective both in terms of computing time for access
- * as well as with regard to memory consumpion.
+ * as well as with regard to memory consumption.
  *
  *
  * <h3>Usage</h3>
diff --git a/include/deal.II/grid/manifold.h b/include/deal.II/grid/manifold.h
index 882ee1e682..b3a06b25e8 100644
--- a/include/deal.II/grid/manifold.h
+++ b/include/deal.II/grid/manifold.h
@@ -65,7 +65,7 @@ namespace Manifolds
  * unlike almost all other cases in the library, we here interpret the points
  * in the quadrature object to be in real space, not on the reference cell.)
  *
- * Internaly, the get_new_point() function calls the project_to_manifold()
+ * Internally, the get_new_point() function calls the project_to_manifold()
  * function after computing the weighted average of the quadrature points.
  * This allows end users to only overload project_to_manifold() for simple
  * situations.
@@ -73,7 +73,7 @@ namespace Manifolds
  * Should a finer control be necessary, then get_new_point() can be
  * overloaded.
  *
- * FlatManifold is the specialization from which StraigthBoundary is derived,
+ * FlatManifold is the specialization from which StraightBoundary is derived,
  * where the project_to_manifold() function is the identity.
  *
  * @ingroup manifold
@@ -242,8 +242,9 @@ public:
    * has zero length, then no periodicity is computed in that direction.
    * Whenever a function that tries to compute averages is called, an
    * exception will be thrown if one of the points which you are using for the
-   * average lies outside the periodicity box. The return points are garanteed
-   * to lie in the perodicity box plus or minus tolerance*periodicity.norm().
+   * average lies outside the periodicity box. The return points are
+   * guaranteed to lie in the periodicity box plus or minus
+   * tolerance*periodicity.norm().
    */
   FlatManifold (const Point<spacedim> periodicity=Point<spacedim>(),
                 const double tolerance=1e-10);
@@ -565,7 +566,7 @@ namespace Manifolds
                          hex->quad(i)->get_manifold().get_new_point_on_quad(hex->quad(i)));
             wp[j] = 1.0/12.0;
           }
-        // Overwrited the weights with 1/np if we don't want to use
+        // Overwrite the weights with 1/np if we don't want to use
         // laplace vectors.
         if (with_laplace == false)
           std::fill(wp.begin(), wp.end(), 1.0/np);
diff --git a/include/deal.II/grid/manifold_lib.h b/include/deal.II/grid/manifold_lib.h
index e6318e4243..e105719f3f 100644
--- a/include/deal.II/grid/manifold_lib.h
+++ b/include/deal.II/grid/manifold_lib.h
@@ -164,7 +164,7 @@ protected:
 
 private:
   /**
-   * Helper FlatManifold to compute temptative midpoints.
+   * Helper FlatManifold to compute tentative midpoints.
    */
   FlatManifold<dim,spacedim> flat_manifold;
 
@@ -180,11 +180,11 @@ private:
  * Function<spacedim> and Function<chartdim> objects describing the
  * push_forward() and pull_back() functions.
  *
- * You can use this Manifold object to describe any arbitray shape domain, as
+ * You can use this Manifold object to describe any arbitrary shape domain, as
  * long as you can express it in terms of an invertible map, for which you
  * provide both the forward expression, and the inverse expression.
  *
- * In debug mode, a check is performed to verify that the tranformations are
+ * In debug mode, a check is performed to verify that the transformations are
  * actually one the inverse of the other.
  *
  * @ingroup manifold
diff --git a/include/deal.II/grid/tria.h b/include/deal.II/grid/tria.h
index 045953c948..d3eeaef749 100644
--- a/include/deal.II/grid/tria.h
+++ b/include/deal.II/grid/tria.h
@@ -124,7 +124,7 @@ struct CellData
   };
 
   /**
-   * Manifold identificator of this object. This identificator should be used
+   * Manifold identifier of this object. This identifier should be used
    * to identify the manifold to which this object belongs, and from which
    * this object will collect information on how to add points upon
    * refinement.
@@ -160,7 +160,7 @@ struct CellData
  * a common number describing the boundary condition to hold on this part of
  * the boundary. The triangulation creation function gives lines not in this
  * list either the boundary indicator zero (if on the boundary) or
- * numbers::internal_face_boundary_id (if in the interior). Explicitely giving
+ * numbers::internal_face_boundary_id (if in the interior). Explicitly giving
  * a line the indicator numbers::internal_face_boundary_id will result in an
  * error, as well as giving an interior line a boundary indicator.
  *
@@ -1048,7 +1048,7 @@ namespace internal
  * For technical reasons, writing and restoring a Triangulation object is not-
  * trivial. The primary reason is that unlike many other objects,
  * triangulations rely on many other objects to which they store pointers or
- * with which they interace; for example, triangulations store pointers to
+ * with which they interface; for example, triangulations store pointers to
  * objects describing boundaries and manifolds, and they have signals that
  * store pointers to other objects so they can be notified of changes in the
  * triangulation (see the section on signals in this introduction). As objects
@@ -1286,12 +1286,12 @@ public:
      * before calling execute_coarsening_and_refinement the first time. The
      * easiest way to achieve this is by calling global_refine(1) straight
      * after creation of the triangulation. It follows that active cells on
-     * level 1 may not be coarsenend.
+     * level 1 may not be coarsened.
      *
      * The main use of this flag is to ensure that each cell has at least one
      * neighbor in each coordinate direction (i.e. each cell has at least a
      * left or right, and at least an upper or lower neighbor in 2d). This is
-     * a necessary precondition for some algorihms that compute finite
+     * a necessary precondition for some algorithms that compute finite
      * differences between cells. The DerivativeApproximation class is one of
      * these algorithms that require that a triangulation is coarsest_level_1
      * unless all cells already have at least one neighbor in each coordinate
@@ -1385,7 +1385,7 @@ public:
     /**
      * This flag includes all the above ones and therefore combines all
      * smoothing algorithms implemented with the exception of anisotropic
-     * smoothening.
+     * smoothing.
      */
     maximum_smoothing                  = 0xffff ^ allow_anisotropic_smoothing
   };
@@ -1593,7 +1593,7 @@ public:
 
   /**
    * Assign a manifold object to a certain part of the the triangulation. If
-   * an object with manfifold number @p number is refined, this object is used
+   * an object with manifold number @p number is refined, this object is used
    * to find the location of new vertices (see the results section of step-49
    * for a more in-depth discussion of this, with examples).  It is also used
    * for non-linear (i.e.: non-Q1) transformations of cells to the unit cell
diff --git a/include/deal.II/grid/tria_accessor.h b/include/deal.II/grid/tria_accessor.h
index 935f7d2f22..a3da804d1c 100644
--- a/include/deal.II/grid/tria_accessor.h
+++ b/include/deal.II/grid/tria_accessor.h
@@ -449,7 +449,7 @@ protected:
 
   /**
    * Used to store the index of the element presently pointed to on the level
-   * presentl used.
+   * presently used.
    */
   int present_index;
 
@@ -761,7 +761,7 @@ public:
    * direction. @p true indicates, that the line is oriented from vertex 0 to
    * vertex 1, whereas it is the other way around otherwise. In 1d and 2d,
    * this is always @p true, but in 3d it may be different, see the respective
-   * discussion in the documentation of the GeometryInfo classe.
+   * discussion in the documentation of the GeometryInfo class.
    *
    * This function is really only for internal use in the library unless you
    * absolutely know what this is all about.
@@ -797,7 +797,7 @@ public:
    * If the present cell is not refined, one is returned.
    *
    * If one considers a triangulation as a forest where the root of each tree
-   * are the coarse mesh cells and nodes have descendents (the children of a
+   * are the coarse mesh cells and nodes have descendants (the children of a
    * cell), then this function returns the number of terminal nodes in the
    * sub-tree originating from the current object; consequently, if the
    * current object is not further refined, the answer is one.
@@ -1123,7 +1123,7 @@ public:
   /**
    * Access the value of the user pointer. It is in the responsibility of the
    * user to make sure that the pointer points to something useful. You should
-   * use the new style cast operator to maintain a minimum of typesafety, e.g.
+   * use the new style cast operator to maintain a minimum of type safety, e.g.
    *
    * @note User pointers and user indices are mutually exclusive. Therefore,
    * you can only use one of them, unless you call
@@ -1281,8 +1281,8 @@ public:
    * Center of the object. The center of an object is defined to be the
    * average of the locations of the vertices. If required, the user may ask
    * this function to return the average of the point according to the
-   * underlyinging Manifold object, by setting to true the optional parameter
-   * @p respect_manifold.
+   * underlying Manifold object, by setting to true the optional parameter @p
+   * respect_manifold.
    *
    * When the geometry of a TriaAccessor is not flat, or when part of the
    * bounding objects of this TriaAccessor are not flat, the result given by
@@ -1377,7 +1377,7 @@ private:
    *
    * This function is only for internal use in the library. Setting this flag
    * to any other value than the one that the triangulation has already set is
-   * bound to bring you desaster.
+   * bound to bring you disaster.
    */
   void set_face_orientation (const unsigned int face,
                              const bool         orientation) const;
@@ -1662,7 +1662,7 @@ public:
   Point<spacedim> &vertex (const unsigned int i = 0) const;
 
   /**
-   * Return the center of this object, which of course co-incides with the
+   * Return the center of this object, which of course coincides with the
    * location of the vertex this object refers to.
    */
   Point<spacedim> center () const;
@@ -1887,7 +1887,7 @@ public:
   /**
    * Set the boundary indicator of this object and all of its lower-
    * dimensional sub-objects.  Since this object only represents a single
-   * vertex, there are no lower-dimensional obejct and this function is
+   * vertex, there are no lower-dimensional object and this function is
    * equivalent to calling set_boundary_id() with the same argument.
    *
    * @ingroup boundary
@@ -1909,7 +1909,7 @@ public:
   /**
    * Set the manifold indicator of this object and all of its lower-
    * dimensional sub-objects.  Since this object only represents a single
-   * vertex, there are no lower-dimensional obejct and this function is
+   * vertex, there are no lower-dimensional object and this function is
    * equivalent to calling set_manifold_id() with the same argument.
    *
    * @ingroup manifold
@@ -2624,7 +2624,7 @@ public:
    * works for parallel triangulations. See the documentation of the CellId
    * class for more information.
    *
-   * @note This operation takes O(level) time to compute. In most practicaly
+   * @note This operation takes O(level) time to compute. In most practical
    * cases, the number of levels of a triangulation will depend
    * logarithmically on the number of cells in the triangulation.
    */
@@ -2662,7 +2662,7 @@ protected:
    * neighbor_of_coarser_neighbor() function should be call. If you'd like to
    * know only the <code>face_no</code> which is required to get back from the
    * neighbor to the present cell then simply use the neighbor_face_no()
-   * function which can be used for coarser as well as noncoarser neighbors.
+   * function which can be used for coarser as well as non-coarser neighbors.
    */
   unsigned int neighbor_of_neighbor_internal (const unsigned int neighbor) const;
 
diff --git a/include/deal.II/grid/tria_accessor.templates.h b/include/deal.II/grid/tria_accessor.templates.h
index e9c88eb62b..0ebb75b840 100644
--- a/include/deal.II/grid/tria_accessor.templates.h
+++ b/include/deal.II/grid/tria_accessor.templates.h
@@ -843,7 +843,7 @@ namespace internal
         // the quad for its line_orientation. however, if
         // the face is rotated, it might be possible,
         // that a standard orientation of the line
-        // with respect to the face corrsponds to a
+        // with respect to the face corresponds to a
         // non-standard orientation for the line with
         // respect to the cell.
         //
@@ -870,7 +870,7 @@ namespace internal
             { { true, true },    // lines 0/1, face_orientation=true, face_flip=false, face_rotation=false and true
               { false, false }
             }
-          },// linea 0/1, face_orientation=true, face_flip=true, face_rotation=false and true
+          },// lines 0/1, face_orientation=true, face_flip=true, face_rotation=false and true
 
           { { { true, true },    // lines 2/3 ...
               { false, false }
diff --git a/include/deal.II/grid/tria_boundary_lib.h b/include/deal.II/grid/tria_boundary_lib.h
index 5db8cc92be..4ac7805207 100644
--- a/include/deal.II/grid/tria_boundary_lib.h
+++ b/include/deal.II/grid/tria_boundary_lib.h
@@ -628,7 +628,7 @@ public:
    */
   TorusBoundary (const double R, const double r);
 
-//Boundary Refinenment  Functions
+//Boundary Refinement Functions
   /**
    * Construct a new point on a line.
    */
diff --git a/include/deal.II/grid/tria_iterator.h b/include/deal.II/grid/tria_iterator.h
index bca384278b..c1c644131c 100644
--- a/include/deal.II/grid/tria_iterator.h
+++ b/include/deal.II/grid/tria_iterator.h
@@ -79,7 +79,7 @@ template <typename> class TriaActiveIterator;
  * The objects pointed to are accessors, derived from TriaAccessorBase. Which
  * kind of accessor is determined by the template argument <em>Accessor</em>.
  * These accessors are not so much data structures as they are a collection of
- * functions providing access to the data stored in Tringulation or DoFHandler
+ * functions providing access to the data stored in Triangulation or DoFHandler
  * objects. Using these accessors, the structure of these classes is hidden
  * from the application program.
  *
@@ -128,7 +128,7 @@ template <typename> class TriaActiveIterator;
  *
  * The iterator class itself does not have much functionality. It only becomes
  * useful when assigned an Accessor (the second template parameter), which
- * really does the access to data. An Accessor has to fulfil some
+ * really does the access to data. An Accessor has to fulfill some
  * requirements:
  *
  * <ul>
@@ -198,7 +198,7 @@ template <typename> class TriaActiveIterator;
  * set to false.
  *
  * The last two checks are not made in <tt>state()</tt> since both cases
- * should only occur upon unitialized construction through @p memcpy and the
+ * should only occur upon uninitialized construction through @p memcpy and the
  * like (the parent triangulation can only be set upon construction). If an
  * iterator is constructed empty through the empty constructor,
  * <tt>present_level==-2</tt> and <tt>present_index==-2</tt>. Thus, the
@@ -213,7 +213,7 @@ template <typename> class TriaActiveIterator;
  * invalid provides a second track of security: if we should have forgotten a
  * check in the library when an iterator is incremented or decremented, we
  * automatically convert the iterator from the allowed state "past-the-end" to
- * the disallowed state "invalid" which increases the chance that somehwen
+ * the disallowed state "invalid" which increases the chance that some time
  * earlier than for past-the-end iterators an exception is raised.
  *
  * @ref Triangulation
@@ -531,7 +531,7 @@ protected:
    *
    * In fact, we would not need them to be friends if they were for different
    * dimensions, but the compiler dislikes giving a fixed dimension and
-   * variable accessor since then it says that would be a artial
+   * variable accessor since then it says that would be a partial
    * specialization.
    */
   template <typename SomeAccessor> friend class TriaRawIterator;
diff --git a/include/deal.II/grid/tria_iterator.templates.h b/include/deal.II/grid/tria_iterator.templates.h
index c736fc4a33..4dbaa4f16b 100644
--- a/include/deal.II/grid/tria_iterator.templates.h
+++ b/include/deal.II/grid/tria_iterator.templates.h
@@ -446,7 +446,7 @@ TriaActiveIterator<Accessor>::operator = (const TriaRawIterator<Accessor> &i)
   // do this like this, because:
   // if we write
   // "Assert (IteratorState::past_the_end || !has_children())"
-  // has_chidlren() is called anyway, even if
+  // has_children() is called anyway, even if
   // state==IteratorState::past_the_end, and will then
   // throw the exception!
   if (this->state() != IteratorState::past_the_end)
@@ -468,7 +468,7 @@ TriaActiveIterator<Accessor>::operator = (const TriaRawIterator<OtherAccessor> &
   // do this like this, because:
   // if we write
   // "Assert (IteratorState::past_the_end || !has_children())"
-  // has_chidlren() is called anyway, even if
+  // has_children() is called anyway, even if
   // state==IteratorState::past_the_end, and will then
   // throw the exception!
   if (this->state() != IteratorState::past_the_end)
diff --git a/include/deal.II/grid/tria_iterator_selector.h b/include/deal.II/grid/tria_iterator_selector.h
index 94a81d5592..5b3702a1d7 100644
--- a/include/deal.II/grid/tria_iterator_selector.h
+++ b/include/deal.II/grid/tria_iterator_selector.h
@@ -144,7 +144,7 @@ namespace internal
 
     /**
      * This class implements some types which differ between the dimensions.
-     * These are the declararions for the 3D case only. See the
+     * These are the declarations for the 3D case only. See the
      * @ref Iterators
      * module for more information.
      *
diff --git a/include/deal.II/grid/tria_levels.h b/include/deal.II/grid/tria_levels.h
index 1c0ab04172..79d7ec592d 100644
--- a/include/deal.II/grid/tria_levels.h
+++ b/include/deal.II/grid/tria_levels.h
@@ -102,8 +102,8 @@ namespace internal
        * In one dimension, a neighbor may have any level less or equal the
        * level of this cell. If it has the same level, it may be refined an
        * arbitrary number of times, but the neighbor pointer still points to
-       * the cell on the same level, while the neighbors of the childs of the
-       * neighbor may point to this cell or its children.
+       * the cell on the same level, while the neighbors of the children of
+       * the neighbor may point to this cell or its children.
        *
        * In two and more dimensions, the neighbor is either on the same level
        * and refined (in which case its children have neighbor pointers to
@@ -169,8 +169,8 @@ namespace internal
 
       /**
        * Check the memory consistency of the different containers. Should only
-       * be called with the prepro flag @p DEBUG set. The function should be
-       * called from the functions of the higher TriaLevel classes.
+       * be called with the preprocessor flag @p DEBUG set. The function
+       * should be called from the functions of the higher TriaLevel classes.
        */
       void monitor_memory (const unsigned int true_dimension) const;
 
diff --git a/include/deal.II/grid/tria_objects.h b/include/deal.II/grid/tria_objects.h
index a8c7606f4b..2bc41967b8 100644
--- a/include/deal.II/grid/tria_objects.h
+++ b/include/deal.II/grid/tria_objects.h
@@ -271,7 +271,7 @@ namespace internal
 
       /**
        * Clear all user pointers or indices and reset their type, such that
-       * the next access may be aither or.
+       * the next access may be either or.
        */
       void clear_user_data();
 
@@ -282,8 +282,8 @@ namespace internal
 
       /**
        * Check the memory consistency of the different containers. Should only
-       * be called with the prepro flag @p DEBUG set. The function should be
-       * called from the functions of the higher TriaLevel classes.
+       * be called with the preprocessor flag @p DEBUG set. The function
+       * should be called from the functions of the higher TriaLevel classes.
        */
       void monitor_memory (const unsigned int true_dimension) const;
 
@@ -383,7 +383,7 @@ namespace internal
       };
 
       /**
-       * Enum descibing the possible types of userdata.
+       * Enum describing the possible types of userdata.
        */
       enum UserDataType
       {
@@ -431,11 +431,11 @@ namespace internal
 
       /**
        * For edges, we enforce a standard convention that opposite edges
-       * should be parallel. Now, that's enforcable in most cases, and we have
-       * code that makes sure that if a mesh allows this to happen, that we
-       * have this convention. We also know that it is always possible to have
-       * opposite faces have parallel normal vectors. (For both things, see
-       * the Agelek, Anderson, Bangerth, Barth paper mentioned in the
+       * should be parallel. Now, that's enforceable in most cases, and we
+       * have code that makes sure that if a mesh allows this to happen, that
+       * we have this convention. We also know that it is always possible to
+       * have opposite faces have parallel normal vectors. (For both things,
+       * see the Agelek, Anderson, Bangerth, Barth paper mentioned in the
        * publications list.)
        *
        * The problem is that we originally had another condition, namely that
@@ -476,8 +476,8 @@ namespace internal
 
       /**
        * Check the memory consistency of the different containers. Should only
-       * be called with the prepro flag @p DEBUG set. The function should be
-       * called from the functions of the higher TriaLevel classes.
+       * be called with the preprocessor flag @p DEBUG set. The function
+       * should be called from the functions of the higher TriaLevel classes.
        */
       void monitor_memory (const unsigned int true_dimension) const;
 
@@ -539,8 +539,8 @@ namespace internal
 
       /**
        * Check the memory consistency of the different containers. Should only
-       * be called with the prepro flag @p DEBUG set. The function should be
-       * called from the functions of the higher TriaLevel classes.
+       * be called with the preprocessor flag @p DEBUG set. The function
+       * should be called from the functions of the higher TriaLevel classes.
        */
       void monitor_memory (const unsigned int true_dimension) const;
 
diff --git a/include/deal.II/hp/dof_faces.h b/include/deal.II/hp/dof_faces.h
index 605367e0e0..93c179c0c0 100644
--- a/include/deal.II/hp/dof_faces.h
+++ b/include/deal.II/hp/dof_faces.h
@@ -216,7 +216,7 @@ namespace internal
      * cells, as this information is independent of the hierarchical structure
      * of cells, which are organized in levels. In 2D we store information on
      * degrees of freedom located on lines whereas in 3D we store information
-     * on drefrees of freedom located on quads and lines. In 1D we do nothing,
+     * on degrees of freedom located on quads and lines. In 1D we do nothing,
      * as the faces of lines are vertices which are treated separately.
      *
      * Apart from the internal::hp::DoFObjects object containing the data to
diff --git a/include/deal.II/hp/dof_handler.h b/include/deal.II/hp/dof_handler.h
index 0140965132..c6ccf3ae65 100644
--- a/include/deal.II/hp/dof_handler.h
+++ b/include/deal.II/hp/dof_handler.h
@@ -602,7 +602,7 @@ namespace hp
      * object.
      *
      * This function is made virtual, since a dof handler object might be
-     * accessed through a pointers to thisr base class, although the actual
+     * accessed through a pointers to this base class, although the actual
      * object might be a derived class.
      */
     virtual std::size_t memory_consumption () const;
diff --git a/include/deal.II/hp/q_collection.h b/include/deal.II/hp/q_collection.h
index 958579de49..e18f865ad8 100644
--- a/include/deal.II/hp/q_collection.h
+++ b/include/deal.II/hp/q_collection.h
@@ -96,7 +96,7 @@ namespace hp
     /**
      * Return the maximum number of quadrature points over all the elements of
      * the collection. This is mostly useful to initialize arrays to allocate
-     * the maxmimum amount of memory that may be used when re-sizing later on
+     * the maximum amount of memory that may be used when re-sizing later on
      * to a articular quadrature formula from within this collection.
      */
     unsigned int max_n_quadrature_points () const;
diff --git a/include/deal.II/lac/block_linear_operator.h b/include/deal.II/lac/block_linear_operator.h
index 6bc4b2d5f3..61c84c22bd 100644
--- a/include/deal.II/lac/block_linear_operator.h
+++ b/include/deal.II/lac/block_linear_operator.h
@@ -53,7 +53,7 @@ template <typename Number> class BlockVector;
  *         |
  *  op_a10 | op_a11
  * @endcode
- * The coresponding block_operator invocation takes the form
+ * The corresponding block_operator invocation takes the form
  * @code
  * block_operator<2, 2, BlockVector<double>>({op_a00, op_a01, op_a10, op_a11});
  * @endcode
@@ -154,7 +154,7 @@ block_operator(const std::array<std::array<LinearOperator<typename Range::BlockT
  *
  * The list @p ops is best passed as an initializer list. Consider for example
  * a linear operator block (acting on Vector<double>) <code>diag(op_a0, op_a1,
- * ..., op_am)</code>. The coresponding block_operator invocation takes the
+ * ..., op_am)</code>. The corresponding block_operator invocation takes the
  * form
  * @code
  * block_diagonal_operator<m, BlockVector<double>>({op_00, op_a1, ..., op_am});
@@ -330,7 +330,7 @@ block_diagonal_operator(const LinearOperator<typename Range::BlockType, typename
  * block triangular matrix.
  * As argument, it takes an array of array of LinearOperators @p block_matrix
  * representing a lower block triangular matrix and an array of LinearOperators
- * @p inverse_diagonal representing inverses of digonal blocks of @p block_matrix.
+ * @p inverse_diagonal representing inverses of diagonal blocks of @p block_matrix.
  *
  * Let us assume we have a linear system with the following block structure:
  *
@@ -439,7 +439,7 @@ block_forward_substitution(const std::array<std::array<LinearOperator<typename R
  * block triangular matrix.
  * As argument, it takes an array of array of LinearOperators @p block_matrix
  * representing an upper block triangular matrix and an array of LinearOperators
- * @p inverse_diagonal representing inverses of digonal blocks of @p block_matrix.
+ * @p inverse_diagonal representing inverses of diagonal blocks of @p block_matrix.
  *
  * Let us assume we have a linear system with the following block structure:
  *
@@ -548,7 +548,7 @@ block_back_substitution(const std::array<std::array<LinearOperator<typename Rang
  * block_forward_substitution to invert triangular matrices. It takes as input
  * a triangular block matrix @p block_matrix, an array of LinearOperators @p
  * inverse_diagonal representing inverses of block_matrix, and an optional
- * bool @p lower used to specify if block_matrix should be conidered as lower
+ * bool @p lower used to specify if block_matrix should be considered as lower
  * triangular matrix (true) or as upper triangular matrix (false). @p lower is
  * equal to true by default.
  *
diff --git a/include/deal.II/lac/block_matrix_base.h b/include/deal.II/lac/block_matrix_base.h
index 84faf97a28..599673b319 100644
--- a/include/deal.II/lac/block_matrix_base.h
+++ b/include/deal.II/lac/block_matrix_base.h
@@ -228,7 +228,7 @@ namespace BlockMatrixIterators
               const size_type col);
 
     /**
-     * Initalize const accessor from non const accessor.
+     * Initialize const accessor from non const accessor.
      */
     Accessor(const Accessor<BlockMatrix, false> &);
 
@@ -380,7 +380,7 @@ public:
    * Copy the given matrix to this one.  The operation throws an error if the
    * sparsity patterns of the two involved matrices do not point to the same
    * object, since in this case the copy operation is cheaper. Since this
-   * operation is notheless not for free, we do not make it available through
+   * operation is nonetheless not for free, we do not make it available through
    * operator=(), since this may lead to unwanted usage, e.g. in copy
    * arguments to functions, which should really be arguments by reference.
    *
@@ -696,7 +696,7 @@ public:
    * Print the matrix to the given stream, using the format <tt>(line,col)
    * value</tt>, i.e. one nonzero entry of the matrix per line. The optional
    * flag outputs the sparsity pattern in a different style according to the
-   * underlying sparsematrix type.
+   * underlying sparse matrix type.
    */
   void print (std::ostream &out,
               const bool    alternative_output = false) const;
diff --git a/include/deal.II/lac/block_sparse_matrix.h b/include/deal.II/lac/block_sparse_matrix.h
index 7f9069d765..4297697e2e 100644
--- a/include/deal.II/lac/block_sparse_matrix.h
+++ b/include/deal.II/lac/block_sparse_matrix.h
@@ -73,7 +73,7 @@ public:
   typedef typename BaseClass::const_iterator  const_iterator;
 
   /**
-   * @name Constructors and initalization
+   * @name Constructors and initialization
    */
 //@{
   /**
diff --git a/include/deal.II/lac/block_sparsity_pattern.h b/include/deal.II/lac/block_sparsity_pattern.h
index c7f916bbc3..06c3868dfb 100644
--- a/include/deal.II/lac/block_sparsity_pattern.h
+++ b/include/deal.II/lac/block_sparsity_pattern.h
@@ -128,9 +128,9 @@ public:
 
   /**
    * Resize the matrix, by setting the number of block rows and columns. This
-   * deletes all blocks and replaces them by unitialized ones, i.e. ones for
-   * which also the sizes are not yet set. You have to do that by calling the
-   * reinit() functions of the blocks themselves. Do not forget to call
+   * deletes all blocks and replaces them with uninitialized ones, i.e. ones
+   * for which also the sizes are not yet set. You have to do that by calling
+   * the reinit() functions of the blocks themselves. Do not forget to call
    * collect_sizes() after that on this object.
    *
    * The reason that you have to set sizes of the blocks yourself is that the
diff --git a/include/deal.II/lac/block_vector_base.h b/include/deal.II/lac/block_vector_base.h
index a46155f0a1..1428d7f775 100644
--- a/include/deal.II/lac/block_vector_base.h
+++ b/include/deal.II/lac/block_vector_base.h
@@ -612,7 +612,7 @@ public:
   /**
    * Update internal structures after resizing vectors. Whenever you reinited
    * a block of a block vector, the internal data structures are corrupted.
-   * Therefore, you should call this function after al blocks got their new
+   * Therefore, you should call this function after all blocks got their new
    * size.
    */
   void collect_sizes ();
@@ -864,7 +864,7 @@ public:
 
 
   /**
-   * A collective add operation: This funnction adds a whole set of values
+   * A collective add operation: This function adds a whole set of values
    * stored in @p values to the vector components specified by @p indices.
    */
   template <typename Number>
diff --git a/include/deal.II/lac/chunk_sparse_matrix.h b/include/deal.II/lac/chunk_sparse_matrix.h
index 28cbb39eee..71875f2d6c 100644
--- a/include/deal.II/lac/chunk_sparse_matrix.h
+++ b/include/deal.II/lac/chunk_sparse_matrix.h
@@ -465,7 +465,7 @@ public:
   };
 
   /**
-   * @name Constructors and initalization.
+   * @name Constructors and initialization.
    */
 //@{
   /**
@@ -695,7 +695,7 @@ public:
    * Copy the given matrix to this one.  The operation throws an error if the
    * sparsity patterns of the two involved matrices do not point to the same
    * object, since in this case the copy operation is cheaper. Since this
-   * operation is notheless not for free, we do not make it available through
+   * operation is nonetheless not for free, we do not make it available through
    * <tt>operator =</tt>, since this may lead to unwanted usage, e.g. in copy
    * arguments to functions, which should really be arguments by reference.
    *
@@ -1328,7 +1328,7 @@ private:
 
   /**
    * Allocated size of #val. This can be larger than the actually used part if
-   * the size of the matrix was reduced somewhen in the past by associating a
+   * the size of the matrix was reduced sometime in the past by associating a
    * sparsity pattern with a smaller size to this object, using the reinit()
    * function.
    */
diff --git a/include/deal.II/lac/constraint_matrix.h b/include/deal.II/lac/constraint_matrix.h
index 4afd5f892f..319cdf1886 100644
--- a/include/deal.II/lac/constraint_matrix.h
+++ b/include/deal.II/lac/constraint_matrix.h
@@ -309,7 +309,7 @@ public:
                     const std::vector<std::pair<size_type,double> > &col_val_pairs);
 
   /**
-   * Set an imhomogeneity to the constraint line <i>i</i>, according to the
+   * Set an inhomogeneity to the constraint line <i>i</i>, according to the
    * discussion in the general class description.
    *
    * @note the line needs to be added with one of the add_line() calls first.
@@ -320,7 +320,7 @@ public:
   /**
    * Close the filling of entries. Since the lines of a matrix of this type
    * are usually filled in an arbitrary order and since we do not want to use
-   * associative constainers to store the lines, we need to sort the lines and
+   * associative constrainers to store the lines, we need to sort the lines and
    * within the lines the columns before usage of the matrix. This is done
    * through this function.
    *
@@ -442,7 +442,7 @@ public:
 
   /**
    * Returns <tt>true</tt> in case the dof is constrained and there is a non-
-   * trivial inhomogeneous valeus set to the dof.
+   * trivial inhomogeneous values set to the dof.
    */
   bool is_inhomogeneously_constrained (const size_type index) const;
 
@@ -1175,7 +1175,7 @@ private:
    * entries takes place when calling the <tt>close()</tt> function.
    *
    * We could, instead of using a vector, use an associative array, like a map
-   * to store the lines. This, however, would mean a much more fractioned heap
+   * to store the lines. This, however, would mean a much more fragmented heap
    * since it allocates many small objects, and would additionally make usage
    * of this matrix much slower.
    */
diff --git a/include/deal.II/lac/constraint_matrix.templates.h b/include/deal.II/lac/constraint_matrix.templates.h
index c0194a7cf4..4a39e5c87e 100644
--- a/include/deal.II/lac/constraint_matrix.templates.h
+++ b/include/deal.II/lac/constraint_matrix.templates.h
@@ -481,7 +481,7 @@ ConstraintMatrix::condense (BlockSparseMatrix<number> &uncondensed,
 }
 
 
-//TODO: I'm sure the followng could be made more elegant by using a bit of
+//TODO: I'm sure the following could be made more elegant by using a bit of
 //introspection using static member variables of the various vector
 //classes to dispatch between the different functions, rather than using
 //knowledge of the individual types
@@ -2252,7 +2252,7 @@ ConstraintMatrix::distribute_local_to_global (
 
       // now to the vectors. besides doing the same job as we did above (i.e.,
       // distribute the content of the local vector into the global one), need
-      // to account for inhomogeneities here: thie corresponds to eliminating
+      // to account for inhomogeneities here: this corresponds to eliminating
       // the respective column in the local matrix with value on the right
       // hand side.
       if (use_vectors == true)
diff --git a/include/deal.II/lac/filtered_matrix.h b/include/deal.II/lac/filtered_matrix.h
index b0f3792ef0..f7bfea2a11 100644
--- a/include/deal.II/lac/filtered_matrix.h
+++ b/include/deal.II/lac/filtered_matrix.h
@@ -177,7 +177,7 @@ template <class VECTOR> class FilteredMatrixBlock;
  * This class takes as template arguments a matrix and a vector class. The
  * former must provide @p vmult, @p vmult_add,  @p Tvmult, and @p residual
  * member function that operate on the vector type (the second template
- * argument). The latter template parameter must provide access to indivual
+ * argument). The latter template parameter must provide access to individual
  * elements through <tt>operator()</tt>, assignment through
  * <tt>operator=</tt>.
  *
@@ -352,7 +352,7 @@ public:
 
   /**
    * Set the matrix to be used further on. You will probably also want to call
-   * the clear_constraints() function if constraits were previously added.
+   * the clear_constraints() function if constraints were previously added.
    *
    * @arg @p m: The matrix being used in multiplications.
    *
@@ -487,7 +487,7 @@ private:
    *
    * We expect this for instance in Newton's method, where the residual
    * already should be zero on constrained nodes. This is, because there is no
-   * testfunction in these nodes.
+   * test function in these nodes.
    */
   bool expect_constrained_source;
 
diff --git a/include/deal.II/lac/full_matrix.templates.h b/include/deal.II/lac/full_matrix.templates.h
index 3e0602e55c..1fbd74528d 100644
--- a/include/deal.II/lac/full_matrix.templates.h
+++ b/include/deal.II/lac/full_matrix.templates.h
@@ -1763,7 +1763,7 @@ FullMatrix<number>::gauss_jordan ()
 #endif
 
   // otherwise do it by hand. use the
-  // Gauss-Jordan-Algorithmus from
+  // Gauss-Jordan-Algorithm from
   // Stoer & Bulirsch I (4th Edition)
   // p. 153
   const size_type N = n();
diff --git a/include/deal.II/lac/householder.h b/include/deal.II/lac/householder.h
index e573859401..b306e4946d 100644
--- a/include/deal.II/lac/householder.h
+++ b/include/deal.II/lac/householder.h
@@ -171,7 +171,7 @@ Householder<number>::initialize(const FullMatrix<number2> &M)
 
 
       // For all subsequent columns do
-      // the Householder reflexion
+      // the Householder reflection
       for (size_type k=j+1 ; k<n ; ++k)
         {
           number2 sum = diagonal[j]*this->el(j,k);
diff --git a/include/deal.II/lac/identity_matrix.h b/include/deal.II/lac/identity_matrix.h
index b5f976a8a4..6dae5bd6aa 100644
--- a/include/deal.II/lac/identity_matrix.h
+++ b/include/deal.II/lac/identity_matrix.h
@@ -71,7 +71,7 @@ class IdentityMatrix
 {
 public:
   /**
-   * Declate type for container size.
+   * Declare type for container size.
    */
   typedef types::global_dof_index size_type;
 
diff --git a/include/deal.II/lac/iterative_inverse.h b/include/deal.II/lac/iterative_inverse.h
index 7bd2d2f773..dbbf17ccfc 100644
--- a/include/deal.II/lac/iterative_inverse.h
+++ b/include/deal.II/lac/iterative_inverse.h
@@ -106,7 +106,7 @@ public:
 
   /**
    * The solver, which allows selection of the actual solver as well as
-   * adjuxtment of parameters.
+   * adjustment of parameters.
    */
   SolverSelector<VECTOR> solver;
 
diff --git a/include/deal.II/lac/matrix_block.h b/include/deal.II/lac/matrix_block.h
index 56c9630640..79d170296b 100644
--- a/include/deal.II/lac/matrix_block.h
+++ b/include/deal.II/lac/matrix_block.h
@@ -70,7 +70,7 @@ namespace internal
  * instance in MGLevelObject without extracting the #matrix first.
  *
  * MatrixBlock comes handy when using BlockMatrixArray. Once the MatrixBlock
- * has been properly initalized and filled, it can be used in the simplest
+ * has been properly initialized and filled, it can be used in the simplest
  * case as:
  * @code
  * MatrixBlockVector<SparseMatrix<double> > > blocks;
@@ -194,7 +194,7 @@ public:
   /**
    * Set several elements in the specified row of the matrix with column
    * indices as given by <tt>col_indices</tt> to the respective value. This is
-   * the function doing thye actual work for the ones adding full matrices.
+   * the function doing the actual work for the ones adding full matrices.
    * The global locations <tt>row_index</tt> and <tt>col_indices</tt> are
    * translated into locations in this block and ExcBlockIndexMismatch is
    * thrown, if the global index does not point into the block referred to by
@@ -292,7 +292,7 @@ public:
 
 private:
   /**
-   * The rwo BlockIndices of the whole system. Using row(), this allows us to
+   * The row BlockIndices of the whole system. Using row(), this allows us to
    * find the index of the first row degree of freedom for this block.
    */
   BlockIndices row_indices;
@@ -363,7 +363,7 @@ public:
    *
    * Since often only clearing of the individual matrices is desired, but not
    * removing the blocks themselves, there is an optional argument. If the
-   * argument is missing or @p false, all matrices will be mepty, but the size
+   * argument is missing or @p false, all matrices will be empty, but the size
    * of this object and the block positions will not change. If @p
    * really_clean is @p true, then the object will contain no blocks at the
    * end.
@@ -475,7 +475,7 @@ public:
    *
    * Since often only clearing of the individual matrices is desired, but not
    * removing the blocks themselves, there is an optional argument. If the
-   * argument is missing or @p false, all matrices will be mepty, but the size
+   * argument is missing or @p false, all matrices will be empty, but the size
    * of this object and the block positions will not change. If @p
    * really_clean is @p true, then the object will contain no blocks at the
    * end.
diff --git a/include/deal.II/lac/matrix_lib.h b/include/deal.II/lac/matrix_lib.h
index 5bb75c3fd9..d358d11172 100644
--- a/include/deal.II/lac/matrix_lib.h
+++ b/include/deal.II/lac/matrix_lib.h
@@ -189,7 +189,7 @@ public:
   void vmult (VECTOR &w, const VECTOR &v) const;
 
   /**
-   * Tranposed matrix-vector product.
+   * Transposed matrix-vector product.
    */
   void Tvmult (VECTOR &w, const VECTOR &v) const;
 
@@ -365,7 +365,7 @@ public:
               const BlockVector<number> &src) const;
 
   /**
-   * Add a soruce to dest, where the mean value in the selected component is
+   * Add a source to dest, where the mean value in the selected component is
    * subtracted.
    */
   template <typename number>
diff --git a/include/deal.II/lac/packaged_operation.h b/include/deal.II/lac/packaged_operation.h
index 955356d3aa..0d428c2994 100644
--- a/include/deal.II/lac/packaged_operation.h
+++ b/include/deal.II/lac/packaged_operation.h
@@ -82,7 +82,7 @@ template <typename Range = Vector<double> > class PackagedOperation;
  *   residual.apply(y);
  *   residual.apply_add(y);
  * @endcode
- * or until the @p PackagedOperation object is implictly converted:
+ * or until the @p PackagedOperation object is implicitly converted:
  * @code
  *   dealii::Vector<double> y;
  *   y = residual;
@@ -229,7 +229,7 @@ public:
   }
 
   /**
-   * Subract a constant @p offset (of the @p Range space) from the result of a
+   * Subtract a constant @p offset (of the @p Range space) from the result of a
    * PackagedOperation.
    */
   PackagedOperation<Range> &operator-=(const Range &offset)
@@ -530,7 +530,7 @@ PackagedOperation<Range> operator+(const Range &u, const Range &v)
   PackagedOperation<Range> return_comp;
 
   // ensure to have valid PackagedOperation objects by catching op by value
-  // u is catched by reference
+  // u is caught by reference
 
   return_comp.reinit_vector = [&u](Range &x, bool fast)
   {
@@ -670,7 +670,7 @@ operator*(const LinearOperator<Range, Domain> &op,
   return_comp.reinit_vector = op.reinit_range_vector;
 
   // ensure to have valid PackagedOperation objects by catching op by value
-  // u is catched by reference
+  // u is caught by reference
 
   return_comp.apply = [op, &u](Range &v)
   {
@@ -712,7 +712,7 @@ operator*(const Range &u,
   return_comp.reinit_vector = op.reinit_domain_vector;
 
   // ensure to have valid PackagedOperation objects by catching op by value
-  // u is catched by reference
+  // u is caught by reference
 
   return_comp.apply = [op, &u](Domain &v)
   {
@@ -746,7 +746,7 @@ operator*(const LinearOperator<Range, Domain> &op,
   return_comp.reinit_vector = op.reinit_range_vector;
 
   // ensure to have valid PackagedOperation objects by catching op by value
-  // u is catched by reference
+  // u is caught by reference
 
   return_comp.apply = [op, comp](Domain &v)
   {
@@ -796,7 +796,7 @@ operator*(const PackagedOperation<Range> &comp,
   return_comp.reinit_vector = op.reinit_domain_vector;
 
   // ensure to have valid PackagedOperation objects by catching op by value
-  // u is catched by reference
+  // u is caught by reference
 
   return_comp.apply = [op, comp](Domain &v)
   {
diff --git a/include/deal.II/lac/parallel_block_vector.h b/include/deal.II/lac/parallel_block_vector.h
index c8ce35ae4c..c7039d580e 100644
--- a/include/deal.II/lac/parallel_block_vector.h
+++ b/include/deal.II/lac/parallel_block_vector.h
@@ -139,7 +139,7 @@ namespace parallel
                    const MPI_Comm  communicator);
 
       /**
-       * Same as above but the ghost indicies are assumed to be empty.
+       * Same as above but the ghost indices are assumed to be empty.
        */
       BlockVector (const std::vector<IndexSet> &local_ranges,
                    const MPI_Comm  communicator);
diff --git a/include/deal.II/lac/parallel_vector.h b/include/deal.II/lac/parallel_vector.h
index d2e78f7c92..eb863216d2 100644
--- a/include/deal.II/lac/parallel_vector.h
+++ b/include/deal.II/lac/parallel_vector.h
@@ -792,7 +792,7 @@ namespace parallel
       Vector<Number> &operator -= (const Vector<Number> &V);
 
       /**
-       * A collective add operation: This funnction adds a whole set of values
+       * A collective add operation: This function adds a whole set of values
        * stored in @p values to the vector components specified by @p indices.
        */
       template <typename OtherNumber>
diff --git a/include/deal.II/lac/petsc_block_sparse_matrix.h b/include/deal.II/lac/petsc_block_sparse_matrix.h
index 3393ee6c5e..c4d7233448 100644
--- a/include/deal.II/lac/petsc_block_sparse_matrix.h
+++ b/include/deal.II/lac/petsc_block_sparse_matrix.h
@@ -127,7 +127,7 @@ namespace PETScWrappers
 
     /**
      * Resize the matrix, by setting the number of block rows and columns.
-     * This deletes all blocks and replaces them by unitialized ones, i.e.
+     * This deletes all blocks and replaces them by uninitialized ones, i.e.
      * ones for which also the sizes are not yet set. You have to do that by
      * calling the @p reinit functions of the blocks themselves. Do not forget
      * to call collect_sizes() after that on this object.
diff --git a/include/deal.II/lac/petsc_matrix_base.h b/include/deal.II/lac/petsc_matrix_base.h
index a0eca82ccb..076c38e51e 100644
--- a/include/deal.II/lac/petsc_matrix_base.h
+++ b/include/deal.II/lac/petsc_matrix_base.h
@@ -250,7 +250,7 @@ namespace PETScWrappers
    *
    * The interface of this class is modeled after the existing SparseMatrix
    * class in deal.II. It has almost the same member functions, and is often
-   * exchangable. However, since PETSc only supports a single scalar type
+   * exchangeable. However, since PETSc only supports a single scalar type
    * (either double, float, or a complex data type), it is not templated, and
    * only works with whatever your PETSc installation has defined the data
    * type PetscScalar to.
@@ -1292,7 +1292,7 @@ namespace PETScWrappers
 
     if (value == PetscScalar())
       {
-        // we have to do checkings on Insert/Add in any case to be
+        // we have to check after using Insert/Add in any case to be
         // consistent with the MPI communication model (see the comments in
         // the documentation of TrilinosWrappers::Vector), but we can save
         // some work if the addend is zero. However, these actions are done
diff --git a/include/deal.II/lac/petsc_parallel_block_sparse_matrix.h b/include/deal.II/lac/petsc_parallel_block_sparse_matrix.h
index 2d913ca579..1f79fa60ed 100644
--- a/include/deal.II/lac/petsc_parallel_block_sparse_matrix.h
+++ b/include/deal.II/lac/petsc_parallel_block_sparse_matrix.h
@@ -129,10 +129,10 @@ namespace PETScWrappers
 
       /**
        * Resize the matrix, by setting the number of block rows and columns.
-       * This deletes all blocks and replaces them by unitialized ones, i.e.
-       * ones for which also the sizes are not yet set. You have to do that by
-       * calling the @p reinit functions of the blocks themselves. Do not
-       * forget to call collect_sizes() after that on this object.
+       * This deletes all blocks and replaces them with uninitialized ones,
+       * i.e.  ones for which also the sizes are not yet set. You have to do
+       * that by calling the @p reinit functions of the blocks themselves. Do
+       * not forget to call collect_sizes() after that on this object.
        *
        * The reason that you have to set sizes of the blocks yourself is that
        * the sizes may be varying, the maximum number of elements per row may
diff --git a/include/deal.II/lac/petsc_parallel_vector.h b/include/deal.II/lac/petsc_parallel_vector.h
index 3e82a41153..015de002f8 100644
--- a/include/deal.II/lac/petsc_parallel_vector.h
+++ b/include/deal.II/lac/petsc_parallel_vector.h
@@ -79,7 +79,7 @@ namespace PETScWrappers
      * the collective MPI functions and wait for all the other processes to
      * join in on this. Since the other processes don't call this function,
      * you will either get a time-out on the first process, or, worse, by the
-     * time the next a callto a PETSc function generates an MPI message on the
+     * time the next a call to a PETSc function generates an MPI message on the
      * other processes, you will get a cryptic message that only a subset of
      * processes attempted a communication. These bugs can be very hard to
      * figure out, unless you are well-acquainted with the communication model
@@ -236,7 +236,7 @@ namespace PETScWrappers
                        const size_type     local_size);
 
       /**
-       * Constructs a new parallel ghosted PETSc vector from an Indexset. Note
+       * Constructs a new parallel ghosted PETSc vector from an IndexSet. Note
        * that @p local must be contiguous and the global size of the vector is
        * determined by local.size(). The global indices in @p ghost are
        * supplied as ghost indices that can also be read locally.
diff --git a/include/deal.II/lac/petsc_precondition.h b/include/deal.II/lac/petsc_precondition.h
index 0256ec8012..da608b85e1 100644
--- a/include/deal.II/lac/petsc_precondition.h
+++ b/include/deal.II/lac/petsc_precondition.h
@@ -647,9 +647,9 @@ namespace PETScWrappers
 
       /**
        * Set this flag to true if you have a symmetric system matrix and you
-       * want to use a solver which asumes a symmetric preconditioner like CG.
-       * The relaxation is done with SSOR/Jacobi when set to true and with
-       * SOR/Jacobi otherwise.
+       * want to use a solver which assumes a symmetric preconditioner like
+       * CG. The relaxation is done with SSOR/Jacobi when set to true and
+       * with SOR/Jacobi otherwise.
        */
       bool symmetric_operator;
 
diff --git a/include/deal.II/lac/petsc_sparse_matrix.h b/include/deal.II/lac/petsc_sparse_matrix.h
index 80a316f554..515abd62bd 100644
--- a/include/deal.II/lac/petsc_sparse_matrix.h
+++ b/include/deal.II/lac/petsc_sparse_matrix.h
@@ -182,7 +182,7 @@ namespace PETScWrappers
      * Despite the fact that it would seem to be an obvious win, setting the
      * @p preset_nonzero_locations flag to @p true doesn't seem to accelerate
      * program. Rather on the contrary, it seems to be able to slow down
-     * entire programs somewhat. This is suprising, since we can use efficient
+     * entire programs somewhat. This is surprising, since we can use efficient
      * function calls into PETSc that allow to create multiple entries at
      * once; nevertheless, given the fact that it is inefficient, the
      * respective flag has a default value equal to @p false.
diff --git a/include/deal.II/lac/petsc_vector_base.h b/include/deal.II/lac/petsc_vector_base.h
index 8ab260e096..ee952979c9 100644
--- a/include/deal.II/lac/petsc_vector_base.h
+++ b/include/deal.II/lac/petsc_vector_base.h
@@ -222,7 +222,7 @@ namespace PETScWrappers
    *
    * The interface of this class is modeled after the existing Vector class in
    * deal.II. It has almost the same member functions, and is often
-   * exchangable. However, since PETSc only supports a single scalar type
+   * exchangeable. However, since PETSc only supports a single scalar type
    * (either double, float, or a complex data type), it is not templated, and
    * only works with whatever your PETSc installation has defined the data
    * type @p PetscScalar to.
@@ -547,7 +547,7 @@ namespace PETScWrappers
 
     /**
      * A collective piecewise multiply operation on <code>this</code> vector
-     * with itself. TODO: The model for this function should be similer to add
+     * with itself. TODO: The model for this function should be similar to add
      * ().
      *
      * This function is deprecated.
@@ -764,7 +764,7 @@ namespace PETScWrappers
 
     /**
      * Denotes if this vector has ghost indices associated with it. This means
-     * that at least one of the processes in a parallel programm has at least
+     * that at least one of the processes in a parallel program has at least
      * one ghost index.
      */
     bool ghosted;
diff --git a/include/deal.II/lac/precondition.h b/include/deal.II/lac/precondition.h
index 117d375668..48c4720e10 100644
--- a/include/deal.II/lac/precondition.h
+++ b/include/deal.II/lac/precondition.h
@@ -651,8 +651,9 @@ private:
  * matrices. This preconditioner is similar to a Jacobi preconditioner if the
  * degree variable is set to one, otherwise some higher order polynomial
  * corrections are used. This preconditioner needs access to the diagonal of
- * the matrix its acts on and needs a respective <tt>vmult</tt> implemention.
- * However, it does not need to explicitly know the matrix entries.
+ * the matrix it acts on and needs a respective <tt>vmult</tt>
+ * implementation. However, it does not need to explicitly know the matrix
+ * entries.
  *
  * This class is useful e.g. in multigrid smoother objects, since it is
  * trivially %parallel (assuming that matrix-vector products are %parallel).
diff --git a/include/deal.II/lac/precondition_block.h b/include/deal.II/lac/precondition_block.h
index 550af09479..472b70b75d 100644
--- a/include/deal.II/lac/precondition_block.h
+++ b/include/deal.II/lac/precondition_block.h
@@ -172,7 +172,7 @@ public:
 protected:
   /**
    * Initialize matrix and block size for permuted preconditioning.
-   * Additionally to the parameters of the other initalize() function, we hand
+   * Additionally to the parameters of the other initialize() function, we hand
    * over two index vectors with the permutation and its inverse. For the
    * meaning of these vectors see PreconditionBlockSOR.
    *
@@ -259,7 +259,7 @@ public:
    * Perform one block relaxation step in forward numbering.
    *
    * Depending on the arguments @p dst and @p pref, this performs an SOR step
-   * (both reference the same vector) of a Jacobi step (botha different
+   * (both reference the same vector) of a Jacobi step (both different
    * vectors). For the Jacobi step, the calling function must copy @p dst to
    * @p pref after this.
    *
@@ -277,7 +277,7 @@ public:
    * Perform one block relaxation step in backward numbering.
    *
    * Depending on the arguments @p dst and @p pref, this performs an SOR step
-   * (both reference the same vector) of a Jacobi step (botha different
+   * (both reference the same vector) of a Jacobi step (both different
    * vectors). For the Jacobi step, the calling function must copy @p dst to
    * @p pref after this.
    *
@@ -915,7 +915,7 @@ Accessor (const PreconditionBlockJacobi<MATRIX, inverse_type> *matrix,
   a_block = row / bs;
 
   // This is the end accessor, which
-  // does not hava a valid block.
+  // does not have a valid block.
   if (a_block == matrix->size())
     return;
 
diff --git a/include/deal.II/lac/precondition_block.templates.h b/include/deal.II/lac/precondition_block.templates.h
index e25f2ce2d7..260b1f2fea 100644
--- a/include/deal.II/lac/precondition_block.templates.h
+++ b/include/deal.II/lac/precondition_block.templates.h
@@ -168,7 +168,7 @@ void PreconditionBlock<MATRIX,inverse_type>::invert_permuted_diagblocks(
       // numbering of the unknowns in the
       // blocks.
       // row, column are the global numbering
-      // of the unkowns.
+      // of the unknowns.
       M_cell = 0;
 
       for (unsigned int cell=0; cell<this->size(); ++cell)
@@ -248,7 +248,7 @@ void PreconditionBlock<MATRIX,inverse_type>::forward_step (
   // numbering of the unknowns in the
   // blocks.
   // row, column are the global numbering
-  // of the unkowns.
+  // of the unknowns.
   size_type row, row_cell;
   number2 b_cell_row;
   // The diagonal block if the
@@ -346,7 +346,7 @@ void PreconditionBlock<MATRIX,inverse_type>::backward_step (
   // numbering of the unknowns in the
   // blocks.
   // row, column are the global numbering
-  // of the unkowns.
+  // of the unknowns.
   size_type row, row_cell;
   number2 b_cell_row;
 
@@ -573,7 +573,7 @@ void PreconditionBlockJacobi<MATRIX,inverse_type>
   // numbering of the unknowns in the
   // blocks.
   // row, column are the global numbering
-  // of the unkowns.
+  // of the unknowns.
   size_type row, row_cell, begin_diag_block=0;
 
   if (!this->inverses_ready())
@@ -741,7 +741,7 @@ void PreconditionBlockSOR<MATRIX,inverse_type>::forward (
   // numbering of the unknowns in the
   // blocks.
   // row, column are the global numbering
-  // of the unkowns.
+  // of the unknowns.
   size_type row, row_cell, block_start=0;
   number2 b_cell_row;
   // The diagonal block if the
@@ -831,7 +831,7 @@ void PreconditionBlockSOR<MATRIX,inverse_type>::backward (
   // numbering of the unknowns in the
   // blocks.
   // row, column are the global numbering
-  // of the unkowns.
+  // of the unknowns.
   size_type row, row_cell;
   size_type block_end=this->blocksize * this->size();
   number2 b_cell_row;
diff --git a/include/deal.II/lac/relaxation_block.h b/include/deal.II/lac/relaxation_block.h
index ea10f845d6..0b807d82ca 100644
--- a/include/deal.II/lac/relaxation_block.h
+++ b/include/deal.II/lac/relaxation_block.h
@@ -109,7 +109,7 @@ public:
      * stored. It is then used for all other blocks.
      *
      * \note Avoid setting this true if your blocks are not equal, in
-     * particularr if their sizes differ.
+     * particular if their sizes differ.
      */
     bool same_diagonal;
     /**
@@ -220,7 +220,7 @@ protected:
    * Pointer to the matrix. Make sure that the matrix exists as long as this
    * class needs it, i.e. until calling @p invert_diagblocks, or (if the
    * inverse matrices should not be stored) until the last call of the
-   * preconditoining @p vmult function of the derived classes.
+   * preconditioning @p vmult function of the derived classes.
    */
   SmartPointer<const MATRIX,RelaxationBlock<MATRIX,inverse_type> > A;
 
diff --git a/include/deal.II/lac/slepc_solver.h b/include/deal.II/lac/slepc_solver.h
index 56e1516542..6fac9094b4 100644
--- a/include/deal.II/lac/slepc_solver.h
+++ b/include/deal.II/lac/slepc_solver.h
@@ -100,8 +100,8 @@ DEAL_II_NAMESPACE_OPEN
  * @author Toby D. Young 2008, 2009, 2010, 2011, 2013; and Rickard Armiento
  * 2008.
  *
- * @note Various tweaks and enhancments contributed by Eloy Romero and Jose E.
- * Roman 2009, 2010.
+ * @note Various tweaks and enhancements contributed by Eloy Romero and Jose
+ * E. Roman 2009, 2010.
  */
 namespace SLEPcWrappers
 {
diff --git a/include/deal.II/lac/slepc_spectral_transformation.h b/include/deal.II/lac/slepc_spectral_transformation.h
index 4f753fda39..94bc5aaeea 100644
--- a/include/deal.II/lac/slepc_spectral_transformation.h
+++ b/include/deal.II/lac/slepc_spectral_transformation.h
@@ -164,7 +164,7 @@ namespace SLEPcWrappers
 
     /**
      * Function that takes a Spectral Transformation context object, and sets
-     * the type of spectral transformationthat is appropriate for this class.
+     * the type of spectral transformation that is appropriate for this class.
      */
     virtual void set_transformation_type (ST &st) const;
   };
@@ -211,7 +211,7 @@ namespace SLEPcWrappers
 
     /**
      * Function that takes a Spectral Transformation context object, and sets
-     * the type of spectral transformationthat is appropriate for this class.
+     * the type of spectral transformation that is appropriate for this class.
      */
     virtual void set_transformation_type (ST &st) const;
   };
@@ -259,7 +259,7 @@ namespace SLEPcWrappers
 
     /**
      * Function that takes a Spectral Transformation context object, and sets
-     * the type of spectral transformationthat is appropriate for this class.
+     * the type of spectral transformation that is appropriate for this class.
      */
     virtual void set_transformation_type (ST &st) const;
   };
@@ -308,7 +308,7 @@ namespace SLEPcWrappers
 
     /**
      * Function that takes a Spectral Transformation context object, and sets
-     * the type of spectral transformationthat is appropriate for this class.
+     * the type of spectral transformation that is appropriate for this class.
      */
     virtual void set_transformation_type (ST &st) const;
   };
diff --git a/include/deal.II/lac/solver_control.h b/include/deal.II/lac/solver_control.h
index 7233a0645f..77eb3252ae 100644
--- a/include/deal.II/lac/solver_control.h
+++ b/include/deal.II/lac/solver_control.h
@@ -392,8 +392,8 @@ protected:
  * This is useful in cases where you don't want to solve exactly, but rather
  * want to gain two digits or if the maximal number of iterations is achieved.
  * For example: The maximal number of iterations is 20, the reduction factor
- * is 1% und the tolerance is 0.1%. The initial residual is 2.5. The process
- * will break if 20 iteration are comleted or the new residual is less then
+ * is 1% and the tolerance is 0.1%. The initial residual is 2.5. The process
+ * will break if 20 iteration are completed or the new residual is less then
  * 2.5*1% or if it is less then 0.1%.
  *
  * @author Guido Kanschat
diff --git a/include/deal.II/lac/solver_minres.h b/include/deal.II/lac/solver_minres.h
index 8b0621776c..aec100c5ea 100644
--- a/include/deal.II/lac/solver_minres.h
+++ b/include/deal.II/lac/solver_minres.h
@@ -255,7 +255,7 @@ SolverMinRes<VECTOR>::solve (const MATRIX         &A,
   *u[1] -= *m[0];
   // Precondition is applied.
   // The preconditioner has to be
-  // positiv definite and symmetric
+  // positive definite and symmetric
 
   // M v = u[1]
   precondition.vmult (v,*u[1]);
@@ -291,7 +291,7 @@ SolverMinRes<VECTOR>::solve (const MATRIX         &A,
       *m[0] = v;
 
       // precondition: solve M v = u[2]
-      // Preconditioner has to be positiv
+      // Preconditioner has to be positive
       // definite and symmetric.
       precondition.vmult(v,*u[2]);
 
diff --git a/include/deal.II/lac/solver_relaxation.h b/include/deal.II/lac/solver_relaxation.h
index 584bd0acfd..59e74cd819 100644
--- a/include/deal.II/lac/solver_relaxation.h
+++ b/include/deal.II/lac/solver_relaxation.h
@@ -76,7 +76,7 @@ public:
 
   /**
    * Solve the system $Ax = b$ using the relaxation method $x_{k+1} =
-   * R(x_k,b)$. The amtrix <i>A</i> itself is only used to compute the
+   * R(x_k,b)$. The matrix <i>A</i> itself is only used to compute the
    * residual.
    */
   template<class MATRIX, class RELAXATION>
diff --git a/include/deal.II/lac/sparse_direct.h b/include/deal.II/lac/sparse_direct.h
index de445e7ace..837e9260d0 100644
--- a/include/deal.II/lac/sparse_direct.h
+++ b/include/deal.II/lac/sparse_direct.h
@@ -50,7 +50,7 @@ DEAL_II_NAMESPACE_OPEN
  *
  * This matrix class implements the usual interface of preconditioners, that
  * is a function initialize(const SparseMatrix<double>&matrix,const
- * AdditionalData) for initalizing and the whole set of vmult() functions
+ * AdditionalData) for initializing and the whole set of vmult() functions
  * common to all matrices. Implemented here are only vmult() and vmult_add(),
  * which perform multiplication with the inverse matrix. Furthermore, this
  * class provides an older interface, consisting of the functions factorize()
@@ -85,7 +85,7 @@ public:
   typedef types::global_dof_index size_type;
 
   /**
-   * Dummy class needed for the usual initalization interface of
+   * Dummy class needed for the usual initialization interface of
    * preconditioners.
    */
   class AdditionalData
diff --git a/include/deal.II/lac/sparse_matrix.h b/include/deal.II/lac/sparse_matrix.h
index e234a03746..eeef96896d 100644
--- a/include/deal.II/lac/sparse_matrix.h
+++ b/include/deal.II/lac/sparse_matrix.h
@@ -520,7 +520,7 @@ public:
   };
 
   /**
-   * @name Constructors and initalization
+   * @name Constructors and initialization
    */
 //@{
   /**
@@ -872,9 +872,10 @@ public:
    * Copy the given matrix to this one.  The operation triggers an assertion
    * if the sparsity patterns of the two involved matrices do not point to the
    * same object, since in this case the copy operation is cheaper. Since this
-   * operation is notheless not for free, we do not make it available through
-   * <tt>operator =</tt>, since this may lead to unwanted usage, e.g. in copy
-   * arguments to functions, which should really be arguments by reference.
+   * operation is nonetheless not for free, we do not make it available
+   * through <tt>operator =</tt>, since this may lead to unwanted usage,
+   * e.g. in copy arguments to functions, which should really be arguments by
+   * reference.
    *
    * The source matrix may be a matrix of arbitrary type, as long as its data
    * type is convertible to the data type of this matrix.
@@ -1567,7 +1568,7 @@ private:
 
   /**
    * Allocated size of #val. This can be larger than the actually used part if
-   * the size of the matrix was reduced somewhen in the past by associating a
+   * the size of the matrix was reduced sometime in the past by associating a
    * sparsity pattern with a smaller size to this object, using the reinit()
    * function.
    */
diff --git a/include/deal.II/lac/sparse_matrix_ez.h b/include/deal.II/lac/sparse_matrix_ez.h
index 1745dcfcd9..14e3bdcf05 100644
--- a/include/deal.II/lac/sparse_matrix_ez.h
+++ b/include/deal.II/lac/sparse_matrix_ez.h
@@ -295,7 +295,7 @@ public:
   typedef number value_type;
 
   /**
-   * @name Constructors and initalization
+   * @name Constructors and initialization
    */
 //@{
   /**
@@ -511,7 +511,7 @@ public:
    * Copy the given matrix to this one.  The operation throws an error if the
    * sparsity patterns of the two involved matrices do not point to the same
    * object, since in this case the copy operation is cheaper. Since this
-   * operation is notheless not for free, we do not make it available through
+   * operation is nonetheless not for free, we do not make it available through
    * <tt>operator =</tt>, since this may lead to unwanted usage, e.g. in copy
    * arguments to functions, which should really be arguments by reference.
    *
diff --git a/include/deal.II/lac/sparse_matrix_ez.templates.h b/include/deal.II/lac/sparse_matrix_ez.templates.h
index dc64139d0b..a83883548d 100644
--- a/include/deal.II/lac/sparse_matrix_ez.templates.h
+++ b/include/deal.II/lac/sparse_matrix_ez.templates.h
@@ -508,7 +508,7 @@ SparseMatrixEZ<number>::print_formatted ( std::ostream          &out,
         width = precision+2;
     }
 
-  // TODO: Skip nonexisting entries
+  // TODO: Skip nonexistant entries
   for (size_type i=0; i<m(); ++i)
     {
       for (size_type j=0; j<n(); ++j)
diff --git a/include/deal.II/lac/sparse_vanka.h b/include/deal.II/lac/sparse_vanka.h
index 0018886eba..41799e942d 100644
--- a/include/deal.II/lac/sparse_vanka.h
+++ b/include/deal.II/lac/sparse_vanka.h
@@ -41,8 +41,8 @@ template <typename number> class SparseBlockVanka;
 /**
  * Point-wise Vanka preconditioning. This class does Vanka preconditioning  on
  * a point-wise base. Vanka preconditioners are used for saddle point problems
- * like Stoke's problem or problems arising in optimization where Lagrange
- * multiplier occur and let Netwon's matrix have a zero block. With these
+ * like Stokes' problem or problems arising in optimization where Lagrange
+ * multipliers occur and the Newton method matrix has a zero block. With these
  * matrices the application of Jacobi or Gauss-Seidel methods is impossible,
  * because some diagonal elements are zero in the rows of the Lagrange
  * multiplier. The approach of Vanka is to solve a small (usually indefinite)
@@ -418,7 +418,7 @@ class SparseBlockVanka : public SparseVanka<number>
 {
 public:
   /**
-   * Declate type for container size.
+   * Declare type for container size.
    */
   typedef types::global_dof_index size_type;
 
diff --git a/include/deal.II/lac/sparse_vanka.templates.h b/include/deal.II/lac/sparse_vanka.templates.h
index 37e0692a9d..141980b5df 100644
--- a/include/deal.II/lac/sparse_vanka.templates.h
+++ b/include/deal.II/lac/sparse_vanka.templates.h
@@ -262,7 +262,7 @@ SparseVanka<number>::apply_preconditioner (Vector<number2>         &dst,
         //   SparsityPattern object
         //
         // since we do not explicitly
-        // consider nonsysmmetric sparsity
+        // consider nonsymmetric sparsity
         // patterns, the first element
         // of each entry simply denotes
         // all degrees of freedom that
diff --git a/include/deal.II/lac/sparsity_tools.h b/include/deal.II/lac/sparsity_tools.h
index 910febf72a..7e69289a2f 100644
--- a/include/deal.II/lac/sparsity_tools.h
+++ b/include/deal.II/lac/sparsity_tools.h
@@ -171,7 +171,7 @@ namespace SparsityTools
 
 #ifdef DEAL_II_WITH_MPI
   /**
-   * Communciate rows in a compressed sparsity pattern over MPI.
+   * Communicate rows in a compressed sparsity pattern over MPI.
    *
    * @param dsp is the sparsity pattern that has been built locally and for
    * which we need to exchange entries with other processors to make sure that
diff --git a/include/deal.II/lac/swappable_vector.h b/include/deal.II/lac/swappable_vector.h
index dbffda8551..b94a271dc1 100644
--- a/include/deal.II/lac/swappable_vector.h
+++ b/include/deal.II/lac/swappable_vector.h
@@ -113,7 +113,7 @@ public:
    * in multithread mode, it spawns another thread that reads the data in
    * parallel to the usual execution of the program, such that when @p reload
    * is called, the data may eventually be available already. It might
-   * therefore be wirthwhile to call this function some time in advance, if
+   * therefore be worthwhile to call this function some time in advance, if
    * you know that the data will be needed, and loading takes some time, for
    * instance if the file to which the data was written is not in a local tmp
    * directory.
diff --git a/include/deal.II/lac/transpose_matrix.h b/include/deal.II/lac/transpose_matrix.h
index 7cb5e3b9c9..571fff646c 100644
--- a/include/deal.II/lac/transpose_matrix.h
+++ b/include/deal.II/lac/transpose_matrix.h
@@ -90,7 +90,7 @@ public:
                       const VECTOR &src) const;
 
   /**
-   * Tranposed matrix-vector product.
+   * Transposed matrix-vector product.
    */
   virtual void Tvmult (VECTOR &dst,
                        const VECTOR &src) const;
@@ -102,7 +102,7 @@ public:
                           const VECTOR &src) const;
 
   /**
-   * Tranposed matrix-vector product, adding to <tt>dst</tt>.
+   * Transposed matrix-vector product, adding to <tt>dst</tt>.
    */
   virtual void Tvmult_add (VECTOR &dst,
                            const VECTOR &src) const;
diff --git a/include/deal.II/lac/tridiagonal_matrix.h b/include/deal.II/lac/tridiagonal_matrix.h
index ea3da622b7..517d65c178 100644
--- a/include/deal.II/lac/tridiagonal_matrix.h
+++ b/include/deal.II/lac/tridiagonal_matrix.h
@@ -57,7 +57,7 @@ public:
   typedef types::global_dof_index size_type;
 
   /**
-   * @name Constructors and initalization.
+   * @name Constructors and initialization.
    */
   /**
    * Constructor generating an empty matrix of dimension <tt>n</tt>.
diff --git a/include/deal.II/lac/trilinos_block_sparse_matrix.h b/include/deal.II/lac/trilinos_block_sparse_matrix.h
index 3f9cb6e5a7..6001c8064b 100644
--- a/include/deal.II/lac/trilinos_block_sparse_matrix.h
+++ b/include/deal.II/lac/trilinos_block_sparse_matrix.h
@@ -134,7 +134,7 @@ namespace TrilinosWrappers
 
     /**
      * Resize the matrix, by setting the number of block rows and columns.
-     * This deletes all blocks and replaces them by unitialized ones, i.e.
+     * This deletes all blocks and replaces them with uninitialized ones, i.e.
      * ones for which also the sizes are not yet set. You have to do that by
      * calling the @p reinit functions of the blocks themselves. Do not forget
      * to call collect_sizes() after that on this object.
diff --git a/include/deal.II/lac/trilinos_precondition.h b/include/deal.II/lac/trilinos_precondition.h
index 8f484b680b..67b63c1071 100644
--- a/include/deal.II/lac/trilinos_precondition.h
+++ b/include/deal.II/lac/trilinos_precondition.h
@@ -926,7 +926,7 @@ namespace TrilinosWrappers
      * <li> @p ilu_fill: This specifies the amount of additional fill-in
      * elements besides the original sparse matrix structure. If $k$ is @p
      * fill, the sparsity pattern of $A^{k+1}$ is used for the storage of the
-     * result of the Gaussian elemination. This is known as ILU($k$) in the
+     * result of the Gaussian elimination. This is known as ILU($k$) in the
      * literature.  When @p fill is large, the preconditioner comes closer to
      * a (direct) sparse LU decomposition. Note, however, that this will
      * drastically increase the memory requirement, especially when the
@@ -1007,7 +1007,7 @@ namespace TrilinosWrappers
    * serial and in parallel, depending on the matrix it is based on. In
    * general, an incomplete factorization does not take all fill-in elements
    * that would appear in a full factorization (that is the basis for a direct
-   * solve). For the ILU-T precondtioner, the parameter <tt>ilut_drop</tt>
+   * solve). For the ILU-T preconditioner, the parameter <tt>ilut_drop</tt>
    * lets the user specify which elements should be dropped (i.e., should not
    * be part of the incomplete decomposition). Trilinos calculates first the
    * complete factorization for one row, and then skips those elements that
@@ -1517,7 +1517,7 @@ namespace TrilinosWrappers
      * remained the same. What this function does is taking the already
      * generated coarsening structure, computing the AMG prolongation and
      * restriction according to a smoothed aggregation strategy and then
-     * building the whole multilevel hiearchy. This function can be
+     * building the whole multilevel hierarchy. This function can be
      * considerably faster than the initialize function, since the coarsening
      * pattern is usually the most difficult thing to do when setting up the
      * AMG ML preconditioner.
diff --git a/include/deal.II/lac/trilinos_sparse_matrix.h b/include/deal.II/lac/trilinos_sparse_matrix.h
index ee6390f618..6abe7d3cfb 100644
--- a/include/deal.II/lac/trilinos_sparse_matrix.h
+++ b/include/deal.II/lac/trilinos_sparse_matrix.h
@@ -441,7 +441,7 @@ namespace TrilinosWrappers
    *
    * The interface of this class is modeled after the existing SparseMatrix
    * class in deal.II. It has almost the same member functions, and is often
-   * exchangable. However, since Trilinos only supports a single scalar type
+   * exchangeable. However, since Trilinos only supports a single scalar type
    * (double), it is not templated, and only works with doubles.
    *
    * Note that Trilinos only guarantees that operations do what you expect if
@@ -576,7 +576,7 @@ namespace TrilinosWrappers
      * meant for use in serial programs, where there is no need to specify how
      * the matrix is going to be distributed among different processors. This
      * function works in %parallel, too, but it is recommended to manually
-     * specify the %parallel partioning of the matrix using an Epetra_Map.
+     * specify the %parallel partitioning of the matrix using an Epetra_Map.
      * When run in %parallel, it is currently necessary that each processor
      * holds the sparsity_pattern structure because each processor sets its
      * rows.
@@ -727,7 +727,7 @@ namespace TrilinosWrappers
      * programs following the style of the tutorial programs, this function
      * (and the respective call for a rectangular matrix) are the natural way
      * to initialize the matrix size, its distribution among the MPI processes
-     * (if run in %parallel) as well as the locatoin of non-zero elements.
+     * (if run in %parallel) as well as the location of non-zero elements.
      * Trilinos stores the sparsity pattern internally, so it won't be needed
      * any more after this call, in contrast to the deal.II own object. The
      * optional argument @p exchange_data can be used for reinitialization
@@ -896,7 +896,7 @@ namespace TrilinosWrappers
      * programs, this function (and the respective call for a rectangular
      * matrix) are the natural way to initialize the matrix size, its
      * distribution among the MPI processes (if run in %parallel) as well as
-     * the locatoin of non-zero elements. Trilinos stores the sparsity pattern
+     * the location of non-zero elements. Trilinos stores the sparsity pattern
      * internally, so it won't be needed any more after this call, in contrast
      * to the deal.II own object. The optional argument @p exchange_data can
      * be used for reinitialization with a sparsity pattern that is not fully
@@ -2463,7 +2463,7 @@ namespace TrilinosWrappers
 
     if (value == 0)
       {
-        // we have to do checkings on Insert/Add in any case to be consistent
+        // we have to check after Insert/Add in any case to be consistent
         // with the MPI communication model (see the comments in the
         // documentation of TrilinosWrappers::Vector), but we can save some
         // work if the addend is zero. However, these actions are done in case
diff --git a/include/deal.II/lac/trilinos_sparsity_pattern.h b/include/deal.II/lac/trilinos_sparsity_pattern.h
index 9474c8b465..cde022917e 100644
--- a/include/deal.II/lac/trilinos_sparsity_pattern.h
+++ b/include/deal.II/lac/trilinos_sparsity_pattern.h
@@ -283,7 +283,7 @@ namespace TrilinosWrappers
     typedef SparsityPatternIterators::Iterator const_iterator;
 
     /**
-     * @name Basic constructors and initalization.
+     * @name Basic constructors and initialization.
      */
 //@{
     /**
@@ -527,7 +527,7 @@ namespace TrilinosWrappers
      * &ndash; the processor that owns a certain row always owns all the
      * column elements, no matter how far they might be spread out. The second
      * Epetra_Map is only used to specify the number of columns and for
-     * internal arragements when doing matrix-vector products with vectors
+     * internal arrangements when doing matrix-vector products with vectors
      * based on that column map.
      *
      * The number of columns entries per row is specified by the argument
@@ -633,7 +633,7 @@ namespace TrilinosWrappers
      * columns &ndash; the processor that owns a certain row always owns all
      * the column elements, no matter how far they might be spread out. The
      * second Epetra_Map is only used to specify the number of columns and for
-     * internal arragements when doing matrix-vector products with vectors
+     * internal arrangements when doing matrix-vector products with vectors
      * based on that column map.
      *
      * The number of columns entries per row is specified as the maximum
@@ -677,7 +677,7 @@ namespace TrilinosWrappers
      * DoFTools::extract_locally_relevant_dofs). The other constructors
      * methods use general Trilinos facilities that allow to add elements to
      * arbitrary rows (as done by all the other reinit functions). However,
-     * this flexbility come at a cost, the most prominent being that adding
+     * this flexibility come at a cost, the most prominent being that adding
      * elements into the same matrix from multiple threads in shared memory is
      * not safe whenever MPI is used. For these settings, the current method
      * is the one to choose: It will store the off-processor data as an
@@ -737,7 +737,7 @@ namespace TrilinosWrappers
      * &ndash; the processor that owns a certain row always owns all the
      * column elements, no matter how far they might be spread out. The second
      * IndexSet is only used to specify the number of columns and for internal
-     * arragements when doing matrix-vector products with vectors based on an
+     * arrangements when doing matrix-vector products with vectors based on an
      * EpetraMap based on that IndexSet.
      *
      * The number of columns entries per row is specified by the argument
@@ -765,12 +765,12 @@ namespace TrilinosWrappers
      * DoFTools::extract_locally_relevant_dofs). Trilinos matrices allow to
      * add elements to arbitrary rows (as done by all the other reinit
      * functions) and this is what all the other reinit methods do, too.
-     * However, this flexbility come at a cost, the most prominent being that
+     * However, this flexibility come at a cost, the most prominent being that
      * adding elements into the same matrix from multiple threads in shared
      * memory is not safe whenever MPI is used. For these settings, the
      * current method is the one to choose: It will store the off-processor
      * data as an additional sparsity pattern (that is then passed to the
-     * Trilinos matrix via the reinit mehtod) which can be organized in such a
+     * Trilinos matrix via the reinit method) which can be organized in such a
      * way that thread-safety can be ensured (as long as the user makes sure
      * to never write into the same matrix row simultaneously, of course).
      */
@@ -1451,7 +1451,7 @@ namespace TrilinosWrappers
 
     // verify that the size of the data type Trilinos expects matches that the
     // iterator points to. we allow for some slippage between signed and
-    // unsigned and only compare that they are both eiter 32 or 64 bit. to
+    // unsigned and only compare that they are both either 32 or 64 bit. to
     // write this test properly, not that we cannot compare the size of
     // '*begin' because 'begin' may be an iterator and '*begin' may be an
     // accessor class. consequently, we need to somehow get an actual value
diff --git a/include/deal.II/lac/trilinos_vector.h b/include/deal.II/lac/trilinos_vector.h
index afaa094024..2fc22227ae 100644
--- a/include/deal.II/lac/trilinos_vector.h
+++ b/include/deal.II/lac/trilinos_vector.h
@@ -114,7 +114,7 @@ namespace TrilinosWrappers
      * the collective MPI functions and wait for all the other processes to
      * join in on this. Since the other processes don't call this function,
      * you will either get a time-out on the first process, or, worse, by the
-     * time the next a callto a Trilinos function generates an MPI message on
+     * time the next a call to a Trilinos function generates an MPI message on
      * the other processes, you will get a cryptic message that only a subset
      * of processes attempted a communication. These bugs can be very hard to
      * figure out, unless you are well-acquainted with the communication model
@@ -271,7 +271,7 @@ namespace TrilinosWrappers
       static const bool supports_distributed_data = true;
 
       /**
-       * @name Basic constructors and initalization.
+       * @name Basic constructors and initialization.
        */
       //@{
       /**
diff --git a/include/deal.II/lac/trilinos_vector_base.h b/include/deal.II/lac/trilinos_vector_base.h
index 896e71b499..e21094fc1e 100644
--- a/include/deal.II/lac/trilinos_vector_base.h
+++ b/include/deal.II/lac/trilinos_vector_base.h
@@ -201,7 +201,7 @@ namespace TrilinosWrappers
    *
    * The interface of this class is modeled after the existing Vector class in
    * deal.II. It has almost the same member functions, and is often
-   * exchangable. However, since Trilinos only supports a single scalar type
+   * exchangeable. However, since Trilinos only supports a single scalar type
    * (double), it is not templated, and only works with that type.
    *
    * Note that Trilinos only guarantees that operations do what you expect if
diff --git a/include/deal.II/lac/vector.h b/include/deal.II/lac/vector.h
index 3da392ce69..9d02cc4a1c 100644
--- a/include/deal.II/lac/vector.h
+++ b/include/deal.II/lac/vector.h
@@ -836,7 +836,7 @@ public:
    * Output of vector in user-defined format. For complex-valued vectors, the
    * format should include specifiers for both the real and imaginary parts.
    *
-   * This funcion is deprecated.
+   * This function is deprecated.
    */
   void print (const char *format = 0) const DEAL_II_DEPRECATED;
 
diff --git a/include/deal.II/lac/vector.templates.h b/include/deal.II/lac/vector.templates.h
index f3bc5d599b..76c554a941 100644
--- a/include/deal.II/lac/vector.templates.h
+++ b/include/deal.II/lac/vector.templates.h
@@ -139,7 +139,7 @@ namespace internal
   }
 
 
-  // Define the functors neccessary to use SIMD with TBB.
+  // Define the functors necessary to use SIMD with TBB.
   template <typename Number>
   struct Vectorization_multiply_factor
   {
diff --git a/include/deal.II/lac/vector_view.h b/include/deal.II/lac/vector_view.h
index ad37f76656..0cf3745b32 100644
--- a/include/deal.II/lac/vector_view.h
+++ b/include/deal.II/lac/vector_view.h
@@ -87,7 +87,7 @@ DEAL_II_NAMESPACE_OPEN
  * // The following line should output 4.
  * cout << array[1] << endl;
  *
- * // If debug mode is on, then the following triggers an execption:
+ * // If debug mode is on, then the following triggers an exception:
  * view(6) = 4;
  *
  * // But notice that no checks are performed, so this is legal but WILL
@@ -95,7 +95,7 @@ DEAL_II_NAMESPACE_OPEN
  * VectorView<double> wrong_view(10, array);
  *
  * // Now no assert will be thrown if you type wrong_view(6), but most
- * // likely a seg fault will occur.
+ * // likely a segfault will occur.
  * view(6) = 4;
  *
  * // Notice that this construction is legal. It will create a copy of
@@ -158,7 +158,7 @@ public:
   VectorView(const size_type new_size, const Number *ptr);
 
   /**
-   * This desctructor will only reset the internal sizes and the internal
+   * This destructor will only reset the internal sizes and the internal
    * pointers, but it will NOT clear the memory.
    */
   ~VectorView();
@@ -194,7 +194,7 @@ public:
    *
    * In the above case, the Vector<double>::reinit method is called, and a NEW
    * area of memory is reserved, possibly not starting at the same place as
-   * before. Hoever, the VectorView<double> object keeps pointing to the same
+   * before. However, the VectorView<double> object keeps pointing to the same
    * old area. After the two reinits, any call to view_of_long_vector(i), with
    * i>0 might cause an attempt to access invalid areas of memory, or might
    * function properly, depending on whether or not the system was able to
diff --git a/include/deal.II/matrix_free/dof_info.templates.h b/include/deal.II/matrix_free/dof_info.templates.h
index 9385f8f778..c57472054b 100644
--- a/include/deal.II/matrix_free/dof_info.templates.h
+++ b/include/deal.II/matrix_free/dof_info.templates.h
@@ -97,7 +97,7 @@ namespace internal
       // implementation computed a hash value based on the truncated array (to
       // given accuracy around 1e-13) in order to easily detect different
       // arrays and then made a fine-grained check when the hash values were
-      // equal. this was quite lenghty and now we use a std::map with a
+      // equal. this was quite lengthy and now we use a std::map with a
       // user-defined comparator to compare floating point arrays to a
       // tolerance 1e-13.
       std::pair<typename std::map<std::vector<double>, types::global_dof_index,
diff --git a/include/deal.II/matrix_free/fe_evaluation.h b/include/deal.II/matrix_free/fe_evaluation.h
index 43d0db8ea7..20ef63f77f 100644
--- a/include/deal.II/matrix_free/fe_evaluation.h
+++ b/include/deal.II/matrix_free/fe_evaluation.h
@@ -1173,7 +1173,7 @@ public:
                        const unsigned int q_point);
 
   /**
-   * Write a constribution that is tested by the divergence to the field
+   * Write a contribution that is tested by the divergence to the field
    * containing the values on quadrature points with component @p q_point.
    * Access to the same field as through @p get_gradient. If applied before
    * the function @p integrate(...,true) is called, this specifies what is
diff --git a/include/deal.II/meshworker/integration_info.h b/include/deal.II/meshworker/integration_info.h
index 2bd707d7f8..615b22b158 100644
--- a/include/deal.II/meshworker/integration_info.h
+++ b/include/deal.II/meshworker/integration_info.h
@@ -85,7 +85,7 @@ namespace MeshWorker
     IntegrationInfo();
 
     /**
-     * Copy constructor, creating a clone to be used by WorksTream::run().
+     * Copy constructor, creating a clone to be used by WorkStream::run().
      */
     IntegrationInfo(const IntegrationInfo<dim, spacedim> &other);
 
@@ -142,7 +142,7 @@ namespace MeshWorker
 
     /// Access to finite elements
     /**
-     * This access function must be used if the initalize() for a group of
+     * This access function must be used if the initialize() for a group of
      * elements was used (with a valid BlockInfo object).
      */
     const FEValuesBase<dim, spacedim> &fe_values (const unsigned int i) const;
diff --git a/include/deal.II/multigrid/mg_base.h b/include/deal.II/multigrid/mg_base.h
index 6588f86f0a..923d9b0b82 100644
--- a/include/deal.II/multigrid/mg_base.h
+++ b/include/deal.II/multigrid/mg_base.h
@@ -144,7 +144,7 @@ public:
  * component or for some components. The classes MGTransferSelect and
  * MGTransferBlock handle these cases.
  *
- * MGTransferSelect is used if you use mutligrid (on Vector objects) for a
+ * MGTransferSelect is used if you use multigrid (on Vector objects) for a
  * single component, possibly grouped using <tt>mg_target_component</tt>.
  *
  * The class MGTransferBlock handles the case where your multigrid method
@@ -185,7 +185,7 @@ public:
    * region covered by cells on level <tt>from_level</tt> is smaller than that
    * of level <tt>from_level-1</tt> (local refinement), then some degrees of
    * freedom in <tt>dst</tt> are active and will not be altered. For the other
-   * degress of freedom, the result of the restriction is added.
+   * degrees of freedom, the result of the restriction is added.
    *
    * @arg src is a vector with as many elements as there are degrees of
    * freedom on the finer level
diff --git a/include/deal.II/multigrid/mg_transfer_block.h b/include/deal.II/multigrid/mg_transfer_block.h
index 850ddfb78b..e13f8ff826 100644
--- a/include/deal.II/multigrid/mg_transfer_block.h
+++ b/include/deal.II/multigrid/mg_transfer_block.h
@@ -104,7 +104,7 @@ protected:
   /**
    * For each block of the whole block vector, list to what block of the
    * multigrid vector it is mapped. Since depending on #selected, there may be
-   * fewer mutlilevel blocks than original blocks, some of the entries may be
+   * fewer multilevel blocks than original blocks, some of the entries may be
    * illegal unsigned integers.
    */
 //TODO: rename this to mg_block_mask, in the same way as has already been done in MGTransferComponent, and give it type BlockMask
diff --git a/include/deal.II/multigrid/mg_transfer_component.templates.h b/include/deal.II/multigrid/mg_transfer_component.templates.h
index bbe7d2b617..6bbfd460b1 100644
--- a/include/deal.II/multigrid/mg_transfer_component.templates.h
+++ b/include/deal.II/multigrid/mg_transfer_component.templates.h
@@ -160,8 +160,7 @@ MGTransferSelect<number>::do_copy_from_mg (
   // data appropriately to the output
   // vector
 
-  // Note that the level is
-  // monotonuosly increasing
+  // Note that the level is increasing monotonically
   dst = 0;
   for (; level_cell != endc; ++level_cell)
     {
@@ -197,8 +196,7 @@ MGTransferSelect<number>::do_copy_from_mg_add (
   // data appropriately to the output
   // vector
 
-  // Note that the level is
-  // monotonuosly increasing
+  // Note that the level is increasing monotonically
   dst = 0;
   for (; level_cell != endc; ++level_cell)
     {
diff --git a/source/base/data_out_base.cc b/source/base/data_out_base.cc
index f7c29cb3d3..1a61e3105f 100644
--- a/source/base/data_out_base.cc
+++ b/source/base/data_out_base.cc
@@ -566,7 +566,7 @@ namespace
   };
 #endif
 
-  // NOTE: The dimension of the array is choosen to 5 to allow the choice
+  // NOTE: The dimension of the array is chosen to 5 to allow the choice
   // DataOutBase<deal_II_dimension,deal_II_dimension+1> in general
   // Wolfgang supposed that we don't need it in general, but however this
   // choice avoids a -Warray-bounds check warning
diff --git a/source/base/geometry_info.cc b/source/base/geometry_info.cc
index 0fbf8f84d0..da75f2ba31 100644
--- a/source/base/geometry_info.cc
+++ b/source/base/geometry_info.cc
@@ -581,7 +581,7 @@ GeometryInfo<3>::line_refinement_case(const RefinementCase<3> &cell_refinement_c
          ExcIndexRange(line_no, 0, GeometryInfo<dim>::lines_per_cell));
 
   // array indicating, which simple refine
-  // case cuts a line in dirextion x, y or
+  // case cuts a line in direction x, y or
   // z. For example, cut_y and everything
   // containing cut_y (cut_xy, cut_yz,
   // cut_xyz) cuts lines, which are in y
diff --git a/source/base/logstream.cc b/source/base/logstream.cc
index fe5297c9a7..abd73a851f 100644
--- a/source/base/logstream.cc
+++ b/source/base/logstream.cc
@@ -405,7 +405,7 @@ LogStream::get_prefixes() const
         = prefixes.get_implementation();
 
       // The thread that created this LogStream object should be the first
-      // in tbb's enumerable_thread_specific containter.
+      // in tbb's enumerable_thread_specific container.
       const tbb::enumerable_thread_specific<std::stack<std::string> >::const_iterator first_elem
         = impl.begin();
 
diff --git a/source/base/mpi.cc b/source/base/mpi.cc
index 28a575330f..ea24b30826 100644
--- a/source/base/mpi.cc
+++ b/source/base/mpi.cc
@@ -355,7 +355,7 @@ namespace Utilities
                    ExcMessage ("MPI error. You can only start MPI once!"));
 
       int mpi_err, provided;
-      // this works likempi_err = MPI_Init (&argc, &argv); but tells MPI that
+      // this works like mpi_err = MPI_Init (&argc, &argv); but tells MPI that
       // we might use several threads but never call two MPI functions at the
       // same time. For an explanation see on why we do this see
       // http://www.open-mpi.org/community/lists/users/2010/03/12244.php
diff --git a/source/base/parameter_handler.cc b/source/base/parameter_handler.cc
index bdbd71e416..d410fdabf1 100644
--- a/source/base/parameter_handler.cc
+++ b/source/base/parameter_handler.cc
@@ -595,7 +595,7 @@ namespace Patterns
     Assert (separator.size() > 0,
             ExcMessage ("The separator must have a non-zero length."));
     Assert (separator != ":",
-            ExcMessage ("The separator can not be a colon ':' sicne that "
+            ExcMessage ("The separator can not be a colon ':' since that "
                         "is the separator between the two elements of <key:value> pairs"));
   }
 
diff --git a/source/base/quadrature_lib.cc b/source/base/quadrature_lib.cc
index e59b3c9968..a25dafe365 100644
--- a/source/base/quadrature_lib.cc
+++ b/source/base/quadrature_lib.cc
@@ -825,7 +825,7 @@ QGaussOneOverR<2>::QGaussOneOverR(const unsigned int n,
   origins.push_back(Point<2>(0.,singularity[1]));
   origins.push_back(singularity);
 
-  // Lexycographical ordering.
+  // Lexicographical ordering.
 
   double eps = 1e-8;
   unsigned int q_id = 0; // Current quad point index.
diff --git a/source/dofs/dof_handler.cc b/source/dofs/dof_handler.cc
index e596cf947a..26059240e7 100644
--- a/source/dofs/dof_handler.cc
+++ b/source/dofs/dof_handler.cc
@@ -49,7 +49,7 @@ template <int dim, int spacedim>
 const unsigned int DoFHandler<dim,spacedim>::default_fe_index;
 
 
-// reference the invalid_dof_index variable explicitely to work around
+// reference the invalid_dof_index variable explicitly to work around
 // a bug in the icc8 compiler
 namespace internal
 {
diff --git a/source/dofs/dof_tools_constraints.cc b/source/dofs/dof_tools_constraints.cc
index 5c580c7e0e..3384d27aa9 100644
--- a/source/dofs/dof_tools_constraints.cc
+++ b/source/dofs/dof_tools_constraints.cc
@@ -61,7 +61,7 @@ namespace DoFTools
 
         // then use the algorithm from FullMatrix::gauss_jordan on this
         // matrix to find out whether it is singular. the algorithm there
-        // does piviting and at the end swaps rows back into their proper
+        // does pivoting and at the end swaps rows back into their proper
         // order -- we omit this step here, since we don't care about the
         // inverse matrix, all we care about is whether the matrix is
         // regular or singular
diff --git a/source/fe/fe.cc b/source/fe/fe.cc
index df3cf0302b..8288a5dad6 100644
--- a/source/fe/fe.cc
+++ b/source/fe/fe.cc
@@ -203,7 +203,7 @@ FiniteElement<dim,spacedim>::FiniteElement (
   base_to_block_indices.reinit(1,1);
 
   // initialize the restriction and prolongation matrices. the default
-  // contructur of FullMatrix<dim> initializes them with size zero
+  // constructor of FullMatrix<dim> initializes them with size zero
   prolongation.resize(RefinementCase<dim>::isotropic_refinement);
   restriction.resize(RefinementCase<dim>::isotropic_refinement);
   for (unsigned int ref=RefinementCase<dim>::cut_x;
@@ -1342,7 +1342,7 @@ FiniteElement<dim,spacedim>::compute_2nd (
                   // component index
                   // of the n-th
                   // nonzero
-                  // compoment
+                  // component
                   unsigned int component=0;
                   for (unsigned int nonzero_comp=0; component<this->n_components();
                        ++component)
diff --git a/source/fe/fe_abf.cc b/source/fe/fe_abf.cc
index 5128de93b3..8277da1d58 100644
--- a/source/fe/fe_abf.cc
+++ b/source/fe/fe_abf.cc
@@ -337,7 +337,7 @@ FE_ABF<dim>::initialize_restriction()
 
       for (unsigned int sub=0; sub<GeometryInfo<dim>::max_children_per_face; ++sub)
         {
-          // The weight fuctions for
+          // The weight functions for
           // the coarse face are
           // evaluated on the subface
           // only.
@@ -357,7 +357,7 @@ FE_ABF<dim>::initialize_restriction()
           // when building the shape
           // functions, these weights
           // are equal to the
-          // corresponding shpe
+          // corresponding shape
           // functions.
           for (unsigned int k=0; k<n_face_points; ++k)
             for (unsigned int i_child = 0; i_child < this->dofs_per_cell; ++i_child)
diff --git a/source/fe/fe_bdm.cc b/source/fe/fe_bdm.cc
index e3ba8dc39f..7fb4e2fa3b 100644
--- a/source/fe/fe_bdm.cc
+++ b/source/fe/fe_bdm.cc
@@ -336,8 +336,8 @@ FE_BDM<dim>::initialize_support_points (const unsigned int deg)
       }
   Assert(current == npoints, ExcInternalError());
 
-  // Finaly, compute the values of
-  // the test functios in the
+  // Finally, compute the values of
+  // the test functions in the
   // interior quadrature points
   PolynomialsP<dim> poly(deg-2);
 
diff --git a/source/fe/fe_q_base.cc b/source/fe/fe_q_base.cc
index 77839adcad..866290fac4 100644
--- a/source/fe/fe_q_base.cc
+++ b/source/fe/fe_q_base.cc
@@ -963,7 +963,7 @@ FE_Q_Base<POLY,dim,spacedim>::initialize_quad_dof_index_permutation ()
       data(local,7)=(n-1-j) + i      *n - local;
     }
 
-  // aditionally initialize reordering of line dofs
+  // additionally initialize reordering of line dofs
   for (unsigned int i=0; i<this->dofs_per_line; ++i)
     this->adjust_line_dof_index_for_line_orientation_table[i]=this->dofs_per_line-1-i - i;
 }
diff --git a/source/fe/fe_q_hierarchical.cc b/source/fe/fe_q_hierarchical.cc
index fa253d66ca..98b151c4e4 100644
--- a/source/fe/fe_q_hierarchical.cc
+++ b/source/fe/fe_q_hierarchical.cc
@@ -400,7 +400,7 @@ FE_Q_Hierarchical<dim>::build_dofs_cell (std::vector<FullMatrix<double> > &dofs_
 
   // TODO: The dofs_subcell shall differ by a factor 2^p due to shape functions
   // defined on [0,1] instead of [-1,1]. However, that does not seem to be
-  // the case. Perhaps this factor is added later on in auxilary functions which
+  // the case. Perhaps this factor is added later on in auxiliary functions which
   // use these matrices.
 
   // dofs_cells[0](j,k):
@@ -894,7 +894,7 @@ get_face_interpolation_matrix (const FiniteElement<dim> &x_source_fe,
       // First this->dofs_per_face DoFs of the constrained
       // element are made equal to the current (dominating)
       // element, which corresponds to 1 on diagonal of the matrix.
-      // DoFs which correspond to higher polynomes
+      // DoFs which correspond to higher polynomials
       // are zeroed (zero rows in the matrix).
       for (unsigned int i = 0; i < this->dofs_per_face; ++i)
         interpolation_matrix (i, i) = 1;
diff --git a/source/fe/fe_raviart_thomas.cc b/source/fe/fe_raviart_thomas.cc
index 497a49963b..aa3303a57a 100644
--- a/source/fe/fe_raviart_thomas.cc
+++ b/source/fe/fe_raviart_thomas.cc
@@ -247,7 +247,7 @@ FE_RaviartThomas<1>::initialize_restriction()
 
 // This function is the same Raviart-Thomas interpolation performed by
 // interpolate. Still, we cannot use interpolate, since it was written
-// for smooth functions. Thefunctions interpolated here are not
+// for smooth functions. The functions interpolated here are not
 // smooth, maybe even not continuous. Therefore, we must double the
 // number of quadrature points in each direction in order to integrate
 // only smooth functions.
@@ -285,7 +285,7 @@ FE_RaviartThomas<dim>::initialize_restriction()
 
       for (unsigned int sub=0; sub<GeometryInfo<dim>::max_children_per_face; ++sub)
         {
-          // The weight fuctions for
+          // The weight functions for
           // the coarse face are
           // evaluated on the subface
           // only.
diff --git a/source/fe/fe_tools.cc b/source/fe/fe_tools.cc
index 09edae1c23..2510e6216b 100644
--- a/source/fe/fe_tools.cc
+++ b/source/fe/fe_tools.cc
@@ -111,7 +111,7 @@ namespace
   // The following three functions serve to fill the maps from element
   // names to elements fe_name_map below. The first one exists because
   // we have finite elements which are not implemented for nonzero
-  // codimension. These should be transfered to the second function
+  // codimension. These should be transferred to the second function
   // eventually.
 
   template <int dim>
diff --git a/source/fe/fe_tools_interpolate.cc b/source/fe/fe_tools_interpolate.cc
index 9f400205ad..ada241182b 100644
--- a/source/fe/fe_tools_interpolate.cc
+++ b/source/fe/fe_tools_interpolate.cc
@@ -151,7 +151,7 @@ namespace FETools
           // for continuous elements on
           // grids with hanging nodes we
           // need hanging node
-          // constraints. Consequentely,
+          // constraints. Consequently,
           // if there are no constraints
           // then hanging nodes are not
           // allowed.
diff --git a/source/fe/fe_trace.cc b/source/fe/fe_trace.cc
index 0acd179ef7..3d68c93ed0 100644
--- a/source/fe/fe_trace.cc
+++ b/source/fe/fe_trace.cc
@@ -120,7 +120,7 @@ std::vector<unsigned int>
 FE_TraceQ<dim,spacedim>::get_dpo_vector (const unsigned int deg)
 {
   // This constructs FE_TraceQ in exactly the same way as FE_Q except for the
-  // interior degrees of freedom that are not present here (lnine in 1D, quad
+  // interior degrees of freedom that are not present here (line in 1D, quad
   // in 2D, hex in 3D).
   AssertThrow(deg>0,ExcMessage("FE_TraceQ needs to be of degree > 0."));
   std::vector<unsigned int> dpo(dim+1, 1U);
diff --git a/source/fe/fe_values.cc b/source/fe/fe_values.cc
index f54eefa036..6960d72c56 100644
--- a/source/fe/fe_values.cc
+++ b/source/fe/fe_values.cc
@@ -1117,7 +1117,7 @@ namespace FEValuesViews
                     // there is no single nonzero component
                     //
                     // the following is not implemented! we need to consider the
-                    // interplay between mutliple non-zero entries in shape
+                    // interplay between multiple non-zero entries in shape
                     // function and the representation as a symmetric
                     // second-order tensor
                     const unsigned int comp =
diff --git a/source/fe/mapping_fe_field.cc b/source/fe/mapping_fe_field.cc
index c5131efabe..6b5ab6bac0 100644
--- a/source/fe/mapping_fe_field.cc
+++ b/source/fe/mapping_fe_field.cc
@@ -171,7 +171,7 @@ MappingFEField<dim,spacedim,VECTOR,DH>::update_each (const UpdateFlags in) const
   // quantities are necessary to
   // compute what we need. note that
   // some flags appear in both
-  // conditions and in subsequents
+  // conditions and in subsequent
   // set operations. this leads to
   // some circular logic. the only
   // way to treat this is to
@@ -283,7 +283,7 @@ MappingFEField<dim,spacedim,VECTOR,DH>::compute_face_data (const UpdateFlags upd
                                         std::vector<Tensor<1,dim> > (n_original_q_points));
           if (dim==2)
             {
-              // ensure a counterclock wise
+              // ensure a counterclockwise
               // orientation of tangentials
               static const int tangential_orientation[4]= {-1,1,1,-1};
               for (unsigned int i=0; i<nfaces; ++i)
@@ -370,7 +370,7 @@ MappingFEField<dim,spacedim,VECTOR,DH>::get_subface_data (const UpdateFlags upda
 }
 
 
-// Note that the CellSimilarity flag is modifyable, since MappingFEField can need to
+// Note that the CellSimilarity flag is modifiable, since MappingFEField can need to
 // recalculate data even when cells are similar.
 template<int dim, int spacedim, class VECTOR, class DH>
 CellSimilarity::Similarity
diff --git a/source/fe/mapping_q.cc b/source/fe/mapping_q.cc
index 0d96e6d922..8cbd21084e 100644
--- a/source/fe/mapping_q.cc
+++ b/source/fe/mapping_q.cc
@@ -287,7 +287,7 @@ MappingQ<dim,spacedim>::get_subface_data (const UpdateFlags update_flags,
 }
 
 
-// Note that the CellSimilarity flag is modifyable, since MappingQ can need to
+// Note that the CellSimilarity flag is modifiable, since MappingQ can need to
 // recalculate data even when cells are similar.
 template<int dim, int spacedim>
 CellSimilarity::Similarity
diff --git a/source/fe/mapping_q1.cc b/source/fe/mapping_q1.cc
index 2a5111fab8..e4117b8d9c 100644
--- a/source/fe/mapping_q1.cc
+++ b/source/fe/mapping_q1.cc
@@ -402,7 +402,7 @@ MappingQ1<dim,spacedim>::update_each (const UpdateFlags in) const
   // quantities are necessary to
   // compute what we need. note that
   // some flags appear in both
-  // conditions and in subsequents
+  // conditions and in subsequent
   // set operations. this leads to
   // some circular logic. the only
   // way to treat this is to
@@ -525,7 +525,7 @@ MappingQ1<dim,spacedim>::compute_face_data (const UpdateFlags update_flags,
                                         std::vector<Tensor<1,dim> > (n_original_q_points));
           if (dim==2)
             {
-              // ensure a counterclock wise
+              // ensure a counterclockwise
               // orientation of tangentials
               static const int tangential_orientation[4]= {-1,1,1,-1};
               for (unsigned int i=0; i<nfaces; ++i)
diff --git a/source/fe/mapping_q_eulerian.cc b/source/fe/mapping_q_eulerian.cc
index c679a47858..67f069b640 100644
--- a/source/fe/mapping_q_eulerian.cc
+++ b/source/fe/mapping_q_eulerian.cc
@@ -156,7 +156,7 @@ compute_mapping_support_points
   std::vector<Vector<double> > shift_vector(n_support_pts,Vector<double>(n_components));
 
   // fill shift vector for each support point using an fe_values object. make
-  // sure that the fe_values variable isn't used simulatenously from different
+  // sure that the fe_values variable isn't used simultaneously from different
   // threads
   Threads::Mutex::ScopedLock lock(fe_values_mutex);
   fe_values.reinit(dof_cell);
-- 
2.39.5