Commit c50af1d2 authored by Jean-Noël Grad's avatar Jean-Noël Grad Committed by Helen Schottenhamml
Browse files

Tutorials and documentation maintenance

parent 7751b2df
......@@ -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)
......
......@@ -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
......
......@@ -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
......
......@@ -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())
{
......
......@@ -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) {}
......
......@@ -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) {}
......
......@@ -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;}
......
......@@ -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.
*/
......
......@@ -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>
......
......@@ -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;}
......
......@@ -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];
......
......@@ -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.
......
......@@ -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];
......
......@@ -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.
......
......@@ -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
//
//======================================================================================================================
......
......@@ -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
*/
......
......@@ -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() );
......
......@@ -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 -----
......
......@@ -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_);
......
......@@ -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;}
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment