diff --git a/apps/benchmarks/FluidParticleCoupling/MotionSettlingSphere.cpp b/apps/benchmarks/FluidParticleCoupling/MotionSettlingSphere.cpp
index 69f6a438e94b659c2f55d94373066770e3b3f8be..a6c85893c0cf5d777caf20ef44ac7b7379502def 100644
--- a/apps/benchmarks/FluidParticleCoupling/MotionSettlingSphere.cpp
+++ b/apps/benchmarks/FluidParticleCoupling/MotionSettlingSphere.cpp
@@ -606,7 +606,7 @@ private:
 /*
  * This extensive, physical test case simulates a single, heavy sphere in ambient fluid flow.
  * It is based on the benchmark proposed in
- * Uhlman, Dusek - "The motion of a single heavy sphere in ambient fluid: A benchmark for interface-resolved
+ * Uhlmann, Dusek - "The motion of a single heavy sphere in ambient fluid: A benchmark for interface-resolved
  *                  particulate flow simulations with significant relative velocities" IJMF (2014),
  *                  doi: 10.1016/j.ijmultiphaseflow.2013.10.010
  * Results for LBM done with waLBerla are published in
diff --git a/apps/benchmarks/MotionSingleHeavySphere/MotionSingleHeavySphere.cpp b/apps/benchmarks/MotionSingleHeavySphere/MotionSingleHeavySphere.cpp
index 293451af236c7c2605968c10cbac6333367911f9..f07496363c82bd456a68200e4e0cecd3ad73a159 100644
--- a/apps/benchmarks/MotionSingleHeavySphere/MotionSingleHeavySphere.cpp
+++ b/apps/benchmarks/MotionSingleHeavySphere/MotionSingleHeavySphere.cpp
@@ -615,7 +615,7 @@ private:
 /*
  * This extensive, physical test case simulates a single, heavy sphere in ambient fluid flow.
  * It is based on the benchmark proposed in
- * Uhlman, Dusek - "The motion of a single heavy sphere in ambient fluid: A benchmark for interface-resolved
+ * Uhlmann, Dusek - "The motion of a single heavy sphere in ambient fluid: A benchmark for interface-resolved
  *                  particulate flow simulations with significant relative velocities" IJMF (2014),
  *                  doi: 10.1016/j.ijmultiphaseflow.2013.10.010
  * Results for LBM done with waLBerla are published in
@@ -634,9 +634,9 @@ private:
  *    - solid collision operator variant: 1, 2, or 3
  *    - weighting factor variant: 1, or 2
  *
- * The results obtained by this benchmark should be compared to the reference spectral method results from Uhlman & Dusek.
+ * The results obtained by this benchmark should be compared to the reference spectral method results from Uhlmann & Dusek.
  * Furthermore, comparisons to the CFD-IBM (classical Navier-Stokes solver with immersed boundary method)
- * results from Uhlman & Dusek are available in their paper.
+ * results from Uhlmann & Dusek are available in their paper.
  * New coupling algorithms or algorithmic changes to the exiting approaches should also be cross-checked with the
  * values in Rettinger & Ruede.
  *
diff --git a/apps/showcases/BidisperseFluidizedBed/BidisperseFluidizedBedDPM.cpp b/apps/showcases/BidisperseFluidizedBed/BidisperseFluidizedBedDPM.cpp
index dad90bc62a911a87738db60f5ffa799046599aa3..415240ca3c82584ea28a7b969d1484ce7debcd08 100644
--- a/apps/showcases/BidisperseFluidizedBed/BidisperseFluidizedBedDPM.cpp
+++ b/apps/showcases/BidisperseFluidizedBed/BidisperseFluidizedBedDPM.cpp
@@ -860,7 +860,7 @@ int main( int argc, char **argv ) {
                                  (real_t(1) - lnDryResCoeff * lnDryResCoeff / (math::pi * math::pi + lnDryResCoeff * lnDryResCoeff)));
    const real_t dampingCoeff = -real_t(2) * std::sqrt(Mij * stiffnessCoeff) *
                                (std::log(restitutionCoeff) / std::sqrt(math::pi * math::pi + (std::log(restitutionCoeff) * std::log(restitutionCoeff))));
-   const real_t contactDuration = real_t(2) * math::pi * Mij / (std::sqrt(real_t(4) * Mij * stiffnessCoeff - dampingCoeff * dampingCoeff)); //formula from Uhlman
+   const real_t contactDuration = real_t(2) * math::pi * Mij / (std::sqrt(real_t(4) * Mij * stiffnessCoeff - dampingCoeff * dampingCoeff)); //formula from Uhlmann
 
    WALBERLA_LOG_INFO_ON_ROOT("Created particle material with:\n"
                                    << " - coefficient of restitution = " << restitutionCoeff << "\n"
diff --git a/apps/tutorials/basics/01_BlocksAndFields.dox b/apps/tutorials/basics/01_BlocksAndFields.dox
index dd679f42c72859df62cb3647dc41ab00c7f7d5c5..944c64cb50331323490d89a6ccb266418fd8de5b 100644
--- a/apps/tutorials/basics/01_BlocksAndFields.dox
+++ b/apps/tutorials/basics/01_BlocksAndFields.dox
@@ -19,7 +19,7 @@ In waLBerla, the domain is first partitioned into blocks, where each block holds
 This has the advantage that the domain can easily be distributed to multiple processes,
 where every process can have one or more local blocks.
 
-The following snippet shows how to create a simple domain decompositon that results in a uniform block grid: 
+The following snippet shows how to create a simple domain decomposition that results in a uniform block grid: 
 
 \code
 #include "core/Environment.h"
@@ -56,7 +56,7 @@ The last three parameters determine if the domain is periodic in x, y, or z dire
 There are a lot more ways for initializing the block decomposition of the simulation space in waLBerla. For this tutorial, we just use
 a very simple form of decomposition. In later tutorials, we will see that the domain decomposition can also be controlled via a configuration
 file that is passed to the application. Also, in general, you can have an arbitrary number of blocks on each process. This can be important
-for balancing work load. For load balancning, there exist many different algorithms: some make use of METIS, others are based on space filling curves.
+for balancing work load. For load balancing, there exist many different algorithms: some make use of METIS, others are based on space filling curves.
 It is even possible to decompose the simulation space into a set of octrees, resulting in a distributed forest of octrees data structure that
 contains blocks of different sizes. This form of decomposition can be used for simulations that require some form of grid refinement. 
 For now, however, we stick to a simple, uniform block decomposition.
diff --git a/apps/tutorials/basics/02_Sweeps.dox b/apps/tutorials/basics/02_Sweeps.dox
index 8c25ea3af4653835b7ee2aa0e660dad46a1b770f..2080d217ae9fdae45486c8cde417c5db90c92f80 100644
--- a/apps/tutorials/basics/02_Sweeps.dox
+++ b/apps/tutorials/basics/02_Sweeps.dox
@@ -13,7 +13,7 @@ A function that takes a single block as argument and operates on the block data
 
 For demonstrating how to write a sweep, let us implement the following "algorithm":
 - Initialize the scalar field with random values.
-- In each time step, double the value in the field if it is bigger than some limit, otherwise half the value.
+- In each time step, double the value in the field if it is bigger than some limit, otherwise halve the value.
 
 \section tut02_initialize Initializing the Field
 
diff --git a/apps/tutorials/basics/03_GameOfLife.dox b/apps/tutorials/basics/03_GameOfLife.dox
index 2ca31c9ad392a53259d616f2616a9791f8cd1c75..58c03591b773a4bad2a122d1f95661d80adf958e 100644
--- a/apps/tutorials/basics/03_GameOfLife.dox
+++ b/apps/tutorials/basics/03_GameOfLife.dox
@@ -252,7 +252,7 @@ while( fieldIter != field->end() )
 Calling Field::clone() returns a pointer to a field that is newly allocated. We immediately
 catch this pointer with a shared_ptr. When the shared_ptr is destroyed at the end of the function,
 the dynamically allocated memory for the field is automatically freed and we don't have to take
-care of freeing the memory ourselves. Not freeing the memory would evantually cause the application to crash,
+care of freeing the memory ourselves. Not freeing the memory would eventually cause the application to crash,
 since this algorithm is called many times and each time the memory usage of our application would grow.
 
 As you can see, we now have to iterate two fields at the same time: `field` and `copy`. 
diff --git a/apps/tutorials/mesa_pd/01_MESAPD.dox b/apps/tutorials/mesa_pd/01_MESAPD.dox
index c30e2cf93341b6ba20d58bc16f85e65ac1fcba8f..28cc3567db443feaf80b942cbc84c9e347f617a8 100644
--- a/apps/tutorials/mesa_pd/01_MESAPD.dox
+++ b/apps/tutorials/mesa_pd/01_MESAPD.dox
@@ -4,8 +4,8 @@ namespace mesa_pd {
 /**
 \page tutorial_mesapd_01 Tutorial - Confined Gas:  Setting up a simple MESA-PD simulation
 
-This tutorial will help you to setup up a simple simulation using the MESA-PD module.
-The scenario for this tutorial a is particle gas (spheres) confined by solid walls.
+This tutorial will help you to set up a simple simulation using the MESA-PD module.
+The scenario for this tutorial is a particle gas (spheres) confined by solid walls.
 
 For this tutorial only a few waLBerla includes are needed, namely:
 \snippet 01_MESAPD.cpp walberlaIncludes
@@ -31,9 +31,9 @@ You can choose the number of blocks you want to have in each direction. In a par
 
 \snippet 01_MESAPD.cpp BlockForest
 
-Next, we initialize all data structures that we need for the simulation. The data::ParticleStorage is the data container for all particles. The data::ShapeStorage stores information about the shape of the particles. This information is separated from the particle due to that fact that most of the time there are many similar particles in on simulation. With this approach you do not need to store the information for every particle but only once.
+Next, we initialize all data structures that we need for the simulation. The data::ParticleStorage is the data container for all particles. The data::ShapeStorage stores information about the shape of the particles. This information is separated from the particle due to that fact that most of the time there are many similar particles in one simulation. With this approach you do not need to store the information for every particle but only once.
 
-Since all kernels are written against an abstract interface to access the particle properties we also need a intermediate accessor class. This class is in most cases is the data::ParticleAccessorWithShape.
+Since all kernels are written against an abstract interface to access the particle properties we also need an intermediate accessor class. This class is in most cases data::ParticleAccessorWithShape.
 
 Finally, to improve the complexity of the collision detection step, we need a data::LinkedCells acceleration data structure.
 
@@ -53,7 +53,7 @@ The gas particles are generated with the help of grid generators. These generato
 
 Before we can run the simulation we have to set up all kernels that we will use.
 \snippet 01_MESAPD.cpp Kernels
-In this example we will use the explicit euler integration method. We further need a kernel which updates our LinkedCell data structure and an interaction kernel. For the collision detection we select the analytic functions available within the framework. Together with all synchronization kernels we can now run the simulation.
+In this example we will use the explicit Euler integration method. We further need a kernel which updates our LinkedCell data structure and an interaction kernel. For the collision detection we select the analytic functions available within the framework. Together with all synchronization kernels we can now run the simulation.
 
 \attention Before you start the simulation loop you should synchronize once to make sure everything is in place.
 
diff --git a/apps/tutorials/pde/01_SolvingPDE.dox b/apps/tutorials/pde/01_SolvingPDE.dox
index a978dbf0cf294c20b92903e495a5de833b4ab735..47d377db67db2d619b56b0e643d7cb7e412ccdcf 100644
--- a/apps/tutorials/pde/01_SolvingPDE.dox
+++ b/apps/tutorials/pde/01_SolvingPDE.dox
@@ -34,7 +34,7 @@ which yields the following discretized equation, valid for a Cartesian grid with
 \f]
 
 The resulting linear system of equations (\f$\mathbf{A}x=b\f$) can be solved with either a direct or an iterative solver. 
-Probably the simplest variant of latter is the Jacobi method which applies a splitting of the system matrix in its diagonal and off-diagonal parts
+Probably the simplest variant of the latter is the Jacobi method which applies a splitting of the system matrix in its diagonal and off-diagonal parts
 to come up with an iterative solution procedure. This finally allows to write the method in a matrix-free version, given by:
 \f[
    u_{i,j}^{(n+1)} = \left(\frac{2}{(\Delta x)^2} + \frac{2}{(\Delta y)^2} + 4\pi^2\right)^{-1}\left[ f_{i,j} + \frac{1}{(\Delta x)^2}\left(u_{i+1,j}^{(n)} + 
@@ -44,7 +44,7 @@ to come up with an iterative solution procedure. This finally allows to write th
 \section implementationJacobiSweep Implementation of the Jacobi Sweep
 
 Coming back to the concepts of waLBerla, this is a perfectly suitable example for a sweep. 
-It requires to sum up weighted values of the neighboring cells together with the function value of the right-hand side, 
+It requires summing up weighted values of the neighboring cells together with the function value of the right-hand side, 
 which is then divided by the weight of the center cell. 
 To avoid data dependencies, i.e., reading neighboring data that has already been updated in a previous step, 
 two fields (source and destination) are used like in \ref tutorial03. 
@@ -81,8 +81,8 @@ void JacobiSweep::operator()( IBlock * const block )
 
 This is already the entire implementation of the Jacobi method! 
 As always, there are of course various other ways to achieve this. 
-The stencil concept utilized by waLBerla allows a very convenient since flexible and also faster implementation with the help of neighborhood iterators and stencil weights.
-The performance problem of above implementation lies in the fact that the prefactors are recomputed for each step and each cell. 
+The stencil concept utilized by waLBerla allows a very convenient (since flexible) and also faster implementation with the help of neighborhood iterators and stencil weights.
+The performance problem of the above implementation lies in the fact that the prefactors are recomputed for each step and each cell. 
 Since they are constant, it is a better idea to precalculate them and store them in a `weights` vector.
 
 \code
@@ -150,7 +150,7 @@ dst->get(x,y,z) *= weights_[ Stencil_T::idx[ stencil::C ] ];
 Despite being faster, the implementation using the stencil concept is more flexible than the hard coded variant from the beginning 
 since it can be used for different stencil layouts.
 Say you use a different, probably higher-order, discretization of the PDE and come up with a D2Q9 stencil.
-Then, simply change the typedef to `typedef stencil::D2Q9 Stencil_T` and change and add the weight values in the `weights` vector accordingly. 
+Then, simply change the typedef to `typedef stencil::D2Q9 Stencil_T` and add the new weight values in the `weights` vector accordingly. 
 The implementation of the JacobiSweepStencil class stays untouched and the simulations can readily be carried out.
 
 
diff --git a/apps/tutorials/pde/02_HeatEquation.dox b/apps/tutorials/pde/02_HeatEquation.dox
index 98afd5ca573cf76fd11e29aad1b2a34569b693c0..353ad06eeb6f37dbeee4c346a7da5f933074e7e1 100644
--- a/apps/tutorials/pde/02_HeatEquation.dox
+++ b/apps/tutorials/pde/02_HeatEquation.dox
@@ -25,7 +25,7 @@ and the initial distribution of \f$u\f$ inside the domain is given by the initia
 \f]
 
 For the numerical solution, we not only have to discretize in space but also in time. 
-Latter is done via an implicit Euler method with a time step length \f$\Delta t\f$ here, resulting in the following formulation: 
+The latter is done via an implicit Euler method with a time step \f$\Delta t\f$, resulting in the following formulation: 
 \f[
    \frac{u^{new} - u^{old}}{\Delta t} = \kappa \left( \frac{\partial^2 u^{new}}{\partial x^2} + \frac{\partial^2 u^{new}}{\partial y^2}\right)
 \f]
@@ -162,7 +162,7 @@ void Reinitialize::operator()( IBlock * block )
 \endcode 
 
 On a side note, this means that the starting solution for the Jacobi method is the former right-hand side.
-This is advantageous to setting it always to zero (which could be done via `src->set( real_c(0) )`) as it is probably already quite close to the converged solution,
+This is more advantageous compared to setting it always to zero (which could be done via `src->set( real_c(0) )`) as it is probably already quite close to the converged solution,
 i.e., the Jacobi method will converge faster.
 
 This functor is now registered as a sweep in the time loop in the known fashion:
@@ -292,7 +292,7 @@ The one that computes the total number of cells inside the domain and stores it
 \code
 void JacobiIterationResidual::init()
 {
-   // temporal storage
+   // temporary storage
    uint_t cells( uint_c(0) );
 
    // iterate all blocks
@@ -323,7 +323,7 @@ real_t JacobiIterationResidual::residualNorm()
       auto u   = block->getData< ScalarField >( srcID_ );
       auto rhs = block->getData< ScalarField >( rhsID_ );
 
-      // temporal storage
+      // temporary storage
       real_t residual( real_c(0) );
 
       // iterate all cells inside the block
diff --git a/apps/tutorials/pde/03_HeatEquation_Extensions.cpp b/apps/tutorials/pde/03_HeatEquation_Extensions.cpp
index a1b42906a8a13107516921c168e76dc903e9996d..6db0cb09153978008bb158dd70d2080771774d6a 100644
--- a/apps/tutorials/pde/03_HeatEquation_Extensions.cpp
+++ b/apps/tutorials/pde/03_HeatEquation_Extensions.cpp
@@ -161,7 +161,7 @@ void JacobiIterationResidual::operator()()
 
 void JacobiIterationResidual::init()
 {
-   // temporal storage
+   // temporary storage
    uint_t cells( uint_c(0) );
 
    // iterate all blocks
@@ -189,7 +189,7 @@ real_t JacobiIterationResidual::residualNorm()
       auto u   = block->getData< ScalarField >( srcID_ );
       auto rhs = block->getData< ScalarField >( rhsID_ );
 
-      // temporal storage
+      // temporary storage
       real_t residual( real_c(0) );
 
       // iterate all cells inside the block
diff --git a/apps/tutorials/pe/01_ConfinedGas.dox b/apps/tutorials/pe/01_ConfinedGas.dox
index 48105ac74e88f2d277570fb2e1bbed61f181e931..7e4fc6a7184963417385d950e408fb1061bc7b4d 100644
--- a/apps/tutorials/pe/01_ConfinedGas.dox
+++ b/apps/tutorials/pe/01_ConfinedGas.dox
@@ -4,7 +4,7 @@ namespace pe {
 /**
 \page tutorial_pe_01 Tutorial - Confined Gas:  Setting up a simple pe simulation
 
-This tutorial will help you to setup up a simple pe simulation. The scenario for this tutorial a is particle
+This tutorial will help you to set up a simple pe simulation. The scenario for this tutorial is a particle
 gas (spheres) confined by solid walls.
 
 For this tutorial only a few includes are needed, namely:
@@ -79,7 +79,7 @@ access their properties.
 \snippet 01_ConfinedGas.cpp PostProcessing
 
 Congratulation! You successfully created your first rigid body simulation.
-In the next tutorial we will look at possible extensions which can make your live easier.
+In the next tutorial we will look at possible extensions which can make your life easier.
 
 */
 
diff --git a/apps/tutorials/pe/02_ConfinedGasExtended.dox b/apps/tutorials/pe/02_ConfinedGasExtended.dox
index 89cd4a837becfdef61bc1c66212e73cafafb65f7..818a8189ee2d625c000aa73af1ede2a1b8ba13fa 100644
--- a/apps/tutorials/pe/02_ConfinedGasExtended.dox
+++ b/apps/tutorials/pe/02_ConfinedGasExtended.dox
@@ -4,7 +4,7 @@ namespace pe {
 /**
 \page tutorial_pe_02 Tutorial - Useful Features
 
-This tutorial will introduce some useful features of the waLBerla framework which can make your live easier.
+This tutorial will introduce some useful features of the waLBerla framework which can make your life easier.
 
 \section tutorial_pe_02_checkpointing Checkpointing
 You can checkpoint the current state of your rigid body dynamics simulation at any point to restore it afterwards.
@@ -51,7 +51,7 @@ Environment::config() function. You can access subblocks of the config with conf
 \snippet LoadFromConfig.cpp Load Config
 To get values from the config call config::Config::getParameter():
 \snippet LoadFromConfig.cpp Config Get Parameter
-Certain task already have predefined loading functions. You can for example directly create a BlockForest
+Certain tasks already have predefined loading functions. You can for example directly create a BlockForest
 from the config file.
 \snippet LoadFromConfig.cpp Config BlockForest
 The corresponding block in the config file looks like:
@@ -73,18 +73,18 @@ globalLinearAcceleration < 1, -2, 3 >;
 \endcode
 
 \section tutorial_pe_02_timing Timing
-To get additional information where you application spends its time you can use the WcTimingTree.
-It will give you a hirarchical view of the time used.
+To get additional information where your application spends its time you can use the WcTimingTree.
+It will give you a hierarchical view of the time used.
 Usage example:
 \snippet 02_ConfinedGasExtended.cpp TT Example
 Before you output the information you should collect all the information from all the processes if you are running
 in parallel.
 \snippet 02_ConfinedGasExtended.cpp TT Log
-Many build-in functions like solver or synchronization methods come with an additional parameter where you can
+Many built-in functions like solver or synchronization methods come with an additional parameter where you can
 specify your timing tree. They will then include detailed information in your timing tree.
 
 \section tutorial_pe_02_sqlite SQLite Output
-waLBerla also supports SQLite database for simulation data output. This can come in handy in parallel simulations
+waLBerla also supports SQLite databases for simulation data output. This can come in handy in parallel simulations
 as well as in data analysis. To store information in a SQLite database you have to fill three property maps
 depending on the type of information you want to store.
 \snippet 02_ConfinedGasExtended.cpp SQLProperties
diff --git a/src/blockforest/BlockForest.h b/src/blockforest/BlockForest.h
index 0edd764afde9eaa965b544fd1aaa61b3b9c48f54..6108ea3e2ce523ca6f8e11549e354f97324524b9 100644
--- a/src/blockforest/BlockForest.h
+++ b/src/blockforest/BlockForest.h
@@ -382,7 +382,7 @@ public:
    //         e.g. diffusive or space filling curve strategy
    // 4) data migration / refinement / coarsening
 
-   /// Triggeres AMR Pipeline
+   /// Triggers AMR Pipeline
    void refresh();
 
    /// Functor that calls refresh with given frequency
diff --git a/src/blockforest/BlockNeighborhoodConstruction.cpp b/src/blockforest/BlockNeighborhoodConstruction.cpp
index aafe81ff5eaadff1bde0838866820e12ea4956ec..4f94588c841708b84a53c702289b2ed7470acf9a 100644
--- a/src/blockforest/BlockNeighborhoodConstruction.cpp
+++ b/src/blockforest/BlockNeighborhoodConstruction.cpp
@@ -219,4 +219,4 @@ void constructNeighborhoodSectionBlockCenters( uint_t sectionIndex, const AABB&
 
 
 } // namespace blockforest
-} // namespace walblera
+} // namespace walberla
diff --git a/src/blockforest/Initialization.cpp b/src/blockforest/Initialization.cpp
index 11d5243e219e826559d0a9e7c9f9ac0cc1ea74fb..75a1d81c96b02cec912e2aaea73361f9a59e2ffa 100644
--- a/src/blockforest/Initialization.cpp
+++ b/src/blockforest/Initialization.cpp
@@ -85,7 +85,7 @@ shared_ptr< StructuredBlockForest > createUniformBlockGridFromConfig( const shar
 \endverbatim
 *          An optional config parameter 'cartesianSetup' is available. Its default, true, causes one block to be
 *          assigned to each process. Setting it to false allows multiple blocks to be assigned to each process.
-*          If the number of blocks is not divisble by the number of processes, the loadbalancer tries to assign
+*          If the number of blocks is not divisible by the number of processes, the loadbalancer tries to assign
 *          the blocks to processes as evenly as possible.
 *    2) Using the number of global cells, #blocks = #processes, if this does not fit, extend the domain
 \verbatim
diff --git a/src/blockforest/communication/DirectionBasedReduceScheme.h b/src/blockforest/communication/DirectionBasedReduceScheme.h
index 72c52ec640bc9bbbe4b7d006922906225a3aff04..138e3f7131c52306e57e0caa199f47913704fce8 100644
--- a/src/blockforest/communication/DirectionBasedReduceScheme.h
+++ b/src/blockforest/communication/DirectionBasedReduceScheme.h
@@ -147,7 +147,7 @@ template< stencil::Direction dir_ >
 void DirectionBasedReduceScheme<dir_>::init()
 {
    if( !blockForest_->containsGlobalBlockInformation() )
-      WALBERLA_ABORT( "For this communication scheme global block information is neeeded" );
+      WALBERLA_ABORT( "For this communication scheme global block information is needed" );
 
    //  -------------------  Block Loop ------------------------------------------------
    uint_t x,y,z;
diff --git a/src/blockforest/loadbalancing/DynamicCurve.h b/src/blockforest/loadbalancing/DynamicCurve.h
index 8b3e5808ac2c23b4b0a2016e91b5c18bd438f52f..6b6c9736612a0b4181112363624e559e1fd1e3fc 100644
--- a/src/blockforest/loadbalancing/DynamicCurve.h
+++ b/src/blockforest/loadbalancing/DynamicCurve.h
@@ -208,7 +208,7 @@ bool DynamicCurveBalance< PhantomData_T >::operator()( std::vector< std::pair< c
                                                                 std::set< uint_t > & processesToRecvFrom,
                                                                 const PhantomBlockForest & phantomForest, const uint_t ) const
 {
-   // Do not change or modifiy this check.
+   // Do not change or modify this check.
    // The Hilbert curve construction relies on "std::numeric_limits< idx_t >::max()" being an invalid number of blocks for a process
    WALBERLA_CHECK_LESS( targetProcess.size(), std::numeric_limits< idx_t >::max() );
    
diff --git a/src/communication/doc/walberlaCommunication.dox b/src/communication/doc/walberlaCommunication.dox
index 3885485e1626909f97dca6ea783741c52062ffa8..4dd9269b4370f71cb89c9ead40fa11ec4d701c6c 100644
--- a/src/communication/doc/walberlaCommunication.dox
+++ b/src/communication/doc/walberlaCommunication.dox
@@ -70,7 +70,7 @@ Gatherv.h , Reduce.h and Broadcast.h
    to implement the communication logic. It consists of communication schemes, the most prominent
    is walberla::blockforest::communication::UniformBufferedScheme . It exchanges information with all neighboring blocks, where the
    data extraction and insertion is handled by the registered PackInfos. There are other more specialized schemes available,
-   as an example have a look at walberla::blockforest::communciation::DirectionBasedReduceScheme.
+   as an example have a look at walberla::blockforest::communication::DirectionBasedReduceScheme.
 
 
 \section direct_comm Direct Communication
diff --git a/src/core/UniqueID.h b/src/core/UniqueID.h
index 4b267070edac6bbc0b734ed7e117523bc2a3143a..de9e883345f9b9720fb5592315fd85c3a55d3be4 100644
--- a/src/core/UniqueID.h
+++ b/src/core/UniqueID.h
@@ -46,7 +46,7 @@ namespace walberla {
  * \ingroup core
  *
  * The UniqueID class is responsible for the generation of unique system IDs even during an MPI
- * parallel execution. The unqiue ID is composed from the number of locally generated objects
+ * parallel execution. The unique ID is composed from the number of locally generated objects
  * of type \a T and the rank of the local MPI process.
  */
 template< typename T >
diff --git a/src/core/cell/Cell.h b/src/core/cell/Cell.h
index 3df78ce5b147c26650cf8caf799a4bb342e34f4c..26d593b801a9c476441f362d494eaaf3fd9168c9 100644
--- a/src/core/cell/Cell.h
+++ b/src/core/cell/Cell.h
@@ -121,7 +121,7 @@ inline Cell::Cell( const uint_t _x, const uint_t _y, const uint_t _z )
 /*******************************************************************************************************************//**
  * \brief   Less-than comparison operator for Cells.
  *
- * Compares a cell's coordinates lexicographically (first x, than eventualy y and (if necessary) finally z).
+ * Compares a cell's coordinates lexicographically (first x, then eventually y and (if necessary) finally z).
  *
  * \param [in] rhs  the cell compared to *this.
  *
@@ -138,7 +138,7 @@ inline bool Cell::operator<( const Cell & rhs ) const
  /******************************************************************************************************************//**
  * \brief   Equal comparison operator for Cells.
  *
- * Compares a cell's coordinates for equality (first x, then eventualy y and (if necessary) finally z).
+ * Compares a cell's coordinates for equality (first x, then eventually y and (if necessary) finally z).
  *
  * \param [in] rhs  The cell compared to *this.
  *
diff --git a/src/core/cell/CellInterval.cpp b/src/core/cell/CellInterval.cpp
index c4df1ea31a656338691e4752ca8829150461eda7..786644d9902c92ab7f703802d64659dcb73842ff 100644
--- a/src/core/cell/CellInterval.cpp
+++ b/src/core/cell/CellInterval.cpp
@@ -57,5 +57,5 @@ bool CellInterval::overlaps( const CellVector& cellVector ) const
 
 
 
-} // namesapce cell
+} // namespace cell
 } // namespace walberla
diff --git a/src/core/cell/CellVector.h b/src/core/cell/CellVector.h
index c05474400a39ba7b59ffd0268649eb12e3abc2eb..0b5ce7d57788d4b1e1e06418f381c75b179cb5b6 100644
--- a/src/core/cell/CellVector.h
+++ b/src/core/cell/CellVector.h
@@ -155,7 +155,7 @@ inline void CellVector::push_back( const uint_t x, const uint_t y, const uint_t
 //**********************************************************************************************************************
 /*! \brief Return if cell (x,y,z) is contained in cell vector
  *
- * Complexity is O(N), where N == this->size(). If you need a data strcuture for storing cells that
+ * Complexity is O(N), where N == this->size(). If you need a data structure for storing cells that
  * provides an contains method that runs in O(logN) use a CellSet, not a CellVector.
  *
  * \return true, if cell is contained
diff --git a/src/core/debug/PrintStacktrace.cpp b/src/core/debug/PrintStacktrace.cpp
index 7eff6bcb948834578474ebb3649d455dd0c40ee4..94f2aa89b34c307b5da5f7b54685f7dc7a4ad0b9 100644
--- a/src/core/debug/PrintStacktrace.cpp
+++ b/src/core/debug/PrintStacktrace.cpp
@@ -100,7 +100,7 @@ namespace debug {
          string offset       = bracketPart.substr( plusPos+1 );
 #endif
 
-         // try to demangle -> no return code if successfull
+         // try to demangle -> no return code if successful
          // but the returned string starts with "demangle" if demangling failed
          // really hacky :(
          string demangled    = demangle( functionName );
diff --git a/src/core/logging/Initialization.cpp b/src/core/logging/Initialization.cpp
index 3ea701abd57207f409927b1e85b19e355f47e7ab..ca442e71288cf914a47de70b05e42e68468baa1b 100644
--- a/src/core/logging/Initialization.cpp
+++ b/src/core/logging/Initialization.cpp
@@ -106,7 +106,7 @@ static void parseIgnoreBlocks( const Config::Blocks & ignoreBlocks, std::vector<
 *   the log message is ignored. To divide components of your path always uses slashes!
 *   They will automatically be converted to the regex (/|\\), matching slashes and back-slashes. For fancy regexes
 *   you can use perl regex syntax.
-*   To ignore warnings use the spcecial ignoreWarning block.
+*   To ignore warnings use the special ignoreWarning block.
 *   Note that you cannot ignore Errors since they abort your program!
 *
 *   Examples:
diff --git a/src/core/math/MatrixMxN.h b/src/core/math/MatrixMxN.h
index 380baeb326b4e8f6841575317c3bf9b61752d352..f523fde9422e06a04c37f7918120f04d6dda1e0c 100644
--- a/src/core/math/MatrixMxN.h
+++ b/src/core/math/MatrixMxN.h
@@ -285,7 +285,7 @@ inline constexpr MatrixMxN<Type>::MatrixMxN( const MatrixMxN& m )
    MatrixMxN<real> A = init;
    \endcode
 
- * The matrix is sized accoring to the size of the array and initialized with the given values.
+ * The matrix is sized according to the size of the array and initialized with the given values.
  * Missing values are initialized with zero (as e.g. the value 6 in the example).
  */
 template< typename Type >  // Data type of the matrix
@@ -348,7 +348,7 @@ inline MatrixMxN<Type>::~MatrixMxN()
    A = init;
    \endcode
 
- * The matrix is resized accoring to the size of the array and initialized with the given values.
+ * The matrix is resized according to the size of the array and initialized with the given values.
  * Missing values are initialized with zero (as e.g. the value 6 in the example).
  */
 template< typename Type >  // Data type of the matrix
diff --git a/src/core/math/Parser.cpp b/src/core/math/Parser.cpp
index 7c39e5e9da6402e5981cabbf9e2685ee58988084..7b12bc35203f7b68d8cd5e193fea4e85bcee2ae3 100644
--- a/src/core/math/Parser.cpp
+++ b/src/core/math/Parser.cpp
@@ -137,7 +137,7 @@ double FunctionParser::evaluate( const std::map<std::string,double> & symbolTabl
       auto symbolEntryIt = symbolTable.find( *vIt );
 
       if( symbolEntryIt == symbolTable.end() )
-         WALBERLA_ABORT( "Error evaluationg expression. Variable \"" << *vIt << "\" not specified in symbol table!" );
+         WALBERLA_ABORT( "Error evaluating expression. Variable \"" << *vIt << "\" not specified in symbol table!" );
 
       symbolTable_->variable_ref( *vIt ) = symbolEntryIt->second;
    }
diff --git a/src/core/math/Quaternion.h b/src/core/math/Quaternion.h
index 417e9b7937c1e1cb372cfa18495514c00a526090..3ee4273ae173a0a1057784db65c531fa6f8256fe 100644
--- a/src/core/math/Quaternion.h
+++ b/src/core/math/Quaternion.h
@@ -230,7 +230,7 @@ static_assert( std::is_trivially_copyable<Quaternion<real_t>>::value, "Quaternio
  * \param j The initial value for the second imaginary part.
  * \param k The initial value for the third imaginary part.
  *
- * The initial values for the quaterion have to be chosen such that the length of the
+ * The initial values for the quaternion have to be chosen such that the length of the
  * quaternion is 1.
  */
 template< typename Type >  // Data type of the quaternion
@@ -733,7 +733,7 @@ inline const Matrix3< typename MathTrait<Type,Other>::MultType >
 
 
 //*************************************************************************************************
-/*!\brief Returns the angle in radian measure between the quaterion and a given axis.
+/*!\brief Returns the angle in radian measure between the quaternion and a given axis.
  *
  * \param axis The given axis.
  * \return The angle in radian measure.
@@ -888,7 +888,7 @@ std::istream& operator>>( std::istream& is, Quaternion<Type>& q )
       return is;
    }
 
-   // Transfering the input to the quaternion values
+   // Transferring the input to the quaternion values
    q.set( r, i, j, k );
 
    // Resetting the flags
diff --git a/src/core/math/Sample.cpp b/src/core/math/Sample.cpp
index bdd9e068973c9177e0e48ca65617f253bf566e8a..a85954e2aaf9e45d18af57d76989be7da23a6665 100644
--- a/src/core/math/Sample.cpp
+++ b/src/core/math/Sample.cpp
@@ -264,7 +264,7 @@ real_t Sample::quantile(const real_t p) const
  *    %mad       by mad()
  *    %size       by size()
  *
- * \returns  The formated string.
+ * \returns  The formatted string.
  **********************************************************************************************************************/
 std::string Sample::format(const std::string & formatString) const
 {
diff --git a/src/core/math/Vector2.h b/src/core/math/Vector2.h
index 00bfabe88bfbf785b2ed3789258358cfc2912a7e..10589c98fa890037c44b5bce145a1aa104ad6393 100644
--- a/src/core/math/Vector2.h
+++ b/src/core/math/Vector2.h
@@ -605,7 +605,7 @@ inline HIGH Vector2<Type>::operator*( const Vector2<Other>& rhs ) const
 
 //**********************************************************************************************************************
 /*!\fn Vector2<HIGH> Vector2<Type>::operator/( Other rhs ) const
-// \brief Division operator for the divison of a vector by a scalar value
+// \brief Division operator for the division of a vector by a scalar value
 // \brief (\f$ \vec{a}=\vec{b}/s \f$).
 //
 // \param rhs The right-hand-side scalar value for the division.
@@ -1062,7 +1062,7 @@ inline bool operator==( long double scalar, const Vector2<Type>& vec )
 // \brief Inequality operator for the comparison of an unsigned char scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1081,7 +1081,7 @@ inline bool operator!=( unsigned char scalar, const Vector2<Type>& vec )
 // \brief Inequality operator for the comparison of a char scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1100,7 +1100,7 @@ inline bool operator!=( char scalar, const Vector2<Type>& vec )
 // \brief Inequality operator for the comparison of a signed char scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1119,7 +1119,7 @@ inline bool operator!=( signed char scalar, const Vector2<Type>& vec )
 // \brief Inequality operator for the comparison of a wchar_t scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1138,7 +1138,7 @@ inline bool operator!=( wchar_t scalar, const Vector2<Type>& vec )
 // \brief Inequality operator for the comparison of an unsigned short scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1157,7 +1157,7 @@ inline bool operator!=( unsigned short scalar, const Vector2<Type>& vec )
 // \brief Inequality operator for the comparison of a short scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1176,7 +1176,7 @@ inline bool operator!=( short scalar, const Vector2<Type>& vec )
 // \brief Inequality operator for the comparison of an uint_t scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1195,7 +1195,7 @@ inline bool operator!=( unsigned int scalar, const Vector2<Type>& vec )
 // \brief Inequality operator for the comparison of an int scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1214,7 +1214,7 @@ inline bool operator!=( int scalar, const Vector2<Type>& vec )
 // \brief Inequality operator for the comparison of an unsigned long scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1233,7 +1233,7 @@ inline bool operator!=( unsigned long scalar, const Vector2<Type>& vec )
 // \brief Inequality operator for the comparison of a long scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1252,7 +1252,7 @@ inline bool operator!=( long scalar, const Vector2<Type>& vec )
 // \brief Inequality operator for the comparison of a float scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1271,7 +1271,7 @@ inline bool operator!=( float scalar, const Vector2<Type>& vec )
 // \brief Inequality operator for the comparison of a double scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1290,7 +1290,7 @@ inline bool operator!=( double scalar, const Vector2<Type>& vec )
 // \brief Inequality operator for the comparison of a long double scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1369,7 +1369,7 @@ std::istream& operator>>( std::istream& is, Vector2<Type>& v )
       return is;
    }
 
-   // Transfering the input to the vector values
+   // Transferring the input to the vector values
    v[0] = x; v[1] = y;
 
    // Resetting the flags
@@ -1428,7 +1428,7 @@ inline std::istream& operator>>( std::istream& is, Vector2<bool>& v )
       }
    }
 
-   // Transfering the input to the vector values
+   // Transferring the input to the vector values
    v[0] = x; v[1] = y;
 
    // Resetting the flags
@@ -1542,7 +1542,7 @@ struct Vector2LexicographicalyLess
    //
    // \param lhs left hand side of less-than-operator.
    // \param rhs right hand side of less-than-operator.
-   // \returns true if lhs < rhs (lexicogrphically), else returns false.
+   // \returns true if lhs < rhs (lexicographically), else returns false.
    */
    bool operator()( const Vector2<T> & lhs, const Vector2<T> & rhs ) const
    {
diff --git a/src/core/math/Vector3.h b/src/core/math/Vector3.h
index c47fd4a66986e94b6bd361ec2eda9bdadb9a98df..413cf0d69e793a7e7bddb2284324f13c75276643 100644
--- a/src/core/math/Vector3.h
+++ b/src/core/math/Vector3.h
@@ -675,7 +675,7 @@ inline HIGH Vector3<Type>::operator*( const Vector3<Other>& rhs ) const
 
 //**********************************************************************************************************************
 /*!\fn Vector3<HIGH> Vector3<Type>::operator/( Other rhs ) const
-// \brief Division operator for the divison of a vector by a scalar value
+// \brief Division operator for the division of a vector by a scalar value
 // \brief (\f$ \vec{a}=\vec{b}/s \f$).
 //
 // \param rhs The right-hand-side scalar value for the division.
@@ -1213,7 +1213,7 @@ inline bool operator==( long double scalar, const Vector3<Type>& vec )
 // \brief Inequality operator for the comparison of an unsigned char scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1232,7 +1232,7 @@ inline bool operator!=( unsigned char scalar, const Vector3<Type>& vec )
 // \brief Inequality operator for the comparison of a char scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1251,7 +1251,7 @@ inline bool operator!=( char scalar, const Vector3<Type>& vec )
 // \brief Inequality operator for the comparison of a signed char scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1270,7 +1270,7 @@ inline bool operator!=( signed char scalar, const Vector3<Type>& vec )
 // \brief Inequality operator for the comparison of a wchar_t scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1289,7 +1289,7 @@ inline bool operator!=( wchar_t scalar, const Vector3<Type>& vec )
 // \brief Inequality operator for the comparison of an unsigned short scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1308,7 +1308,7 @@ inline bool operator!=( unsigned short scalar, const Vector3<Type>& vec )
 // \brief Inequality operator for the comparison of a short scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1327,7 +1327,7 @@ inline bool operator!=( short scalar, const Vector3<Type>& vec )
 // \brief Inequality operator for the comparison of an uint_t scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1346,7 +1346,7 @@ inline bool operator!=( unsigned int scalar, const Vector3<Type>& vec )
 // \brief Inequality operator for the comparison of an int scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1365,7 +1365,7 @@ inline bool operator!=( int scalar, const Vector3<Type>& vec )
 // \brief Inequality operator for the comparison of an unsigned long scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1384,7 +1384,7 @@ inline bool operator!=( unsigned long scalar, const Vector3<Type>& vec )
 // \brief Inequality operator for the comparison of a long scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1403,7 +1403,7 @@ inline bool operator!=( long scalar, const Vector3<Type>& vec )
 // \brief Inequality operator for the comparison of a float scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1422,7 +1422,7 @@ inline bool operator!=( float scalar, const Vector3<Type>& vec )
 // \brief Inequality operator for the comparison of a double scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1441,7 +1441,7 @@ inline bool operator!=( double scalar, const Vector3<Type>& vec )
 // \brief Inequality operator for the comparison of a long double scalar value and a vector.
 //
 // \param scalar The left-hand-side scalar value for the comparison.
-// \param vec The right-hand-side vector for the comparision.
+// \param vec The right-hand-side vector for the comparison.
 // \return bool
 //
 // If one value of the vector is inequal to the scalar value, the inequality test returns true,
@@ -1520,7 +1520,7 @@ std::istream& operator>>( std::istream& is, Vector3<Type>& v )
       return is;
    }
 
-   // Transfering the input to the vector values
+   // Transferring the input to the vector values
    v[0] = x; v[1] = y; v[2] = z;
 
    // Resetting the flags
@@ -1579,7 +1579,7 @@ inline std::istream& operator>>( std::istream& is, Vector3<bool>& v )
       }
    }
 
-   // Transfering the input to the vector values
+   // Transferring the input to the vector values
    v[0] = x; v[1] = y; v[2] = z;
 
    // Resetting the flags
@@ -1802,7 +1802,7 @@ struct Vector3LexicographicalyLess
    //
    // \param lhs left hand side of less-than-operator.
    // \param rhs right hand side of less-than-operator.
-   // \returns true if lhs < rhs (lexicogrphically), else returns false.
+   // \returns true if lhs < rhs (lexicographically), else returns false.
    */
    bool operator()( const Vector3<T> & lhs, const Vector3<T> & rhs ) const
    {
diff --git a/src/core/math/equation_system/EquationParser.cpp b/src/core/math/equation_system/EquationParser.cpp
index aaf1b146d72c91f4bc429ba8d628e7010b897fa7..d5bdb0aafa54228fcecc356c9d24f877a65f5d80 100644
--- a/src/core/math/equation_system/EquationParser.cpp
+++ b/src/core/math/equation_system/EquationParser.cpp
@@ -180,7 +180,7 @@ NodePtr EquationParser::parseFunction( const std::string& str, size_t& index ) c
    }
    NodePtr nodePtr = parseExpression(str, index);
    if ( ! (str[index] == ')') )
-      THROW( "Found no enclosing paranthesis", str, index );
+      THROW( "Found no enclosing parenthesis", str, index );
    ++index;
 
    NodePtr funcPtr;
@@ -230,7 +230,7 @@ NodePtr EquationParser::parseTerm( const std::string& str, size_t& index ) const
    if ( str[index] == '(' ){
       nodePtr = parseExpression(str, ++index);
       if ( ! (str[index] == ')') )
-         THROW( "Found no enclosing paranthesis", str, index );
+         THROW( "Found no enclosing parenthesis", str, index );
       ++index;
    } else if ( checkFunction(str, index) ) {
       nodePtr = parseFunction(str, index);
@@ -239,7 +239,7 @@ NodePtr EquationParser::parseTerm( const std::string& str, size_t& index ) const
    } else if ( checkNumber(str, index) ) {
       nodePtr = parseNumber(str, index);
    } else {
-      THROW( "Found no paranthesis, variable or number", str, index );
+      THROW( "Found no parenthesis, variable or number", str, index );
    }
    return nodePtr;
 }
diff --git a/src/core/math/equation_system/FwdOperator.h b/src/core/math/equation_system/FwdOperator.h
index 2df1ae9abda4bed416e52223400111758ea4e4fa..062f371cc3eba90cab5aacb9ccdd92e18b290132 100644
--- a/src/core/math/equation_system/FwdOperator.h
+++ b/src/core/math/equation_system/FwdOperator.h
@@ -51,5 +51,5 @@ namespace math {
    extern OpLog   OP_LOG;
    extern OpRoot  OP_ROOT;
 
-} // namepsace math
+} // namespace math
 } // namespace walberla
diff --git a/src/core/mpi/BufferSystem.h b/src/core/mpi/BufferSystem.h
index f2b0cbf431741cf020eaadea1f0268e27c8b3429..6a531fa907e6f95ceb09d29b6ce31ecb9cbecf2e 100644
--- a/src/core/mpi/BufferSystem.h
+++ b/src/core/mpi/BufferSystem.h
@@ -255,7 +255,7 @@ protected:
    //each concurrently running communication uses different tags
    static std::set<int> activeTags_;
 
-   bool useIProbe_ = false; ///< switch betwenn IProbe and two message communication for varying size communication
+   bool useIProbe_ = false; ///< switch between IProbe and two message communication for varying size communication
 
    int64_t bytesSent_        = 0; ///< number of bytes sent during last communication
    int64_t bytesReceived_    = 0; ///< number of bytes received during last communication
diff --git a/src/core/timing/TimingNode.h b/src/core/timing/TimingNode.h
index 6682ab62600653b3b52dcb73da912e66b86d1a53..a72c2f193378d94dd47f292f9758dd247758e553 100644
--- a/src/core/timing/TimingNode.h
+++ b/src/core/timing/TimingNode.h
@@ -45,7 +45,7 @@ namespace timing {
 /***********************************************************************************************************************
  * \brief Hierarchical structure of timers.
  *
- * Timer class to time different code snippets. Nested timers can be created and will be outputed
+ * Timer class to time different code snippets. Nested timers can be created and will be output
  * in a tree like structure. Also works MPI parallel by using the reduce function but is NOT
  * threadsafe!
  *
diff --git a/src/core/timing/TimingTree.h b/src/core/timing/TimingTree.h
index 32ed44549b97482bf4a06604588f5a7d2311f336..248dcdcced8edbf32743f3cf6ae507e66ae857de 100644
--- a/src/core/timing/TimingTree.h
+++ b/src/core/timing/TimingTree.h
@@ -41,7 +41,7 @@ namespace timing {
 /***********************************************************************************************************************
  * \brief Hierarchical structure of timers.
  *
- * Timer class to time different code snippets. Nested timers can be created and will be outputed
+ * Timer class to time different code snippets. Nested timers can be created and will be output
  * in a tree like structure. Also works MPI parallel by using the reduce function but is NOT
  * threadsafe!
  *
@@ -173,7 +173,7 @@ void TimingTree<TP>::stop(const std::string& name)
    {
       current_->timer_.end();
       current_ = current_->last_;
-//      WALBERLA_LOG_DEVEL("Timer stoped: " << name);
+//      WALBERLA_LOG_DEVEL("Timer stopped: " << name);
    }
 }
 
diff --git a/src/cuda/GPUField.h b/src/cuda/GPUField.h
index 75766957a0199448b61cddf200261fa96d44fc3c..431ce15263f0bb460456983ff52299f18135d4d6 100755
--- a/src/cuda/GPUField.h
+++ b/src/cuda/GPUField.h
@@ -47,7 +47,7 @@ namespace cuda {
    *  Internally represented by a cudaPitchedPtr which is allocated with cudaMalloc3D to take padding of the
    *  innermost coordinate into account.
    *
-   *  Supports Array-of-Structures (AoS,zyxf) layout and Structure-of-Arrays (SoA, fzyx) layout, in a similiar way
+   *  Supports Array-of-Structures (AoS,zyxf) layout and Structure-of-Arrays (SoA, fzyx) layout, in a similar way
    *  to field::Field
    *
    *  To work with the GPUField look at the cuda::fieldCpy functions to transfer a field::Field to a cuda::GPUField
diff --git a/src/cuda/communication/CustomMemoryBuffer.h b/src/cuda/communication/CustomMemoryBuffer.h
index 7ca7ab46fb115118f88a55d27ce91d9df01a650d..ddf475b1a1a2dece4ab39e908cc04dc12e2ee7fc 100644
--- a/src/cuda/communication/CustomMemoryBuffer.h
+++ b/src/cuda/communication/CustomMemoryBuffer.h
@@ -52,7 +52,7 @@ namespace communication {
     * The buffer has a beginning, a current position and an end position. Here is an overview of the most important
     * operations:
     *   - clear: reset current position to begin, does not change size
-    *   - advance: moves current position number of bytes forward and returns poitner to the old current position
+    *   - advance: moves current position number of bytes forward and returns pointer to the old current position
     *              two versions are available, one that automatically resizes and reallocates the buffer, and one that
     *              fails if not enough space is available
     */
diff --git a/src/domain_decomposition/MapPointToPeriodicDomain.h b/src/domain_decomposition/MapPointToPeriodicDomain.h
index 0835af1809046737d876b8cbfa99001138be7eb4..fc56eddd4e4f24da71819daa54acde37861d4dbf 100644
--- a/src/domain_decomposition/MapPointToPeriodicDomain.h
+++ b/src/domain_decomposition/MapPointToPeriodicDomain.h
@@ -46,7 +46,7 @@ void mapPointToPeriodicDomain( const std::array< bool, 3 > & periodic, const AAB
 
 
 
-/// see documetation of 'void mapPointToPeriodicDomain( const std::array< bool, 3 > & periodic, const AABB & domain, real_t & x, real_t & y, real_t & z )'
+/// see documentation of 'void mapPointToPeriodicDomain( const std::array< bool, 3 > & periodic, const AABB & domain, real_t & x, real_t & y, real_t & z )'
 inline void mapPointToPeriodicDomain( const std::array< bool, 3 > & periodic, const AABB & domain, Vector3< real_t > & p )
 {
    mapPointToPeriodicDomain( periodic, domain, p[0], p[1], p[2] );
@@ -54,7 +54,7 @@ inline void mapPointToPeriodicDomain( const std::array< bool, 3 > & periodic, co
 
 
 
-/// see documetation of 'void mapPointToPeriodicDomain( const std::array< bool, 3 > & periodic, const AABB & domain, real_t & x, real_t & y, real_t & z )'
+/// see documentation of 'void mapPointToPeriodicDomain( const std::array< bool, 3 > & periodic, const AABB & domain, real_t & x, real_t & y, real_t & z )'
 inline Vector3< real_t > mapPointToPeriodicDomain( const std::array< bool, 3 > & periodic, const AABB & domain, const Vector3< real_t > & p )
 {
    Vector3< real_t > point( p );
diff --git a/src/field/VolumetricFlowRateEvaluation.h b/src/field/VolumetricFlowRateEvaluation.h
index 063bd1518ed2af8f79635311aa046d51566fc322..8d6aee70b899d617cb10cd0492a9295224b16fa9 100644
--- a/src/field/VolumetricFlowRateEvaluation.h
+++ b/src/field/VolumetricFlowRateEvaluation.h
@@ -105,7 +105,7 @@ const std::string volumetricFlowRateEvaluationConfigBlock("VolumetricFlowRateEva
 *   You do not have to specify an evaluation filter! If you do not specify any filter, _all_ cells are processed and no
 *   cell is excluded.
 *
-*   If you want to use a flag field as evaluatio n filter, fitting 'makeVolumetricFlowRateEvaluation' functions already
+*   If you want to use a flag field as evaluation filter, fitting 'makeVolumetricFlowRateEvaluation' functions already
 *   exist. These functions need an additional template parameter FlagField_T and you have to provide the block data ID
 *   of the flag field together with a set of flag UIDs that specify which cells need to be processed.
 *
diff --git a/src/field/allocation/AlignedMalloc.h b/src/field/allocation/AlignedMalloc.h
index b811a15a289997f76cf938452b6458d2d981a174..5e4e6a523dd381b8e8d0d77db2dc96150e9996ce 100644
--- a/src/field/allocation/AlignedMalloc.h
+++ b/src/field/allocation/AlignedMalloc.h
@@ -43,7 +43,7 @@ namespace field {
     * \param size      size of allocated memory, total allocation will be greater by
     *                  'alignment' + sizeof(void*) bytes
     * \param alignment  the alignment boundary ,
-    *                   \important has to be a power of 2!   */
+    *                   **important** has to be a power of 2!   */
    //*******************************************************************************************************************
    void *aligned_malloc( uint_t size, uint_t alignment );
 
diff --git a/src/field/interpolators/TrilinearFieldInterpolator.h b/src/field/interpolators/TrilinearFieldInterpolator.h
index 8eb24a4cf0877e0692f6e963fc8a01f5a47db9b4..e9809d835f1bf67e89da8a0eb2b5a9493624c84e 100644
--- a/src/field/interpolators/TrilinearFieldInterpolator.h
+++ b/src/field/interpolators/TrilinearFieldInterpolator.h
@@ -94,7 +94,7 @@ public:
       const cell_idx_t zNeighbor1 = cell_idx_c( floor( z - containingCellCenter[2] ) );
       const cell_idx_t zNeighbor2 = zNeighbor1 + cell_idx_t(1);
 
-      // define the 8 nearest cells required for the trilienar interpolation
+      // define the 8 nearest cells required for the trilinear interpolation
       // the cell 'ccc' is the one with the smallest x-, y-, and z-indices
       Cell ccc( containingCell.x() + xNeighbor1, containingCell.y() + yNeighbor1, containingCell.z() + zNeighbor1 );
       Cell hcc( containingCell.x() + xNeighbor2, containingCell.y() + yNeighbor1, containingCell.z() + zNeighbor1 );
diff --git a/src/gather/CurveGatherPackInfo.h b/src/gather/CurveGatherPackInfo.h
index 6bdd3bab099c0a7cb4c9c5c5ccf94b6e0e1ff1a8..ea42f21dfb326ac7719052125417dffbd1956a2d 100644
--- a/src/gather/CurveGatherPackInfo.h
+++ b/src/gather/CurveGatherPackInfo.h
@@ -97,8 +97,8 @@ class CurveGatherPackInfo : public GatherPackInfo
       /**
        * Construction using vector of sample points
        *
-       * @samplePoints  Curve definition using a vector of points in R^3.
-       *                The points are expected to be in "world" coordinates
+       * @param samplePoints  Curve definition using a vector of points in R^3.
+       *                      The points are expected to be in "world" coordinates
        */
       CurveGatherPackInfo( const shared_ptr<StructuredBlockStorage> & bs,
                            ConstBlockDataID field,
diff --git a/src/gather/MPIGatherScheme.h b/src/gather/MPIGatherScheme.h
index e9270289ba1a1b4ff4b5d445e91fd679cc450b01..6ef3d5458f3fef27edeb79beb8d6f064edd32049 100644
--- a/src/gather/MPIGatherScheme.h
+++ b/src/gather/MPIGatherScheme.h
@@ -58,7 +58,7 @@ namespace gather {
  *   this potentially very expensive operation is done only once in the setup phases
  * - a MPI communicator is created for all processes participating in the gather operation (i.e. that packed
  *   something ), and the amount of data that each process sends is sent to the gathering process
- * - subsequent calls of communciate() use that communicator for an MPI_Gatherv operation
+ * - subsequent calls of communicate() use that communicator for an MPI_Gatherv operation
  *
  */
 class MPIGatherScheme
diff --git a/src/geometry/mesh/TriangleMesh.cpp b/src/geometry/mesh/TriangleMesh.cpp
index c3596c6c814026232e30888a13628bb4c2abcfdf..64c48fcffd98b169a2aef906d329d454d70ed2e8 100644
--- a/src/geometry/mesh/TriangleMesh.cpp
+++ b/src/geometry/mesh/TriangleMesh.cpp
@@ -291,7 +291,7 @@ void TriangleMesh::split( vector<TriangleMesh>& meshes ) const
       tnode[2]->conns.insert( tnode[1] );
    }
 
-   // split vertices by trinagle connetions
+   // split vertices by triangle connections
    set< vector< TriangleMeshNode* > > ssnode;
    for( auto nit = nodes.begin(); nit != nodes.end(); ++nit )
    {
diff --git a/src/geometry/mesh/TriangleMeshIO.cpp b/src/geometry/mesh/TriangleMeshIO.cpp
index 653166a44f54b796f1ddd3e3ffb9c01289ffdc64..cb885950972a8c2621a17ecf897a0187c66385f3 100644
--- a/src/geometry/mesh/TriangleMeshIO.cpp
+++ b/src/geometry/mesh/TriangleMeshIO.cpp
@@ -312,7 +312,7 @@ namespace geometry {
             else if ( c == '*' )
                state = STATE_MLC0;
             else
-               throw std::runtime_error("Invalid inputsream syntax");
+               throw std::runtime_error("Invalid inputstream syntax");
             break;
 
          case STATE_LC:
diff --git a/src/geometry/structured/BasicVoxelFileReader.h b/src/geometry/structured/BasicVoxelFileReader.h
index 918fc41c309fcd2a8616892f019e98d162a84b7a..21f7187c387069cf2225927fadb430ff521a292c 100644
--- a/src/geometry/structured/BasicVoxelFileReader.h
+++ b/src/geometry/structured/BasicVoxelFileReader.h
@@ -18,7 +18,7 @@
 //! \author Christian Godenschwager <christian.godenschwager@fau.de>
 //! \brief Declares class StructuredGeometryFileBasicReader that provides a low-level reader for waLBerla geometry files.
 //!
-//! This reader has no dependencies towards waLberla or even boost so it can be used by external
+//! This reader has no dependencies towards waLBerla or even boost so it can be used by external
 //! software to read or write geometry files.
 //
 //======================================================================================================================
diff --git a/src/geometry/structured/VoxelFileReader.h b/src/geometry/structured/VoxelFileReader.h
index ff0ec910766a33a88ff29158c13c7a42b5f6219b..afd0312ddf0660ca6c79aa03901b5748a4720dad 100644
--- a/src/geometry/structured/VoxelFileReader.h
+++ b/src/geometry/structured/VoxelFileReader.h
@@ -39,7 +39,7 @@ namespace geometry {
  * \brief Provides a reader for waLBerla geometry files.
  *
  * Note that the data is stored in binary form. There is no correction for other binary data
- * representations on different architectures (e.g. different Endianess)!
+ * representations on different architectures (e.g. different endianness)!
  * An opened file is automatically closed upon destruction.
  *
  * \tparam T The underlying datatype that is stored in binary form in the geometry file
diff --git a/src/geometry/structured/VoxelFileReader.impl.h b/src/geometry/structured/VoxelFileReader.impl.h
index 31c28af8b65615718beb4f8532e8a45653b86338..e91b75357f37943cdf24bf24bfaf0fbd6b0d1a7d 100644
--- a/src/geometry/structured/VoxelFileReader.impl.h
+++ b/src/geometry/structured/VoxelFileReader.impl.h
@@ -19,7 +19,7 @@
 //! \brief Defines class StructuredGeometryFileReader that provides a reader for waLBerla geometry files.
 //!
 //! Note that the data is stored in binary form. There is no correction for other binary data
-//! representations on different architectures (e.g. different Endianess)!
+//! representations on different architectures (e.g. different endianness)!
 //
 //======================================================================================================================
 
diff --git a/src/lbm/MassEvaluation.h b/src/lbm/MassEvaluation.h
index 9757137db90342d2fc4f34505dcefb064eb73432..7efe2daaebf0d9e89134f77702a889b49e306fea 100644
--- a/src/lbm/MassEvaluation.h
+++ b/src/lbm/MassEvaluation.h
@@ -60,7 +60,7 @@ Vector3<real_t> massEvaluationDomain( const shared_ptr< StructuredBlockStorage >
 *   \code
 *   BlockDataID densityId = field::addFieldAdaptor< lbm::Adaptor<LatticeModel_T>::Density >( blocks, pdfFieldId,
 *                                                                                            "density adaptor" );
-*   \code
+*   \endcode
 *
 *   for creating a density adaptor. The type of this adaptor/field is 'lbm::Adaptor<LatticeModel_T>::Density'.
 *   An example for using a SharedFunctor that can be used to register the mass evaluation at a time loop might look
@@ -69,7 +69,7 @@ Vector3<real_t> massEvaluationDomain( const shared_ptr< StructuredBlockStorage >
 *   \code
 *   makeSharedFunctor( lbm::makeMassEvaluation< lbm::Adaptor<LatticeModel_T>::Density >( config, blocks,
 *                                                                                        uint_t(0), densityId ) )
-*   \code
+*   \endcode
 *
 *   Note that for this example the plot and log frequency can be controlled via the configuration file. In this example,
 *   _all_ cells are processed. If not all of your cells are actually fluid cells, you should use a 'makeMassEvaluation'
@@ -78,7 +78,7 @@ Vector3<real_t> massEvaluationDomain( const shared_ptr< StructuredBlockStorage >
 *   \code
 *   makeSharedFunctor( lbm::makeMassEvaluation< lbm::Adaptor<LatticeModel_T>::Density, FlagField_T >(
                           config, blocks, uint_t(0), densityId, flagFieldId, fluidFlagUID ) )
-*   \code
+*   \endcode
 */
 //**********************************************************************************************************************
 
diff --git a/src/lbm/boundary/Curved.h b/src/lbm/boundary/Curved.h
index 9275543895ba067d7d89b9b5659a0956b852d2d6..38e3d308ca03dbf6312c0d6e5badc35f90ee934d 100644
--- a/src/lbm/boundary/Curved.h
+++ b/src/lbm/boundary/Curved.h
@@ -259,7 +259,7 @@ inline void Curved< LatticeModel_T, FlagField_T >::treatDirection( const cell_id
       WALBERLA_ASSERT( weights_->get( nx, ny, nz ).get() != nullptr );
       WALBERLA_ASSERT_LESS( Stencil::invDirIdx(dir), weights_->get( nx, ny, nz )->size() );
       
-      // linear multi reflection model without non-equilibirum
+      // linear multi reflection model without non-equilibrium
 
       const real_t weight = ( *( weights_->get( nx, ny, nz ) ) )[Stencil::invDirIdx( dir )];
 
diff --git a/src/lbm/boundary/DiffusionDirichlet.h b/src/lbm/boundary/DiffusionDirichlet.h
index 643027743f14683e830cc9015d633fa5e1b8997c..219732fc28df01d43232d48c42621d43b4355120 100644
--- a/src/lbm/boundary/DiffusionDirichlet.h
+++ b/src/lbm/boundary/DiffusionDirichlet.h
@@ -17,7 +17,7 @@
 //! \ingroup lbm
 //! \author Matthias Markl <matthias.markl@fau.de>
 //
-// @see Ginzbourg, I.   : Generic boundary conditions for lattice Boltzmann models and their application to advection and anisotropic disperion equations
+// @see Ginzbourg, I.   : Generic boundary conditions for lattice Boltzmann models and their application to advection and anisotropic dispersion equations
 // @see Like, L. et. al.: Boundary Conditions for thermal lattice Boltzmann equation method
 //
 //======================================================================================================================
diff --git a/src/lbm/boundary/DynamicUBB.h b/src/lbm/boundary/DynamicUBB.h
index 07aac83ceda73ecfc7ba6bca30938af327b50294..de6c9db27703fdf466530a8fd7fdc191cd1663d2 100644
--- a/src/lbm/boundary/DynamicUBB.h
+++ b/src/lbm/boundary/DynamicUBB.h
@@ -47,10 +47,10 @@ namespace lbm {
 
 
 // VelocityFunctor_T: functor that requires to implement two member functions:
-//   1. A member function "void operator()( const real_t t )" that is called once before the boundary treatement with the current time
+//   1. A member function "void operator()( const real_t t )" that is called once before the boundary treatment with the current time
 //   2. A member function "Vector3< real_t > operator()( const Vector3< real_t > & x, const real_t t )" that is called for every
-//      boundary link treated by "treatDirection". The arguments are the position 'x' of the boudnary cell in the simulation space and the current time 't'.
-//      The functon is supposed to return the velocity used by the boundary treatment.
+//      boundary link treated by "treatDirection". The arguments are the position 'x' of the boundary cell in the simulation space and the current time 't'.
+//      The function is supposed to return the velocity used by the boundary treatment.
 template< typename LatticeModel_T, typename flag_t, typename VelocityFunctor_T, bool AdaptVelocityToExternalForce = false, bool StoreForce = false >
 class DynamicUBB : public Boundary<flag_t>
 {
diff --git a/src/lbm/boundary/SimpleDiffusionDirichlet.h b/src/lbm/boundary/SimpleDiffusionDirichlet.h
index e3a6dde2fefc7a201b49ba05c8d6bfe9ce7f50cd..81805c5b80a4adf75498d0b1930424d000f1af91 100644
--- a/src/lbm/boundary/SimpleDiffusionDirichlet.h
+++ b/src/lbm/boundary/SimpleDiffusionDirichlet.h
@@ -17,7 +17,7 @@
 //! \ingroup lbm
 //! \author Matthias Markl <matthias.markl@fau.de>
 //
-// @see Ginzbourg, I.   : Generic boundary conditions for lattice Boltzmann models and their application to advection and anisotropic disperion equations
+// @see Ginzbourg, I.   : Generic boundary conditions for lattice Boltzmann models and their application to advection and anisotropic dispersion equations
 // @see Like, L. et. al.: Boundary Conditions for thermal lattice Boltzmann equation method
 //
 //======================================================================================================================
diff --git a/src/lbm/cumulant/CellwiseSweep.impl.h b/src/lbm/cumulant/CellwiseSweep.impl.h
index bb40b8d50849906cb61cfaa018a87d28a404d6b2..ade7fbc50aee331592ff7e0a106142b07162eb9b 100644
--- a/src/lbm/cumulant/CellwiseSweep.impl.h
+++ b/src/lbm/cumulant/CellwiseSweep.impl.h
@@ -98,7 +98,7 @@ WALBERLA_LBM_CELLWISE_SWEEP_STREAM_COLLIDE_HEAD( WALBERLA_LBM_CELLWISE_SWEEP_SPE
 
          this->densityVelocityOut( x, y, z, lm, Vector3<real_t>( velX, velY, velZ ), updated_rho );  // dont really understand what is been done here 
 	 
-         // defining the sqaure of velocities 
+         // defining the square of velocities 
 	 const real_t velXX = velX * velX;
          const real_t velYY = velY * velY;
          const real_t velZZ = velZ * velZ;
@@ -219,7 +219,7 @@ WALBERLA_LBM_CELLWISE_SWEEP_STREAM_COLLIDE_HEAD( WALBERLA_LBM_CELLWISE_SWEEP_SPE
 	 // defining the constants for central moment space 
 	 const real_t rho_inv = real_t(1.0) / updated_rho; 
 
-	 // defining the sqaures 
+	 // defining the squares 
 	 const real_t sqr_k_110 = k_110 * k_110;
 	 const real_t sqr_k_101 = k_101 * k_101;
 	 const real_t sqr_k_011 = k_011 * k_011;
@@ -348,7 +348,7 @@ WALBERLA_LBM_CELLWISE_SWEEP_STREAM_COLLIDE_HEAD( WALBERLA_LBM_CELLWISE_SWEEP_SPE
 	 const real_t KC_222 = CS_222 + (real_t(4.0) * sqr_KC_111 + KC_200 * KC_022 + KC_020 * KC_202 + KC_002 * KC_220 + real_t(4.0) * (KC_011 * KC_211 + KC_101 * KC_121 + KC_110 * KC_112) + real_t(2.0) * (KC_120 * KC_102 + KC_210 * KC_012 + KC_201 * KC_021)) * rho_inv
 	 - (real_t(16.0) * KC_110 * KC_101 * KC_011 + real_t(4.0) * (KC_020 * sqr_KC_101 + KC_200 * sqr_KC_011 + KC_002 * sqr_KC_110) + real_t(2.0) * KC_200 * KC_020 * KC_002) * sqr_rho_inv;
                      
-	 // trnasform back to central moment space 
+	 // transform back to central moment space 
 	 // transform from central moment space to distribution funtion 
 	 
 	 // const defined for velocity in X direction 
@@ -389,7 +389,7 @@ WALBERLA_LBM_CELLWISE_SWEEP_STREAM_COLLIDE_HEAD( WALBERLA_LBM_CELLWISE_SWEEP_SPE
 	
 	
 	 // collision is taking place from here and I need to change it from here 	
-         // transform from velocity space to moment space and then to cumulant space , perform collsiopn and then again back transform to velocity space // 
+         // transform from velocity space to moment space and then to cumulant space , perform collision and then again back transform to velocity space // 
          
          // const defined for velocity in Y direction 
          const real_t oneminus_sqr_vely = real_t(1.0) - velYY ;
@@ -633,7 +633,7 @@ WALBERLA_LBM_CELLWISE_SWEEP_COLLIDE_HEAD( WALBERLA_LBM_CELLWISE_SWEEP_SPECIALIZA
 	 // defining the constants for central moment space 
 	 const real_t rho_inv = real_t(1.0) / updated_rho; 
 
-	 // defining the sqaures 
+	 // defining the squares 
 	 const real_t sqr_k_110 = k_110 * k_110 ;
 	 const real_t sqr_k_101 = k_101 * k_101 ;
 	 const real_t sqr_k_011 = k_011 * k_011 ;
@@ -765,7 +765,7 @@ WALBERLA_LBM_CELLWISE_SWEEP_COLLIDE_HEAD( WALBERLA_LBM_CELLWISE_SWEEP_SPECIALIZA
 	 const real_t KC_222 = CS_222 + (real_t(4.0) * sqr_KC_111 + KC_200 * KC_022 + KC_020 * KC_202 + KC_002 * KC_220 + real_t(4.0) * (KC_011 * KC_211 + KC_101 * KC_121 + KC_110 * KC_112) + real_t(2.0) * (KC_120 * KC_102 + KC_210 * KC_012 + KC_201 * KC_021)) * rho_inv
 	 - (real_t(16.0) * KC_110 * KC_101 * KC_011 + real_t(4.0) * (KC_020 * sqr_KC_101 + KC_200 * sqr_KC_011 + KC_002 * sqr_KC_110) + real_t(2.0) * KC_200 * KC_020 * KC_002) * sqr_rho_inv;
                      
-	 // trnasform back to central moment space 
+	 // transform back to central moment space 
 	 // transform from central moment space to distribution funtion 
 	 // const defined for velocity in X direction 
 	 const real_t oneminus_sqr_velx = real_t(1.0) - velXX ;
@@ -805,7 +805,7 @@ WALBERLA_LBM_CELLWISE_SWEEP_COLLIDE_HEAD( WALBERLA_LBM_CELLWISE_SWEEP_SPECIALIZA
 	
 	
 	 // collision is taking place from here and I need to change it from here 	
-         // transform from velocity space to moment space and then to cumulant space , perform collsiopn and then again back transform to velocity space // 
+         // transform from velocity space to moment space and then to cumulant space , perform collision and then again back transform to velocity space // 
          
          // const defined for velocity in Y direction 
          const real_t oneminus_sqr_vely = real_t(1.0) - velYY ;
diff --git a/src/lbm_mesapd_coupling/amr/InfoCollection.h b/src/lbm_mesapd_coupling/amr/InfoCollection.h
index f3e596eb74e2bdf07baa5b3dd4e97da5441d5994..621ab8f7b2826d8d3a4ce3ebbb5d9818cfc87fe9 100644
--- a/src/lbm_mesapd_coupling/amr/InfoCollection.h
+++ b/src/lbm_mesapd_coupling/amr/InfoCollection.h
@@ -102,7 +102,7 @@ void updateAndSyncInfoCollection(BlockForest& bf, const BlockDataID boundaryHand
    bs.setReceiverInfoFromSendBufferState(false, true);
    bs.sendAll();
 
-   // info collection has to be distirbuted to neighboring processes such that later on when coarsening was applied,
+   // info collection has to be distributed to neighboring processes such that later on when coarsening was applied,
    // the weight of the coarsened block can be computed
    for( auto recvIt = bs.begin(); recvIt != bs.end(); ++recvIt )
    {
@@ -203,6 +203,6 @@ private:
 };
 
 
-} // namepace amr
+} // namespace amr
 } // namespace lbm_mesapd_coupling
 } // namespace walberla
diff --git a/src/lbm_mesapd_coupling/momentum_exchange_method/reconstruction/Reconstructor.h b/src/lbm_mesapd_coupling/momentum_exchange_method/reconstruction/Reconstructor.h
index acb4fd95b1455af0973cde6b5ab80df1f0b99002..e3d7ae05a958b6610affdda29d5327a3d452f41a 100644
--- a/src/lbm_mesapd_coupling/momentum_exchange_method/reconstruction/Reconstructor.h
+++ b/src/lbm_mesapd_coupling/momentum_exchange_method/reconstruction/Reconstructor.h
@@ -577,7 +577,7 @@ private:
  * also in Dorschner, Chikatamarla, Boesch, Karlin - Grad's approximation for moving and stationary walls in entropic lattice Boltzmann simulations, Journal of Computational Physics, 2015
  * omegaShear: relaxation RATE that determines the kinematic viscosity
  *
- * To obtain the pressure gradient information, finite differences with central differences (useCentralDifferences) are used if enouhg information available, else upwinding differences are applied.
+ * To obtain the pressure gradient information, finite differences with central differences (useCentralDifferences) are used if enough information available, else upwinding differences are applied.
  * When useDataFromGhostLayers = true, a full ghost layer sync is required just before the reconstruction step. This is required to avoid inconsistencies when using parallelization as else the behavior close to block boarders is altered.
  */
 template< typename BoundaryHandling_T >
diff --git a/src/mesa_pd/collision_detection/EPA.cpp b/src/mesa_pd/collision_detection/EPA.cpp
index defefd3a9dbeaac773a069e71a23744b465b1752..0335591507b111e612a4d5d561eac760ab7bed66 100644
--- a/src/mesa_pd/collision_detection/EPA.cpp
+++ b/src/mesa_pd/collision_detection/EPA.cpp
@@ -122,7 +122,7 @@ inline bool EPA::EPA_Triangle::link( size_t edge0, EPA_Triangle* tria, size_t ed
  */
 inline void EPA::EPA_Triangle::silhouette( const Vec3& w, EPA_EdgeBuffer& edgeBuffer )
 {
-   //std::cerr << "Starting Silhoutette search on Triangle {" << indices_[0] << "," << indices_[1] << "," << indices_[2] << "}" << std::endl;
+   //std::cerr << "Starting Silhouette search on Triangle {" << indices_[0] << "," << indices_[1] << "," << indices_[2] << "}" << std::endl;
    edgeBuffer.clear();
    obsolete_ = true;
 
@@ -134,7 +134,7 @@ inline void EPA::EPA_Triangle::silhouette( const Vec3& w, EPA_EdgeBuffer& edgeBu
 
 
 //*************************************************************************************************
-/*! \brief Recursive silhuette finding method.
+/*! \brief Recursive silhouette finding method.
  */
 void EPA::EPA_Triangle::silhouette( size_t index, const Vec3& w,
                                     EPA_EdgeBuffer& edgeBuffer )
@@ -221,7 +221,7 @@ bool EPA::doEPAmargin( Support &geom1,
 
 
 //*************************************************************************************************
-/*! \brief Does an epa computation with contact margin added and specified realtive error.
+/*! \brief Does an epa computation with contact margin added and specified relative error.
  */
 bool EPA::doEPA( Support &geom1,
                  Support &geom2,
@@ -233,7 +233,7 @@ bool EPA::doEPA( Support &geom1,
                  real_t eps_rel )
 {
    //have in mind that we use a support mapping which blows up the objects a wee bit so
-   //zero penetraion aka toching contact means that the original bodies have a distance of 2*margin between them
+   //zero penetration aka touching contact means that the original bodies have a distance of 2*margin between them
 
    //Set references to the results of GJK
    size_t     numPoints( static_cast<size_t>( gjk.getSimplexSize() ) );
@@ -521,12 +521,12 @@ inline void EPA::createInitialSimplex( size_t numPoints,
    switch(numPoints) {
    case 2:
    {
-      //simplex is a line segement
+      //simplex is a line segment
       //add 3 points around the this segment
       //the COS is konvex so the resulting hexaheadron should be konvex too
 
       Vec3 d = epaVolume[1] - epaVolume[0];
-      //find coordinate axis e_i which is furthest from paralell to d
+      //find coordinate axis e_i which is furthest from parallel to d
       //and therefore d has the smallest abs(d[i])
       real_t abs0 = std::abs(d[0]);
       real_t abs1 = std::abs(d[1]);
@@ -616,7 +616,7 @@ inline void EPA::createInitialSimplex( size_t numPoints,
       const Vec3& A = epaVolume[2];  //The Point last added to the simplex
       const Vec3& B = epaVolume[1];  //One Point that was already in the simplex
       const Vec3& C = epaVolume[0];  //One Point that was already in the simplex
-      //ABC is a conterclockwise triangle
+      //ABC is a counterclockwise triangle
 
       const Vec3  AB  = B-A;       //The vector A->B
       const Vec3  AC  = C-A;       //The vector A->C
@@ -719,7 +719,7 @@ inline bool EPA::originInTetrahedron( const Vec3& p0, const Vec3& p1, const Vec3
 
 
 //*************************************************************************************************
-/*! \brief Retrurns true, if the origin lies in the tetrahedron ABCD.
+/*! \brief Returns true, if the origin lies in the tetrahedron ABCD.
  */
 inline bool EPA::originInTetrahedronVolumeMethod( const Vec3& A, const Vec3& B, const Vec3& C,
                                                   const Vec3& D )
@@ -745,7 +745,7 @@ inline bool EPA::originInTetrahedronVolumeMethod( const Vec3& A, const Vec3& B,
 
 
 //*************************************************************************************************
-/*! \brief Retrurns true, if a point lies in the tetrahedron ABCD.
+/*! \brief Returns true, if a point lies in the tetrahedron ABCD.
  *  \param point The point to be checked for containment.
  */
 inline bool EPA::pointInTetrahedron( const Vec3& A, const Vec3& B, const Vec3& C, const Vec3& D,
@@ -812,7 +812,7 @@ inline bool EPA::searchTetrahedron(Support &geom1,
    do{
       loopCount++;
       pointIndexToRemove = -1;
-      //Check if opposite tetrahedron point and orign are on the same side
+      //Check if opposite tetrahedron point and origin are on the same side
       //of the face. (for all faces)
       Vec3 normal0T = (epaVolume[1] -epaVolume[0]) % (epaVolume[2]-epaVolume[0]);
       real_t dot_val = normal0T*epaVolume[0];
diff --git a/src/mesa_pd/collision_detection/EPA.h b/src/mesa_pd/collision_detection/EPA.h
index 052f6cdf89d71733580f4fc013630b2f76a07e04..a83cc1f5b6d35c441740ddc8a93f7c8a2cbf2dce 100644
--- a/src/mesa_pd/collision_detection/EPA.h
+++ b/src/mesa_pd/collision_detection/EPA.h
@@ -199,7 +199,7 @@ private:
 //*************************************************************************************************
 /*!\brief Class storing Information about a triangular facette (Triangle) of the EPA-Polytope
  *
- * see Collision detction in interactiv 3D environments; Gino van den bergen page 155
+ * see Collision detection in interactive 3D environments; Gino van den bergen page 155
  */
 class EPA::EPA_Triangle {
 public:
@@ -392,7 +392,7 @@ inline bool EPA::EPA_Triangle::isClosestInternal() const
 //=================================================================================================
 
 //*************************************************************************************************
-/*! \brief Calucates a support point of a body extended by threshold.
+/*! \brief Calculates a support point of a body extended by threshold.
  * Adds this support and the base points at bodies a and b to the vector.
  * \param geom The body.
  * \param dir The support point direction.
@@ -424,7 +424,7 @@ inline void EPA::pushSupportMargin(const Support &geom1,
 
 
 //*************************************************************************************************
-/*! \brief Calucates a support point of a body extended by threshold.
+/*! \brief Calculates a support point of a body extended by threshold.
  * Replaces the old value in the vectors at "IndexToReplace" with this support and the base points at bodies a and b .
  * \param geom The body.
  * \param dir The support point direction.
diff --git a/src/mesa_pd/collision_detection/GJK.cpp b/src/mesa_pd/collision_detection/GJK.cpp
index 002f3f78826cd63eaaa3113bec3d25f6389bb3cc..757c065b17446468f89d6e7c1a0e1e69388b0e2b 100644
--- a/src/mesa_pd/collision_detection/GJK.cpp
+++ b/src/mesa_pd/collision_detection/GJK.cpp
@@ -42,7 +42,7 @@ GJK::GJK()
 }
 
 /**
- * \brief Calucate a support point of a particle extended by threshold.
+ * \brief Calculate a support point of a particle extended by threshold.
  * \param geom support functions for particle 1 and 2.
  * \param dir The support point direction.
  * \param threshold Extension of the particle.
@@ -189,7 +189,7 @@ real_t GJK::doGJK(const Support &geom1, const Support &geom2, Vec3& normal, Vec3
  * \param geom1 support function for the first particle
  * \param geom2 support function for the second particle
  * \param margin The margin by which the objects will be enlarged.
- * \return true, if an itersection is found.
+ * \return true, if an intersection is found.
  */
 bool GJK::doGJKmargin(const Support &geom1, const Support &geom2, real_t margin)
 {
@@ -305,7 +305,7 @@ bool GJK::doGJKmargin(const Support &geom1, const Support &geom2, real_t margin)
 
 //*************************************************************************************************
 /**
- * \brief Calculate clostes Point in the simplex and its distance to the origin.
+ * \brief Calculate closest Point in the simplex and its distance to the origin.
  */
 inline real_t GJK::calcDistance( Vec3& normal, Vec3& contactPoint )
 {
@@ -341,7 +341,7 @@ inline real_t GJK::calcDistance( Vec3& normal, Vec3& contactPoint )
       //Vec3 ac = -A;
       //Vec3 bc = -simplex[1];
 
-      //calc baryzenctric coordinats
+      //calc barycentric coordinates
       // compare "Real-Time Collision Detection" by Christer Ericson page 129
       //double t = ac*ab;
       real_t t     = real_t(-1.0) * (A * ab);
@@ -461,7 +461,7 @@ bool GJK::simplex3(Vec3& d)
    const Vec3& A = simplex_[2];  //The Point last added to the simplex
    const Vec3& B = simplex_[1];  //One Point that was already in the simplex
    const Vec3& C = simplex_[0];  //One Point that was already in the simplex
-   //ABC is a conterclockwise triangle
+   //ABC is a counterclockwise triangle
 
    const Vec3  AO  = -A;        //The vector A->O with 0 the origin
    const Vec3&  AOt = AO;        //The transposed vector A->O with O the origin
@@ -586,7 +586,7 @@ bool GJK::simplex4(Vec3& d)
 {
    //the simplex is a tetrahedron
    const Vec3& A  = simplex_[3];  //The Point last added to the tetrahedron
-   //t in front mens just a temp varialble
+   //t in front means just a temp variable
    const Vec3& B = simplex_[2];  //One Point that was already in the simplex
    const Vec3& C = simplex_[1];  //One Point that was already in the simplex
    const Vec3& D = simplex_[0];
diff --git a/src/mesa_pd/collision_detection/GJK.h b/src/mesa_pd/collision_detection/GJK.h
index 7ccff51287b6b184934d93bddc07d9ee8b0ff25b..438ea25a37ade3c0890f60adeb24280fdd263b3f 100644
--- a/src/mesa_pd/collision_detection/GJK.h
+++ b/src/mesa_pd/collision_detection/GJK.h
@@ -35,7 +35,7 @@ namespace mesa_pd {
 namespace collision_detection {
 
 //*************************************************************************************************
-/*!\brief Impelementation of the Gilbert-Johnson-Keerthi Algorithm.
+/*!\brief Implementation of the Gilbert-Johnson-Keerthi Algorithm.
  */
 class GJK
 {
diff --git a/src/mesa_pd/collision_detection/Support.h b/src/mesa_pd/collision_detection/Support.h
index e7ffebfd93de7987019241b0f67eadd9bd99837e..a8d0c3557c90884bd4a66cc8a21bcc37783dcb60 100644
--- a/src/mesa_pd/collision_detection/Support.h
+++ b/src/mesa_pd/collision_detection/Support.h
@@ -43,7 +43,7 @@ public:
     * \brief Estimates the point which is farthest in direction \a d.
     *
     * \param d The normalized search direction in world-frame coordinates.
-    * \return The support point in world-frame coordinates in direction a\ d.
+    * \return The support point in world-frame coordinates in direction \a d.
     */
    Vec3 support( Vec3 d ) const;
 public:
diff --git a/src/mesa_pd/domain/BlockForestDomain.h b/src/mesa_pd/domain/BlockForestDomain.h
index 7df1f9b6827fda77c950acadfbf28bc69e2b91a5..ed2c727c9a6d98948af30dff5bebb5f64a70f1c3 100644
--- a/src/mesa_pd/domain/BlockForestDomain.h
+++ b/src/mesa_pd/domain/BlockForestDomain.h
@@ -37,7 +37,7 @@ public:
 
    /**
     * @brief If the BlockForest is changed this function has to be called in order to
-    * update all interal caches!
+    * update all internal caches!
     *
     * Updates the local caches for local and neighbor AABBs.
     */
@@ -45,7 +45,7 @@ public:
 
    bool   isContainedInProcessSubdomain(const uint_t rank, const Vec3& pt) const override;
    bool   isContainedInLocalSubdomain(const Vec3& pt, const real_t& radius) const override;
-   /// Is the sphere defined by \p pt and \p radius completely inside the local subdomin?
+   /// Is the sphere defined by \p pt and \p radius completely inside the local subdomain?
    /// \attention Also take into account periodicity!
    /// \param pt center of the sphere
    /// \param radius radius of the sphere
diff --git a/src/mesa_pd/kernel/DetectAndStoreContacts.h b/src/mesa_pd/kernel/DetectAndStoreContacts.h
index 7656703b9ffd300375853e77061cb20ee9a7c161..66897885565b951c45c28eafa8beea3dd398ffb4 100644
--- a/src/mesa_pd/kernel/DetectAndStoreContacts.h
+++ b/src/mesa_pd/kernel/DetectAndStoreContacts.h
@@ -41,7 +41,7 @@ namespace mesa_pd {
 namespace kernel {
 
 /**
- * Kernel which performes collision detection on a pair of two particles
+ * Kernel which performs collision detection on a pair of two particles
  * and inserts the contact (if existent) into the contact storage passed in the constructor.
  * Call this kernel on each particle pair to perform contact detection and insert each contact in the contact
  * storage.
diff --git a/src/mesa_pd/kernel/ForceLJ.h b/src/mesa_pd/kernel/ForceLJ.h
index 483e586b70f383544f3847336524eec204747eb1..1affbc8f82ca99fa1fae40e2fb3fef1f22cbdd58 100644
--- a/src/mesa_pd/kernel/ForceLJ.h
+++ b/src/mesa_pd/kernel/ForceLJ.h
@@ -37,7 +37,7 @@ namespace mesa_pd {
 namespace kernel {
 
 /**
- * Kernel which calculates the Lennard Jones froce between two particles.
+ * Kernel which calculates the Lennard Jones force between two particles.
  *
  * This kernel uses the type property of a particle to decide on the material parameters.
  *
diff --git a/src/mesa_pd/kernel/HCSITSRelaxationStep.h b/src/mesa_pd/kernel/HCSITSRelaxationStep.h
index bcc0a7dc8a3f6782e9cc494b3011039b19212d2a..f377c02b57dedc95e67db292f7f7346b50d4777f 100644
--- a/src/mesa_pd/kernel/HCSITSRelaxationStep.h
+++ b/src/mesa_pd/kernel/HCSITSRelaxationStep.h
@@ -1009,7 +1009,7 @@ inline real_t HCSITSRelaxationStep::relaxInelasticContactsByProjectedGaussSeidel
       // No need to apply zero impulse.
    }
    else {
-      // Dissect the impuls in a tangetial and normal directions
+      // Dissect the impuls in a tangential and normal directions
       // Use the inverted contact frame with -n as in the publication
       Mat3 reversedContactFrame( -ca.getNormal(cid), ca.getT(cid), ca.getO(cid) );
       Vec3 p_rcf( reversedContactFrame.getTranspose() * p_wf );
diff --git a/src/mesa_pd/kernel/HeatConduction.h b/src/mesa_pd/kernel/HeatConduction.h
index b474db018ac02f02dd6b0805e950314ae33b022c..e41d117047bce400a4e9d6601c70aa1d46fe7f69 100644
--- a/src/mesa_pd/kernel/HeatConduction.h
+++ b/src/mesa_pd/kernel/HeatConduction.h
@@ -40,7 +40,7 @@ namespace kernel {
 /**
  * Heat conduction interaction kernel
  *
- * This kernel implements a simple heat conduction: \frac{dQ}{dt} = - \alpha (T_2 - T_1)
+ * This kernel implements a simple heat conduction: \f$ \frac{dQ}{dt} = - \alpha (T_2 - T_1) \f$
  *
  * \code
  * const walberla::real_t& getTemperature(const size_t p_idx) const;
diff --git a/src/mesa_pd/kernel/InitParticlesForHCSITS.h b/src/mesa_pd/kernel/InitParticlesForHCSITS.h
index ba95fbf82d6549060e50d3bdfecad954192df4df..2022a0b804b4911442e3d8a7ba7f54966e8dad48 100644
--- a/src/mesa_pd/kernel/InitParticlesForHCSITS.h
+++ b/src/mesa_pd/kernel/InitParticlesForHCSITS.h
@@ -40,7 +40,7 @@ namespace kernel {
 /**
  * Init the datastructures for the particles for later use of the HCSITS-Solver.
  * Call this kernel on all particles that will be treated with HCSITS before performing any relaxation timesteps.
- * Use setGlobalAcceleration() to set an accelleration action uniformly across all particles (e.g. gravity)
+ * Use setGlobalAcceleration() to set an acceleration action uniformly across all particles (e.g. gravity)
  * \ingroup mesa_pd_kernel
  */
 class InitParticlesForHCSITS
diff --git a/src/mesa_pd/kernel/VelocityVerlet.h b/src/mesa_pd/kernel/VelocityVerlet.h
index 1564842e494d092ea22a0cf3f6295ef1de515adf..67a5f1dc2c58bcbc2a79b432768304b060fbab09 100644
--- a/src/mesa_pd/kernel/VelocityVerlet.h
+++ b/src/mesa_pd/kernel/VelocityVerlet.h
@@ -36,7 +36,7 @@ namespace kernel {
 /**
  * Velocity verlet integration for all particles.
  *
- * Velocit verlet integration is a two part kernel. preForceUpdate has to be
+ * Velocity verlet integration is a two part kernel. preForceUpdate has to be
  * called before the force calculation and postFroceUpdate afterwards. The
  * integration is only complete when both functions are called. The integration
  * is symplectic.
diff --git a/src/mesa_pd/kernel/cnt/AnisotropicVDWContact.h b/src/mesa_pd/kernel/cnt/AnisotropicVDWContact.h
index 5beb8622bed219a931b8264fdf8c750fe1dc5b65..cfe7e61d6a8c36049898cafd6c6cc641b59ac6bb 100644
--- a/src/mesa_pd/kernel/cnt/AnisotropicVDWContact.h
+++ b/src/mesa_pd/kernel/cnt/AnisotropicVDWContact.h
@@ -111,9 +111,9 @@ void AnisotropicVDWContact::operator()(const size_t p_idx1,
    // c1 - contact 1-2 normal
    // b1 - ball 1 axial direction
    // b2 - ball 2 axial direction
-   // b3 - neytral direction
-   // g - alighning torque direction
-   // d - neytral plane normal direction
+   // b3 - neutral direction
+   // g - aligning torque direction
+   // d - neutral plane normal direction
    // s - shear force direction
 
    // angle gamma - angle between two axial directions
@@ -121,7 +121,7 @@ void AnisotropicVDWContact::operator()(const size_t p_idx1,
 
 
 
-   // if the angle between two axal directions is blunt, then inverce b2
+   // if the angle between two axial directions is blunt, then inverse b2
    if (cos_gamma < 0_r)
    {
       b2 = -b2;
diff --git a/src/mesa_pd/kernel/cnt/Parameters.h b/src/mesa_pd/kernel/cnt/Parameters.h
index fc4b98f7f666a6fc6707ba13fbeb12bcf2c91ef5..27496277669e0d9c6ad8440c248c9ed5e205124d 100644
--- a/src/mesa_pd/kernel/cnt/Parameters.h
+++ b/src/mesa_pd/kernel/cnt/Parameters.h
@@ -76,7 +76,7 @@ constexpr auto ro = 4_r * mm / ( math::root_three * a_CC );
 /// Atomic mass of Carbon in AMU
 constexpr auto M_C = 12.011_r;
 
-/// Mass of the repetative cell in AMU
+/// Mass of the repetitive cell in AMU
 constexpr auto mass_T = ro * T * M_C * 104.397_r;
 
 /// Volume of a capsule
diff --git a/src/mesa_pd/mpi/notifications/ContactHistoryNotification.h b/src/mesa_pd/mpi/notifications/ContactHistoryNotification.h
index 92bfe1dac82b233b84eda7add4d5be83cf786cf4..3785f0ffbbb0e92e184c9635d1626e95ec9ef388 100644
--- a/src/mesa_pd/mpi/notifications/ContactHistoryNotification.h
+++ b/src/mesa_pd/mpi/notifications/ContactHistoryNotification.h
@@ -41,7 +41,7 @@ namespace walberla {
 namespace mesa_pd {
 
 /**
- * Trasmits the contact history
+ * Transmits the contact history
  */
 class ContactHistoryNotification
 {
diff --git a/src/mesa_pd/mpi/notifications/ForceTorqueNotification.h b/src/mesa_pd/mpi/notifications/ForceTorqueNotification.h
index eb5c3198f2096acd9d3620a1352f2a7f9c9f84d0..5c8ad6f79507d114423115d9e3082808a166e3e1 100644
--- a/src/mesa_pd/mpi/notifications/ForceTorqueNotification.h
+++ b/src/mesa_pd/mpi/notifications/ForceTorqueNotification.h
@@ -39,7 +39,7 @@ namespace walberla {
 namespace mesa_pd {
 
 /**
- * Trasmits force and torque information.
+ * Transmits force and torque information.
  */
 class ForceTorqueNotification
 {
diff --git a/src/mesa_pd/mpi/notifications/HeatFluxNotification.h b/src/mesa_pd/mpi/notifications/HeatFluxNotification.h
index 5ed1d294c50d5f3db75cc99ae76537b3980f5416..6b580a50083295eb7c40646ef95dbc5af94c1d34 100644
--- a/src/mesa_pd/mpi/notifications/HeatFluxNotification.h
+++ b/src/mesa_pd/mpi/notifications/HeatFluxNotification.h
@@ -39,7 +39,7 @@ namespace walberla {
 namespace mesa_pd {
 
 /**
- * Trasmits force and torque information.
+ * Transmits force and torque information.
  */
 class HeatFluxNotification
 {
diff --git a/src/mesa_pd/mpi/notifications/HydrodynamicForceTorqueNotification.h b/src/mesa_pd/mpi/notifications/HydrodynamicForceTorqueNotification.h
index 7d6ac15949c876eb574346b4ff1c77efd5a0c9d4..ce874188127bd4cfa0c11e6d7087ce7e1ef61bd5 100644
--- a/src/mesa_pd/mpi/notifications/HydrodynamicForceTorqueNotification.h
+++ b/src/mesa_pd/mpi/notifications/HydrodynamicForceTorqueNotification.h
@@ -39,7 +39,7 @@ namespace walberla {
 namespace mesa_pd {
 
 /**
- * Trasmits force and torque information.
+ * Transmits force and torque information.
  */
 class HydrodynamicForceTorqueNotification
 {
diff --git a/src/mesa_pd/vtk/ConvexPolyhedron/MeshParticleVTKOutput.h b/src/mesa_pd/vtk/ConvexPolyhedron/MeshParticleVTKOutput.h
index 95127646d85a706f20d2b4fcade6191e95725e9b..b744ae730def8ab0c6d85f1ebce44415d74221ba 100644
--- a/src/mesa_pd/vtk/ConvexPolyhedron/MeshParticleVTKOutput.h
+++ b/src/mesa_pd/vtk/ConvexPolyhedron/MeshParticleVTKOutput.h
@@ -167,7 +167,7 @@ void MeshParticleVTKOutput<MeshType>::assembleMesh() {
    // ensure the mesh is empty, as this will contain the new output
    mesh_->clean();
 
-   // then iterate over every particle and tesselate it to include it in the output mesh
+   // then iterate over every particle and tessellate it to include it in the output mesh
    for (auto pIt = ps_->begin(); pIt != ps_->end(); ++pIt) {
       if (!particleSelector_(pIt)) continue;
 
@@ -180,7 +180,7 @@ void MeshParticleVTKOutput<MeshType>::assembleMesh() {
          const auto& convexPolyhedron = *static_cast<walberla::mesa_pd::data::ConvexPolyhedron*>(shape.get());
          const auto& particle = *pIt;
 
-         // tesselate: add the shape at the particle's position into the output mesh
+         // tessellate: add the shape at the particle's position into the output mesh
          tesselate(convexPolyhedron, particle, mesh_, newVertices, newFaces);
       }
 
diff --git a/src/mesh/mesh_module.dox b/src/mesh/mesh_module.dox
index 830bfc633c4e160aa9d632f07c745927d6b51228..8f7a4746d015b1b8a54464e5b7dae07d39c54d8d 100644
--- a/src/mesh/mesh_module.dox
+++ b/src/mesh/mesh_module.dox
@@ -55,7 +55,7 @@ mesh::PythonTriangleMesh might be the right choice.
 \subsection load Loading meshes
 Meshes can be loaded from any file format supported by OpenMesh including obj, off, ply, stl and a custom om format.
 To load a mesh at large scale simulations waLBerla provides the function readAndBroadcast() which reads a file from disk on a single process and broadcasts it.
-This way the pressure on the file system is kept to a minmum.
+This way the pressure on the file system is kept to a minimum.
 
 \subsection conversion Conversion between OpenMesh and waLBerla data types
 OpenMesh and waLBerla use different vector data types. The file MatrixVectorOperations.h provides the functions toWalberla() and toOpenMesh()
@@ -68,11 +68,11 @@ can be found in MeshConversion.h.
 
 \section setup How can I setup my simulation using the mesh module?
 
-\subsection  distance Initilization of mesh distance data structures
+\subsection  distance Initialization of mesh distance data structures
 To set up the simulation using a surface mesh, waLBerla needs to compute distances to the surface and determine the location of points relative to mesh.
 The necessary data structure is called mesh::TriangleDistance and is defined in DistanceComputations.h.
 It adds the necessary information to the mesh's triangles and offers functions to compute a signed point<->triangle distance.
-It also offers to compute a asigned point<->mesh distance but this is only recommended for smaller meshes with only a few triangles.
+It also offers to compute a assigned point<->mesh distance but this is only recommended for smaller meshes with only a few triangles.
 Larger meshes should use a \ref mesh::distance_octree::DistanceOctree "mesh::DistanceOctree" which reduces the number of evaluated point<->mesh distances significantly from \f$\mathcal O(n)\f$ to \f$\mathcal O(\log n)\f$.
 If you are only interested whether a point is contained in the mesh you can use the \ref mesh::distance_octree::DistanceOctree "mesh::DistanceOctree" with geometry::ContainmentOctree to get faster results.
 
diff --git a/src/mesh/pe/DefaultTesselation.h b/src/mesh/pe/DefaultTesselation.h
index f3de74322f0544cb382664b8c77d9dd53da1286d..9391779ca9b7f65ae93e1480407477acfbbf0046 100644
--- a/src/mesh/pe/DefaultTesselation.h
+++ b/src/mesh/pe/DefaultTesselation.h
@@ -50,7 +50,7 @@ public:
       }
       else
       {
-         WALBERLA_ABORT( "Tesselation not implemented for your body!" );
+         WALBERLA_ABORT( "Tessellation not implemented for your body!" );
       }
    }
 
diff --git a/src/mesh/pe/rigid_body/ConvexPolyhedron.cpp b/src/mesh/pe/rigid_body/ConvexPolyhedron.cpp
index 2b505e09bde0060b510ce2e6eb746665358558f1..933a6d28f6ea58a12c4e5ceec92c937586c39b0a 100644
--- a/src/mesh/pe/rigid_body/ConvexPolyhedron.cpp
+++ b/src/mesh/pe/rigid_body/ConvexPolyhedron.cpp
@@ -103,7 +103,7 @@ void ConvexPolyhedron::init( const Vec3& gpos,  const Quat& q,
       setMassAndInertiaToInfinity();
    } else
    {
-      // sets inverse mass and interatio tensor
+      // sets inverse mass and inertia tensor
       setMassAndInertia( getVolume() * Material::getDensity( getMaterial() ), mesh::computeInertiaTensor( mesh_ ) );
    }
    setCommunicating( communicating );
@@ -189,7 +189,7 @@ real_t ConvexPolyhedron::getSurfaceArea() const
 /*!\brief Estimates the point which is farthest in direction \a d.
  *
  * \param d The normalized search direction in world-frame coordinates.
- * \return The support point in world-frame coordinates in direction a\ d.
+ * \return The support point in world-frame coordinates in direction \a d.
  */
 Vec3 ConvexPolyhedron::support( const Vec3& d ) const
 {
@@ -233,7 +233,7 @@ Vec3 ConvexPolyhedron::support( const Vec3& d ) const
 /*!\brief Estimates the vertex which is farthest in direction \a d.
 *
 * \param d The normalized search direction in body-frame coordinates.
-* \return The support vertex in direction a\ d.
+* \return The support vertex in direction \a d.
 */
 TriangleMesh::VertexHandle ConvexPolyhedron::supportVertex( const TriangleMesh::Normal & d, const TriangleMesh::VertexHandle startVertex ) const
 {
@@ -266,7 +266,7 @@ TriangleMesh::VertexHandle ConvexPolyhedron::supportVertex( const TriangleMesh::
 /*!\brief Estimates the point which is farthest in direction \a d.
  *
  * \param d The normalized search direction in world-frame coordinates
- * \return The support point in world-frame coordinates in direction a\ d extended by a vector in
+ * \return The support point in world-frame coordinates in direction \a d extended by a vector in
  *         direction \a d of length \a pe::contactThreshold.
  */
 Vec3 ConvexPolyhedron::supportContactThreshold( const Vec3& /*d*/ ) const
diff --git a/src/mesh/pe/rigid_body/ConvexPolyhedronFactory.cpp b/src/mesh/pe/rigid_body/ConvexPolyhedronFactory.cpp
index eb8fdfa7c0402d71b247272320a30782d328f6e2..e0685e8dbdf5544525b68b3f6e6dcff9279eaf89 100644
--- a/src/mesh/pe/rigid_body/ConvexPolyhedronFactory.cpp
+++ b/src/mesh/pe/rigid_body/ConvexPolyhedronFactory.cpp
@@ -43,11 +43,11 @@ ConvexPolyhedronID createConvexPolyhedron( BodyStorage& globalStorage, BlockStor
                                            MaterialID material,
                                            bool global, bool communicating, bool infiniteMass )
 {
-   WALBERLA_ASSERT_UNEQUAL( ConvexPolyhedron::getStaticTypeID(), std::numeric_limits<id_t>::max(), "ConvexPolyhedron TypeID not initalized!");
+   WALBERLA_ASSERT_UNEQUAL( ConvexPolyhedron::getStaticTypeID(), std::numeric_limits<id_t>::max(), "ConvexPolyhedron TypeID not initialized!");
 
    // Checking the side lengths
    if( pointCloud.size() < size_t(4) )
-      WALBERLA_ABORT( "Polyhedron needs at leat 4 points!" );
+      WALBERLA_ABORT( "Polyhedron needs at least 4 points!" );
    
    shared_ptr< TriangleMesh > mesh = make_shared<TriangleMesh>();
    mesh::QHull<TriangleMesh> qhull( pointCloud, mesh );
@@ -63,7 +63,7 @@ ConvexPolyhedronID createConvexPolyhedron( BodyStorage& globalStorage, BlockStor
                                            MaterialID material,
                                            bool global, bool communicating, bool infiniteMass )
 {
-   WALBERLA_ASSERT_UNEQUAL( ConvexPolyhedron::getStaticTypeID(), std::numeric_limits<id_t>::max(), "ConvexPolyhedron TypeID not initalized!");
+   WALBERLA_ASSERT_UNEQUAL( ConvexPolyhedron::getStaticTypeID(), std::numeric_limits<id_t>::max(), "ConvexPolyhedron TypeID not initialized!");
 
    ConvexPolyhedronID poly = nullptr;
 
diff --git a/src/mesh_common/DistanceComputations.h b/src/mesh_common/DistanceComputations.h
index 6333a53884dfa9a8babe8de650391c803fea1330..9155aa1d12aa0ec05f6d3abc7f00d2acf123723b 100644
--- a/src/mesh_common/DistanceComputations.h
+++ b/src/mesh_common/DistanceComputations.h
@@ -67,7 +67,7 @@ struct DistanceProperties
 * \brief Adds information required to compute signed distances from a point to a triangle
 * 
 * The class adds vertex, edge and face normals to mesh. The normals are calculated according to \cite Baerentzen2005
-* to allow for a numerically stable sign computation. To compute the point<->trinagle distance, we use the rotation
+* to allow for a numerically stable sign computation. To compute the point<->triangle distance, we use the rotation
 * method described in \cite Jones1995. Some data is precomputed to allow for faster computations and is stored
 * at each face in an object of class DistanceProperties. The numbering of vertices, edges and voronoi regions in
 * the rotated triangles are shown here:
@@ -75,13 +75,12 @@ struct DistanceProperties
 * \image html mesh/triangle_topo.svg "A rotated triangle in the planar coordinate system. The vertex numbering is shown in red, the edge numbering in blue and the numbering of the voronoi regions in green."
 *
 * The class offers multiple methods to get the signed squared distance from a point to a single triangle or the whole mesh.
-* Please note that the distance compuattion for whole meshes is rather ineffecient. Instead you should an object of this
-* class into a \ref mesh::distance_octree::DistanceOctree "mesh::DistanceOctree" reduce the computaional complexity
+* Please note that the distance computation for whole meshes is rather inefficient. Instead you should an object of this
+* class into a \ref mesh::distance_octree::DistanceOctree "mesh::DistanceOctree" reduce the computational complexity
 * from \f$\mathcal O(n)\f$ to \f$\mathcal O(\log n)\f$, where \f$\mathcal O(n)\f$ where \f$n\f$ is the number triangles.
 *
 * Additionally to the signed squared distance you can also retrieve the closest point on the triangle or mesh to
-* your point of inquiry. You may also retrieve the coresponding normal and the clostest voronoi region region.
-
+* your point of inquiry. You may also retrieve the corresponding normal and the closest voronoi region.
 */
 template< typename MeshType >
 class TriangleDistance
diff --git a/src/mesh_common/MeshOperations.h b/src/mesh_common/MeshOperations.h
index 1694edf876107b953b7e6f02f9d20d843dc9f28c..979d0be61ed0322db26f437bb093228e71822914 100644
--- a/src/mesh_common/MeshOperations.h
+++ b/src/mesh_common/MeshOperations.h
@@ -495,7 +495,7 @@ walberla::optional< bool > isIntersecting( const DistanceObject & distanceObject
       if( sqSignedDistance < sqInRadius )
          return true; // clearly the box must intersect the mesh
 
-      // The point closest to the box center is located in the spherical shell between the box's insphere and ciricumsphere
+      // The point closest to the box center is located in the spherical shell between the box's insphere and circumsphere
       const Scalar error = circumRadius - inRadius;
 
       if( error < maxErrorScalar )
@@ -566,7 +566,7 @@ walberla::optional< bool > fullyCoversAABB( const DistanceObject & distanceObjec
       if( sqSignedDistance > -sqInRadius )
          return false; // clearly the box must partially be outside of the mesh
 
-      // The point closest to the box center is located in the spherical shell between the box's insphere and ciricumsphere
+      // The point closest to the box center is located in the spherical shell between the box's insphere and circumsphere
       const Scalar error = circumRadius - inRadius;
 
       if( error < maxErrorScalar )
@@ -639,7 +639,7 @@ walberla::optional< bool > intersectsSurface( const DistanceObject & distanceObj
       if( sqDistance < sqInRadius)
          return true; // clearly the box must intersect the mesh
 
-                      // The point closest to the box center is located in the spherical shell between the box's insphere and ciricumsphere
+                      // The point closest to the box center is located in the spherical shell between the box's insphere and circumsphere
       const Scalar error = circumRadius - inRadius;
 
       if(error < maxErrorScalar)
diff --git a/src/mesh_common/QHull.h b/src/mesh_common/QHull.h
index 160d3e8a01ae304138dfee39e2da58656af2c73a..6011ce09b5a4ee3fc6d9edb36e08a4f82859ea54 100644
--- a/src/mesh_common/QHull.h
+++ b/src/mesh_common/QHull.h
@@ -107,10 +107,10 @@ private:
 
    
    std::vector< Point > pointCloud_; /// The initial point cloud
-   shared_ptr< MeshType > mesh_; /// The genereated convex mesh
+   shared_ptr< MeshType > mesh_; /// The generated convex mesh
    typedef typename OpenMesh::FPropHandleT< std::vector<Point> > VisiblePointsPropertyHandle;
    OpenMesh::PropertyManager< VisiblePointsPropertyHandle, MeshType > visiblePoints_; /// Property storing the points of a certain face
-   std::priority_queue<FaceHandle, std::vector<FaceHandle>, QHullFaceSorter<MeshType> > queue_; /// queue to proptize faces
+   std::priority_queue<FaceHandle, std::vector<FaceHandle>, QHullFaceSorter<MeshType> > queue_; /// queue to prioritize faces
 
    // Vectors to be reused in between iterations
    std::vector<Point> orphanPoints_; /// Points getting orphaned during face removal
diff --git a/src/pe/Materials.h b/src/pe/Materials.h
index 15863462f6de1e896f2f034c605c11ae100e2179..d44772ffd26759304540efbabb9c9605702d689d 100644
--- a/src/pe/Materials.h
+++ b/src/pe/Materials.h
@@ -196,7 +196,7 @@ private:
                             force are related by an inequality:
                             \f[ |\vec{f_t}| \leq \mu_s |\vec{f_n}| \f]
                             The direction of the friction must oppose acceleration if sliding is
-                            imminent and is unresticted otherwise. */
+                            imminent and is unrestricted otherwise. */
    real_t dynamic_;      //!< The coefficient of dynamic friction (CDF) \f$ [0..\infty) \f$.
                        /*!< The CDF is a dimensionless, non-negative quantity representing the
                             amount of dynamic friction between two touching rigid bodies. Dynamic
diff --git a/src/pe/amr/level_determination/MinMaxLevelDetermination.cpp b/src/pe/amr/level_determination/MinMaxLevelDetermination.cpp
index d29f5011c77aafb66a5da612664e0de5be5d5797..93f0b31c0600044184742c62ed8450ae74a1e7d3 100644
--- a/src/pe/amr/level_determination/MinMaxLevelDetermination.cpp
+++ b/src/pe/amr/level_determination/MinMaxLevelDetermination.cpp
@@ -65,7 +65,7 @@ blockforest::InfoCollection::const_iterator MinMaxLevelDetermination::getOrCreat
    {
       blockforest::BlockID childId(fatherId, child);
       auto childIt = ic_->find( childId );
-      //meight be not available if not all blocks are on the same level
+      //might be not available if not all blocks are on the same level
       //return giant number to prevent coarsening
       if (childIt == ic_->end())
       {
diff --git a/src/pe/amr/weight_assignment/MetisAssignmentFunctor.h b/src/pe/amr/weight_assignment/MetisAssignmentFunctor.h
index f0797401ed1eb68c002fe905722746661c755ced..e16d67540be79cd84eba9d650b3ec247ccf9ad1e 100644
--- a/src/pe/amr/weight_assignment/MetisAssignmentFunctor.h
+++ b/src/pe/amr/weight_assignment/MetisAssignmentFunctor.h
@@ -41,7 +41,7 @@ class MetisAssignmentFunctor
 public:
    ///Convenience typedef to be used as PhantomBlock weight in conjunction with this weight assignment functor.
    using PhantomBlockWeight = blockforest::DynamicParMetisBlockInfo;
-   ///Convenience typdef for pack and unpack functions to be used in conjunction with PhantomBlockWeight.
+   ///Convenience typedef for pack and unpack functions to be used in conjunction with PhantomBlockWeight.
    using PhantomBlockWeightPackUnpackFunctor = blockforest::DynamicParMetisBlockInfoPackUnpack;
 
    MetisAssignmentFunctor( shared_ptr<blockforest::InfoCollection>& ic, const real_t baseWeight = real_t(10.0) ) : ic_(ic), baseWeight_(baseWeight) {}
diff --git a/src/pe/amr/weight_assignment/WeightAssignmentFunctor.h b/src/pe/amr/weight_assignment/WeightAssignmentFunctor.h
index 069efae7e14d587208d50558e3f4d3180ca47d7b..e6373152aac5a98fe2a13559b788c18b8c2b50bb 100644
--- a/src/pe/amr/weight_assignment/WeightAssignmentFunctor.h
+++ b/src/pe/amr/weight_assignment/WeightAssignmentFunctor.h
@@ -39,7 +39,7 @@ class WeightAssignmentFunctor
 public:
    ///Convenience typedef to be used as PhantomBlock weight in conjunction with this weight assignment functor.
    using PhantomBlockWeight = walberla::blockforest::PODPhantomWeight<double>;
-   ///Convenience typdef for pack and unpack functions to be used in conjunction with PhantomBlockWeight.
+   ///Convenience typedef for pack and unpack functions to be used in conjunction with PhantomBlockWeight.
    using PhantomBlockWeightPackUnpackFunctor = walberla::blockforest::PODPhantomWeightPackUnpack<double>;
 
    WeightAssignmentFunctor( shared_ptr<blockforest::InfoCollection>& ic, const real_t baseWeight = real_t(10.0) ) : ic_(ic), baseWeight_(baseWeight) {}
diff --git a/src/pe/bg/IBG.h b/src/pe/bg/IBG.h
index fa7ec0662a0a3699434a936de9580a454f1f0e94..72bec0903a2b45af33fbf9601c493816617bd092 100644
--- a/src/pe/bg/IBG.h
+++ b/src/pe/bg/IBG.h
@@ -35,7 +35,7 @@ public:
 //*************************************************************************************************
 /*!\brief Compare if two batch generators are equal.
  *
- * Since batch generators are uncopyable two batch generators are considered equal if their adresses are equal.
+ * Since batch generators are uncopyable two batch generators are considered equal if their addresses are equal.
  */
 inline bool operator==(const IBG& lhs, const IBG& rhs) {return &lhs == &rhs;}
 
diff --git a/src/pe/ccd/HashGrids.cpp b/src/pe/ccd/HashGrids.cpp
index 3c312fa36242e462e7baf789500c0c50fc90260d..5c2f691edc76df566c984677f8586a0d9fe1ae77 100644
--- a/src/pe/ccd/HashGrids.cpp
+++ b/src/pe/ccd/HashGrids.cpp
@@ -378,7 +378,7 @@ size_t HashGrids::HashGrid::hashPoint(real_t x, real_t y, real_t z) const {
 /*!\brief Adds a body to a specific cell in this hash grid.
  *
  * \param body The body that is about to be added to this hash grid.
- * \param cell The cell the body is assigend to.
+ * \param cell The cell the body is assigned to.
  * \return void
  */
 void HashGrids::HashGrid::add( BodyID body, Cell* cell )
@@ -1237,7 +1237,7 @@ const size_t HashGrids::zCellCount = 16;
 
 
 //*************************************************************************************************
-/*!\brief The initial storage capaciy of a newly created grid cell body container.
+/*!\brief The initial storage capacity of a newly created grid cell body container.
  *
  * This value specifies the initial storage capacity reserved for every grid cell body container,
  * i.e., the number of bodies that can initially be assigned to a grid cell with the need to
@@ -1257,7 +1257,7 @@ const size_t HashGrids::cellVectorSize = 16;
  *
  * This value specifies the initial storage capacity of the grid-global vector that keeps track
  * of all body-occupied cells. As long as at least one body is assigned to a certain cell, this
- * cell is recored in a grid-global list that keeps track of all body-occupied cells in order to
+ * cell is recorded in a grid-global list that keeps track of all body-occupied cells in order to
  * avoid iterating through all grid cells whenever all bodies that are stored in the grid need
  * to be addressed.
  */
diff --git a/src/pe/ccd/HashGrids.h b/src/pe/ccd/HashGrids.h
index cbfe0471da80d0ced8bc6851b884b7cc34034ffa..372fb452dc4ad5c5892714ca499d2a78cd4f605e 100644
--- a/src/pe/ccd/HashGrids.h
+++ b/src/pe/ccd/HashGrids.h
@@ -605,7 +605,7 @@ BodyID HashGrids::HashGrid::getBodyIntersectionForBlockCell(const Vector3<int32_
  * \param ray Ray getting shot through this grid.
  * \param blockAABB AABB of the block this grid corresponds to.
  * \param t Reference for the distance.
- * \param n Reference for the intersetion normal.
+ * \param n Reference for the intersection normal.
  * \return BodyID of closest body, NULL if none found.
  *
  * This function calculates ray-cell intersections and the closest body in those cells. Also, neighboring
@@ -762,7 +762,7 @@ BodyID HashGrids::HashGrid::getRayIntersectingBody(const raytracing::Ray& ray, c
  * \param ray Ray getting shot through those grids.
  * \param blockAABB AABB of the block the grids correspond to.
  * \param t Reference for the distance.
- * \param n Reference for the intersetion normal.
+ * \param n Reference for the intersection normal.
  * \return BodyID of closest body, NULL if none found.
  */
 template<typename BodyTuple>
diff --git a/src/pe/ccd/ICCD.h b/src/pe/ccd/ICCD.h
index 8aeb8d50ac9ede85a2729ed29a6f865444c329d1..831c8d78af11569a7dc2952be66ddec01d631d8f 100644
--- a/src/pe/ccd/ICCD.h
+++ b/src/pe/ccd/ICCD.h
@@ -49,7 +49,7 @@ protected:
 //*************************************************************************************************
 /*!\brief Compare if two coarse collision detectors are equal.
  *
- * Since collision detectors are uncopyable two collision detectors are considered equal if their adresses are equal.
+ * Since collision detectors are uncopyable two collision detectors are considered equal if their addresses are equal.
  */
 inline bool operator==(const ICCD& lhs, const ICCD& rhs) {return &lhs == &rhs;}
 
diff --git a/src/pe/collision/EPA.cpp b/src/pe/collision/EPA.cpp
index 171dc85949828e61adb9df099c7141867b6a93fc..e8d54f178d8e46392fee521524f988eb41b1dd53 100644
--- a/src/pe/collision/EPA.cpp
+++ b/src/pe/collision/EPA.cpp
@@ -130,7 +130,7 @@ inline bool EPA::EPA_Triangle::link( size_t edge0, EPA_Triangle* tria, size_t ed
  */
 inline void EPA::EPA_Triangle::silhouette( const Vec3& w, EPA_EdgeBuffer& edgeBuffer )
 {
-   //std::cerr << "Starting Silhoutette search on Triangle {" << indices_[0] << "," << indices_[1] << "," << indices_[2] << "}" << std::endl;
+   //std::cerr << "Starting Silhouette search on Triangle {" << indices_[0] << "," << indices_[1] << "," << indices_[2] << "}" << std::endl;
    edgeBuffer.clear();
    obsolete_ = true;
 
@@ -142,7 +142,7 @@ inline void EPA::EPA_Triangle::silhouette( const Vec3& w, EPA_EdgeBuffer& edgeBu
 
 
 //*************************************************************************************************
-/*! \brief Recursive silhuette finding method.
+/*! \brief Recursive silhouette finding method.
  */
 void EPA::EPA_Triangle::silhouette( size_t index, const Vec3& w,
                                     EPA_EdgeBuffer& edgeBuffer )
@@ -215,13 +215,13 @@ bool EPA::doEPAmargin( GeomPrimitive &geom1, GeomPrimitive &geom2, const GJK& gj
 
 
 //*************************************************************************************************
-/*! \brief Does an epa computation with contact margin added and specified realtive error.
+/*! \brief Does an epa computation with contact margin added and specified relative error.
  */
 bool EPA::doEPA( GeomPrimitive &geom1, GeomPrimitive &geom2, const GJK& gjk, Vec3& retNormal,
                  Vec3& contactPoint, real_t& penetrationDepth, real_t margin, real_t eps_rel )
 {
    //have in mind that we use a support mapping which blows up the objects a wee bit so
-   //zero penetraion aka toching contact means that the original bodies have a distance of 2*margin between them
+   //zero penetration aka touching contact means that the original bodies have a distance of 2*margin between them
 
    //Set references to the results of GJK
    size_t     numPoints( static_cast<size_t>( gjk.getSimplexSize() ) );
@@ -504,12 +504,12 @@ inline void EPA::createInitialSimplex( size_t numPoints, GeomPrimitive &geom1, G
    switch(numPoints) {
    case 2:
    {
-      //simplex is a line segement
+      //simplex is a line segment
       //add 3 points around the this segment
       //the COS is konvex so the resulting hexaheadron should be konvex too
 
       Vec3 d = epaVolume[1] - epaVolume[0];
-      //find coordinate axis e_i which is furthest from paralell to d
+      //find coordinate axis e_i which is furthest from parallel to d
       //and therefore d has the smallest abs(d[i])
       real_t abs0 = std::abs(d[0]);
       real_t abs1 = std::abs(d[1]);
@@ -599,7 +599,7 @@ inline void EPA::createInitialSimplex( size_t numPoints, GeomPrimitive &geom1, G
       const Vec3& A = epaVolume[2];  //The Point last added to the simplex
       const Vec3& B = epaVolume[1];  //One Point that was already in the simplex
       const Vec3& C = epaVolume[0];  //One Point that was already in the simplex
-      //ABC is a conterclockwise triangle
+      //ABC is a counterclockwise triangle
 
       const Vec3  AB  = B-A;       //The vector A->B
       const Vec3  AC  = C-A;       //The vector A->C
@@ -702,7 +702,7 @@ inline bool EPA::originInTetrahedron( const Vec3& p0, const Vec3& p1, const Vec3
 
 
 //*************************************************************************************************
-/*! \brief Retrurns true, if the origin lies in the tetrahedron ABCD.
+/*! \brief Returns true, if the origin lies in the tetrahedron ABCD.
  */
 inline bool EPA::originInTetrahedronVolumeMethod( const Vec3& A, const Vec3& B, const Vec3& C,
                                                   const Vec3& D )
@@ -728,7 +728,7 @@ inline bool EPA::originInTetrahedronVolumeMethod( const Vec3& A, const Vec3& B,
 
 
 //*************************************************************************************************
-/*! \brief Retrurns true, if a point lies in the tetrahedron ABCD.
+/*! \brief Returns true, if a point lies in the tetrahedron ABCD.
  *  \param point The point to be checked for containment.
  */
 inline bool EPA::pointInTetrahedron( const Vec3& A, const Vec3& B, const Vec3& C, const Vec3& D,
@@ -787,7 +787,7 @@ inline bool EPA::searchTetrahedron(GeomPrimitive &geom1, GeomPrimitive &geom2, s
    do{
       loopCount++;
       pointIndexToRemove = -1;
-      //Check if opposite tetrahedron point and orign are on the same side
+      //Check if opposite tetrahedron point and origin are on the same side
       //of the face. (for all faces)
       Vec3 normal0T = (epaVolume[1] -epaVolume[0]) % (epaVolume[2]-epaVolume[0]);
       real_t dot_val = normal0T*epaVolume[0];
diff --git a/src/pe/collision/EPA.h b/src/pe/collision/EPA.h
index 7bc5840d1311ceec2c21f2054f86ca25a7773a98..6c5d762650b0d269fd2a340d89073651b499cee8 100644
--- a/src/pe/collision/EPA.h
+++ b/src/pe/collision/EPA.h
@@ -210,7 +210,7 @@ private:
 //*************************************************************************************************
 /*!\brief Class storing Information about a triangular facette (Triangle) of the EPA-Polytope
  *
- * see Collision detction in interactiv 3D environments; Gino van den bergen page 155
+ * see Collision detection in interactive 3D environments; Gino van den bergen page 155
  */
 class EPA::EPA_Triangle {
 public:
@@ -468,7 +468,7 @@ inline bool EPA::EPA_TriangleComp::operator()( const EPA_Triangle *tria1,
 //=================================================================================================
 
 //*************************************************************************************************
-/*! \brief Calucates a support point of a body extended by threshold.
+/*! \brief Calculates a support point of a body extended by threshold.
  * Adds this support and the base points at bodies a and b to the vector.
  * \param geom The body.
  * \param dir The support point direction.
@@ -495,7 +495,7 @@ inline void EPA::pushSupportMargin(const GeomPrimitive &geom1, const GeomPrimiti
 
 
 //*************************************************************************************************
-/*! \brief Calucates a support point of a body extended by threshold.
+/*! \brief Calculates a support point of a body extended by threshold.
  * Replaces the old value in the vectors at "IndexToReplace" with this support and the base points at bodies a and b .
  * \param geom The body.
  * \param dir The support point direction.
diff --git a/src/pe/collision/GJK.cpp b/src/pe/collision/GJK.cpp
index d2320f9ec63d8c9c68b919e149e8a21d360a695f..84c437a60cdf1fb6d39462a9e10da168156e772e 100644
--- a/src/pe/collision/GJK.cpp
+++ b/src/pe/collision/GJK.cpp
@@ -163,7 +163,7 @@ real_t GJK::doGJK(GeomPrimitive &geom1, GeomPrimitive &geom2, Vec3& normal, Vec3
  * \param geom1 The first Body
  * \param geom2 The second Body
  * \param margin The margin by which the objects will be enlarged.
- * \return true, if an itersection is found.
+ * \return true, if an intersection is found.
  */
 bool GJK::doGJKmargin(GeomPrimitive &geom1, GeomPrimitive &geom2, real_t margin)
 {
@@ -278,7 +278,7 @@ bool GJK::doGJKmargin(GeomPrimitive &geom1, GeomPrimitive &geom2, real_t margin)
 
 
 //*************************************************************************************************
-/*!\brief Calculate clostes Point in the simplex and its distance to the origin.
+/*!\brief Calculate closest Point in the simplex and its distance to the origin.
  */
 inline real_t GJK::calcDistance( Vec3& normal, Vec3& contactPoint )
 {
@@ -314,7 +314,7 @@ inline real_t GJK::calcDistance( Vec3& normal, Vec3& contactPoint )
       //Vec3 ac = -A;
       //Vec3 bc = -simplex[1];
 
-      //calc baryzenctric coordinats
+      //calc barycentric coordinates
       // compare "Real-Time Collision Detection" by Christer Ericson page 129
       //double t = ac*ab;
       real_t t     = real_t(-1.0) * (A * ab);
@@ -434,7 +434,7 @@ bool GJK::simplex3(Vec3& d)
    const Vec3& A = simplex_[2];  //The Point last added to the simplex
    const Vec3& B = simplex_[1];  //One Point that was already in the simplex
    const Vec3& C = simplex_[0];  //One Point that was already in the simplex
-   //ABC is a conterclockwise triangle
+   //ABC is a counterclockwise triangle
 
    const Vec3  AO  = -A;        //The vector A->O with 0 the origin
    const Vec3&  AOt = AO;        //The transposed vector A->O with O the origin
@@ -559,7 +559,7 @@ bool GJK::simplex4(Vec3& d)
 {
    //the simplex is a tetrahedron
    const Vec3& A  = simplex_[3];  //The Point last added to the tetrahedron
-   //t in front mens just a temp varialble
+   //t in front means just a temp variable
    const Vec3& B = simplex_[2];  //One Point that was already in the simplex
    const Vec3& C = simplex_[1];  //One Point that was already in the simplex
    const Vec3& D = simplex_[0];
diff --git a/src/pe/collision/GJK.h b/src/pe/collision/GJK.h
index a562ccc0dca3e819b5e7fe1de0b02e1d1ecb8576..15680d93fad68bb054344659c2b22c557d751a39 100644
--- a/src/pe/collision/GJK.h
+++ b/src/pe/collision/GJK.h
@@ -45,7 +45,7 @@ namespace fcd {
 //=================================================================================================
 
 //*************************************************************************************************
-/*!\brief Impelementation of the Gilbert-Johnson-Keerthi Algorithm.
+/*!\brief Implementation of the Gilbert-Johnson-Keerthi Algorithm.
  */
 class GJK
 {
@@ -185,7 +185,7 @@ inline bool GJK::zeroLengthVector(const Vec3& vec) const
 
 
 //*************************************************************************************************
-/*!\brief Calucate a support point of a body extended by threshold.
+/*!\brief Calculate a support point of a body extended by threshold.
  * \param geom The body.
  * \param dir The support point direction.
  * \param threshold Extension of the Body.
diff --git a/src/pe/communication/RigidBodyRemoteMigrationNotification.h b/src/pe/communication/RigidBodyRemoteMigrationNotification.h
index 3dcd20a3cacc9b41052d03c48e00f1d0c86109f5..5924e67aad219f74acc1a649398f5ac71376bf69 100644
--- a/src/pe/communication/RigidBodyRemoteMigrationNotification.h
+++ b/src/pe/communication/RigidBodyRemoteMigrationNotification.h
@@ -16,7 +16,7 @@
 //! \file RigidBodyRemoteMigrationNotification.h
 //! \author Tobias Preclik
 //! \author Sebastian Eibl <sebastian.eibl@fau.de>
-//! \brief Header file for the RigidBodyRemoteMigrationNotification classs
+//! \brief Header file for the RigidBodyRemoteMigrationNotification class
 //
 //======================================================================================================================
 
diff --git a/src/pe/cr/HCSITS.h b/src/pe/cr/HCSITS.h
index 93da3f0f2abc075eb768d3d2745c04117ea8eaf6..24b3d7d59f2659ca43c56389837a1ac388a6520d 100644
--- a/src/pe/cr/HCSITS.h
+++ b/src/pe/cr/HCSITS.h
@@ -60,7 +60,7 @@ namespace cr {
 //*************************************************************************************************
 /**
  * \ingroup pe
- * \brief Particular implementation of the collision resoution for the hard contacts.
+ * \brief Particular implementation of the collision resolution for the hard contacts.
  *
  * The following code example illustrates the setup of the solver:
  * \snippet PeDocumentationSnippets.cpp Setup HCSITS
@@ -237,7 +237,7 @@ private:
    size_t maxSubIterations_;          //!< Maximum number of iterations of iterative solvers in the one-contact problem.
    real_t abortThreshold_;            //!< If L-infinity iterate difference drops below this threshold the iteration is aborted.
    RelaxationModel relaxationModel_;  //!< The method used to relax unilateral contacts
-   real_t overRelaxationParam_;       //!< Parameter specifying the convergence speed for othogonal projection models.
+   real_t overRelaxationParam_;       //!< Parameter specifying the convergence speed for orthogonal projection models.
    real_t relaxationParam_;           //!< Parameter specifying underrelaxation of velocity corrections for boundary bodies.
    real_t maximumPenetration_;
    size_t numContacts_;
@@ -331,12 +331,12 @@ inline real_t HardContactSemiImplicitTimesteppingSolvers::getSpeedLimitFactor()
  * \param f The overrelaxation parameter.
  * \return void
  *
- * The overrelaxation parameter \omega is only used when the relaxation model is one of
+ * The overrelaxation parameter \a omega is only used when the relaxation model is one of
  * - ApproximateInelasticCoulombContactByOrthogonalProjections
  * - InelasticCoulombContactByOrthogonalProjections
  *
  * It is used to control the convergence of the model. Large values show faster convergence,
- * but they can also lead to divergence ("exploding" particles). The default values is 1.0.
+ * but they can also lead to divergence ("exploding" particles). The default value is 1.0.
  */
 inline void HardContactSemiImplicitTimesteppingSolvers::setOverRelaxationParameter( real_t omega )
 {
@@ -416,7 +416,7 @@ inline void HardContactSemiImplicitTimesteppingSolvers::setErrorReductionParamet
 
 
 //*************************************************************************************************
-/*!\brief Sets the threshold of movement of a particle during collsion resolulution
+/*!\brief Sets the threshold of movement of a particle during collision resolution
 *
 * \param threshold If movement is smaller than threshold, col. resolution is stopped.
 * \return void
@@ -433,7 +433,7 @@ inline void HardContactSemiImplicitTimesteppingSolvers::setAbortThreshold( real_
 //*************************************************************************************************
 /*!\brief Activates/Deactivates the speed limiter and sets the limit
 *
-* \param active activate/deactivate speed limtier
+* \param active activate/deactivate speed limiter
 * \param speedLimitFactor size of bounding box will be multiplied by this factor to get the maximal distance a body is allowed to travel within one timestep
 * \return void
 */
diff --git a/src/pe/cr/HCSITS.impl.h b/src/pe/cr/HCSITS.impl.h
index 25cccf846670b51e57300aa82a6fad088a242da9..b46362df2e1a7fa09294461c6ce0e3e301533995 100644
--- a/src/pe/cr/HCSITS.impl.h
+++ b/src/pe/cr/HCSITS.impl.h
@@ -1662,14 +1662,14 @@ inline void HardContactSemiImplicitTimesteppingSolvers::synchronizeVelocities( )
    //   for( ProcessIterator process = processstorage_.begin(); process != processstorage_.end(); ++process )
    //      sentVelocitiesSyncUpdates_.transfered( process->getSendBuffer().size() );
 
-   if (tt_ != nullptr) tt_->start("Velocity Sync Update Communincate");
+   if (tt_ != nullptr) tt_->start("Velocity Sync Update Communicate");
 
    WALBERLA_LOG_DETAIL( "Communication of velocity update message starts...");
 
    syncVelBS.setReceiverInfo(recvRanks, true);
    syncVelBS.sendAll();
 
-   if (tt_ != nullptr) tt_->stop("Velocity Sync Update Communincate");
+   if (tt_ != nullptr) tt_->stop("Velocity Sync Update Communicate");
 
    //   for( ProcessIterator process = processstorage_.begin(); process != processstorage_.end(); ++process )
    //      receivedVelocitiesSyncUpdates_.transfered( process->getRecvBuffer().size() );
diff --git a/src/pe/fcd/AnalyticCollisionDetection.h b/src/pe/fcd/AnalyticCollisionDetection.h
index 2fbda8d98e6a67f689445706cc91d929f0b5959d..65737205c2be080e82bb0ed533d18cf017b133d4 100644
--- a/src/pe/fcd/AnalyticCollisionDetection.h
+++ b/src/pe/fcd/AnalyticCollisionDetection.h
@@ -798,7 +798,7 @@ bool collide( BoxID b1, BoxID b2, Container& container )
    WALBERLA_LOG_DETAIL(
              "         Selected contact case = " << contactCase << "\n"
           << "         Contact normal = " << contactNormal << "\n"
-          << "         Normal invertion? " << invertNormal );
+          << "         Normal inversion? " << invertNormal );
 
 
    //----- Treating edge/edge collisions -----
diff --git a/src/pe/fcd/GJKEPACollideFunctor.h b/src/pe/fcd/GJKEPACollideFunctor.h
index 4dcc97a7d519d0c1dc4f8bcba4e9a3f8788fe5a0..372d44edf5285b5ec6aced36537d4700a7175874 100644
--- a/src/pe/fcd/GJKEPACollideFunctor.h
+++ b/src/pe/fcd/GJKEPACollideFunctor.h
@@ -193,7 +193,7 @@ namespace gjkepa{
       return collision;
    }
 
-   //Union and Plane (these calls are ambigous if not implemented seperatly)
+   //Union and Plane (these calls are ambiguous if not implemented separately)
    template<typename... BodyTypesA, typename Container>
    inline bool generateContacts(Union<BodyTypesA...> *a, Plane *b, Container& contacts_){
       GJKEPASingleCollideFunctor<Plane, Container> func(b, contacts_);
diff --git a/src/pe/fcd/IFCD.h b/src/pe/fcd/IFCD.h
index e34592b3df6320c97a0fa6104f438d5464fe2f2f..d671a1abf1c8a3579e7727614a973ac90bb4135b 100644
--- a/src/pe/fcd/IFCD.h
+++ b/src/pe/fcd/IFCD.h
@@ -57,7 +57,7 @@ protected:
 //*************************************************************************************************
 /*!\brief Compare if two fine collision detectors are equal.
  *
- * Since collision detectors are uncopyable two collision detectors are considered equal if their adresses are equal.
+ * Since collision detectors are uncopyable two collision detectors are considered equal if their addresses are equal.
  */
 inline bool operator==(const IFCD& lhs, const IFCD& rhs) {return &lhs == &rhs;}
 
diff --git a/src/pe/raytracing/Intersects.h b/src/pe/raytracing/Intersects.h
index ea7c6f8507b52b20e03d21a6d2400e0078f60ec1..a956e4efe90e78f9c5cd8fbc3a35ba0a92f28060 100644
--- a/src/pe/raytracing/Intersects.h
+++ b/src/pe/raytracing/Intersects.h
@@ -222,7 +222,7 @@ inline bool intersects(const CapsuleID capsule, const Ray& ray, real_t& t, Vec3&
    }
    
    // Check now for end capping half spheres.
-   // Only check them if the ray didnt both enter and leave the cylinder part of the capsule already (t0hit && t1hit).
+   // Only check them if the ray didn't both enter and leave the cylinder part of the capsule already (t0hit && t1hit).
    if (!t0hit || !t1hit) {
       real_t t0_left, t1_left;
       Vec3 leftSpherePos(-halfLength, 0, 0);
diff --git a/src/pe/raytracing/Raytracer.cpp b/src/pe/raytracing/Raytracer.cpp
index 344b8af9938271e05aa5af4f97fe10b6095642f4..de604aee626fa6bfa2fd87f2c3da24302d3f21a0 100644
--- a/src/pe/raytracing/Raytracer.cpp
+++ b/src/pe/raytracing/Raytracer.cpp
@@ -250,7 +250,7 @@ void Raytracer::setupMPI_() {
 }
    
 /*!\brief Generates the filename for output files.
- * \param base String that precedes the timestap and rank info.
+ * \param base String that precedes the timestep and rank info.
  * \param timestep Timestep this image is from.
  * \param isGlobalImage Whether this image is the fully stitched together one.
  */
diff --git a/src/pe/rigidbody/BodyStorage.h b/src/pe/rigidbody/BodyStorage.h
index b6e159f675df8f975e232e30370006b6276f999d..40b4594ef65ec69e04aa4e6930011b58e1b3ce14 100644
--- a/src/pe/rigidbody/BodyStorage.h
+++ b/src/pe/rigidbody/BodyStorage.h
@@ -682,7 +682,7 @@ inline BodyStorage::iterator BodyStorage::remove( iterator pos )
  * \param body A handle of the rigid body to be removed.
  * \return void
  *
- * This function removes a body from the body storage. \a body must be a valid rigid body poitner
+ * This function removes a body from the body storage. \a body must be a valid rigid body pointer
  * and must be registered in the body storage. Invalidates all iterators pointing at or past
  * the element to be removed. The time complexity is logarithmic unless reallocation occurs.
  */
@@ -882,7 +882,7 @@ inline void BodyStorage::validate()
 //*************************************************************************************************
 /*!\brief Compare if two BodyStorages are equal.
  *
- * Since BodyStorages are uncopyable two BodyStorages are considered equal if their adresses are equal.
+ * Since BodyStorages are uncopyable two BodyStorages are considered equal if their addresses are equal.
  */
 inline bool operator==(const BodyStorage& lhs, const BodyStorage& rhs) {return &lhs == &rhs;}
 
diff --git a/src/pe/rigidbody/Box.h b/src/pe/rigidbody/Box.h
index 883739868f995502cf292bee6540e4d3f5136a58..b4c291ae484766f7b7f67eb2cba35e09cdaa236c 100644
--- a/src/pe/rigidbody/Box.h
+++ b/src/pe/rigidbody/Box.h
@@ -417,7 +417,7 @@ inline real_t Box::calcDensity( const Vec3& l, real_t mass )
 /*!\brief Estimates the point which is farthest in direction \a d.
  *
  * \param d The normalized search direction in world-frame coordinates.
- * \return The support point in world-frame coordinates in direction a\ d.
+ * \return The support point in world-frame coordinates in direction \a d.
  */
 inline Vec3 Box::support( const Vec3& d ) const
 {
@@ -449,7 +449,7 @@ inline Vec3 Box::support( const Vec3& d ) const
 /*!\brief Estimates the point which is farthest in direction \a d.
  *
  * \param d The normalized search direction in world-frame coordinates.
- * \return The support point in world-frame coordinates in direction a\ d extended by a vector in
+ * \return The support point in world-frame coordinates in direction \a d extended by a vector in
  *         direction \a d of length \a pe::contactThreshold.
  */
 inline Vec3 Box::supportContactThreshold( const Vec3& d ) const
diff --git a/src/pe/rigidbody/BoxFactory.cpp b/src/pe/rigidbody/BoxFactory.cpp
index 2a703600420f9931015675cbe82af1c20b635818..0dbeb2140eaa3070d40f4b70799c94b16d38c81b 100644
--- a/src/pe/rigidbody/BoxFactory.cpp
+++ b/src/pe/rigidbody/BoxFactory.cpp
@@ -37,7 +37,7 @@ BoxID createBox(       BodyStorage& globalStorage, BlockStorage& blocks, BlockDa
                        MaterialID material,
                        bool global, bool communicating, bool infiniteMass )
 {
-   WALBERLA_ASSERT_UNEQUAL( Box::getStaticTypeID(), std::numeric_limits<id_t>::max(), "Box TypeID not initalized!");
+   WALBERLA_ASSERT_UNEQUAL( Box::getStaticTypeID(), std::numeric_limits<id_t>::max(), "Box TypeID not initialized!");
 
    // Checking the side lengths
    if( lengths[0] <= real_t(0) || lengths[1] <= real_t(0) || lengths[2] <= real_t(0) )
diff --git a/src/pe/rigidbody/Capsule.h b/src/pe/rigidbody/Capsule.h
index 52311a2041fb06096bf89dea32bd9bb401865bd4..210d3c251c042fe79a3bad83099212f9ad1a2465 100644
--- a/src/pe/rigidbody/Capsule.h
+++ b/src/pe/rigidbody/Capsule.h
@@ -262,7 +262,7 @@ inline real_t  Capsule::calcDensity( real_t  radius, real_t  length, real_t  mas
 /*!\brief Estimates the point which is farthest in direction \a d.
  *
  * \param d The normalized search direction in world-frame coordinates.
- * \return The support point in world-frame coordinates in direction a\ d.
+ * \return The support point in world-frame coordinates in direction \a d.
  */
 inline Vec3 Capsule::support( const Vec3& d ) const
 {
diff --git a/src/pe/rigidbody/CapsuleFactory.cpp b/src/pe/rigidbody/CapsuleFactory.cpp
index 349e30b2f6e897af0806fade153506fc6e7d71fd..8723226c6d8dde629a694bb54766d2cbfe0d908c 100644
--- a/src/pe/rigidbody/CapsuleFactory.cpp
+++ b/src/pe/rigidbody/CapsuleFactory.cpp
@@ -37,7 +37,7 @@ CapsuleID createCapsule(   BodyStorage& globalStorage, BlockStorage& blocks, Blo
                            MaterialID material,
                            bool global, bool communicating, bool infiniteMass )
 {
-   WALBERLA_ASSERT_UNEQUAL( Capsule::getStaticTypeID(), std::numeric_limits<id_t>::max(), "Capsule TypeID not initalized!");
+   WALBERLA_ASSERT_UNEQUAL( Capsule::getStaticTypeID(), std::numeric_limits<id_t>::max(), "Capsule TypeID not initialized!");
 
    // Checking the radius and the length
    WALBERLA_ASSERT_GREATER( radius, real_t(0), "Invalid capsule radius" );
diff --git a/src/pe/rigidbody/CylindricalBoundary.cpp b/src/pe/rigidbody/CylindricalBoundary.cpp
index 58f4f97ea3a4e68bdc5d85e7e2b3f329a735118c..656c5f3ae1f63ab52181b4f77b0bed892565cbdc 100644
--- a/src/pe/rigidbody/CylindricalBoundary.cpp
+++ b/src/pe/rigidbody/CylindricalBoundary.cpp
@@ -194,7 +194,7 @@ void CylindricalBoundary::print( std::ostream& os, const char* tab ) const
 //=================================================================================================
 
 //*************************************************************************************************
-/*!\brief Global output operator for cylindrical boundaryies.
+/*!\brief Global output operator for cylindrical boundaries.
  *
  * \param os Reference to the output stream.
  * \param c Reference to a cylindrical boundary object.
@@ -213,7 +213,7 @@ std::ostream& operator<<( std::ostream& os, const CylindricalBoundary& c )
 
 
 //*************************************************************************************************
-/*!\brief Global output operator for cylindrical boundaryies handles.
+/*!\brief Global output operator for cylindrical boundaries handles.
  *
  * \param os Reference to the output stream.
  * \param c Constant cylindrical boundary handle.
diff --git a/src/pe/rigidbody/CylindricalBoundaryFactory.cpp b/src/pe/rigidbody/CylindricalBoundaryFactory.cpp
index 6cbf752cb9bb0c29f576e34c7ce336b2077ec4b1..a6e78c6b82256fe8347d8c81b5aca7c9ecf24cb8 100644
--- a/src/pe/rigidbody/CylindricalBoundaryFactory.cpp
+++ b/src/pe/rigidbody/CylindricalBoundaryFactory.cpp
@@ -34,7 +34,7 @@ CylindricalBoundaryID createCylindricalBoundary( BodyStorage& globalStorage,
                                                  id_t uid, const Vec3& gpos, const real_t radius,
                                                  MaterialID material)
 {
-   WALBERLA_ASSERT_UNEQUAL( CylindricalBoundary::getStaticTypeID(), std::numeric_limits<id_t>::max(), "CylindricalBoundary TypeID not initalized!");
+   WALBERLA_ASSERT_UNEQUAL( CylindricalBoundary::getStaticTypeID(), std::numeric_limits<id_t>::max(), "CylindricalBoundary TypeID not initialized!");
 
    const id_t sid( UniqueID<RigidBody>::createGlobal() );
 
diff --git a/src/pe/rigidbody/Ellipsoid.h b/src/pe/rigidbody/Ellipsoid.h
index e9a73305f0646a39fbaf82259f3967ba86b60332..8608e493b6f2d1f15dc4f4ddc946d2366fae3306 100644
--- a/src/pe/rigidbody/Ellipsoid.h
+++ b/src/pe/rigidbody/Ellipsoid.h
@@ -15,7 +15,7 @@
 //
 //! \file Ellipsoid.h
 //! \author Klaus Iglberger
-//! \author Sebastian Eibl <sebastian.eibl@fau.de
+//! \author Sebastian Eibl <sebastian.eibl@fau.de>
 //! \author Tobias Leemann <tobias.leemann@fau.de>
 //
 //======================================================================================================================
@@ -297,7 +297,7 @@ inline Mat3 Ellipsoid::calcInertia( const real_t mass, const Vec3& semiAxes )
 /*!\brief Estimates the point which is farthest in direction \a d.
  *
  * \param d The normalized search direction in world-frame coordinates.
- * \return The support point in world-frame coordinates in direction a\ d.
+ * \return The support point in world-frame coordinates in direction \a d.
  */
 inline Vec3 Ellipsoid::support( const Vec3& d ) const
 {
diff --git a/src/pe/rigidbody/EllipsoidFactory.cpp b/src/pe/rigidbody/EllipsoidFactory.cpp
index 2136a8414bb80da7d0518b97a9aa039c290e0ca2..14c1bde5dc2e12d0f6f721388a6d4a560bca0c9d 100644
--- a/src/pe/rigidbody/EllipsoidFactory.cpp
+++ b/src/pe/rigidbody/EllipsoidFactory.cpp
@@ -36,7 +36,7 @@ EllipsoidID createEllipsoid( BodyStorage& globalStorage, BlockStorage& blocks, B
                              MaterialID material,
                              bool global, bool communicating, bool infiniteMass )
 {
-   WALBERLA_ASSERT_UNEQUAL( Ellipsoid::getStaticTypeID(), std::numeric_limits<id_t>::max(), "Ellipsoid TypeID not initalized!");
+   WALBERLA_ASSERT_UNEQUAL( Ellipsoid::getStaticTypeID(), std::numeric_limits<id_t>::max(), "Ellipsoid TypeID not initialized!");
    // Checking the semiAxes
    if( semiAxes[0] <= real_c(0) || semiAxes[1] <= real_c(0) || semiAxes[2] <= real_c(0) )
       throw std::invalid_argument( "Invalid Ellipsoid semi-axes" );
diff --git a/src/pe/rigidbody/PlaneFactory.cpp b/src/pe/rigidbody/PlaneFactory.cpp
index 650054ee07b68655d53d5e959122d35ed66ea2ce..79e4579346bbf2bfcca0f61966e5cee0a66f93c6 100644
--- a/src/pe/rigidbody/PlaneFactory.cpp
+++ b/src/pe/rigidbody/PlaneFactory.cpp
@@ -34,7 +34,7 @@ namespace pe {
 
 PlaneID createPlane( BodyStorage& globalStorage, id_t uid, Vec3 normal, const Vec3& gpos, MaterialID material)
 {
-   WALBERLA_ASSERT_UNEQUAL( Plane::getStaticTypeID(), std::numeric_limits<id_t>::max(), "Plane TypeID not initalized!");
+   WALBERLA_ASSERT_UNEQUAL( Plane::getStaticTypeID(), std::numeric_limits<id_t>::max(), "Plane TypeID not initialized!");
 
    // Checking the normal of the plane
    if( floatIsEqual(normal.sqrLength(), real_c(0) ) )
diff --git a/src/pe/rigidbody/RigidBody.h b/src/pe/rigidbody/RigidBody.h
index eaecb02dabdb773b29f55f95a8695b9af7664f61..f6d3cfb03977119f60fb5ebda8cde1402cb9f042 100644
--- a/src/pe/rigidbody/RigidBody.h
+++ b/src/pe/rigidbody/RigidBody.h
@@ -713,7 +713,7 @@ inline const Vec3 RigidBody::getPosition() const
  *
  * \return The relative position of the rigid body.
  *
- * If this body is not containted in a superbody the zero-vector is returned.
+ * If this body is not contained in a superbody the zero-vector is returned.
  */
 inline const Vec3 RigidBody::getRelPosition() const
 {
@@ -780,7 +780,7 @@ inline const Vec3 RigidBody::getBodyAngularVel() const
  *
  * \return The global angular velocity.
  *
- * This function returns the angluar velocity of the center of mass in reference to the global
+ * This function returns the angular velocity of the center of mass in reference to the global
  * world frame.
  */
 inline const Vec3 & RigidBody::getAngularVel() const
@@ -1848,7 +1848,7 @@ inline void RigidBody::addImpulseAtPos( const Vec3& j, const Vec3& p )
 //=================================================================================================
 
 //*************************************************************************************************
-/*!\brief Signals an internal modification of a contained subordiante body.
+/*!\brief Signals an internal modification of a contained subordinate body.
  *
  * \return void
  *
@@ -1863,7 +1863,7 @@ inline void RigidBody::signalModification()
 
 
 //*************************************************************************************************
-/*!\brief Signals a position change of a contained subordiante body.
+/*!\brief Signals a position change of a contained subordinate body.
  *
  * \return void
  *
@@ -1878,7 +1878,7 @@ inline void RigidBody::signalTranslation()
 
 
 //*************************************************************************************************
-/*!\brief Signals an orientation change of a contained subordiante body.
+/*!\brief Signals an orientation change of a contained subordinate body.
  *
  * \return void
  *
@@ -1893,7 +1893,7 @@ inline void RigidBody::signalRotation()
 
 
 //*************************************************************************************************
-/*!\brief Signals a fixation change of a contained subordiante body.
+/*!\brief Signals a fixation change of a contained subordinate body.
  *
  * \return void
  *
@@ -2141,7 +2141,7 @@ inline void RigidBody::setPositionImpl( real_t px, real_t py, real_t pz )
  * \param gpos The relative position.
  * \return void
  *
- * This function sets the relatvie position of the rigid body w. r. t. the superbodies position.
+ * This function sets the relative position of the rigid body w. r. t. the superbodies position.
  *
  * \b Note:
  * - Setting the position of a rigid body without superbody will have no effect.
@@ -2598,7 +2598,7 @@ inline void RigidBody::rotate( const Quat& dq )
 //*************************************************************************************************
 
 //*************************************************************************************************
-/*!\brief Implements the rotation of a rigid body. May be overwritten in dervied classes for performance reasons.
+/*!\brief Implements the rotation of a rigid body. May be overwritten in derived classes for performance reasons.
  *
  * \param dq The quaternion for the rotation.
  * \return void
@@ -2729,7 +2729,7 @@ inline void RigidBody::rotateAroundOrigin( const Quat& dq )
 //*************************************************************************************************
 
 //*************************************************************************************************
-/*!\brief Implements the rotation of a rigid body. May be overwritten in dervied classes for performance reasons.
+/*!\brief Implements the rotation of a rigid body. May be overwritten in derived classes for performance reasons.
  *
  * \param dq The quaternion for the rotation.
  * \return void
@@ -2757,7 +2757,7 @@ inline void RigidBody::rotateAroundOriginImpl( const Quat& dq )
  * \param angle The rotation angle (radian measure).
  * \return void
  *
- * This function rotates the rigid body around the given global coordiante \a point and changes
+ * This function rotates the rigid body around the given global coordinate \a point and changes
  * both the global position and the orientation/rotation of the rigid body. The rigid body is rotated
  * around the given axis \a axis by \a angle degrees (radian measure).\n
  *
@@ -2797,7 +2797,7 @@ inline void RigidBody::rotateAroundPointImpl( const Vec3& point, const Quat& dq
  * \param angle The rotation angle (radian measure).
  * \return void
  *
- * This function rotates the rigid body around the given global coordiante \a point and changes
+ * This function rotates the rigid body around the given global coordinate \a point and changes
  * both the global position and the orientation/rotation of the rigid body. The rigid body is rotated
  * around the given axis \a axis by \a angle degrees (radian measure).\n
  *
@@ -3016,7 +3016,7 @@ inline bool RigidBody::isSurfaceRelPointImpl( real_t /*px*/, real_t /*py*/, real
 /*!\brief Estimates the point which is farthest in direction \a d.
  *
  * \param d The normalized search direction in world-frame coordinates.
- * \return The support point in world-frame coordinates in direction a\ d.
+ * \return The support point in world-frame coordinates in direction \a d.
  */
 inline Vec3 RigidBody::support(const Vec3& /*d*/) const
 {
@@ -3030,7 +3030,7 @@ inline Vec3 RigidBody::support(const Vec3& /*d*/) const
 /*!\brief Estimates the point which is farthest in direction \a d.
  *
  * \param d The normalized search direction in world-frame coordinates
- * \return The support point in world-frame coordinates in direction a\ d extended by a vector in
+ * \return The support point in world-frame coordinates in direction \a d extended by a vector in
  *         direction \a d of length \a pe::contactThreshold.
  */
 inline Vec3 RigidBody::supportContactThreshold(const Vec3& /*d*/) const
diff --git a/src/pe/rigidbody/Sphere.h b/src/pe/rigidbody/Sphere.h
index a7400fdb7d93d899b6fa686c9e663cacf0a1062b..3a0919266d3a7e760a065816b98b04b9dc026d45 100644
--- a/src/pe/rigidbody/Sphere.h
+++ b/src/pe/rigidbody/Sphere.h
@@ -297,7 +297,7 @@ inline Mat3 Sphere::calcInertia( const real_t mass, const real_t radius )
 /*!\brief Estimates the point which is farthest in direction \a d.
  *
  * \param d The normalized search direction in world-frame coordinates.
- * \return The support point in world-frame coordinates in direction a\ d.
+ * \return The support point in world-frame coordinates in direction \a d.
  */
 inline Vec3 Sphere::support( const Vec3& d ) const
 {
diff --git a/src/pe/rigidbody/SphereFactory.cpp b/src/pe/rigidbody/SphereFactory.cpp
index dfe500daa4d1246a2fedb3de3efcf56b323f6f83..bec349526b3304b087ed1f9342fac60dfceded16 100644
--- a/src/pe/rigidbody/SphereFactory.cpp
+++ b/src/pe/rigidbody/SphereFactory.cpp
@@ -37,7 +37,7 @@ SphereID createSphere( BodyStorage& globalStorage, BlockStorage& blocks, BlockDa
                        MaterialID material,
                        bool global, bool communicating, bool infiniteMass )
 {
-   WALBERLA_ASSERT_UNEQUAL( Sphere::getStaticTypeID(), std::numeric_limits<id_t>::max(), "Sphere TypeID not initalized!");
+   WALBERLA_ASSERT_UNEQUAL( Sphere::getStaticTypeID(), std::numeric_limits<id_t>::max(), "Sphere TypeID not initialized!");
    // Checking the radius
    if( radius <= real_c(0) )
       throw std::invalid_argument( "Invalid sphere radius" );
diff --git a/src/pe/rigidbody/SquirmerFactory.cpp b/src/pe/rigidbody/SquirmerFactory.cpp
index caac4c9a00e3290aeabca4144d2056f4ff32c72d..491ddd86c6d5268c75c673b71902ddd979e11a1a 100644
--- a/src/pe/rigidbody/SquirmerFactory.cpp
+++ b/src/pe/rigidbody/SquirmerFactory.cpp
@@ -36,7 +36,7 @@ SquirmerID createSquirmer( BodyStorage& globalStorage, BlockStorage& blocks, Blo
                         MaterialID material,
                         bool global, bool communicating, bool infiniteMass )
 {
-   WALBERLA_ASSERT_UNEQUAL( Squirmer::getStaticTypeID(), std::numeric_limits<id_t>::max(), "Squirmer TypeID not initalized!");
+   WALBERLA_ASSERT_UNEQUAL( Squirmer::getStaticTypeID(), std::numeric_limits<id_t>::max(), "Squirmer TypeID not initialized!");
    // Checking the radius
    if( radius <= real_c(0) )
       throw std::invalid_argument( "Invalid squirmer radius" );
diff --git a/src/pe/rigidbody/Union.h b/src/pe/rigidbody/Union.h
index 31a224d2602df0e7339307a191f3c144faf67be9..b682f159ab3f6bf7870291e917fe228352ee2888 100644
--- a/src/pe/rigidbody/Union.h
+++ b/src/pe/rigidbody/Union.h
@@ -55,7 +55,7 @@ namespace pe {
 //*************************************************************************************************
 /**
  * \ingroup pe
- * \brief Base class for the union geometry, a rigid assebly of bodies.
+ * \brief Base class for the union geometry, a rigid assembly of bodies.
  *
  * The Union class represents the base class for the sphere geometry.
  * For a full description of the union geometry,
@@ -589,7 +589,7 @@ void Union<BodyTypes...>::setOrientationImpl( real_t r, real_t i, real_t j, real
  *  - Neither the (in-)visibility of the added rigid body nor (in-)visibility of the union will
  *    change due to the add operation. For instance adding a visible rigid body to an invisible
  *    union will not change the visibility of the body. Neither is the visibility of the union
- *    changed. In order to change the visiblity, the setVisible() function can be either called
+ *    changed. In order to change the visibility, the setVisible() function can be either called
  *    individually for the rigid body (to exclusively make the body (in-)visible) or the entire
  *    union (to make the entire union (in-)visible.
  */
@@ -744,7 +744,7 @@ void Union<BodyTypes...>::rotateAroundOriginImpl( const Quat& dq )
  * \return void
  * \exception std::logic_error Invalid rotation of a global union inside an exclusive section.
  *
- * This function rotates the entire union around the given global coordiante \a point and
+ * This function rotates the entire union around the given global coordinate \a point and
  * changes both the global position and the orientation/rotation of the union. Additionally,
  * all contained rigid bodies change their position and orientation accordingly. The orientation
  * of the bodies within the union in reference to the body frame of the union is not changed.
@@ -828,11 +828,11 @@ bool Union<BodyTypes...>::isSurfaceRelPointImpl( real_t px, real_t py, real_t pz
 //=================================================================================================
 
 //*************************************************************************************************
-/*!\brief Signals an internal modification of a contained subordiante rigid body.
+/*!\brief Signals an internal modification of a contained subordinate rigid body.
  *
  * \return void
  *
- * In case one of the contained rigid bodies is interally modified, this function is called to
+ * In case one of the contained rigid bodies is internally modified, this function is called to
  * recalculate the changed properties of the union.
  */
 template <typename... BodyTypes>
@@ -866,7 +866,7 @@ void Union<BodyTypes...>::handleModification()
 
 
 //*************************************************************************************************
-/*!\brief Signals a position change of a contained subordiante rigid body.
+/*!\brief Signals a position change of a contained subordinate rigid body.
  *
  * \return void
  *
@@ -890,7 +890,7 @@ void Union<BodyTypes...>::handleTranslation()
 
 
 //*************************************************************************************************
-/*!\brief Signals an orientation change of a contained subordiante rigid body.
+/*!\brief Signals an orientation change of a contained subordinate rigid body.
  *
  * \return void
  *
diff --git a/src/pe/rigidbody/UnionFactory.h b/src/pe/rigidbody/UnionFactory.h
index 04090a61dfa8e06d05a4f1275ae0bd4270ea28da..13f5eed8a145100d3ca3b4a2e4b9a0efca9a6e41 100644
--- a/src/pe/rigidbody/UnionFactory.h
+++ b/src/pe/rigidbody/UnionFactory.h
@@ -60,7 +60,7 @@ namespace pe {
  * \param communicating specifies if the union should take part in synchronization (syncNextNeighbour, syncShadowOwner)
  * \param infiniteMass specifies if the union has infinite mass and will be treated as an obstacle
  * \return Handle for the new union.
- * \exception std::runtime_error Union TypeID not initalized!
+ * \exception std::runtime_error Union TypeID not initialized!
  *
  * The code example illustrates the setup of a Union. For convenience the following typedefs were made.
  * You can adapt them to your needs.
@@ -73,7 +73,7 @@ Union<BodyTypes...>* createUnion(   BodyStorage& globalStorage, BlockStorage& bl
                                      bool global = false, bool communicating = true, bool infiniteMass = false )
 {
    if (Union<BodyTypes...>::getStaticTypeID() == std::numeric_limits<id_t>::max())
-      throw std::runtime_error("Union TypeID not initalized!");
+      throw std::runtime_error("Union TypeID not initialized!");
 
    Union<BodyTypes...>* bd = nullptr;
 
@@ -117,7 +117,7 @@ Union<BodyTypes...>* createUnion(   BodyStorage& globalStorage, BlockStorage& bl
  * \brief Setup of a new Box directly attached to a Union.
  *
  * \tparam BodyTypes all geometries the Union is able to contain
- * \exception std::runtime_error    Box TypeID not initalized!
+ * \exception std::runtime_error    Box TypeID not initialized!
  * \exception std::invalid_argument createBox: Union argument is NULL
  * \exception std::logic_error      createBox: Union is remote
  * \exception std::invalid_argument Invalid side length
@@ -130,7 +130,7 @@ BoxID createBox( Union<BodyTypes...>* un,
                  bool global = false, bool communicating = true, bool infiniteMass = false )
 {
    if (Box::getStaticTypeID() == std::numeric_limits<id_t>::max())
-      throw std::runtime_error("Box TypeID not initalized!");
+      throw std::runtime_error("Box TypeID not initialized!");
 
    // union not on this process/block -> terminate creation
    if (un == nullptr)
@@ -181,7 +181,7 @@ BoxID createBox( Union<BodyTypes...>* un,
  * \brief Setup of a new Capsule directly attached to a Union.
  *
  * \tparam BodyTypes all geometries the Union is able to contain
- * \exception std::runtime_error    Capsule TypeID not initalized!
+ * \exception std::runtime_error    Capsule TypeID not initialized!
  * \exception std::invalid_argument createCapsule: Union argument is NULL
  * \exception std::logic_error      createCapsule: Union is remote
  * \exception std::invalid_argument Invalid capsule radius
@@ -196,7 +196,7 @@ CapsuleID createCapsule( Union<BodyTypes...>* un,
                          bool global = false, bool communicating = true, bool infiniteMass = false )
 {
    if (Capsule::getStaticTypeID() == std::numeric_limits<id_t>::max())
-      throw std::runtime_error("Capsule TypeID not initalized!");
+      throw std::runtime_error("Capsule TypeID not initialized!");
 
    // union not on this process/block -> terminate creation
    if (un == nullptr)
@@ -243,7 +243,7 @@ CapsuleID createCapsule( Union<BodyTypes...>* un,
  * \brief Setup of a new Sphere directly attached to a Union.
  *
  * \tparam BodyTypes all geometries the Union is able to contain
- * \exception std::runtime_error    Sphere TypeID not initalized!
+ * \exception std::runtime_error    Sphere TypeID not initialized!
  * \exception std::invalid_argument createSphere: Union argument is NULL
  * \exception std::logic_error      createSphere: Union is remote
  * \exception std::invalid_argument Invalid sphere radius
@@ -257,7 +257,7 @@ SphereID createSphere( Union<BodyTypes...>* un,
                        bool global = false, bool communicating = true, bool infiniteMass = false )
 {
    if (Sphere::getStaticTypeID() == std::numeric_limits<id_t>::max())
-      throw std::runtime_error("Sphere TypeID not initalized!");
+      throw std::runtime_error("Sphere TypeID not initialized!");
 
    // union not on this process/block -> terminate creation
    if (un == nullptr)
diff --git a/src/pe/statistics/BodyStatistics.cpp b/src/pe/statistics/BodyStatistics.cpp
index e76910eff77b6ec92b0bb35b9e0c6414c1895a96..ad599f239324e0c2f1f37d931683360b52c6052f 100644
--- a/src/pe/statistics/BodyStatistics.cpp
+++ b/src/pe/statistics/BodyStatistics.cpp
@@ -78,7 +78,7 @@ void BodyStatistics::operator()()
 void BodyStatistics::toStream( std::ostream & os ) const
 {
    os << "Number of bodies:           " << numBodies_ << "\n" <<
-         "Number of shodow copies:    " << numShadowCopies_ << "\n" <<
+         "Number of shadow copies:    " << numShadowCopies_ << "\n" <<
          "Bodies on blocks:           " << localBodiesBlockSample_.format() << "\n" <<
          "Shadow copies on blocks:    " << shadowBodiesBlockSample_.format() << "\n" <<
          "Bodies on processes:        " << localBodiesProcessSample_.format() << "\n" <<
diff --git a/src/pe/synchronization/SyncShadowOwners.h b/src/pe/synchronization/SyncShadowOwners.h
index 32669e30349f6c4e72be0ffde47cce56d08b412f..721ba255e70da54a868f3591d784553ca295231a 100644
--- a/src/pe/synchronization/SyncShadowOwners.h
+++ b/src/pe/synchronization/SyncShadowOwners.h
@@ -254,10 +254,10 @@ void checkAndResolveOverlap( BlockForest& forest, BlockDataID storageID, const r
 
             if (b->MPITrait.getOwner() == nbProcess) continue; // dont send to owner!!
             if (b->MPITrait.getBlockState( nbProcess.blockID_ )) continue; // only send to neighbor which do not know this body
-            //            WALBERLA_LOG_DEVEL("neighobur aabb: " << block.getNeighborAABB(nb));
+            //            WALBERLA_LOG_DEVEL("neighbor aabb: " << block.getNeighborAABB(nb));
             //            WALBERLA_LOG_DEVEL("isInsideDomain: " << isInsideDomain);
             //            WALBERLA_LOG_DEVEL("body AABB: " << b->getAABB());
-            //            WALBERLA_LOG_DEVEL("neighbour AABB: " << block.getNeighborAABB(nb));
+            //            WALBERLA_LOG_DEVEL("neighbor AABB: " << block.getNeighborAABB(nb));
 
             if( (isInsideDomain ? block.getNeighborAABB(nb).intersects( b->getAABB(), dx ) : block.getBlockStorage().periodicIntersect(block.getNeighborAABB(nb), b->getAABB(), dx)) )
             {
diff --git a/src/pe_coupling/mapping/BodyBBMapping.cpp b/src/pe_coupling/mapping/BodyBBMapping.cpp
index 41d5e0c10803c49a031bddd6fe6e4b021f2ae158..6058c3b5c621ab1f0bf1404e4f74e0dcbfc81f6b 100644
--- a/src/pe_coupling/mapping/BodyBBMapping.cpp
+++ b/src/pe_coupling/mapping/BodyBBMapping.cpp
@@ -53,7 +53,7 @@ CellInterval getCellBB( const pe::ConstBodyID body, const IBlock & block, Struct
                                                  real_c(numberOfGhostLayersToInclude) * dz);
       auto extendedBlockAABB = blockStorage.getAABB(block.getId()).getExtended( aabbExtensionByGhostLayers );
 
-      // intersect the infinte (global) body with the block AABB, extended by its ghost layers
+      // intersect the infinite (global) body with the block AABB, extended by its ghost layers
       // then determine the cell bounding box of the intersection
       blockStorage.getCellBBFromAABB( cellBB, body->getAABB().getIntersection( extendedBlockAABB ), level );
 
diff --git a/src/pe_coupling/partially_saturated_cells_method/PSMUtility.h b/src/pe_coupling/partially_saturated_cells_method/PSMUtility.h
index b78a4e45f94dcbe31c2741ebadc55e27ebcbb4c6..52ece45971da8bef135b9663d41cebc712e947c4 100644
--- a/src/pe_coupling/partially_saturated_cells_method/PSMUtility.h
+++ b/src/pe_coupling/partially_saturated_cells_method/PSMUtility.h
@@ -33,7 +33,7 @@ namespace pe_coupling {
 /*!\brief Evaluates the macroscopic velocity for a given cell when using the PSM method.
  *
  * returns the cell local macroscopic velocity for the PSM method
- * cell local velocity = (1-\sum_s B_s) * u + \sum_s B_s * v_s
+ * cell local velocity = \f$ (1-\sum_s B_s) * u + \sum_s B_s * v_s \f$
  * u = fluid velocity
  * v_s = velocity of object s at cell center
  *
diff --git a/src/postprocessing/FieldToSurfaceMesh.h b/src/postprocessing/FieldToSurfaceMesh.h
index 75f2577e2f3ab2294b891a9ed9817620667b35e1..5fe433dd1566a6c03043e15345c82fbc51a8dc47 100644
--- a/src/postprocessing/FieldToSurfaceMesh.h
+++ b/src/postprocessing/FieldToSurfaceMesh.h
@@ -62,7 +62,7 @@ namespace postprocessing {
       static_assert( Field_T::F_SIZE == 1, "Works only for FlagFields" );
 
 
-      // Do not use ghost layer information in non-perdiodic directions
+      // Do not use ghost layer information in non-periodic directions
       CellInterval domainCellBB = bs->getDomainCellBB();
       for( size_t i=0; i<3; ++i )
          if ( ! bs->isPeriodic( i) )
@@ -125,7 +125,7 @@ namespace postprocessing {
       auto mesh = make_shared<geometry::TriangleMesh> ();
 
 
-      // Do not use ghost layer information in non-perdiodic directions
+      // Do not use ghost layer information in non-periodic directions
       CellInterval domainCellBB = bs->getDomainCellBB();
       for( size_t i=0; i<3; ++i )
          if ( ! bs->isPeriodic( i) )
diff --git a/src/python_coupling/DictWrapper.h b/src/python_coupling/DictWrapper.h
index c3e1c2686b647f7f52c4522784cf772584fa1d8b..c7f1f9511b2b8ef31f2bb01a57f702c14ee7704f 100644
--- a/src/python_coupling/DictWrapper.h
+++ b/src/python_coupling/DictWrapper.h
@@ -92,7 +92,7 @@ namespace python_coupling {
    template<typename T> bool DictWrapper::checkedGet( const std::string & name, T output ) { return false; }
 
    template<typename T> T DictWrapper::get( const std::string & ) {
-      WALBERLA_ABORT("Not available - waLBerla was built without Python suppport");
+      WALBERLA_ABORT("Not available - waLBerla was built without Python support");
 #ifdef __IBMCPP__
       return *(reinterpret_cast< T * >( NULL )); // silencing incorrect IBM compiler warning
 #endif
diff --git a/src/python_coupling/PythonCallback.h b/src/python_coupling/PythonCallback.h
index 9eeaec6505516b6e80b9aa3b0fdd341912bc0d29..5d7aeb48cdb396e5531248bc0040c78cb5a3f526 100644
--- a/src/python_coupling/PythonCallback.h
+++ b/src/python_coupling/PythonCallback.h
@@ -63,7 +63,9 @@ namespace python_coupling {
    *
    *  This example calls the python function "walberla_cpp.callbacks.atEndOfTimestep", which can be either
    *  set directly or using a decorator:
+   *  \code
    *     @waLBerla.callback( "atEndOfTimestep" )
+   *  \endcode
    *
    *
    *
diff --git a/src/python_coupling/export/BasicExport.cpp b/src/python_coupling/export/BasicExport.cpp
index c4fad8eb6cf39d9442ddbbe46e4e278d5e738a4d..29dd8a4934c309287e2abdaf2db566919b0ad538 100644
--- a/src/python_coupling/export/BasicExport.cpp
+++ b/src/python_coupling/export/BasicExport.cpp
@@ -709,7 +709,7 @@ void exportBasicWalberlaDatastructures(py::module_ &m)
    exportStencilDirections(m);
 
    // Add empty callbacks module
-   m.def_submodule("callbacks", "Empty callbacks module. Needed for the Szenario manager");
+   m.def_submodule("callbacks", "Empty callbacks module. Needed for the Scenario manager");
 
 }
 
diff --git a/src/python_coupling/export/GatherExport.impl.h b/src/python_coupling/export/GatherExport.impl.h
index 6d567f0756658a92175ff60eca8873a066eb9963..cc7de19a7be15e432f40516b8e092d13a27f98dc 100644
--- a/src/python_coupling/export/GatherExport.impl.h
+++ b/src/python_coupling/export/GatherExport.impl.h
@@ -30,12 +30,12 @@ namespace walberla {
 namespace field {
 
 //*******************************************************************************************************************
-/*! Exports the gather functionality of waLberla
+/*! Exports the gather functionality of waLBerla
 *
 * With field.gather a corresponding field will the gathered to the specified process. This field can be viewed as a
-* numpy array with field.toArrayOn all other porcesses an empty pybind11::object will be returned.
+* numpy array with field.toArrayOn all other processes an empty pybind11::object will be returned.
 *
-* \hint For large scale simulations it is also possible to provide a slice to keep the gathered data low!
+* \note For large scale simulations it is also possible to provide a slice to keep the gathered data low!
 */
 //*******************************************************************************************************************
 namespace py = pybind11;
diff --git a/src/python_coupling/helper/SliceToCellInterval.h b/src/python_coupling/helper/SliceToCellInterval.h
index fd0a7ecdc5c2fa4c800b370131e5ea1070bfc786..cf9ea3c33fe4f8daa8dcb10ff3143d0078f3bcf1 100644
--- a/src/python_coupling/helper/SliceToCellInterval.h
+++ b/src/python_coupling/helper/SliceToCellInterval.h
@@ -65,7 +65,7 @@ inline cell_idx_t normalizeIdx(py::object pyIndex, uint_t coordinateSize)
  *     Example: Python Slice: [ :, 3, -1 ]  and a domain size of ( 3,4,5 )
  *                 - x coordinate is the complete valid x-range indicated by the semicolon: i.e. [0,3)
  *                 - y coordinate is just a normal index i.e. the range from [3,4)
- *                 - z coordiante is the first valid coordinate from the back [4,5)
+ *                 - z coordinate is the first valid coordinate from the back [4,5)
  *
  *     Python slices are tuples with slice classes as entry. Each slice has start, stop and step.
  *     Steps are not supported since they can not be encoded in a CellInterval
diff --git a/src/simd/IntelVecTypesCppOperators.h b/src/simd/IntelVecTypesCppOperators.h
index 55961a441dfbe4ec04e860a309c1b26a429dc984..f43903528cbd781f2958182b934b415c2e077d1b 100644
--- a/src/simd/IntelVecTypesCppOperators.h
+++ b/src/simd/IntelVecTypesCppOperators.h
@@ -16,7 +16,7 @@
 //! \file IntelVecTypesCppOperators.h
 //! \ingroup avx
 //! \author Martin Bauer <martin.bauer@fau.de>
-//! \brief C++ Operators for the Intel intrinsiscs vector types
+//! \brief C++ Operators for the Intel intrinsics vector types
 //
 //======================================================================================================================
 
diff --git a/src/timeloop/SweepTimeloop.cpp b/src/timeloop/SweepTimeloop.cpp
index 15b40719112fceed4775077f5953d5102a12a509..ba8032391781725d91cfde27d7c17d5fc5788943 100644
--- a/src/timeloop/SweepTimeloop.cpp
+++ b/src/timeloop/SweepTimeloop.cpp
@@ -86,7 +86,7 @@ void SweepTimeloop::doTimeStep(const Set<SUID> &selectors, WcTimingPool &timing)
       for( auto sweepIt = sweeps_.begin(); sweepIt != sweeps_.end(); ++sweepIt )
       {
          SweepAdder & s = * ( sweepIt->second );
-         // loop over all possibilites in selectable object
+         // loop over all possibilities in selectable object
          for( auto it = s.sweep.begin(); it != s.sweep.end(); ++it )
             timing.registerTimer( it.identifier() );
       }
diff --git a/src/timeloop/SweepTimeloop.h b/src/timeloop/SweepTimeloop.h
index 3bd6c1488092c6f8528db3f73417600828599e11..4ffc8df9e0937ff9b5dd5a2cbcea0b4407078c2b 100644
--- a/src/timeloop/SweepTimeloop.h
+++ b/src/timeloop/SweepTimeloop.h
@@ -49,7 +49,7 @@ namespace timeloop {
     *
     * \section sweepTimeloop_simple Simple Registration
     *
-    * When registering sweeps (even without Selectable concept) the syntax may seem a litte strange.
+    * When registering sweeps (even without Selectable concept) the syntax may seem a little strange.
     * Lets do an example where we register simple C functions as sweeps:
       \code
       // The callback functions
diff --git a/tests/lbm/BoundaryHandlingCommunication.cpp b/tests/lbm/BoundaryHandlingCommunication.cpp
index 6529e69134df4a6ea185864883f86ed4b7bfe9fb..9d4ba72aaa76fb1982bf2d6ba05bd13b32ddeafb 100644
--- a/tests/lbm/BoundaryHandlingCommunication.cpp
+++ b/tests/lbm/BoundaryHandlingCommunication.cpp
@@ -251,7 +251,7 @@ int main( int argc, char ** argv )
                                                       uint_t(12), uint_t(9), uint_t(11),
                                                       real_c(1.0),
                                                       uint_t(2),  uint_t(2),  uint_t(2),
-                                                      true, false, false ); // periodicty
+                                                      true, false, false ); // periodicity
 
    const real_t velocity = real_t(0.0005);
 
diff --git a/tests/lbm/SweepEquivalenceTest.cpp b/tests/lbm/SweepEquivalenceTest.cpp
index 091033dabda9f72e8cde20c887b95efe48a5b68a..71f4d739e94696d2f43729050b2549c22c34edf3 100644
--- a/tests/lbm/SweepEquivalenceTest.cpp
+++ b/tests/lbm/SweepEquivalenceTest.cpp
@@ -338,7 +338,7 @@ int main( int argc, char ** argv )
    auto blocks = blockforest::createUniformBlockGrid( uint_t(1), uint_t(1), uint_t(1),
                                                       FieldSize, FieldSize, FieldSize,
                                                       real_c(1.0), true,
-                                                      true, true, false ); // periodicty
+                                                      true, true, false ); // periodicity
 
    BlockDataID flagFieldId = field::addFlagFieldToStorage< FlagField_T >( blocks, "flag field" );
 
diff --git a/tests/lbm/evaluations/PermeabilityTest.cpp b/tests/lbm/evaluations/PermeabilityTest.cpp
index cb224e30fe8f837110de353ca10a0051c56881d1..2cc1fffafc70721dee63b0143e588542e663dcf0 100644
--- a/tests/lbm/evaluations/PermeabilityTest.cpp
+++ b/tests/lbm/evaluations/PermeabilityTest.cpp
@@ -77,7 +77,7 @@ struct Setup
    real_t epsilon;
    // LBM omega value
    real_t omega;
-   // denstiy (pressure) difference applied at domain borders
+   // density (pressure) difference applied at domain borders
    real_t rhoDiff;
    // control parameter for BCC scenario
    real_t kappa;
diff --git a/tests/lbm_mesapd_coupling/momentum_exchange_method/DragForceSphere.cpp b/tests/lbm_mesapd_coupling/momentum_exchange_method/DragForceSphere.cpp
index 18c91bd3ddbdbf45bc5bebc63782a999d9f9f450..d6c317521cd63cde70f3c94c237ea23ecf600525 100644
--- a/tests/lbm_mesapd_coupling/momentum_exchange_method/DragForceSphere.cpp
+++ b/tests/lbm_mesapd_coupling/momentum_exchange_method/DragForceSphere.cpp
@@ -336,14 +336,17 @@ private:
  *
  * The drag force for this problem (often denoted as Simple Cubic setup) is given by a semi-analytical series expansion.
  * The cubic domain is periodic in all directions, making it a physically infinite periodic array of spheres.
- *         _______________
- *      ->|               |->
- *      ->|      ___      |->
- *    W ->|     /   \     |-> E
- *    E ->|    |  x  |    |-> A
- *    S ->|     \___/     |-> S
- *    T ->|               |-> T
- *      ->|_______________|->
+   \verbatim
+           _______________
+        ->|               |->
+        ->|      ___      |->
+      W ->|     /   \     |-> E
+      E ->|    |  x  |    |-> A
+      S ->|     \___/     |-> S
+      T ->|               |-> T
+        ->|_______________|->
+
+   \endverbatim
  *
  * The collision model used for the LBM is TRT with a relaxation parameter tau=1.5 and the magic parameter 3/16.
  * The Stokes approximation of the equilibrium PDFs is used.
diff --git a/tests/lbm_mesapd_coupling/momentum_exchange_method/ForceBetweenTwoStationaryObjects.cpp b/tests/lbm_mesapd_coupling/momentum_exchange_method/ForceBetweenTwoStationaryObjects.cpp
index 8e994002b926f320cad0d631dbcb61b2ecae61e8..6034afaef3ebdb17e66340885e2766a2f979dd68 100644
--- a/tests/lbm_mesapd_coupling/momentum_exchange_method/ForceBetweenTwoStationaryObjects.cpp
+++ b/tests/lbm_mesapd_coupling/momentum_exchange_method/ForceBetweenTwoStationaryObjects.cpp
@@ -276,7 +276,7 @@ void createSimulationSetup( shared_ptr< StructuredBlockForest > blocks, shared_p
  * This can also be seen as an implicit reconstruction of the PDFs in the missing cells with feq(0, vec(0)).
  * As such, it can/will lead to errors if the velocity of the obstacle covering the missing cells is different from the
  * surrounding flow. In that case, an explicit reconstruction like in Ernst et al. should be applied, which however will
- * change the algorithm, as the computation of the force components can probbaly no longer be fused with the boundary handling.
+ * change the algorithm, as the computation of the force components can probably no longer be fused with the boundary handling.
  *
  * Tested variants:
  *  - boundary condition: SimpleBB, CLI
diff --git a/tests/mesa_pd/ContactDetection.cpp b/tests/mesa_pd/ContactDetection.cpp
index 94d6c757514feb3adcf3fc10d77d06387c4e4f8d..65196877218ce561dcd8fe17bd83dac8a27d9fd3 100644
--- a/tests/mesa_pd/ContactDetection.cpp
+++ b/tests/mesa_pd/ContactDetection.cpp
@@ -98,7 +98,7 @@ int main( const int particlesPerAxisPerProcess = 2 )
    WALBERLA_LOG_DEVEL_VAR_ON_ROOT(cornerParticles);
 
    // create forest
-   const real_t eps = real_c(0.01); //shift to make contact points unambigous
+   const real_t eps = real_c(0.01); //shift to make contact points unambiguous
    Vector3<uint_t>blocksPerDirection (2,2,2);
    int numBlocks = int(blocksPerDirection[0] * blocksPerDirection[1] * blocksPerDirection[2]);
    Vector3<bool> periodicity(true, true, true);
diff --git a/tests/mesa_pd/collision_detection/ConvexPolyhedron_GJK_EPA.cpp b/tests/mesa_pd/collision_detection/ConvexPolyhedron_GJK_EPA.cpp
index 2436e89684373784ef13cc1ce43e751ee4e74c96..83d68f83e9cebc31749a83e5efcd38c31587fa53 100644
--- a/tests/mesa_pd/collision_detection/ConvexPolyhedron_GJK_EPA.cpp
+++ b/tests/mesa_pd/collision_detection/ConvexPolyhedron_GJK_EPA.cpp
@@ -42,7 +42,7 @@ using namespace walberla::mesa_pd::data;
 bool gjkEPAcollideHybrid(Support &geom1, Support &geom2, Vec3& normal, Vec3& contactPoint, real_t& penetrationDepth) {
    // This function is stolen from the general mesapd GJK-EPA test.
 
-   // For more information on hybrid GJK/EPA see page 166 in "Collision Detecton in Interactive 3D
+   // For more information on hybrid GJK/EPA see page 166 in "Collision Detection in Interactive 3D
    // Environments" by Gino van den Bergen.
 
    //1. Run GJK with considerably enlarged objects.
@@ -50,7 +50,7 @@ bool gjkEPAcollideHybrid(Support &geom1, Support &geom2, Vec3& normal, Vec3& con
    GJK gjk;
    if(gjk.doGJKmargin(geom1, geom2, margin)){
       //2. If collision is possible perform EPA.
-      //std::cerr << "Peforming EPA.";
+      //std::cerr << "Performing EPA.";
       EPA epa;
       epa.useSphereOptimization( true );
       return epa.doEPAmargin(geom1, geom2, gjk, normal, contactPoint, penetrationDepth, margin);
diff --git a/tests/mesa_pd/collision_detection/GJK_EPA.cpp b/tests/mesa_pd/collision_detection/GJK_EPA.cpp
index 998276419fa39744a1d9251dddc6466375a569e5..4bf43098e975634bbbfae5ac7bfcd0f625134494 100644
--- a/tests/mesa_pd/collision_detection/GJK_EPA.cpp
+++ b/tests/mesa_pd/collision_detection/GJK_EPA.cpp
@@ -41,7 +41,7 @@ using namespace walberla::mesa_pd::collision_detection::analytic;
 
 bool gjkEPAcollideHybrid(Support &geom1, Support &geom2, Vec3& normal, Vec3& contactPoint, real_t& penetrationDepth)
 {
-   // For more information on hybrid GJK/EPA see page 166 in "Collision Detecton in Interactive 3D
+   // For more information on hybrid GJK/EPA see page 166 in "Collision Detection in Interactive 3D
    // Environments" by Gino van den Bergen.
 
    //1. Run GJK with considerably enlarged objects.
@@ -49,7 +49,7 @@ bool gjkEPAcollideHybrid(Support &geom1, Support &geom2, Vec3& normal, Vec3& con
    GJK gjk;
    if(gjk.doGJKmargin(geom1, geom2, margin)){
       //2. If collision is possible perform EPA.
-      //std::cerr << "Peforming EPA.";
+      //std::cerr << "Performing EPA.";
       EPA epa;
       epa.useSphereOptimization( true );
       return epa.doEPAmargin(geom1, geom2, gjk, normal, contactPoint, penetrationDepth, margin);
@@ -143,8 +143,8 @@ void runCollisionDataTest(Support &rb1, Support &rb2, const Vec3& dir1, const re
    }
 }
 
-/** Test the GJK-EPA implementation on a variety of configuations 
- * and penetation depths */
+/** Test the GJK-EPA implementation on a variety of configurations
+ * and penetration depths */
 void MainTest()
 {
    using namespace walberla::mesa_pd::data;
diff --git a/tests/mesa_pd/kernel/CoefficientOfRestitutionLSD.cpp b/tests/mesa_pd/kernel/CoefficientOfRestitutionLSD.cpp
index a9cb84564f6d559a808eeedbb9b6357bbd1d1bbd..b425ece1be55911c6733ec3f09442459e8cf6029 100644
--- a/tests/mesa_pd/kernel/CoefficientOfRestitutionLSD.cpp
+++ b/tests/mesa_pd/kernel/CoefficientOfRestitutionLSD.cpp
@@ -61,7 +61,7 @@ private:
 /*
  * Tests the integrator accuracy for a DEM simulation by comparing the given coefficient of restitution to the simulated one.
  * For that, the velocity after a single sphere-wall collision is divided by the initial velocity before the simulation.
- * The parameters of the DEM are chosen such as to (analytically) yield the desried coefficient of restitution.
+ * The parameters of the DEM are chosen such as to (analytically) yield the desired coefficient of restitution.
  *
  * The simulation can be adapted via command line arguments.
  *
diff --git a/tests/mesa_pd/kernel/CoefficientOfRestitutionNLSD.cpp b/tests/mesa_pd/kernel/CoefficientOfRestitutionNLSD.cpp
index 5912892af2b3df1351804f433dea1b3f4d402790..25e47423b4c9f8a4d39c39913c6a7a3796f78047 100644
--- a/tests/mesa_pd/kernel/CoefficientOfRestitutionNLSD.cpp
+++ b/tests/mesa_pd/kernel/CoefficientOfRestitutionNLSD.cpp
@@ -62,7 +62,7 @@ private:
 /*
  * Tests the integrator accuracy for a DEM simulation by comparing the given coefficient of restitution to the simulated one.
  * For that, the velocity after a single sphere-wall collision is divided by the initial velocity before the simulation.
- * The parameters of the DEM are chosen such as to (analytically) yield the desried coefficient of restitution.
+ * The parameters of the DEM are chosen such as to (analytically) yield the desired coefficient of restitution.
  *
  * The simulation can be adapted via command line arguments.
  *
diff --git a/tests/mesa_pd/kernel/CoefficientOfRestitutionSD.cpp b/tests/mesa_pd/kernel/CoefficientOfRestitutionSD.cpp
index 00fb530524ebaf88be3dca3754aed6e4ad86d5a1..7bed1e98502c000fc8def474b688b5144dc77808 100644
--- a/tests/mesa_pd/kernel/CoefficientOfRestitutionSD.cpp
+++ b/tests/mesa_pd/kernel/CoefficientOfRestitutionSD.cpp
@@ -61,7 +61,7 @@ private:
 /*
  * Tests the integrator accuracy for a DEM simulation by comparing the given coefficient of restitution to the simulated one.
  * For that, the velocity after a single sphere-wall collision is divided by the initial velocity before the simulation.
- * The parameters of the DEM are chosen such as to (analytically) yield the desried coefficient of restitution.
+ * The parameters of the DEM are chosen such as to (analytically) yield the desired coefficient of restitution.
  *
  * The simulation can be adapted via command line arguments.
  *
diff --git a/tests/mesa_pd/kernel/ForceLJ.cpp b/tests/mesa_pd/kernel/ForceLJ.cpp
index adcb643cd4c90f4db741f226245f97f8959b983b..026745ee91f2bdeb8f19bcdf18f3dcc9ef47856c 100644
--- a/tests/mesa_pd/kernel/ForceLJ.cpp
+++ b/tests/mesa_pd/kernel/ForceLJ.cpp
@@ -95,7 +95,7 @@ int main( int argc, char ** argv )
    WALBERLA_CHECK_LESS   ( p1.getForce()[0], real_t(0), p1 << p2 );
    WALBERLA_CHECK_GREATER( p2.getForce()[0], real_t(0), p1 << p2 );
 
-   //action = reactio
+   //action = reaction
    p1.getForceRef()           = Vec3(0,0,0);
    p2.getForceRef()           = Vec3(0,0,0);
    p2.getPositionRef()        = Vec3( 1, 2, 3) * real_t(0.1);
diff --git a/tests/mesa_pd/kernel/HCSITSKernels.cpp b/tests/mesa_pd/kernel/HCSITSKernels.cpp
index dc26956395e64a6623613ef7dff38a7321e755d2..297f6c25b46cddef4d6c3fbe15ef8c5023a63052 100644
--- a/tests/mesa_pd/kernel/HCSITSKernels.cpp
+++ b/tests/mesa_pd/kernel/HCSITSKernels.cpp
@@ -260,8 +260,8 @@ void normalReactionTest(kernel::HCSITSRelaxationStep::RelaxationModel model)
 
 
 /**Check hard contact constraints on two overlapping, colliding spheres
- * Works only for the solvers that really archieve seperation after a single
- * timestep. Use SphereSeperationTest to check for seperation after multiple
+ * Works only for the solvers that really achieve separation after a single
+ * timestep. Use SphereSeperationTest to check for separation after multiple
  * timesteps.
  * @param model The collision model to use.
  * */
@@ -360,10 +360,10 @@ void SphereSeperationTest(kernel::HCSITSRelaxationStep::RelaxationModel model){
       WALBERLA_LOG_INFO(p2->getLinearVelocity());
       solveCount ++;
       if(solveCount==maxIter){
-         WALBERLA_CHECK(false, "Seperation did not occur after " << maxIter << " Iterations performed.");
+         WALBERLA_CHECK(false, "Separation did not occur after " << maxIter << " Iterations performed.");
       }
    }
-   WALBERLA_LOG_INFO("Seperation achieved after " << solveCount << " iterations.");
+   WALBERLA_LOG_INFO("Separation achieved after " << solveCount << " iterations.");
 }
 
 /**
diff --git a/tests/mesa_pd/kernel/LinearSpringDashpot.cpp b/tests/mesa_pd/kernel/LinearSpringDashpot.cpp
index 0b749b822dcee35737060803593e528a95380565..bf14293e0e1a27fcb6caf981ab80d50d6293e98d 100644
--- a/tests/mesa_pd/kernel/LinearSpringDashpot.cpp
+++ b/tests/mesa_pd/kernel/LinearSpringDashpot.cpp
@@ -116,7 +116,7 @@ int main( int argc, char ** argv )
    const real_t Mij = particleMass; // * particleMass / ( real_t(2) * particleMass ); // Mij = M for sphere-wall collision
    const real_t lnDryResCoeff = std::log(restitutionCoeff);
 
-   // normal material aprameters
+   // normal material parameters
    const real_t stiffnessN = math::pi * math::pi * Mij / ( collisionTime * collisionTime * ( real_t(1) - lnDryResCoeff * lnDryResCoeff / ( math::pi * math::pi + lnDryResCoeff* lnDryResCoeff ))  );
    const real_t dampingN = - real_t(2) * std::sqrt( Mij * stiffnessN ) *
    ( lnDryResCoeff / std::sqrt( math::pi * math::pi + ( lnDryResCoeff * lnDryResCoeff ) ) );
diff --git a/tests/pde/MGConvergenceTest.cpp b/tests/pde/MGConvergenceTest.cpp
index f9643a83fc02bd10ff2ab4046d8afa02e6ef0761..c5c66aae1a365252d2e5bd48daab89936540f0f8 100644
--- a/tests/pde/MGConvergenceTest.cpp
+++ b/tests/pde/MGConvergenceTest.cpp
@@ -83,7 +83,7 @@ void initU( const shared_ptr< StructuredBlockStorage > & blocks, const BlockData
     // Set mean value to zero //
     uint_t numCells(0);
     
-    // Initalizing non-zero block with a given value in center of domain, relative to domain extension
+    // Initializing non-zero block with a given value in center of domain, relative to domain extension
     for( auto block = blocks->begin(); block != blocks->end(); ++block )
     {
         PdeField_T * u = block->getData< PdeField_T >( uId );
diff --git a/tests/pe/CollisionTobiasGJK.cpp b/tests/pe/CollisionTobiasGJK.cpp
index a2de970709a85388bef0015e45d3be666f08d844..34c29676c78c43dff486c9f1bdd249917aa6acf7 100644
--- a/tests/pe/CollisionTobiasGJK.cpp
+++ b/tests/pe/CollisionTobiasGJK.cpp
@@ -54,7 +54,7 @@ typedef std::tuple<Box, Capsule, Plane, Sphere, Union<Sphere>, Union<Sphere, Uni
 bool gjkEPAcollideHybrid(GeomPrimitive &geom1, GeomPrimitive &geom2, Vec3& normal, Vec3& contactPoint, real_t& penetrationDepth)
 {
    using namespace walberla::pe::fcd;
-   // For more information on hybrid GJK/EPA see page 166 in "Collision Detecton in Interactive 3D
+   // For more information on hybrid GJK/EPA see page 166 in "Collision Detection in Interactive 3D
    // Environments" by Gino van den Bergen.
 
    //1. Run GJK with considerably enlarged objects.
@@ -62,7 +62,7 @@ bool gjkEPAcollideHybrid(GeomPrimitive &geom1, GeomPrimitive &geom2, Vec3& norma
    GJK gjk;
    if(gjk.doGJKmargin(geom1, geom2, margin)){
       //2. If collision is possible perform EPA.
-      //std::cerr << "Peforming EPA.";
+      //std::cerr << "Performing EPA.";
       EPA epa;
       epa.useSphereOptimization( true );
       return epa.doEPAmargin(geom1, geom2, gjk, normal, contactPoint, penetrationDepth, margin);
@@ -153,8 +153,8 @@ void runCollisionDataTest(GeomPrimitive &rb1, GeomPrimitive &rb2, const Vec3& di
    }
 }
 
-/** Test the GJK-EPA implementation on a variety of configuations 
- * and penetation depths */
+/** Test the GJK-EPA implementation on a variety of configurations
+ * and penetration depths */
 void MainTest()
 {
    MaterialID iron = Material::find("iron");
@@ -442,4 +442,4 @@ int main( int argc, char** argv )
 int main( int argc, char* argv[] )
 {
   return walberla::main( argc, argv );
-}
\ No newline at end of file
+}
diff --git a/tests/pe/PeDocumentationSnippets.cpp b/tests/pe/PeDocumentationSnippets.cpp
index 6c4e49c51ef1a900efe6b0f5c8bcc7631ee519f4..b800d5984d978fa412ad971d6048c4c7c6e91ab7 100644
--- a/tests/pe/PeDocumentationSnippets.cpp
+++ b/tests/pe/PeDocumentationSnippets.cpp
@@ -101,7 +101,7 @@ int main( int argc, char ** argv )
    //! [Create a Box]
 
    //! [Create a Capsule]
-   // Create a capsule and rotate it after successfull creation.
+   // Create a capsule and rotate it after successful creation.
    CapsuleID capsule = createCapsule( *globalBodyStorage, forest->getBlockStorage(), storageID, 1, Vec3(2,3,4), real_t(1), real_t(1) );
    if (capsule != nullptr)
       capsule->rotate( 0.0, real_c(math::pi/3.0), 0.0 );
@@ -114,7 +114,7 @@ int main( int argc, char ** argv )
    WALBERLA_UNUSED( plane );
 
    //! [Create a Sphere]
-   // Create a sphere and rotate it after successfull creation.
+   // Create a sphere and rotate it after successful creation.
    SphereID sphere = createSphere( *globalBodyStorage, forest->getBlockStorage(), storageID, 1, Vec3(2,3,4), real_t(1) );
    if (sphere != nullptr)
       sphere->rotate( 0.0, real_c(math::pi/3.0), 0.0 );
diff --git a/tests/pe/RaytracingIntersection.cpp b/tests/pe/RaytracingIntersection.cpp
index 08b9a980c5193f607ca6aa8f4f36e9b787fbbe13..6b770805b71464052832c39393498d69c4d9287e 100644
--- a/tests/pe/RaytracingIntersection.cpp
+++ b/tests/pe/RaytracingIntersection.cpp
@@ -103,7 +103,7 @@ void PlaneIntersectsTest() {
    
    // plane with center 3,3,3 and parallel to x-z plane
    Plane pl2(1, 1, Vec3(3, 3, 3), Vec3(0, 1, 0), real_t(1.0), iron);
-   WALBERLA_CHECK(!intersects(&pl2, ray1, t, n), "ray parallel to plane shouldnt hit");
+   WALBERLA_CHECK(!intersects(&pl2, ray1, t, n), "ray parallel to plane shouldn't hit");
    
    // plane with center -10,3,3 and parallel to y-z plane
    Plane pl4(1, 1, Vec3(-10, 3, 3), Vec3(1, 0, 0), real_t(1.0), iron);
@@ -111,7 +111,7 @@ void PlaneIntersectsTest() {
    
    Plane pl6(1, 1, Vec3(3, 3, 0), Vec3(-1, 0, 0), real_t(1.0), iron);
    Ray ray4(Vec3(0,0,5), Vec3(1, 0, -1).getNormalized());
-   WALBERLA_CHECK(intersects(&pl6, ray4, t, n), "ray didnt hit");
+   WALBERLA_CHECK(intersects(&pl6, ray4, t, n), "ray didn't hit");
    WALBERLA_CHECK_FLOAT_EQUAL(n[0], real_t(-1), "incorrect normal calculated");
    WALBERLA_CHECK_FLOAT_EQUAL(n[1], real_t(0), "incorrect normal calculated");
    WALBERLA_CHECK_FLOAT_EQUAL(n[2], real_t(0), "incorrect normal calculated");
diff --git a/tests/pe/Synchronization.cpp b/tests/pe/Synchronization.cpp
index 67dd068321b7d0cd72b86732349cd368548befe7..e592f2b399de8a89df2ac03ec5b42c4e54bd001c 100644
--- a/tests/pe/Synchronization.cpp
+++ b/tests/pe/Synchronization.cpp
@@ -142,7 +142,7 @@ int main( int argc, char ** argv )
       }
    }
    mpi::broadcastObject(sid, sphereRank);
-   WALBERLA_LOG_DETAIL("sphere with sid " << sid << " is loacted on rank " << sphereRank);
+   WALBERLA_LOG_DETAIL("sphere with sid " << sid << " is located on rank " << sphereRank);
 
    WALBERLA_LOG_PROGRESS("*********************** [1 1 1] TEST ***********************");
    syncNextNeighbors<BodyTuple>(forest->getBlockForest(), storageID);
diff --git a/tests/pe/SynchronizationLargeBody.cpp b/tests/pe/SynchronizationLargeBody.cpp
index 94e205db7e8fba495ee8610bd286fd83d646a9cf..d5fd5bd8580d94ed62a77a8b98134454d5a53917 100644
--- a/tests/pe/SynchronizationLargeBody.cpp
+++ b/tests/pe/SynchronizationLargeBody.cpp
@@ -188,7 +188,7 @@ int main( int argc, char ** argv )
       }
    }
    mpi::broadcastObject(sid, sphereRank);
-   WALBERLA_LOG_DETAIL("sphere with sid " << sid << " is loacted on rank " << sphereRank);
+   WALBERLA_LOG_DETAIL("sphere with sid " << sid << " is located on rank " << sphereRank);
 
    syncShadowOwners<BodyTuple>(forest->getBlockForest(), storageID);
    syncShadowOwners<BodyTuple>(forest->getBlockForest(), storageID);
diff --git a/tests/pe/UnionBehavior.cpp b/tests/pe/UnionBehavior.cpp
index 51037cf4842022719aeca8d7596263863b2ced08..ed1756f35c4ac9a5adc5a6e56ebb6ac04edf62fc 100644
--- a/tests/pe/UnionBehavior.cpp
+++ b/tests/pe/UnionBehavior.cpp
@@ -163,7 +163,7 @@ int main( int argc, char ** argv )
    MaterialID     material = createMaterial( "granular", real_t( 1.0 ), 0, static_cof, dynamic_cof, real_t( 0.5 ), 1, real_t(8.11e5), real_t(6.86e1), real_t(6.86e1) );
    //! [Material]
 
-   // Create surronding planes in y,z directions, but not in x.
+   // Create surrounding planes in y,z directions, but not in x.
    auto simulationDomain = forest->getDomain();
    //! [Planes]
    createPlane(*globalBodyStorage, 100, Vec3(0,1,0), simulationDomain.minCorner(), material );
diff --git a/tests/pe_coupling/discrete_particle_methods/HinderedSettlingDynamicsDPM.cpp b/tests/pe_coupling/discrete_particle_methods/HinderedSettlingDynamicsDPM.cpp
index 81350061ffd987857518de3efec925df2fbdd4bc..fb5fb03cdbf0c56352de123a5b4596ae31805d08 100644
--- a/tests/pe_coupling/discrete_particle_methods/HinderedSettlingDynamicsDPM.cpp
+++ b/tests/pe_coupling/discrete_particle_methods/HinderedSettlingDynamicsDPM.cpp
@@ -834,7 +834,7 @@ int main( int argc, char **argv )
    const real_t stiffnessCoeff = math::pi * math::pi * Mij / ( collisionTime * collisionTime * ( real_t(1) - lnDryResCoeff * lnDryResCoeff / ( math::pi * math::pi + lnDryResCoeff* lnDryResCoeff ) ) );
    const real_t dampingCoeff = - real_t(2) * std::sqrt( Mij * stiffnessCoeff ) *
                                ( std::log(restitutionCoeff) / std::sqrt( math::pi * math::pi + (std::log(restitutionCoeff) * std::log(restitutionCoeff) ) ) );
-   const real_t contactDuration = real_t(2) * math::pi * Mij / ( std::sqrt( real_t(4) * Mij * stiffnessCoeff - dampingCoeff * dampingCoeff )); //formula from Uhlman
+   const real_t contactDuration = real_t(2) * math::pi * Mij / ( std::sqrt( real_t(4) * Mij * stiffnessCoeff - dampingCoeff * dampingCoeff )); //formula from Uhlmann
 
    if( !funcTest ) {
       WALBERLA_LOG_INFO_ON_ROOT("Created sediment material with:\n"
@@ -964,7 +964,7 @@ int main( int argc, char **argv )
    // add boundary handling & initialize outer domain boundaries
    BlockDataID boundaryHandlingID = blocks->addStructuredBlockData< BoundaryHandling_T >( MyBoundaryHandling( flagFieldID, pdfFieldID ), "boundary handling" );
 
-   // field to store fluid velolcity
+   // field to store fluid velocity
    BlockDataID velocityFieldID = field::addToStorage< Vec3Field_T >( blocks, "velocity field", initialFluidVelocity, field::zyxf, FieldGhostLayers );
    BlockDataID oldVelocityFieldID = field::addToStorage< Vec3Field_T >( blocks, "old velocity field", initialFluidVelocity, field::zyxf, FieldGhostLayers );
    BlockDataID swappedOldVelocityFieldID = field::addToStorage< Vec3Field_T >( blocks, "swapped old velocity field", initialFluidVelocity, field::zyxf, FieldGhostLayers );
diff --git a/tests/pe_coupling/discrete_particle_methods/SphereWallCollisionBehaviorDPM.cpp b/tests/pe_coupling/discrete_particle_methods/SphereWallCollisionBehaviorDPM.cpp
index 2ae19a3bc5d34ced1119dfc4686d7718b27b87c6..b6b545bef04cdc72d1f3b2bf7c1b910b3df79904 100644
--- a/tests/pe_coupling/discrete_particle_methods/SphereWallCollisionBehaviorDPM.cpp
+++ b/tests/pe_coupling/discrete_particle_methods/SphereWallCollisionBehaviorDPM.cpp
@@ -467,17 +467,20 @@ void emptyFunction(){}
  *
  * A glass sphere of radius D is settling under gravity towards the bottom plane.
  * The domain size is [32 x 32 x 512] * D, to ensure that the terminal settling velocity is reached before it hits the wall.
- *     _______________
- *    |               |
- *    |       o       | |
- *    |       |       | | gravity (z-direction)
- *    |       |       | v
- *    |       |       |
- *    |       |       |
- *    |_______|_______|
+   \verbatim
+       _______________
+      |               |
+      |       o       | |
+      |       |       | | gravity (z-direction)
+      |       |       | v
+      |       |       |
+      |       |       |
+      |_______|_______|
+
+   \endverbatim
  *
  * The sphere properties are: dry coeff of restitution = 0.97, coeff of friction = 0.1
- * Depending on the Stokes number ( St = ( rho_s / rho_f ) * Re / 9 ), the actual coefficient of resitution changes
+ * Depending on the Stokes number ( St = ( rho_s / rho_f ) * Re / 9 ), the actual coefficient of restitution changes
  * due to the presence of the viscous fluid.
  * The Reynolds number is evaluated as Re = u_T * D / visc, with the terminal settling velocity u_T.
  * Thus, this quantity is not a-priori available.
@@ -715,7 +718,7 @@ int main( int argc, char **argv )
 
    const real_t dampingCoeff = - real_t(2) * std::sqrt( Mij * stiffnessCoeff ) *
                                ( std::log(restitutionCoeff) / std::sqrt( math::pi * math::pi + (std::log(restitutionCoeff) * std::log(restitutionCoeff) ) ) );
-   const real_t contactDuration = real_t(2) * math::pi * Mij / ( std::sqrt( real_t(4) * Mij * stiffnessCoeff - dampingCoeff * dampingCoeff )); //formula from Uhlman
+   const real_t contactDuration = real_t(2) * math::pi * Mij / ( std::sqrt( real_t(4) * Mij * stiffnessCoeff - dampingCoeff * dampingCoeff )); //formula from Uhlmann
    const real_t contactDuration2 = std::sqrt(( math::pi * math::pi + std::log(restitutionCoeff) * std::log(restitutionCoeff)) / ( stiffnessCoeff / Mij)); //formula from Finn
 
    if( !funcTest )
@@ -764,7 +767,7 @@ int main( int argc, char **argv )
    // add boundary handling & initialize outer domain boundaries
    BlockDataID boundaryHandlingID = blocks->addStructuredBlockData< BoundaryHandling_T >( MyBoundaryHandling( flagFieldID, pdfFieldID ), "boundary handling" );
 
-   // field to store fluid velolcity
+   // field to store fluid velocity
    BlockDataID velocityFieldID = field::addToStorage< Vec3Field_T >( blocks, "velocity field", Vector3<real_t>(0), field::zyxf, FieldGhostLayers );
    BlockDataID swappedOldVelocityFieldID = field::addToStorage< Vec3Field_T >( blocks, "swapped old velocity field", Vector3<real_t>(0), field::zyxf, FieldGhostLayers );
 
diff --git a/tests/pe_coupling/momentum_exchange_method/DragForceSphereMEM.cpp b/tests/pe_coupling/momentum_exchange_method/DragForceSphereMEM.cpp
index 5999df24dd04fd3cfe88138d641a3af255a6ef6c..0320375a4f5677cb2a414647daaabaaf6c4bdb6c 100644
--- a/tests/pe_coupling/momentum_exchange_method/DragForceSphereMEM.cpp
+++ b/tests/pe_coupling/momentum_exchange_method/DragForceSphereMEM.cpp
@@ -361,14 +361,17 @@ private:
  *
  * The drag force for this problem (often denoted as Simple Cubic setup) is given by a semi-analytical series expansion.
  * The cubic domain is periodic in all directions, making it a physically infinite periodic array of spheres.
- *         _______________
- *      ->|               |->
- *      ->|      ___      |->
- *    W ->|     /   \     |-> E
- *    E ->|    |  x  |    |-> A
- *    S ->|     \___/     |-> S
- *    T ->|               |-> T
- *      ->|_______________|->
+   \verbatim
+           _______________
+        ->|               |->
+        ->|      ___      |->
+      W ->|     /   \     |-> E
+      E ->|    |  x  |    |-> A
+      S ->|     \___/     |-> S
+      T ->|               |-> T
+        ->|_______________|->
+
+   \endverbatim
  *
  * The collision model used for the LBM is TRT with a relaxation parameter tau=1.5 and the magic parameter 3/16.
  * The Stokes approximation of the equilibrium PDFs is used.
diff --git a/tests/pe_coupling/momentum_exchange_method/DragForceSphereMEMRefinement.cpp b/tests/pe_coupling/momentum_exchange_method/DragForceSphereMEMRefinement.cpp
index f77f8076fb7be877189dea7c7ac819d704005535..9184f1f112ffa711501654bc32c4d382746cc96f 100644
--- a/tests/pe_coupling/momentum_exchange_method/DragForceSphereMEMRefinement.cpp
+++ b/tests/pe_coupling/momentum_exchange_method/DragForceSphereMEMRefinement.cpp
@@ -417,14 +417,17 @@ class ForceEval
  *
  * The drag force for this problem (often denoted as Simple Cubic setup) is given by a semi-analytical series expansion.
  * The cubic domain is periodic in all directions, making it a physically infinite periodic array of spheres.
- *         _______________
- *      ->|               |->
- *      ->|      ___      |->
- *    W ->|     /   \     |-> E
- *    E ->|    |  x  |    |-> A
- *    S ->|     \___/     |-> S
- *    T ->|               |-> T
- *      ->|_______________|->
+   \verbatim
+           _______________
+        ->|               |->
+        ->|      ___      |->
+      W ->|     /   \     |-> E
+      E ->|    |  x  |    |-> A
+      S ->|     \___/     |-> S
+      T ->|               |-> T
+        ->|_______________|->
+
+   \endverbatim
  *
  * The collision model used for the LBM is TRT with a relaxation parameter tau=1.5 and the magic parameter 3/16.
  * The Stokes approximation of the equilibrium PDFs is used.
diff --git a/tests/pe_coupling/momentum_exchange_method/GlobalBodyAsBoundaryMEMStaticRefinement.cpp b/tests/pe_coupling/momentum_exchange_method/GlobalBodyAsBoundaryMEMStaticRefinement.cpp
index c19452458880578dc384d808a921a9278e45f842..5cf642886a317cafdbe321e134f7afaf2a8d763c 100644
--- a/tests/pe_coupling/momentum_exchange_method/GlobalBodyAsBoundaryMEMStaticRefinement.cpp
+++ b/tests/pe_coupling/momentum_exchange_method/GlobalBodyAsBoundaryMEMStaticRefinement.cpp
@@ -256,7 +256,7 @@ BoundaryHandling_T * MyBoundaryHandling::operator()( IBlock * const block, const
  *  - the mapping has to be consistent on the coarse and the fine level,
  *    i.e. a boundary cell on the coarse level has to be 8 boundary cells on the fine level.
  *    This implies that only cell-aligned and axis-aligned PE bodies are allowed to have this refinement boundary.
- *    All others (inclindes planes, cylinders, spheres) must have and maintain the same refinement level
+ *    All others (inclined planes, cylinders, spheres) must have and maintain the same refinement level
  *    throughout the entire simulation.
  *
  *  - boundary conditions that access PDF values from cells apart from the near-boundary cell
@@ -265,7 +265,7 @@ BoundaryHandling_T * MyBoundaryHandling::operator()( IBlock * const block, const
  *    for the Lattice Boltzmann Method on NonUniform Grids" (2016)). Thus accesses to ghost layer PDF values that
  *    happen in those BCs are highly dangerous since those are often given NaN values.
  *    Problems are here two-fold:
- *     - boundary handling on fine levels is carried out in two of the four ghost layers. This is done tice on the
+ *     - boundary handling on fine levels is carried out in two of the four ghost layers. This is done twice on the
  *       finer levels and in this second time, the third and fourth ghost layer feature NaN values only
  *       (due to the swap during the streaming step).
  *     - on coarse blocks, the ghost layer at the coarse-fine boundary does not contain valid PDF values since the
diff --git a/tests/pe_coupling/momentum_exchange_method/SegreSilberbergMEM.cpp b/tests/pe_coupling/momentum_exchange_method/SegreSilberbergMEM.cpp
index 0c90a90d7ecd823585d0e628b1b2b82da8cb1028..9fb1b7c8db61bf27ef1dfb754987f55701be70f1 100644
--- a/tests/pe_coupling/momentum_exchange_method/SegreSilberbergMEM.cpp
+++ b/tests/pe_coupling/momentum_exchange_method/SegreSilberbergMEM.cpp
@@ -415,14 +415,17 @@ private:
  *
  *   The Segre Silberberg effect denotes that a particle in a Poiseuille flow will eventually arrive
  *   at a distinct equilibrium position, depending on the particle size and its velocity.
- *      __________________
- * ->
- * -->        ___
- * --->      /   \
- * --->     |  x  |-\
- * --->      \___/   \-\
- * -->                  \------ equilibrium position
- * ->  ___________________
+   \verbatim
+        __________________
+   ->
+   -->        ___
+   --->      /   \
+   --->     |  x  |-\
+   --->      \___/   \-\
+   -->                  \------ equilibrium position
+   ->  ___________________
+
+   \endverbatim
  *
  * The collision model used for the LBM is TRT with a relaxation parameter tau=1.4 and the magic parameter 3/16.
  * The particle is a sphere with diameter d=12 cells and density 1 (LU).
diff --git a/tests/pe_coupling/momentum_exchange_method/TorqueSphereMEM.cpp b/tests/pe_coupling/momentum_exchange_method/TorqueSphereMEM.cpp
index ee405e7b449d899909ddac558a413fa6f1e52615..0dc2dba168c8f0f48ff67acdf2ebf1c0df23472a 100644
--- a/tests/pe_coupling/momentum_exchange_method/TorqueSphereMEM.cpp
+++ b/tests/pe_coupling/momentum_exchange_method/TorqueSphereMEM.cpp
@@ -306,14 +306,17 @@ private:
  *
  * The torque for this problem (often denoted as Simple Cubic setup) is given by a semi-analytical formula.
  * The cubic domain is periodic in all directions, making it a physically infinite periodic array of spheres.
- *       _______________
- *      |       <-      |
- *      |      ___      |
- *      |     /   \     |
- *      |    |  x  |    |
- *      |     \___/     |
- *      |      ->       |
- *      |_______________|
+   \verbatim
+         _______________
+        |       <-      |
+        |      ___      |
+        |     /   \     |
+        |    |  x  |    |
+        |     \___/     |
+        |      ->       |
+        |_______________|
+
+   \endverbatim
  *
  * The collision model used for the LBM is TRT with a relaxation parameter tau=1.5 and the magic parameter 3/16.
  * The Stokes approximation of the equilibrium PDFs is used.
diff --git a/tests/pe_coupling/partially_saturated_cells_method/DragForceSpherePSM.cpp b/tests/pe_coupling/partially_saturated_cells_method/DragForceSpherePSM.cpp
index a2042350550ef9d957890c79138076a5c8a629c6..24902900f47a2504fad7fd515c6fc983f902c3d9 100644
--- a/tests/pe_coupling/partially_saturated_cells_method/DragForceSpherePSM.cpp
+++ b/tests/pe_coupling/partially_saturated_cells_method/DragForceSpherePSM.cpp
@@ -297,14 +297,17 @@ private:
  *
  * The drag force for this problem (often denoted as Simple Cubic setup) is given by a semi-analytical series expansion.
  * The cubic domain is periodic in all directions, making it a physically infinite periodic array of spheres.
- *         _______________
- *      ->|               |->
- *      ->|      ___      |->
- *    W ->|     /   \     |-> E
- *    E ->|    |  x  |    |-> A
- *    S ->|     \___/     |-> S
- *    T ->|               |-> T
- *      ->|_______________|->
+   \verbatim
+           _______________
+        ->|               |->
+        ->|      ___      |->
+      W ->|     /   \     |-> E
+      E ->|    |  x  |    |-> A
+      S ->|     \___/     |-> S
+      T ->|               |-> T
+        ->|_______________|->
+
+   \endverbatim
  *
  * The collision model used for the LBM is TRT with a relaxation parameter tau=1.5 and the magic parameter 3/16.
  * The Stokes approximation of the equilibrium PDFs is used.
diff --git a/tests/pe_coupling/partially_saturated_cells_method/DragForceSpherePSMRefinement.cpp b/tests/pe_coupling/partially_saturated_cells_method/DragForceSpherePSMRefinement.cpp
index e974330128b4eee25abc3cc6a49804be89123729..d5444ab41c7122d9851fa6a0a75fcb608eccc35e 100644
--- a/tests/pe_coupling/partially_saturated_cells_method/DragForceSpherePSMRefinement.cpp
+++ b/tests/pe_coupling/partially_saturated_cells_method/DragForceSpherePSMRefinement.cpp
@@ -420,14 +420,17 @@ private:
  *
  * The drag force for this problem (often denoted as Simple Cubic setup) is given by a semi-analytical series expansion.
  * The cubic domain is periodic in all directions, making it a physically infinite periodic array of spheres.
- *         _______________
- *      ->|               |->
- *      ->|      ___      |->
- *    W ->|     /   \     |-> E
- *    E ->|    |  x  |    |-> A
- *    S ->|     \___/     |-> S
- *    T ->|               |-> T
- *      ->|_______________|->
+   \verbatim
+           _______________
+        ->|               |->
+        ->|      ___      |->
+      W ->|     /   \     |-> E
+      E ->|    |  x  |    |-> A
+      S ->|     \___/     |-> S
+      T ->|               |-> T
+        ->|_______________|->
+
+   \endverbatim
  *
  * The collision model used for the LBM is TRT with a relaxation parameter tau=1.5 and the magic parameter 3/16.
  * The Stokes approximation of the equilibrium PDFs is used.
diff --git a/tests/pe_coupling/partially_saturated_cells_method/SegreSilberbergPSM.cpp b/tests/pe_coupling/partially_saturated_cells_method/SegreSilberbergPSM.cpp
index 38ae149c9bb0394eee46418a634af575190f3544..e94410757e8c5e6a82cd7a9ab51d96da9c43d31a 100644
--- a/tests/pe_coupling/partially_saturated_cells_method/SegreSilberbergPSM.cpp
+++ b/tests/pe_coupling/partially_saturated_cells_method/SegreSilberbergPSM.cpp
@@ -364,14 +364,17 @@ class SteadyStateCheck
  *
  *   The Segre Silberberg effect denotes that a particle in a Poiseuille flow will eventually arrive
  *   at a distinct equilibrium position, depending on the particle size and its velocity.
- *      __________________
- * ->
- * -->        ___
- * --->      /   \
- * --->     |  x  |-\
- * --->      \___/   \-\
- * -->                  \------ equilibrium position
- * ->  ___________________
+   \verbatim
+        __________________
+   ->
+   -->        ___
+   --->      /   \
+   --->     |  x  |-\
+   --->      \___/   \-\
+   -->                  \------ equilibrium position
+   ->  ___________________
+
+   \endverbatim
  *
  * The collision model used for the LBM is TRT with a relaxation parameter tau=1.4 and the magic parameter 3/16.
  * The particle is a sphere with diameter d=12 cells and density 1 (LU).
diff --git a/tests/pe_coupling/partially_saturated_cells_method/TorqueSpherePSM.cpp b/tests/pe_coupling/partially_saturated_cells_method/TorqueSpherePSM.cpp
index 1a2e16a8937ef95f9f3037415679e9bb0069c01f..cd72e01bd32c73c892bfb21afe8b6db720f096ac 100644
--- a/tests/pe_coupling/partially_saturated_cells_method/TorqueSpherePSM.cpp
+++ b/tests/pe_coupling/partially_saturated_cells_method/TorqueSpherePSM.cpp
@@ -229,14 +229,17 @@ class TorqueEval
  *
  * The torque for this problem (often denoted as Simple Cubic setup) is given by a semi-analytical formula.
  * The cubic domain is periodic in all directions, making it a physically infinite periodic array of spheres.
- *       _______________
- *      |       <-      |
- *      |      ___      |
- *      |     /   \     |
- *      |    |  x  |    |
- *      |     \___/     |
- *      |      ->       |
- *      |_______________|
+   \verbatim
+         _______________
+        |       <-      |
+        |      ___      |
+        |     /   \     |
+        |    |  x  |    |
+        |     \___/     |
+        |      ->       |
+        |_______________|
+
+   \endverbatim
  *
  * The collision model used for the LBM is TRT with a relaxation parameter tau=1.5 and the magic parameter 3/16.
  * The Stokes approximation of the equilibrium PDFs is used.