Merge branch 'implict' into 'master'

[API] Fix implict/explict typos in pe::cr

See merge request walberla/walberla!90

src/pe/cr/DEM.h

@@ -79,7 +79,7 @@ private:
    size_t                            numberOfContactsTreated_;
 };
 
-class DEM : public DEMSolver<IntegrateImplictEuler, ResolveContactSpringDashpotHaffWerner>
+class DEM : public DEMSolver<IntegrateImplicitEuler, ResolveContactSpringDashpotHaffWerner>
 {
 public:
    DEM(  const shared_ptr<BodyStorage>&    globalBodyStorage
@@ -88,8 +88,8 @@ public:
        , domain_decomposition::BlockDataID ccdID
        , domain_decomposition::BlockDataID fcdID
        , WcTimingTree*                     tt = NULL)
-   : DEMSolver<IntegrateImplictEuler, ResolveContactSpringDashpotHaffWerner>(
-              IntegrateImplictEuler(), ResolveContactSpringDashpotHaffWerner(),
+   : DEMSolver<IntegrateImplicitEuler, ResolveContactSpringDashpotHaffWerner>(
+              IntegrateImplicitEuler(), ResolveContactSpringDashpotHaffWerner(),
               globalBodyStorage, blockStorage, storageID, ccdID, fcdID, tt )
    {
    }

src/pe/cr/DEM.impl.h

@@ -128,7 +128,7 @@ void DEMSolver<Integrator,ContactResolver>::timestep( real_t dt )
          WALBERLA_ASSERT( bodyIt->checkInvariants(), "Invalid body state detected" );
          WALBERLA_ASSERT( !bodyIt->hasSuperBody(), "Invalid superordinate body detected" );
          
-         // Moving the capsule according to the acting forces (don't move a sleeping capsule)
+         // Moving the body according to the acting forces (don't move a sleeping body)
          if( bodyIt->isAwake() && !bodyIt->hasInfiniteMass() )
          {
             integrate_( *bodyIt, dt, *this );
@@ -138,7 +138,7 @@ void DEMSolver<Integrator,ContactResolver>::timestep( real_t dt )
          bodyIt->resetForceAndTorque();
          
          // Checking the state of the rigid body
-         WALBERLA_ASSERT( bodyIt->checkInvariants(), "Invalid capsule state detected" );
+         WALBERLA_ASSERT( bodyIt->checkInvariants(), "Invalid body state detected" );
 
          // Resetting the acting forces
          bodyIt->resetForceAndTorque();

src/pe/cr/Integrators.h

@@ -30,7 +30,7 @@ namespace pe {
 namespace cr {
 
 //*************************************************************************************************
-/*!\brief Integrate the trajectory of one body using implict Euler.
+/*!\brief Integrate the trajectory of one body using implicit Euler.
 *
 * \param id Body ID.
 * \param dt Time step size.
@@ -40,7 +40,7 @@ namespace cr {
 * The implicit Euler algorithm, also known as backward Euler, is used. It is a first-order
 * integrator that does conserves energy (i.e. it is symplectic.)
 */
-class IntegrateImplictEuler {
+class IntegrateImplicitEuler {
 public:
    void operator()( BodyID id, real_t dt, ICR & solver ) const
    {
@@ -72,7 +72,7 @@ public:
       // Setting the axis-aligned bounding box
       id->calcBoundingBox();
 
-      // Calculating the current motion of the capsule
+      // Calculating the current motion of the body
       id->calcMotion();
    }
 };
@@ -88,7 +88,7 @@ public:
 * The explicit Euler algorithm, also known as forward Euler, is used. It is a first-order
 * integrator that does not conserve energy (i.e. it is not symplectic.)
 */
-class IntegrateExplictEuler {
+class IntegrateExplicitEuler {
 public:
    void operator()( BodyID id, real_t dt, ICR & solver ) const
    {
@@ -120,7 +120,7 @@ public:
       // Setting the axis-aligned bounding box
       id->calcBoundingBox();
 
-      // Calculating the current motion of the capsule
+      // Calculating the current motion of the body
       id->calcMotion();
    }
 };

src/pe/cr/PlainIntegrator.h

@@ -61,14 +61,14 @@ private:
    WcTimingTree*                     tt_;
 };
    
-class PlainIntegrator : public PlainIntegratorSolver<IntegrateImplictEuler>
+class PlainIntegrator : public PlainIntegratorSolver<IntegrateImplicitEuler>
 {
 public:
    PlainIntegrator(  const shared_ptr<BodyStorage>&    globalBodyStorage
                    , const shared_ptr<BlockStorage>&   blockStorage
                    , domain_decomposition::BlockDataID storageID
                    , WcTimingTree*                     tt = NULL)
-   : PlainIntegratorSolver<IntegrateImplictEuler>( IntegrateImplictEuler(), globalBodyStorage, blockStorage,
+   : PlainIntegratorSolver<IntegrateImplicitEuler>( IntegrateImplicitEuler(), globalBodyStorage, blockStorage,
                                                    storageID, tt )
    {
    }

src/pe/cr/PlainIntegrator.impl.h

@@ -65,14 +65,14 @@ void PlainIntegratorSolver<Integrator>::timestep( const real_t dt )
       BodyStorage& localStorage = (*storage)[0];
       for (auto bd = localStorage.begin(); bd != localStorage.end(); ++bd){
          // Checking the state of the body
-         WALBERLA_ASSERT( bd->checkInvariants(), "Invalid capsule state detected" );
+         WALBERLA_ASSERT( bd->checkInvariants(), "Invalid body state detected" );
          WALBERLA_ASSERT( !bd->hasSuperBody(), "Invalid superordinate body detected" );
 
          // Resetting the contact node and removing all attached contacts
       //      bd->resetNode();
          bd->clearContacts();
 
-         // Moving the capsule according to the acting forces (don't move a sleeping capsule)
+         // Moving the body according to the acting forces (don't move a sleeping body)
          if( bd->isAwake() && !bd->hasInfiniteMass() ) {
             integrate_( *bd, dt, *this );
          }
@@ -80,8 +80,8 @@ void PlainIntegratorSolver<Integrator>::timestep( const real_t dt )
          // Resetting the acting forces
          bd->resetForceAndTorque();
 
-         // Checking the state of the capsule
-         WALBERLA_ASSERT( bd->checkInvariants(), "Invalid capsule state detected" );
+         // Checking the state of the body
+         WALBERLA_ASSERT( bd->checkInvariants(), "Invalid body state detected" );
       }
    }
    if (tt_!=NULL) tt_->stop("Integrate Bodies");

src/pe/rigidbody/CylindricalBoundary.cpp

@@ -56,7 +56,7 @@ namespace pe {
 CylindricalBoundary::CylindricalBoundary( id_t sid, id_t uid, const Vec3& gpos, const real_t radius,
                                           MaterialID material )
    : GeomPrimitive( getStaticTypeID(), sid, uid, material )           // Initializing the base object
-   , radius_(radius)                                                  // Radius of the cylinder                                                // Length of the capsule
+   , radius_(radius)                                                  // Radius of the cylinder
 {
    //boundaries are always considered locally and have infinite mass
    setGlobal( true );
@@ -66,11 +66,11 @@ CylindricalBoundary::CylindricalBoundary( id_t sid, id_t uid, const Vec3& gpos,
 
    // Checking the radius
    // Since the constructor is never directly called but only used in a small number
-   // of functions that already check the capsule arguments, only asserts are used here to
+   // of functions that already check the cylinder arguments, only asserts are used here to
    // double check the arguments.
-   WALBERLA_ASSERT_GREATER( radius, real_t(0), "Invalid capsule radius"  );
+   WALBERLA_ASSERT_GREATER( radius, real_t(0), "Invalid cylinder radius"  );
 
-   // Initializing the instantiated capsule
+   // Initializing the instantiated cylinder
    gpos_   = gpos;
    q_      = Quat();                 // Setting the orientation
    R_      = q_.toRotationMatrix();  // Setting the rotation matrix

src/pe/rigidbody/CylindricalBoundary.h

@@ -175,7 +175,7 @@ inline id_t CylindricalBoundary::getStaticTypeID()
 //=================================================================================================
 
 //*************************************************************************************************
-/*!\name Capsule operators */
+/*!\name Cylinder operators */
 //@{
 std::ostream& operator<<( std::ostream& os, const CylindricalBoundary& cb );
 std::ostream& operator<<( std::ostream& os, CylindricalBoundaryID cb );