From c50af1d2b529b82d3848cc4f236b4659420178d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jean-No=C3=ABl=20Grad?= <jgrad@icp.uni-stuttgart.de>
Date: Thu, 15 Apr 2021 08:28:42 +0000
Subject: [PATCH] Tutorials and documentation maintenance
---
.../MotionSettlingSphere.cpp | 2 +-
.../MotionSingleHeavySphere.cpp | 6 ++--
.../BidisperseFluidizedBedDPM.cpp | 2 +-
apps/tutorials/basics/01_BlocksAndFields.dox | 4 +--
apps/tutorials/basics/02_Sweeps.dox | 2 +-
apps/tutorials/basics/03_GameOfLife.dox | 2 +-
apps/tutorials/mesa_pd/01_MESAPD.dox | 10 +++---
apps/tutorials/pde/01_SolvingPDE.dox | 10 +++---
apps/tutorials/pde/02_HeatEquation.dox | 8 ++---
.../pde/03_HeatEquation_Extensions.cpp | 4 +--
apps/tutorials/pe/01_ConfinedGas.dox | 4 +--
apps/tutorials/pe/02_ConfinedGasExtended.dox | 12 +++----
src/blockforest/BlockForest.h | 2 +-
.../BlockNeighborhoodConstruction.cpp | 2 +-
src/blockforest/Initialization.cpp | 2 +-
.../DirectionBasedReduceScheme.h | 2 +-
src/blockforest/loadbalancing/DynamicCurve.h | 2 +-
.../doc/walberlaCommunication.dox | 2 +-
src/core/UniqueID.h | 2 +-
src/core/cell/Cell.h | 4 +--
src/core/cell/CellInterval.cpp | 2 +-
src/core/cell/CellVector.h | 2 +-
src/core/debug/PrintStacktrace.cpp | 2 +-
src/core/logging/Initialization.cpp | 2 +-
src/core/math/MatrixMxN.h | 4 +--
src/core/math/Parser.cpp | 2 +-
src/core/math/Quaternion.h | 6 ++--
src/core/math/Sample.cpp | 2 +-
src/core/math/Vector2.h | 34 +++++++++----------
src/core/math/Vector3.h | 34 +++++++++----------
.../math/equation_system/EquationParser.cpp | 6 ++--
src/core/math/equation_system/FwdOperator.h | 2 +-
src/core/mpi/BufferSystem.h | 2 +-
src/core/timing/TimingNode.h | 2 +-
src/core/timing/TimingTree.h | 4 +--
src/cuda/GPUField.h | 2 +-
src/cuda/communication/CustomMemoryBuffer.h | 2 +-
.../MapPointToPeriodicDomain.h | 4 +--
src/field/VolumetricFlowRateEvaluation.h | 2 +-
src/field/allocation/AlignedMalloc.h | 2 +-
.../TrilinearFieldInterpolator.h | 2 +-
src/gather/CurveGatherPackInfo.h | 4 +--
src/gather/MPIGatherScheme.h | 2 +-
src/geometry/mesh/TriangleMesh.cpp | 2 +-
src/geometry/mesh/TriangleMeshIO.cpp | 2 +-
.../structured/BasicVoxelFileReader.h | 2 +-
src/geometry/structured/VoxelFileReader.h | 2 +-
.../structured/VoxelFileReader.impl.h | 2 +-
src/lbm/MassEvaluation.h | 6 ++--
src/lbm/boundary/Curved.h | 2 +-
src/lbm/boundary/DiffusionDirichlet.h | 2 +-
src/lbm/boundary/DynamicUBB.h | 6 ++--
src/lbm/boundary/SimpleDiffusionDirichlet.h | 2 +-
src/lbm/cumulant/CellwiseSweep.impl.h | 14 ++++----
src/lbm_mesapd_coupling/amr/InfoCollection.h | 4 +--
.../reconstruction/Reconstructor.h | 2 +-
src/mesa_pd/collision_detection/EPA.cpp | 20 +++++------
src/mesa_pd/collision_detection/EPA.h | 6 ++--
src/mesa_pd/collision_detection/GJK.cpp | 12 +++----
src/mesa_pd/collision_detection/GJK.h | 2 +-
src/mesa_pd/collision_detection/Support.h | 2 +-
src/mesa_pd/domain/BlockForestDomain.h | 4 +--
src/mesa_pd/kernel/DetectAndStoreContacts.h | 2 +-
src/mesa_pd/kernel/ForceLJ.h | 2 +-
src/mesa_pd/kernel/HCSITSRelaxationStep.h | 2 +-
src/mesa_pd/kernel/HeatConduction.h | 2 +-
src/mesa_pd/kernel/InitParticlesForHCSITS.h | 2 +-
src/mesa_pd/kernel/VelocityVerlet.h | 2 +-
.../kernel/cnt/AnisotropicVDWContact.h | 8 ++---
src/mesa_pd/kernel/cnt/Parameters.h | 2 +-
.../ContactHistoryNotification.h | 2 +-
.../notifications/ForceTorqueNotification.h | 2 +-
.../mpi/notifications/HeatFluxNotification.h | 2 +-
.../HydrodynamicForceTorqueNotification.h | 2 +-
.../ConvexPolyhedron/MeshParticleVTKOutput.h | 4 +--
src/mesh/mesh_module.dox | 6 ++--
src/mesh/pe/DefaultTesselation.h | 2 +-
src/mesh/pe/rigid_body/ConvexPolyhedron.cpp | 8 ++---
.../pe/rigid_body/ConvexPolyhedronFactory.cpp | 6 ++--
src/mesh_common/DistanceComputations.h | 9 +++--
src/mesh_common/MeshOperations.h | 6 ++--
src/mesh_common/QHull.h | 4 +--
src/pe/Materials.h | 2 +-
.../MinMaxLevelDetermination.cpp | 2 +-
.../MetisAssignmentFunctor.h | 2 +-
.../WeightAssignmentFunctor.h | 2 +-
src/pe/bg/IBG.h | 2 +-
src/pe/ccd/HashGrids.cpp | 6 ++--
src/pe/ccd/HashGrids.h | 4 +--
src/pe/ccd/ICCD.h | 2 +-
src/pe/collision/EPA.cpp | 20 +++++------
src/pe/collision/EPA.h | 6 ++--
src/pe/collision/GJK.cpp | 10 +++---
src/pe/collision/GJK.h | 4 +--
.../RigidBodyRemoteMigrationNotification.h | 2 +-
src/pe/cr/HCSITS.h | 12 +++----
src/pe/cr/HCSITS.impl.h | 4 +--
src/pe/fcd/AnalyticCollisionDetection.h | 2 +-
src/pe/fcd/GJKEPACollideFunctor.h | 2 +-
src/pe/fcd/IFCD.h | 2 +-
src/pe/raytracing/Intersects.h | 2 +-
src/pe/raytracing/Raytracer.cpp | 2 +-
src/pe/rigidbody/BodyStorage.h | 4 +--
src/pe/rigidbody/Box.h | 4 +--
src/pe/rigidbody/BoxFactory.cpp | 2 +-
src/pe/rigidbody/Capsule.h | 2 +-
src/pe/rigidbody/CapsuleFactory.cpp | 2 +-
src/pe/rigidbody/CylindricalBoundary.cpp | 4 +--
.../rigidbody/CylindricalBoundaryFactory.cpp | 2 +-
src/pe/rigidbody/Ellipsoid.h | 4 +--
src/pe/rigidbody/EllipsoidFactory.cpp | 2 +-
src/pe/rigidbody/PlaneFactory.cpp | 2 +-
src/pe/rigidbody/RigidBody.h | 26 +++++++-------
src/pe/rigidbody/Sphere.h | 2 +-
src/pe/rigidbody/SphereFactory.cpp | 2 +-
src/pe/rigidbody/SquirmerFactory.cpp | 2 +-
src/pe/rigidbody/Union.h | 14 ++++----
src/pe/rigidbody/UnionFactory.h | 16 ++++-----
src/pe/statistics/BodyStatistics.cpp | 2 +-
src/pe/synchronization/SyncShadowOwners.h | 4 +--
src/pe_coupling/mapping/BodyBBMapping.cpp | 2 +-
.../PSMUtility.h | 2 +-
src/postprocessing/FieldToSurfaceMesh.h | 4 +--
src/python_coupling/DictWrapper.h | 2 +-
src/python_coupling/PythonCallback.h | 2 ++
src/python_coupling/export/BasicExport.cpp | 2 +-
.../export/GatherExport.impl.h | 6 ++--
.../helper/SliceToCellInterval.h | 2 +-
src/simd/IntelVecTypesCppOperators.h | 2 +-
src/timeloop/SweepTimeloop.cpp | 2 +-
src/timeloop/SweepTimeloop.h | 2 +-
tests/lbm/BoundaryHandlingCommunication.cpp | 2 +-
tests/lbm/SweepEquivalenceTest.cpp | 2 +-
tests/lbm/evaluations/PermeabilityTest.cpp | 2 +-
.../DragForceSphere.cpp | 19 ++++++-----
.../ForceBetweenTwoStationaryObjects.cpp | 2 +-
tests/mesa_pd/ContactDetection.cpp | 2 +-
.../ConvexPolyhedron_GJK_EPA.cpp | 4 +--
tests/mesa_pd/collision_detection/GJK_EPA.cpp | 8 ++---
.../kernel/CoefficientOfRestitutionLSD.cpp | 2 +-
.../kernel/CoefficientOfRestitutionNLSD.cpp | 2 +-
.../kernel/CoefficientOfRestitutionSD.cpp | 2 +-
tests/mesa_pd/kernel/ForceLJ.cpp | 2 +-
tests/mesa_pd/kernel/HCSITSKernels.cpp | 8 ++---
tests/mesa_pd/kernel/LinearSpringDashpot.cpp | 2 +-
tests/pde/MGConvergenceTest.cpp | 2 +-
tests/pe/CollisionTobiasGJK.cpp | 10 +++---
tests/pe/PeDocumentationSnippets.cpp | 4 +--
tests/pe/RaytracingIntersection.cpp | 4 +--
tests/pe/Synchronization.cpp | 2 +-
tests/pe/SynchronizationLargeBody.cpp | 2 +-
tests/pe/UnionBehavior.cpp | 2 +-
.../HinderedSettlingDynamicsDPM.cpp | 4 +--
.../SphereWallCollisionBehaviorDPM.cpp | 25 ++++++++------
.../DragForceSphereMEM.cpp | 19 ++++++-----
.../DragForceSphereMEMRefinement.cpp | 19 ++++++-----
...lobalBodyAsBoundaryMEMStaticRefinement.cpp | 4 +--
.../SegreSilberbergMEM.cpp | 19 ++++++-----
.../TorqueSphereMEM.cpp | 19 ++++++-----
.../DragForceSpherePSM.cpp | 19 ++++++-----
.../DragForceSpherePSMRefinement.cpp | 19 ++++++-----
.../SegreSilberbergPSM.cpp | 19 ++++++-----
.../TorqueSpherePSM.cpp | 19 ++++++-----
163 files changed, 447 insertions(+), 416 deletions(-)
diff --git a/apps/benchmarks/FluidParticleCoupling/MotionSettlingSphere.cpp b/apps/benchmarks/FluidParticleCoupling/MotionSettlingSphere.cpp
index 69f6a438e..a6c85893c 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 293451af2..f07496363 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 dad90bc62..415240ca3 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 dd679f42c..944c64cb5 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 8c25ea3af..2080d217a 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 2ca31c9ad..58c03591b 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 c30e2cf93..28cc3567d 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 a978dbf0c..47d377db6 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 98afd5ca5..353ad06ee 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 a1b42906a..6db0cb091 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 48105ac74..7e4fc6a71 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 89cd4a837..818a8189e 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 0edd764af..6108ea3e2 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 aafe81ff5..4f94588c8 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 11d5243e2..75a1d81c9 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 72c52ec64..138e3f713 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 8b3e5808a..6b6c97366 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 3885485e1..4dd9269b4 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 4b267070e..de9e88334 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 3df78ce5b..26d593b80 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 c4df1ea31..786644d99 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 c05474400..0b5ce7d57 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 7eff6bcb9..94f2aa89b 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 3ea701abd..ca442e712 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 380baeb32..f523fde94 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 7c39e5e9d..7b12bc352 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 417e9b793..3ee4273ae 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 bdd9e0689..a85954e2a 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 00bfabe88..10589c98f 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 c47fd4a66..413cf0d69 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 aaf1b146d..d5bdb0aaf 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 2df1ae9ab..062f371cc 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 f2b0cbf43..6a531fa90 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 6682ab626..a72c2f193 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 32ed44549..248dcdcce 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 75766957a..431ce1526 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 7ca7ab46f..ddf475b1a 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 0835af180..fc56eddd4 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 063bd1518..8d6aee70b 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 b811a15a2..5e4e6a523 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 8eb24a4cf..e9809d835 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 6bdd3bab0..ea42f21df 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 e9270289b..6ef3d5458 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 c3596c6c8..64c48fcff 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 653166a44..cb8859509 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 918fc41c3..21f7187c3 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 ff0ec9107..afd0312dd 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 31c28af8b..e91b75357 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 9757137db..7efe2daae 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 927554389..38e3d308c 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 643027743..219732fc2 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 07aac83ce..de6c9db27 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 e3a6dde2f..81805c5b8 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 bb40b8d50..ade7fbc50 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 f3e596eb7..621ab8f7b 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 acb4fd95b..e3d7ae05a 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 defefd3a9..033559150 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 052f6cdf8..a83cc1f5b 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 002f3f788..757c065b1 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 7ccff5128..438ea25a3 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 e7ffebfd9..a8d0c3557 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 7df1f9b68..ed2c727c9 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 7656703b9..668978855 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 483e586b7..1affbc8f8 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 bcc0a7dc8..f377c02b5 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 b474db018..e41d11704 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 ba95fbf82..2022a0b80 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 1564842e4..67a5f1dc2 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 5beb8622b..cfe7e61d6 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 fc4b98f7f..274962776 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 92bfe1dac..3785f0ffb 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 eb5c3198f..5c8ad6f79 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 5ed1d294c..6b580a500 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 7d6ac1594..ce8741881 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 95127646d..b744ae730 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 830bfc633..8f7a4746d 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 f3de74322..9391779ca 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 2b505e09b..933a6d28f 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 eb8fdfa7c..e0685e8db 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 6333a5388..9155aa1d1 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 1694edf87..979d0be61 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 160d3e8a0..6011ce09b 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 15863462f..d44772ffd 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 d29f5011c..93f0b31c0 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 f0797401e..e16d67540 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 069efae7e..e6373152a 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 fa7ec0662..72bec0903 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 3c312fa36..5c2f691ed 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 cbfe0471d..372fb452d 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 8aeb8d50a..831c8d78a 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 171dc8594..e8d54f178 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 7bc5840d1..6c5d76265 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 d2320f9ec..84c437a60 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 a562ccc0d..15680d93f 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 3dcd20a3c..5924e67aa 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 93da3f0f2..24b3d7d59 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 25cccf846..b46362df2 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 2fbda8d98..65737205c 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 4dcc97a7d..372d44edf 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 e34592b3d..d671a1abf 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 ea7c6f850..a956e4efe 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 344b8af99..de604aee6 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 b6e159f67..40b4594ef 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 883739868..b4c291ae4 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 2a7036004..0dbeb2140 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 52311a204..210d3c251 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 349e30b2f..8723226c6 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 58f4f97ea..656c5f3ae 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 6cbf752cb..a6e78c6b8 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 e9a73305f..8608e493b 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 2136a8414..14c1bde5d 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 650054ee0..79e457934 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 eaecb02da..f6d3cfb03 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 a7400fdb7..3a0919266 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 dfe500daa..bec349526 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 caac4c9a0..491ddd86c 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 31a224d26..b682f159a 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 04090a61d..13f5eed8a 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 e76910eff..ad599f239 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 32669e303..721ba255e 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 41d5e0c10..6058c3b5c 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 b78a4e45f..52ece4597 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 75f2577e2..5fe433dd1 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 c3e1c2686..c7f1f9511 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 9eeaec650..5d7aeb48c 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 c4fad8eb6..29dd8a493 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 6d567f075..cc7de19a7 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 fd0a7ecdc..cf9ea3c33 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 55961a441..f43903528 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 15b407191..ba8032391 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 3bd6c1488..4ffc8df9e 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 6529e6913..9d4ba72aa 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 091033dab..71f4d739e 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 cb224e30f..2cc1fffaf 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 18c91bd3d..d6c317521 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 8e994002b..6034afaef 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 94d6c7575..651968772 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 2436e8968..83d68f83e 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 998276419..4bf43098e 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 a9cb84564..b425ece1b 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 5912892af..25e47423b 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 00fb53052..7bed1e985 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 adcb643cd..026745ee9 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 dc2695639..297f6c25b 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 0b749b822..bf14293e0 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 f9643a83f..c5c66aae1 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 a2de97070..34c29676c 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 6c4e49c51..b800d5984 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 08b9a980c..6b770805b 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 67dd06832..e592f2b39 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 94e205db7..d5fd5bd85 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 51037cf48..ed1756f35 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 81350061f..fb5fb03cd 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 2ae19a3bc..b6b545bef 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 5999df24d..0320375a4 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 f77f8076f..9184f1f11 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 c19452458..5cf642886 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 0c90a90d7..9fb1b7c8d 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 ee405e7b4..0dc2dba16 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 a20423505..24902900f 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 e97433012..d5444ab41 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 38ae149c9..e94410757 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 1a2e16a89..cd72e01bd 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.
--
GitLab