SPHNormalSpecies contains the parameters used to describe a SPH model. More...

#include <SPHNormalSpecies.h>

Inheritance diagram for SPHNormalSpecies:

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

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

	SPHNormalSpecies (const SPHNormalSpecies &p)
	The default copy constructor. More...

	~SPHNormalSpecies ()
	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...

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

Mdouble	getMaximumVelocity (Mdouble radius, Mdouble mass) const
	Calculates the maximum velocity allowed for a collision of two copies of P (for higher velocities particles could pass through each other) More...

void	setStiffnessAndRestitutionCoefficient (Mdouble k_, Mdouble eps, Mdouble mass)
	Sets k, disp such that it matches a given tc and eps for a collision of two copies of P. More...

void	setRestitutionCoefficient (double eps, Mdouble mass)
	Sets disp to obtain a restitution coefficient eps for a collision of two particles of mass m. More...

void	setCollisionTimeAndRestitutionCoefficient (Mdouble tc, Mdouble eps, BaseParticle *p)
	Sets k, disp such that it matches a given tc and eps for a collision of two copies of particle p. More...

void	setCollisionTimeAndRestitutionCoefficient (Mdouble tc, Mdouble eps, Mdouble mass)
	Sets k, disp such that it matches a given tc and eps for a collision of two copies of equal mass m. More...

void	setCollisionTimeAndRestitutionCoefficient (Mdouble collisionTime, Mdouble restitutionCoefficient, Mdouble mass1, Mdouble mass2)

Mdouble	getCollisionTime (Mdouble mass) const
	Calculates collision time for two copies of a particle of given disp, k, mass. More...

Mdouble	getRestitutionCoefficient (Mdouble mass) const
	Calculates restitution coefficient for two copies of given disp, k, mass. More...

void	mix (SPHNormalSpecies SBase, SPHNormalSpecies TBase)
	creates default values for mixed species More...

void	setStiffness (Mdouble new_k)
	Allows the spring constant to be changed. More...

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

void	setDissipation (Mdouble dissipation)
	Allows the normal dissipation to be changed. More...

Mdouble	getDissipation () const
	Allows the normal dissipation to be accessed. More...

MERCURYDPM_DEPRECATED void	setStiffnessAndDissipation (helpers::KAndDisp new_)
	Allows the spring and dissipation constants to be changed simultaneously. More...

Public Member Functions inherited from BaseNormalForce
	BaseNormalForce ()

	BaseNormalForce (const BaseNormalForce &p)

bool	getConstantRestitution () const

void	setConstantRestitution (bool constantRestitution)

virtual void	actionsAfterTimeStep (BaseParticle *particle) const

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

void	setBaseSpecies (BaseSpecies *baseSpecies)

Private Attributes
Mdouble	stiffness_
	(normal) spring constant More...

Mdouble	dissipation_
	(normal) viscosity More...

Detailed Description

SPHNormalSpecies contains the parameters used to describe a SPH model.

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

Member Typedef Documentation

◆ InteractionType

typedef SPHInteraction SPHNormalSpecies::InteractionType

The correct Interaction type for this FrictionForceSpecies.

Constructor & Destructor Documentation

◆ SPHNormalSpecies() [1/2]

SPHNormalSpecies::SPHNormalSpecies ( )

The default constructor.

         : BaseNormalForce()
 {
     stiffness_ = 0.0;
     dissipation_ = 0.0;
 #ifdef DEBUG_CONSTRUCTOR
     std::cout<<"LinearViscoelasticNormalSpecies::LinearViscoelasticNormalSpecies() finished"<<std::endl;
 #endif
 }

References dissipation_, and stiffness_.

◆ SPHNormalSpecies() [2/2]

SPHNormalSpecies::SPHNormalSpecies ( const SPHNormalSpecies & p )

The default copy constructor.

Parameters

[in] the species that is copied

         : BaseNormalForce(p)
 {
     stiffness_ = p.stiffness_;
     dissipation_ = p.dissipation_;
 #ifdef DEBUG_CONSTRUCTOR
     std::cout<<"LinearViscoelasticNormalSpecies::LinearViscoelasticNormalSpecies(const LinearViscoelasticNormalSpecies &p) finished"<<std::endl;
 #endif
 }

References dissipation_, p, and stiffness_.

◆ ~SPHNormalSpecies()

SPHNormalSpecies::~SPHNormalSpecies ( )

The default destructor.

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

Member Function Documentation

◆ getBaseName()

std::string SPHNormalSpecies::getBaseName ( ) const

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")

 {
     return "LinearViscoelastic";
 }

◆ getCollisionTime()

Mdouble SPHNormalSpecies::getCollisionTime ( Mdouble mass ) const

Calculates collision time for two copies of a particle of given disp, k, mass.

Calculates collision time for two copies of a particle of given disp, k, mass

Parameters

[in] mass mass of a typical particle

 {
     if (mass <= 0)
     {
         std::cerr << "Warning in getCollisionTime(" << mass
                   << ") mass is not set or has an unexpected value, (getCollisionTime(" << mass << "))" << std::endl;
     }
     if (stiffness_ <= 0)
     {
         std::cerr << "Warning in getCollisionTime(" << mass << ") stiffness=" << stiffness_
                   << " is not set or has an unexpected value, (getCollisionTime(" << mass << "), with stiffness="
                   << stiffness_ << ")" << std::endl;
     }
     if (dissipation_ < 0)
     {
         std::cerr << "Warning in getCollisionTime(" << mass << ") dissipation=" << dissipation_
                   << " is not set or has an unexpected value, (getCollisionTime(" << mass << "), with dissipation="
                   << dissipation_ << ")" << std::endl;
     }
     Mdouble tosqrt = stiffness_ / (.5 * mass) - mathsFunc::square(dissipation_ / mass);
     if (tosqrt <= 0)
     {
         std::cerr << "Warning in getCollisionTime(" << mass
                   << ") values for mass, stiffness and dissipation would lead to an overdamped system, (getCollisionTime("
                   << mass << "), with stiffness=" << stiffness_ << " and dissipation=" << dissipation_ << ")"
                   << std::endl;
     }
     return constants::pi / std::sqrt(tosqrt);
 }

References dissipation_, constants::pi, sqrt(), mathsFunc::square(), and stiffness_.

Referenced by getRestitutionCoefficient().

◆ getDissipation()

Mdouble SPHNormalSpecies::getDissipation ( ) const

Allows the normal dissipation to be accessed.

 {
     return dissipation_;
 }

References dissipation_.

Referenced by SPHInteraction::computeNormalForce(), and setCollisionTimeAndRestitutionCoefficient().

◆ getMaximumVelocity()

Mdouble SPHNormalSpecies::getMaximumVelocity	(	Mdouble	radius,
		Mdouble	mass
	)		const

Calculates the maximum velocity allowed for a collision of two copies of P (for higher velocities particles could pass through each other)

 {
     return radius * std::sqrt(stiffness_ / (.5 * mass));
 }

References UniformPSDSelfTest::radius, sqrt(), and stiffness_.

◆ getRestitutionCoefficient()

Mdouble SPHNormalSpecies::getRestitutionCoefficient ( Mdouble mass ) const

Calculates restitution coefficient for two copies of given disp, k, mass.

 {
     return std::exp(-dissipation_ / mass * getCollisionTime(mass));
 }

References dissipation_, Eigen::bfloat16_impl::exp(), and getCollisionTime().

◆ getStiffness()

Mdouble SPHNormalSpecies::getStiffness ( ) const

Allows the spring constant to be accessed.

 {
     return stiffness_;
 }

References stiffness_.

Referenced by SPHInteraction::computeNormalForce(), SPHInteraction::getElasticEnergy(), SPHInteraction::getElasticEnergyAtEquilibrium(), setCollisionTimeAndRestitutionCoefficient(), and setRestitutionCoefficient().

◆ mix()

void SPHNormalSpecies::mix	(	SPHNormalSpecies *	SBase,
		SPHNormalSpecies *	TBase
	)

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] S,T the two species whose properties are mixed to create the new species

 {
     stiffness_ = BaseSpecies::average(S->getStiffness(), T->getStiffness());
     dissipation_ = BaseSpecies::average(S->getDissipation(), T->getDissipation());
 }

References BaseSpecies::average(), dissipation_, oomph::QuadTreeNames::S, and stiffness_.

◆ read()

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

Reads the species properties from an input stream.

Parameters

[in] input stream (typically the restart file)

 {
     std::string dummy;
     is >> dummy >> stiffness_
        >> dummy >> dissipation_;
 }

References dissipation_, stiffness_, and oomph::Global_string_for_annotation::string().

◆ setCollisionTimeAndRestitutionCoefficient() [1/3]

void SPHNormalSpecies::setCollisionTimeAndRestitutionCoefficient	(	Mdouble	collisionTime,
		Mdouble	restitutionCoefficient,
		Mdouble	mass1,
		Mdouble	mass2
	)

Set k, disp such that is matches a given tc and eps for a collision of two different masses. Recall the resitution constant is a function of k, disp and the mass of each particle in the collision See also setCollisionTimeAndRestitutionCoefficient(Mdouble tc, Mdouble eps, Mdouble mass)

Parameters

[in] collision time

 {
     Mdouble reduced_mass = mass1 * mass2 / (mass1 + mass2);
     setCollisionTimeAndRestitutionCoefficient(collisionTime, restitutionCoefficient, 2.0 * reduced_mass);
 }

References setCollisionTimeAndRestitutionCoefficient().

◆ setCollisionTimeAndRestitutionCoefficient() [2/3]

void SPHNormalSpecies::setCollisionTimeAndRestitutionCoefficient	(	Mdouble	tc,
		Mdouble	eps,
		BaseParticle *	p
	)

Sets k, disp such that it matches a given tc and eps for a collision of two copies of particle p.

 {
     Mdouble mass = p->getSpecies()->getDensity() * p->getVolume();
     setCollisionTimeAndRestitutionCoefficient(tc, eps, mass);
 }

References CRBond_Bessel::eps, and p.

Referenced by setCollisionTimeAndRestitutionCoefficient().

◆ setCollisionTimeAndRestitutionCoefficient() [3/3]

void SPHNormalSpecies::setCollisionTimeAndRestitutionCoefficient	(	Mdouble	tc,
		Mdouble	eps,
		Mdouble	mass
	)

Sets k, disp such that it matches a given tc and eps for a collision of two copies of equal mass m.

Sets k, disp such that it matches a given tc and eps for a collision of two copies of equal mass m

Parameters

[in]	tc	collision time
[in]	eps	restitution coefficient
[in]	mass	harmonic average particle mass, \(\frac{2}{1/m1+1/m2}\)

 {
     if (eps == 0.0)
     {
         stiffness_ = .5 * mass * mathsFunc::square(constants::pi / tc);
         dissipation_ = std::sqrt(2.0 * mass * stiffness_);
     }
     else
     {
         dissipation_ = -mass / tc * mathsFunc::log(eps);
         stiffness_ = .5 * mass * (mathsFunc::square(constants::pi / tc)
                                   + mathsFunc::square(dissipation_ / mass));
     }
     logger(INFO,
            "setCollisionTimeAndRestitutionCoefficient: set stiffness to % and dissipation to % to obtain a collision time of % and a restitution coefficient of % for two particles of mass %",
            getStiffness(), getDissipation(), tc, eps, mass);
 }

References dissipation_, CRBond_Bessel::eps, getDissipation(), getStiffness(), INFO, mathsFunc::log(), logger, constants::pi, sqrt(), mathsFunc::square(), and stiffness_.

◆ setDissipation()

void SPHNormalSpecies::setDissipation ( Mdouble dissipation )

Allows the normal dissipation to be changed.

 {
     if (dissipation >= 0)
     {
         dissipation_ = dissipation;
     }
     else
     {
         std::cerr << "Error in setDissipation(" << dissipation << ")" << std::endl;
         exit(-1);
     }
 }

References dissipation_.

Referenced by setStiffnessAndDissipation().

◆ setRestitutionCoefficient()

void SPHNormalSpecies::setRestitutionCoefficient	(	double	eps,
		Mdouble	mass
	)

Sets disp to obtain a restitution coefficient eps for a collision of two particles of mass m.

Sets k, disp such that it matches a given tc and eps for a collision of two copies of P

Parameters

[in]	stiffness	stiffness
[in]	eps	restitution coefficient
[in]	mass	effective particle mass, \(\frac{2}{1/m1+1/m2}\)

 {
     if (eps == 0.0) {
         dissipation_ = std::sqrt(2.0 * mass * getStiffness());
     } else {
         const Mdouble logEps = log(eps);
         dissipation_ = -std::sqrt(2.0 * mass * getStiffness()
                                   / (constants::sqr_pi + mathsFunc::square(logEps))) * logEps;
     }
 }

References dissipation_, CRBond_Bessel::eps, getStiffness(), Eigen::bfloat16_impl::log(), constants::sqr_pi, sqrt(), and mathsFunc::square().

Referenced by setStiffnessAndRestitutionCoefficient().

◆ setStiffness()

void SPHNormalSpecies::setStiffness ( Mdouble new_k )

Allows the spring constant to be changed.

 {
     if (new_k >= 0)
         stiffness_ = new_k;
     else
     {
         std::cerr << "Error in set_k" << std::endl;
         exit(-1);
     }
 }

References stiffness_.

Referenced by setStiffnessAndDissipation().

◆ setStiffnessAndDissipation()

void SPHNormalSpecies::setStiffnessAndDissipation ( helpers::KAndDisp new_ )

Allows the spring and dissipation constants to be changed simultaneously.

 {
     setStiffness(new_.k);
     setDissipation(new_.disp);
 }

References helpers::KAndDisp::disp, helpers::KAndDisp::k, setDissipation(), and setStiffness().

◆ setStiffnessAndRestitutionCoefficient()

void SPHNormalSpecies::setStiffnessAndRestitutionCoefficient	(	Mdouble	stiffness,
		Mdouble	eps,
		Mdouble	mass
	)

Sets k, disp such that it matches a given tc and eps for a collision of two copies of P.

Sets k, disp such that it matches a given tc and eps for a collision of two copies of P

Parameters

[in]	stiffness	stiffness
[in]	eps	restitution coefficient
[in]	harmonic	mean of particle masses, \(\frac{2}{1/m1+1/m2}\)

 {
     stiffness_ = stiffness;
     setRestitutionCoefficient(eps, mass);
 }

References CRBond_Bessel::eps, setRestitutionCoefficient(), and stiffness_.

◆ write()

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

Writes the species properties to an output stream.

Parameters

[out] output stream (typically the restart file)

 {
     os << " stiffness " << stiffness_
        << " dissipation " << dissipation_;
 }

References dissipation_, and stiffness_.

Member Data Documentation

◆ dissipation_

Mdouble SPHNormalSpecies::dissipation_

private

(normal) viscosity

Referenced by getCollisionTime(), getDissipation(), getRestitutionCoefficient(), mix(), read(), setCollisionTimeAndRestitutionCoefficient(), setDissipation(), setRestitutionCoefficient(), SPHNormalSpecies(), and write().

◆ stiffness_

Mdouble SPHNormalSpecies::stiffness_

private

(normal) spring constant

Referenced by getCollisionTime(), getMaximumVelocity(), getStiffness(), mix(), read(), setCollisionTimeAndRestitutionCoefficient(), setStiffness(), setStiffnessAndRestitutionCoefficient(), SPHNormalSpecies(), 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

◆ SPHNormalSpecies() [1/2]

◆ SPHNormalSpecies() [2/2]

◆ ~SPHNormalSpecies()

Member Function Documentation

◆ getBaseName()

◆ getCollisionTime()

◆ getDissipation()

◆ getMaximumVelocity()

◆ getRestitutionCoefficient()

◆ getStiffness()

◆ mix()

◆ read()

◆ setCollisionTimeAndRestitutionCoefficient() [1/3]

◆ setCollisionTimeAndRestitutionCoefficient() [2/3]

◆ setCollisionTimeAndRestitutionCoefficient() [3/3]

◆ setDissipation()

◆ setRestitutionCoefficient()

◆ setStiffness()

◆ setStiffnessAndDissipation()

◆ setStiffnessAndRestitutionCoefficient()

◆ write()

Member Data Documentation

◆ dissipation_

◆ stiffness_