SlidingFrictionSpecies contains the parameters used to describe sliding friction. More...

#include <SlidingFrictionSpecies.h>

Inheritance diagram for SlidingFrictionSpecies:

Public Types
typedef SlidingFrictionInteraction	InteractionType
	The correct Interaction type for this FrictionForceSpecies. More...

Public Member Functions
	SlidingFrictionSpecies ()
	The default constructor. More...

	SlidingFrictionSpecies (const SlidingFrictionSpecies &s)
	The default copy constructor. More...

	~SlidingFrictionSpecies ()
	The default destructor. More...

void	read (std::istream &is)
	Reads the species properties from an input stream. More...

void	write (std::ostream &os) const
	Writes the species properties to an output stream. More...

virtual std::string	getBaseName () const
	Used in Species::getName to obtain a unique name for each Species. More...

void	setSlidingStiffness (Mdouble new_kt)
	Allows the spring constant to be changed. More...

Mdouble	getSlidingStiffness () const
	Allows the spring constant to be accessed. More...

void	setSlidingDissipation (Mdouble new_dispt)
	Allows the tangential viscosity to be changed. More...

Mdouble	getSlidingDissipation () const
	Allows the tangential viscosity to be accessed. More...

void	setSlidingFrictionCoefficient (Mdouble new_mu)
	Allows the (dynamic) Coulomb friction coefficient to be changed; also sets mu_s by default. More...

Mdouble	getSlidingFrictionCoefficient () const
	Allows the (dynamic) Coulomb friction coefficient to be accessed. More...

void	setSlidingFrictionCoefficientStatic (Mdouble new_mu)
	Allows the static Coulomb friction coefficient to be changed. More...

Mdouble	getSlidingFrictionCoefficientStatic () const
	Allows the static Coulomb friction coefficient to be accessed. More...

bool	getUseAngularDOFs () const override
	Returns true if torques have to be calculated. More...

void	mix (SlidingFrictionSpecies S, SlidingFrictionSpecies T)
	creates default values for mixed species More...

void	setCollisionTimeAndNormalAndTangentialRestitutionCoefficient (Mdouble tc, Mdouble eps, Mdouble beta, Mdouble mass)
	Sets k, disp, kt, dispt such that it matches a given tc and eps for a collision of two particles of masses m0,m1. More...

void	setCollisionTimeAndNormalAndTangentialRestitutionCoefficientNoDispt (Mdouble tc, Mdouble eps, Mdouble beta, Mdouble mass)
	Sets k, disp, kt (with dispt=0) such that it matches a given tc and eps for a collision of two particles of mass m. More...

void	setIsSuperquadricSpecies (bool isSuperquadricSpecies)

bool	getIsSuperquadricSpecies () const

Public Member Functions inherited from BaseForce
BaseSpecies *	getBaseSpecies () const

void	setBaseSpecies (BaseSpecies *baseSpecies)

Private Attributes
Mdouble	slidingStiffness_
	tangential stiffness. More...

Mdouble	slidingDissipation_
	tangential dissipation coefficient. More...

Mdouble	slidingFrictionCoefficient_
	(dynamic) Coulomb friction coefficient More...

Mdouble	slidingFrictionCoefficientStatic_
	static Coulomb friction coefficient (by default set equal to mu) More...

bool	isSuperquadricSpecies_

Detailed Description

SlidingFrictionSpecies contains the parameters used to describe sliding friction.

See SlidingFrictionInteraction::computeForce for a description of the force law.

Member Typedef Documentation

◆ InteractionType

typedef SlidingFrictionInteraction SlidingFrictionSpecies::InteractionType

The correct Interaction type for this FrictionForceSpecies.

Constructor & Destructor Documentation

◆ SlidingFrictionSpecies() [1/2]

SlidingFrictionSpecies::SlidingFrictionSpecies ( )

The default constructor.

 {
     slidingStiffness_ = 0;
     slidingDissipation_ = 0;
     slidingFrictionCoefficient_ = 0;
     slidingFrictionCoefficientStatic_ = 0;
     isSuperquadricSpecies_ = false;
 #ifdef DEBUG_CONSTRUCTOR
     std::cout<<"SlidingFrictionSpecies::SlidingFrictionSpecies() finished"<<std::endl;
 #endif
 }

References isSuperquadricSpecies_, slidingDissipation_, slidingFrictionCoefficient_, slidingFrictionCoefficientStatic_, and slidingStiffness_.

◆ SlidingFrictionSpecies() [2/2]

SlidingFrictionSpecies::SlidingFrictionSpecies ( const SlidingFrictionSpecies & s )

The default copy constructor.

Parameters

[in] s the species that is copied

 {
     slidingStiffness_ = s.slidingStiffness_;
     slidingDissipation_ = s.slidingDissipation_;
     slidingFrictionCoefficient_ = s.slidingFrictionCoefficient_;
     slidingFrictionCoefficientStatic_ = s.slidingFrictionCoefficientStatic_;
     isSuperquadricSpecies_ = s.isSuperquadricSpecies_;
 #ifdef DEBUG_CONSTRUCTOR
     std::cout<<"SlidingFrictionSpecies::SlidingFrictionSpecies(const SlidingFrictionSpecies &p) finished"<<std::endl;
 #endif
 }

References isSuperquadricSpecies_, slidingDissipation_, slidingFrictionCoefficient_, slidingFrictionCoefficientStatic_, and slidingStiffness_.

◆ ~SlidingFrictionSpecies()

SlidingFrictionSpecies::~SlidingFrictionSpecies ( )

The default destructor.

 {
 #ifdef DEBUG_DESTRUCTOR
     std::cout<<"SlidingFrictionSpecies::~SlidingFrictionSpecies() finished"<<std::endl;
 #endif
 }

Member Function Documentation

◆ getBaseName()

std::string SlidingFrictionSpecies::getBaseName ( ) const

virtual

Used in Species::getName to obtain a unique name for each Species.

Returns: a string containing the name of the species (minus the word "Species")

Reimplemented in FrictionSpecies.

 {
     return "SlidingFriction";
 }

◆ getIsSuperquadricSpecies()

bool SlidingFrictionSpecies::getIsSuperquadricSpecies ( ) const

 {
     return isSuperquadricSpecies_;
 }

References isSuperquadricSpecies_.

Referenced by SlidingFrictionInteraction::computeFrictionForce().

◆ getSlidingDissipation()

Mdouble SlidingFrictionSpecies::getSlidingDissipation ( ) const

Allows the tangential viscosity to be accessed.

 {
     return slidingDissipation_;
 }

References slidingDissipation_.

Referenced by SlidingFrictionInteraction::computeFrictionForce(), and mix().

◆ getSlidingFrictionCoefficient()

Mdouble SlidingFrictionSpecies::getSlidingFrictionCoefficient ( ) const

Allows the (dynamic) Coulomb friction coefficient to be accessed.

 {
     return slidingFrictionCoefficient_;
 }

References slidingFrictionCoefficient_.

Referenced by SlidingFrictionInteraction::computeFrictionForce(), and mix().

◆ getSlidingFrictionCoefficientStatic()

Mdouble SlidingFrictionSpecies::getSlidingFrictionCoefficientStatic ( ) const

Allows the static Coulomb friction coefficient to be accessed.

 {
     return slidingFrictionCoefficientStatic_;
 }

References slidingFrictionCoefficientStatic_.

Referenced by SlidingFrictionInteraction::computeFrictionForce(), and mix().

◆ getSlidingStiffness()

Mdouble SlidingFrictionSpecies::getSlidingStiffness ( ) const

Allows the spring constant to be accessed.

 {
     return slidingStiffness_;
 }

References slidingStiffness_.

Referenced by SlidingFrictionInteraction::computeFrictionForce(), SlidingFrictionInteraction::getElasticEnergy(), mix(), and setCollisionTimeAndNormalAndTangentialRestitutionCoefficient().

◆ getUseAngularDOFs()

bool SlidingFrictionSpecies::getUseAngularDOFs ( ) const

overridevirtual

Returns true if torques have to be calculated.

Returns true for any FrictionForceSpecies except EmptyFrictionSpecies, because for spherical particles, torques are only caused by tangential forces. See SpeciesHandler::useAngularDOFs for more details

Returns: true

Implements BaseFrictionForce.

Reimplemented in Species< LinearPlasticViscoelasticNormalSpecies, SlidingFrictionSpecies, IrreversibleAdhesiveSpecies >, and Species< LinearViscoelasticNormalSpecies, SlidingFrictionSpecies, IrreversibleAdhesiveSpecies >.

 {
     return true;
 }

◆ mix()

void SlidingFrictionSpecies::mix	(	SlidingFrictionSpecies *	S,
		SlidingFrictionSpecies *	T
	)

creates default values for mixed species

For all parameters we assume that the harmonic mean of the parameters of the original two species is a sensible default.

Parameters

[in]	SFrictional	the first species whose properties are mixed to create the new species
[in]	TFrictional	the second species whose properties are mixed to create the new species

 {
     slidingStiffness_ = BaseSpecies::average(S->getSlidingStiffness(), T->getSlidingStiffness());
     slidingDissipation_ = BaseSpecies::average(S->getSlidingDissipation(), T->getSlidingDissipation());
     slidingFrictionCoefficient_ = BaseSpecies::average(S->getSlidingFrictionCoefficient(),
                                           T->getSlidingFrictionCoefficient());
     slidingFrictionCoefficientStatic_ = BaseSpecies::average(S->getSlidingFrictionCoefficientStatic(),
                                                 T->getSlidingFrictionCoefficientStatic());
 }

References BaseSpecies::average(), getSlidingDissipation(), getSlidingFrictionCoefficient(), getSlidingFrictionCoefficientStatic(), getSlidingStiffness(), slidingDissipation_, slidingFrictionCoefficient_, slidingFrictionCoefficientStatic_, and slidingStiffness_.

◆ read()

void SlidingFrictionSpecies::read ( std::istream & is )

Reads the species properties from an input stream.

Parameters

[in] is input stream (typically the restart file)

 {
     //BaseSpecies::read(is);
     std::string dummy;
     is >> dummy >> slidingStiffness_;
     is >> dummy >> slidingDissipation_;
     is >> dummy >> slidingFrictionCoefficient_;
     is >> dummy >> slidingFrictionCoefficientStatic_;
 }

References slidingDissipation_, slidingFrictionCoefficient_, slidingFrictionCoefficientStatic_, and slidingStiffness_.

Referenced by FrictionSpecies::read().

◆ setCollisionTimeAndNormalAndTangentialRestitutionCoefficient()

void SlidingFrictionSpecies::setCollisionTimeAndNormalAndTangentialRestitutionCoefficient	(	Mdouble	tc,
		Mdouble	eps,
		Mdouble	beta,
		Mdouble	mass
	)

Sets k, disp, kt, dispt such that it matches a given tc and eps for a collision of two particles of masses m0,m1.

 {
     Mdouble stiffness;
     //the dynamic cast is needed to check if the normal force species is LinearViscoelasticSpecies; otherwise this function cannot be used
     LinearViscoelasticNormalSpecies* species = dynamic_cast<LinearViscoelasticNormalSpecies*>(this);
     if (species != nullptr)
     {
         species->setCollisionTimeAndRestitutionCoefficient(tc, eps, mass);
         stiffness = species->getStiffness();
     }
     else
     {
         LinearPlasticViscoelasticNormalSpecies* species2 = dynamic_cast<LinearPlasticViscoelasticNormalSpecies*>(this);
         if (species2 != nullptr)
         {
             species2->setDissipation(-mass / tc * std::log(eps));
             species2->setLoadingStiffness(.5 * mass * (mathsFunc::square(constants::pi / tc) +
                                                        mathsFunc::square(species2->getDissipation()) / mass));
             stiffness = species2->getLoadingStiffness();
         }
         else
         {
             logger(ERROR,
                    "SlidingFrictionSpecies::setCollisionTimeAndNormalAndTangentialRestitutionCoefficient only works for "
                    "LinearViscoelasticSlidingFrictionSpecies or LinearPlasticViscoelasticSlidingFrictionSpecies");
         }
     }
     
     // from: N. G. Deen et. al. https://doi.org/10.1016/j.ces.2006.08.014
     // eq. 43 and 30
     setSlidingStiffness(2.0 / 7.0 * stiffness * (mathsFunc::square(constants::pi) + mathsFunc::square(log(beta))) /
                         (mathsFunc::square(constants::pi) + mathsFunc::square(log(eps))));
     if (beta != 0.0)
         setSlidingDissipation(-2 * log(beta) * sqrt(1.0 / 7.0 * mass * getSlidingStiffness() /
                                                     (mathsFunc::square(constants::pi) + mathsFunc::square(log(beta)))));
     else
         setSlidingDissipation(2. * sqrt(1.0 / 7.0 * mass * getSlidingStiffness()));
 }

References mathsFunc::beta(), ERROR, LinearPlasticViscoelasticNormalSpecies::getDissipation(), LinearPlasticViscoelasticNormalSpecies::getLoadingStiffness(), getSlidingStiffness(), LinearViscoelasticNormalSpecies::getStiffness(), mathsFunc::log(), logger, constants::pi, LinearViscoelasticNormalSpecies::setCollisionTimeAndRestitutionCoefficient(), LinearPlasticViscoelasticNormalSpecies::setDissipation(), LinearPlasticViscoelasticNormalSpecies::setLoadingStiffness(), setSlidingDissipation(), setSlidingStiffness(), and mathsFunc::square().

◆ setCollisionTimeAndNormalAndTangentialRestitutionCoefficientNoDispt()

void SlidingFrictionSpecies::setCollisionTimeAndNormalAndTangentialRestitutionCoefficientNoDispt	(	Mdouble	tc,
		Mdouble	eps,
		Mdouble	beta,
		Mdouble	mass
	)

Sets k, disp, kt (with dispt=0) such that it matches a given tc and eps for a collision of two particles of mass m.

Sets k, disp, kt, dispt such that it matches a given tc and eps for a collision of two particles of masses m0,m1.

 {
     //the dynamic cast is needed to check if the normal force species is LinearViscoelasticSpecies; otherwise this function cannot be used
     LinearViscoelasticNormalSpecies* species = dynamic_cast<LinearViscoelasticNormalSpecies*>(this);
     if (species == nullptr)
     {
         logger(ERROR, "SlidingFrictionSpecies::setCollisionTimeAndNormalAndTangentialRestitutionCoefficient only "
                       "works for LinearViscoelasticSlidingFrictionSpecies");
     }
     species->setCollisionTimeAndRestitutionCoefficient(tc, eps, mass);
     // from: V. Becker et. al. https://doi.org/10.1103/PhysRevE.77.011304
     // eq. 56
     setSlidingStiffness(2.0 / 7.0 * species->getStiffness() * mathsFunc::square(acos(-beta) / constants::pi));
     setSlidingDissipation(0);
 }

References mathsFunc::beta(), ERROR, LinearViscoelasticNormalSpecies::getStiffness(), logger, constants::pi, LinearViscoelasticNormalSpecies::setCollisionTimeAndRestitutionCoefficient(), setSlidingDissipation(), setSlidingStiffness(), and mathsFunc::square().

◆ setIsSuperquadricSpecies()

void SlidingFrictionSpecies::setIsSuperquadricSpecies ( bool isSuperquadricSpecies )

 {
     SlidingFrictionSpecies::isSuperquadricSpecies_ = isSuperquadricSpecies;
 }

References isSuperquadricSpecies_.

◆ setSlidingDissipation()

void SlidingFrictionSpecies::setSlidingDissipation ( Mdouble new_dispt )

Allows the tangential viscosity to be changed.

 {
     if (new_dispt >= 0)
         slidingDissipation_ = new_dispt;
     else
     {
         logger(ERROR, "Error in setSlidingDissipation");
     }
 }

References ERROR, logger, and slidingDissipation_.

Referenced by setCollisionTimeAndNormalAndTangentialRestitutionCoefficient(), and setCollisionTimeAndNormalAndTangentialRestitutionCoefficientNoDispt().

◆ setSlidingFrictionCoefficient()

void SlidingFrictionSpecies::setSlidingFrictionCoefficient ( Mdouble new_mu )

Allows the (dynamic) Coulomb friction coefficient to be changed; also sets mu_s by default.

 {
     if (new_mu >= 0)
     {
         slidingFrictionCoefficient_ = new_mu;
         slidingFrictionCoefficientStatic_ = slidingFrictionCoefficient_;
     }
     else
     {
         logger(ERROR, "Error in setSlidingFrictionCoefficient");
     }
 }

References ERROR, logger, slidingFrictionCoefficient_, and slidingFrictionCoefficientStatic_.

Referenced by ChuteBottom::makeRoughBottom(), ParticleParticleInteraction::setupInitialConditions(), ParticleParticleInteractionWithPlasticForces::setupInitialConditions(), and ParticleWallInteraction::setupInitialConditions().

◆ setSlidingFrictionCoefficientStatic()

void SlidingFrictionSpecies::setSlidingFrictionCoefficientStatic ( Mdouble new_mu )

Allows the static Coulomb friction coefficient to be changed.

Allows the static Coulomb friction coefficient to be changed; also sets mu_s by default.

 {
     if (new_mu >= 0)
     {
         slidingFrictionCoefficientStatic_ = new_mu;
     }
     else
     {
         logger(ERROR, "Error in setSlidingFrictionCoefficientStatic");
     }
 }

References ERROR, logger, and slidingFrictionCoefficientStatic_.

◆ setSlidingStiffness()

void SlidingFrictionSpecies::setSlidingStiffness ( Mdouble new_kt )

Allows the spring constant to be changed.

 {
     if (new_kt >= 0)
     {
         slidingStiffness_ = new_kt;
     }
     else
     {
         logger(ERROR, "Error in setSlidingStiffness");
     }
 }

References ERROR, logger, and slidingStiffness_.

Referenced by setCollisionTimeAndNormalAndTangentialRestitutionCoefficient(), setCollisionTimeAndNormalAndTangentialRestitutionCoefficientNoDispt(), ParticleParticleInteraction::setupInitialConditions(), ParticleParticleInteractionWithPlasticForces::setupInitialConditions(), and ParticleWallInteraction::setupInitialConditions().

◆ write()

void SlidingFrictionSpecies::write ( std::ostream & os ) const

Writes the species properties to an output stream.

Parameters

[out] os output stream (typically the restart file)

 {
     //BaseSpecies::write(os);
     os << " slidingStiffness " << slidingStiffness_;
     os << " slidingDissipation " << slidingDissipation_;
     os << " slidingFrictionCoefficient " << slidingFrictionCoefficient_;
     os << " slidingFrictionCoefficientStatic " << slidingFrictionCoefficientStatic_;
 }

References slidingDissipation_, slidingFrictionCoefficient_, slidingFrictionCoefficientStatic_, and slidingStiffness_.

Referenced by FrictionSpecies::write().

Member Data Documentation

◆ isSuperquadricSpecies_

bool SlidingFrictionSpecies::isSuperquadricSpecies_

private

Referenced by getIsSuperquadricSpecies(), setIsSuperquadricSpecies(), and SlidingFrictionSpecies().

◆ slidingDissipation_

Mdouble SlidingFrictionSpecies::slidingDissipation_

private

tangential dissipation coefficient.

Typically set to 2/7 of the normal force dissipation, as both the tangential and the normal spring have the same restitution coefficients (if the tangential and normal stiffnesses also have a ratio of 2/7). should always satisfy \(4*dispt*dt<mass, dispt \approx disp\), otherwise the restitution is zero and the particles stick.

Referenced by getSlidingDissipation(), mix(), read(), setSlidingDissipation(), SlidingFrictionSpecies(), and write().

◆ slidingFrictionCoefficient_

Mdouble SlidingFrictionSpecies::slidingFrictionCoefficient_

private

(dynamic) Coulomb friction coefficient

Referenced by getSlidingFrictionCoefficient(), mix(), read(), setSlidingFrictionCoefficient(), SlidingFrictionSpecies(), and write().

◆ slidingFrictionCoefficientStatic_

Mdouble SlidingFrictionSpecies::slidingFrictionCoefficientStatic_

private

static Coulomb friction coefficient (by default set equal to mu)

Referenced by getSlidingFrictionCoefficientStatic(), mix(), read(), setSlidingFrictionCoefficient(), setSlidingFrictionCoefficientStatic(), SlidingFrictionSpecies(), and write().

◆ slidingStiffness_

Mdouble SlidingFrictionSpecies::slidingStiffness_

private

tangential stiffness.

Typically set to 2/7 of the stiffness of the normal force, as
both the tangential and the normal spring have the same oscillation
frequency (and thus require the same timeStep)in this case.

Referenced by getSlidingStiffness(), mix(), read(), setSlidingStiffness(), SlidingFrictionSpecies(), and write().

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ InteractionType

Constructor & Destructor Documentation

◆ SlidingFrictionSpecies() [1/2]

◆ SlidingFrictionSpecies() [2/2]

◆ ~SlidingFrictionSpecies()

Member Function Documentation

◆ getBaseName()

◆ getIsSuperquadricSpecies()

◆ getSlidingDissipation()

◆ getSlidingFrictionCoefficient()

◆ getSlidingFrictionCoefficientStatic()

◆ getSlidingStiffness()

◆ getUseAngularDOFs()

◆ mix()

◆ read()

◆ setCollisionTimeAndNormalAndTangentialRestitutionCoefficient()

◆ setCollisionTimeAndNormalAndTangentialRestitutionCoefficientNoDispt()

◆ setIsSuperquadricSpecies()

◆ setSlidingDissipation()

◆ setSlidingFrictionCoefficient()

◆ setSlidingFrictionCoefficientStatic()

◆ setSlidingStiffness()

◆ write()

Member Data Documentation

◆ isSuperquadricSpecies_

◆ slidingDissipation_

◆ slidingFrictionCoefficient_

◆ slidingFrictionCoefficientStatic_

◆ slidingStiffness_