LinearPlasticViscoelasticNormalSpecies Class Reference

LinearPlasticViscoelasticNormalSpecies contains the parameters used to describe a plastic-cohesive normal force (Stefan Ludings plastic-cohesive force model). More...

#include <LinearPlasticViscoelasticNormalSpecies.h>

Inheritance diagram for LinearPlasticViscoelasticNormalSpecies:

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

Public Member Functions
	LinearPlasticViscoelasticNormalSpecies ()
	The default constructor. More...
	LinearPlasticViscoelasticNormalSpecies (const LinearPlasticViscoelasticNormalSpecies &p)
	The default copy constructor. More...
	~LinearPlasticViscoelasticNormalSpecies ()
	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...
void	mix (LinearPlasticViscoelasticNormalSpecies *S, LinearPlasticViscoelasticNormalSpecies *T)
	creates default values for mixed species More...
void	setCollisionTimeAndRestitutionCoefficient (Mdouble tc, Mdouble eps, Mdouble mass)
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...
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	setPlasticParameters (Mdouble loadingStiffness, Mdouble unloadingStiffnessMax, Mdouble cohesionStiffness, Mdouble penetrationDepthMax)
	Sets all parameters of the linear plastic-viscoelastic normal force at once. More...
Mdouble	getLoadingStiffness () const
	Returns the loading stiffness of the linear plastic-viscoelastic normal force. More...
Mdouble	getUnloadingStiffnessMax () const
	Returns the maximum unloading stiffness of the linear plastic-viscoelastic normal force. More...
Mdouble	getCohesionStiffness () const
	Returns the cohesive stiffness of the linear plastic-viscoelastic normal force. More...
Mdouble	getPenetrationDepthMax () const
	Returns the maximum penetration depth of the linear plastic-viscoelastic normal force. More...
void	setLoadingStiffness (Mdouble loadingStiffness)
	Sets the loading stiffness of the linear plastic-viscoelastic normal force. More...
void	setUnloadingStiffnessMax (Mdouble unloadingStiffnessMax)
	Sets the maximum unloading stiffness of the linear plastic-viscoelastic normal force. More...
void	setCohesionStiffness (Mdouble cohesionStiffness)
	Sets the cohesive stiffness of the linear plastic-viscoelastic normal force. More...
void	setPenetrationDepthMax (Mdouble penetrationDepthMax)
	Sets the maximum penetration depth of the linear plastic-viscoelastic normal force. More...
void	setDissipation (Mdouble dissipation)
	Sets the linear dissipation coefficient of the linear plastic-viscoelastic normal force. More...
MERCURYDPM_DEPRECATED void	setLoadingStiffnessAndDissipation (helpers::KAndDisp new_)
	Allows the spring and dissipation constants to be changed simultaneously. More...
Mdouble	computeTimeStep (Mdouble mass)
	Returns the optimal time step to resolve a collision of two particles of a given mass. More...
Mdouble	getDissipation () const
	Allows the normal dissipation to be accessed. More...
Mdouble	computeBondNumberMax (Mdouble harmonicMeanRadius, Mdouble gravitationalAcceleration) const
	1) Computes the maximum plastic overlap delta_p* = phi*r 2) Computes the overlap at which the maximum adhesive force is generated: delta_c* = delta_p* / (1+k_c/k_2*) 3) Computes the maximum adhesive force f_c* = k_c * delta_c* 4) Computes the maximum bond number Bo* = f_c* / (m*g) More...
bool	getDoConstantUnloadingStiffness () const
void	setDoConstantUnloadingStiffness (bool doConstantUnloadingStiffness)
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	loadingStiffness_
	(normal) spring constant (k_1) More...
Mdouble	unloadingStiffnessMax_
	the maximum elastic constant (k_2^max) for plastic deformations More...
Mdouble	cohesionStiffness_
	the adhesive spring constant (k^c) for plastic deformations More...
Mdouble	penetrationDepthMax_
	the depth (relative to the normalized radius) at which k_2^max is used (phi_f) More...
Mdouble	dissipation_
	linear dissipation coefficient More...
bool	doConstantUnloadingStiffness_ = false

Detailed Description

LinearPlasticViscoelasticNormalSpecies contains the parameters used to describe a plastic-cohesive normal force (Stefan Ludings plastic-cohesive force model).

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

Member Typedef Documentation

InteractionType

typedef LinearPlasticViscoelasticInteraction LinearPlasticViscoelasticNormalSpecies::InteractionType

The correct Interaction type for this FrictionForceSpecies.

Constructor & Destructor Documentation

LinearPlasticViscoelasticNormalSpecies() [1/2]

LinearPlasticViscoelasticNormalSpecies::LinearPlasticViscoelasticNormalSpecies

(

)

The default constructor.

        : BaseNormalForce()
{
    loadingStiffness_ = 0.0;
    unloadingStiffnessMax_ = 0.0;
    cohesionStiffness_ = 0.0;
    penetrationDepthMax_ = 0.0;
    dissipation_ = 0.0;
    doConstantUnloadingStiffness_ = 0.0;
#ifdef DEBUG_CONSTRUCTOR
    std::cout<<"LinearPlasticViscoelasticNormalSpecies::LinearPlasticViscoelasticNormalSpecies() finished"<<std::endl;
#endif
}

References cohesionStiffness_, dissipation_, doConstantUnloadingStiffness_, loadingStiffness_, penetrationDepthMax_, and unloadingStiffnessMax_.

LinearPlasticViscoelasticNormalSpecies() [2/2]

LinearPlasticViscoelasticNormalSpecies::LinearPlasticViscoelasticNormalSpecies

(

const LinearPlasticViscoelasticNormalSpecies &

p

)

The default copy constructor.

Parameters

[in]

the

species that is copied

        : BaseNormalForce(p)
{
    loadingStiffness_ = p.loadingStiffness_;
    unloadingStiffnessMax_ = p.unloadingStiffnessMax_;
    cohesionStiffness_ = p.cohesionStiffness_;
    penetrationDepthMax_ = p.penetrationDepthMax_;
    dissipation_ = p.dissipation_;
    doConstantUnloadingStiffness_ = p.doConstantUnloadingStiffness_;
#ifdef DEBUG_CONSTRUCTOR
    std::cout<<"LinearPlasticViscoelasticNormalSpecies::LinearPlasticViscoelasticNormalSpecies(const LinearPlasticViscoelasticNormalSpecies &p) finished"<<std::endl;
#endif
}

References cohesionStiffness_, dissipation_, doConstantUnloadingStiffness_, loadingStiffness_, penetrationDepthMax_, and unloadingStiffnessMax_.

~LinearPlasticViscoelasticNormalSpecies()

LinearPlasticViscoelasticNormalSpecies::~LinearPlasticViscoelasticNormalSpecies

(

)

The default destructor.

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

Member Function Documentation

computeBondNumberMax()

Mdouble LinearPlasticViscoelasticNormalSpecies::computeBondNumberMax	(	Mdouble	harmonicMeanRadius,
		Mdouble	gravitationalAcceleration
	)		const

1) Computes the maximum plastic overlap delta_p* = phi*r 2) Computes the overlap at which the maximum adhesive force is generated: delta_c* = delta_p* / (1+k_c/k_2*) 3) Computes the maximum adhesive force f_c* = k_c * delta_c* 4) Computes the maximum bond number Bo* = f_c* / (m*g)

                                                                                                                                        {
    if (getConstantRestitution()) {
        //harmonicMeanRadius unused
        const Mdouble plasticOverlapMax = penetrationDepthMax_;
        const Mdouble overlapMaxCohesion = plasticOverlapMax / (1 + cohesionStiffness_ / unloadingStiffnessMax_);
        const Mdouble cohesionAccelerationMax = cohesionStiffness_ * overlapMaxCohesion;
        return cohesionAccelerationMax / gravitationalAcceleration;
    } else {
        const Mdouble plasticOverlapMax = penetrationDepthMax_ * harmonicMeanRadius;
        const Mdouble overlapMaxCohesion = plasticOverlapMax / (1 + cohesionStiffness_ / unloadingStiffnessMax_);
        const Mdouble cohesionForceMax = cohesionStiffness_ * overlapMaxCohesion;
        auto species = dynamic_cast<const ParticleSpecies*>(getBaseSpecies());
        logger.assert_debug(species,"computeBondNumberMax: species needs to be a ParticleSpecies");
        const Mdouble gravitationalForce = gravitationalAcceleration * species->getMassFromRadius(harmonicMeanRadius);
        return cohesionForceMax / gravitationalForce;
    }
}

References cohesionStiffness_, BaseForce::getBaseSpecies(), BaseNormalForce::getConstantRestitution(), logger, penetrationDepthMax_, and unloadingStiffnessMax_.

computeTimeStep()

Mdouble LinearPlasticViscoelasticNormalSpecies::computeTimeStep

(

Mdouble

mass

)

Returns the optimal time step to resolve a collision of two particles of a given mass.

Calculates collision time for stiffest spring constant, divides by 50

Parameters

[in]

the

optimal time step is computed to resolve a collision of two particles of this mass. If constant restitution is enabled, the collision time is mass-independent.

{
    if (getConstantRestitution()) mass = 1;
    return 0.02 * constants::pi /
           std::sqrt(unloadingStiffnessMax_ / (.5 * mass) - mathsFunc::square(dissipation_ / mass));
}

References dissipation_, BaseNormalForce::getConstantRestitution(), constants::pi, mathsFunc::square(), and unloadingStiffnessMax_.

getBaseName()

std::string LinearPlasticViscoelasticNormalSpecies::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 "LinearPlasticViscoelastic";
}

getCohesionStiffness()

Mdouble LinearPlasticViscoelasticNormalSpecies::getCohesionStiffness

(

)

const

Returns the cohesive stiffness of the linear plastic-viscoelastic normal force.

Returns

the cohesive stiffness of the linear plastic-viscoelastic normal force.

{
    return cohesionStiffness_;
}

References cohesionStiffness_.

Referenced by LinearPlasticViscoelasticInteraction::computeNormalForce(), and mix().

getCollisionTime()

Mdouble LinearPlasticViscoelasticNormalSpecies::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 If constant restitution is enabled, the collision time is mass-independent.

Todo:

should this use unloading stiffness?

{
    if (getConstantRestitution()) mass = 1;
 
    logger.assert_debug(mass > 0, "getCollisionTime(%): mass should be positive",mass);
 
    Mdouble elasticContribution = loadingStiffness_ / (.5 * mass);
    Mdouble elastoDissipativeContribution = elasticContribution - mathsFunc::square(dissipation_ / mass);
 
    logger.assert_debug(elastoDissipativeContribution > -1e-8 * elasticContribution,
            "getCollisionTime(%): values for mass, stiffness and dissipation lead to an overdamped system: reduce dissipation",mass);
 
    return constants::pi / std::sqrt(elastoDissipativeContribution);
}

References dissipation_, BaseNormalForce::getConstantRestitution(), loadingStiffness_, logger, constants::pi, and mathsFunc::square().

Referenced by getRestitutionCoefficient().

getDissipation()

Mdouble LinearPlasticViscoelasticNormalSpecies::getDissipation

(

)

const

Allows the normal dissipation to be accessed.

Returns

the linear dissipation coefficient

{
    return dissipation_;
}

References dissipation_.

Referenced by LinearPlasticViscoelasticInteraction::computeNormalForce(), mix(), and SlidingFrictionSpecies::setCollisionTimeAndNormalAndTangentialRestitutionCoefficient().

getDoConstantUnloadingStiffness()

bool LinearPlasticViscoelasticNormalSpecies::getDoConstantUnloadingStiffness ( ) const

inline

{return doConstantUnloadingStiffness_;}

References doConstantUnloadingStiffness_.

Referenced by LinearPlasticViscoelasticInteraction::computeNormalForce().

getLoadingStiffness()

Mdouble LinearPlasticViscoelasticNormalSpecies::getLoadingStiffness

(

)

const

Returns the loading stiffness of the linear plastic-viscoelastic normal force.

Returns

the loading stiffness of the linear plastic-viscoelastic normal force.

{
    return loadingStiffness_;
}

References loadingStiffness_.

Referenced by LinearPlasticViscoelasticInteraction::computeNormalForce(), LinearPlasticViscoelasticInteraction::getElasticEnergy(), LinearPlasticViscoelasticInteraction::getUnloadingStiffness(), mix(), SlidingFrictionSpecies::setCollisionTimeAndNormalAndTangentialRestitutionCoefficient(), setRestitutionCoefficient(), and ParticleParticleInteractionWithPlasticForces::setupInitialConditions().

getPenetrationDepthMax()

Mdouble LinearPlasticViscoelasticNormalSpecies::getPenetrationDepthMax

(

)

const

Returns the maximum penetration depth of the linear plastic-viscoelastic normal force.

Returns

the maximum penetration depth of the linear plastic-viscoelastic normal force.

{
    return penetrationDepthMax_;
}

References penetrationDepthMax_.

Referenced by LinearPlasticViscoelasticInteraction::computeNormalForce(), LinearPlasticViscoelasticInteraction::getUnloadingStiffness(), and mix().

getRestitutionCoefficient()

Mdouble LinearPlasticViscoelasticNormalSpecies::getRestitutionCoefficient

(

Mdouble

mass

)

const

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

{
    if (getConstantRestitution()) mass = 1;
 
    return std::exp(-dissipation_ / mass * getCollisionTime(mass));
}

References dissipation_, mathsFunc::exp(), getCollisionTime(), and BaseNormalForce::getConstantRestitution().

getUnloadingStiffnessMax()

Mdouble LinearPlasticViscoelasticNormalSpecies::getUnloadingStiffnessMax

(

)

const

Returns the maximum unloading stiffness of the linear plastic-viscoelastic normal force.

Returns

the maximum unloading stiffness of the linear plastic-viscoelastic normal force.

{
    return unloadingStiffnessMax_;
}

References unloadingStiffnessMax_.

Referenced by LinearPlasticViscoelasticInteraction::computeNormalForce(), LinearPlasticViscoelasticInteraction::getUnloadingStiffness(), and mix().

mix()

void LinearPlasticViscoelasticNormalSpecies::mix	(	LinearPlasticViscoelasticNormalSpecies *	S,
		LinearPlasticViscoelasticNormalSpecies *	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]

S,T

the two species whose properties are mixed to create the new species

{
    loadingStiffness_ = BaseSpecies::average(S->getLoadingStiffness(), T->getLoadingStiffness());
    unloadingStiffnessMax_ = BaseSpecies::average(S->getUnloadingStiffnessMax(), T->getUnloadingStiffnessMax());
    cohesionStiffness_ = BaseSpecies::average(S->getCohesionStiffness(), T->getCohesionStiffness());
    penetrationDepthMax_ = BaseSpecies::average(S->getPenetrationDepthMax(), T->getPenetrationDepthMax());
    dissipation_ = BaseSpecies::average(S->getDissipation(), T->getDissipation());
    logger.assert_debug(S->doConstantUnloadingStiffness_==T->doConstantUnloadingStiffness_,"you cannot mix species where doConstantUnloadingStiffness is not the same");
    doConstantUnloadingStiffness_ = S->doConstantUnloadingStiffness_;
}

References BaseSpecies::average(), cohesionStiffness_, dissipation_, doConstantUnloadingStiffness_, getCohesionStiffness(), getDissipation(), getLoadingStiffness(), getPenetrationDepthMax(), getUnloadingStiffnessMax(), loadingStiffness_, logger, penetrationDepthMax_, and unloadingStiffnessMax_.

read()

void LinearPlasticViscoelasticNormalSpecies::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 >> loadingStiffness_;
    is >> dummy >> unloadingStiffnessMax_;
    helpers::readOptionalVariable<bool>(is,"doConstantUnloadingStiffness",doConstantUnloadingStiffness_);
    is >> dummy >> cohesionStiffness_;
    is >> dummy >> penetrationDepthMax_;
    is >> dummy >> dissipation_;
}

References cohesionStiffness_, dissipation_, doConstantUnloadingStiffness_, loadingStiffness_, penetrationDepthMax_, and unloadingStiffnessMax_.

setCohesionStiffness()

void LinearPlasticViscoelasticNormalSpecies::setCohesionStiffness

(

Mdouble

cohesionStiffness

)

Sets the cohesive stiffness of the linear plastic-viscoelastic normal force.

Parameters

[in]

cohesionStiffness

the cohesive stiffness of the linear plastic-viscoelastic normal force.

{
    cohesionStiffness_ = cohesionStiffness;
}

References cohesionStiffness_.

Referenced by setPlasticParameters(), and ParticleParticleInteractionWithPlasticForces::setupInitialConditions().

setCollisionTimeAndRestitutionCoefficient()

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

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)

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 mean of particle mass, \(\frac{2}{1/m1+1/m2}\) If constant restitution is enabled, the collision time and restitution is mass-independent.

Todo:

TW: check that the masses are described correctly here (m_eff or m_p?))

{
    if (getConstantRestitution()) mass = 1;
    if (eps == 0.0)
    {
        loadingStiffness_ = .5 * mass * mathsFunc::square(constants::pi / tc);
        dissipation_ = std::sqrt(2.0 * mass * loadingStiffness_);
    }
    else
    {
        dissipation_ = -mass / tc * std::log(eps);
        loadingStiffness_ =
                .5 * mass * (mathsFunc::square(constants::pi / tc) + mathsFunc::square(dissipation_ / mass));
    }
    unloadingStiffnessMax_ = loadingStiffness_;
}

References dissipation_, BaseNormalForce::getConstantRestitution(), loadingStiffness_, mathsFunc::log(), constants::pi, mathsFunc::square(), and unloadingStiffnessMax_.

setDissipation()

void LinearPlasticViscoelasticNormalSpecies::setDissipation

(

Mdouble

dissipation

)

Sets the linear dissipation coefficient of the linear plastic-viscoelastic normal force.

should be non-negative

Parameters

[in]

the

linear dissipation coefficient of the linear plastic-viscoelastic normal force.

{
    logger.assert_debug(dissipation >= 0, "setDissipation(%): dissipation should be non-negative",dissipation);
    dissipation_ = dissipation;
}

References dissipation_, and logger.

Referenced by SlidingFrictionSpecies::setCollisionTimeAndNormalAndTangentialRestitutionCoefficient(), and setLoadingStiffnessAndDissipation().

setDoConstantUnloadingStiffness()

void LinearPlasticViscoelasticNormalSpecies::setDoConstantUnloadingStiffness ( bool  doConstantUnloadingStiffness )

inline

{doConstantUnloadingStiffness_ = doConstantUnloadingStiffness;}

References doConstantUnloadingStiffness_.

setLoadingStiffness()

void LinearPlasticViscoelasticNormalSpecies::setLoadingStiffness

(

Mdouble

loadingStiffness

)

Sets the loading stiffness of the linear plastic-viscoelastic normal force.

Parameters

[in]

loadingStiffness

the loading stiffness of the linear plastic-viscoelastic normal force.

{
    loadingStiffness_ = loadingStiffness;
}

References loadingStiffness_.

Referenced by SlidingFrictionSpecies::setCollisionTimeAndNormalAndTangentialRestitutionCoefficient(), setLoadingStiffnessAndDissipation(), setPlasticParameters(), and ParticleParticleInteractionWithPlasticForces::setupInitialConditions().

setLoadingStiffnessAndDissipation()

void LinearPlasticViscoelasticNormalSpecies::setLoadingStiffnessAndDissipation

(

helpers::KAndDisp

new_

)

Allows the spring and dissipation constants to be changed simultaneously.

Parameters

[in]

a

helper struct containing both the loading stiffness and the disssipation coefficient.

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

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

setPenetrationDepthMax()

void LinearPlasticViscoelasticNormalSpecies::setPenetrationDepthMax

(

Mdouble

penetrationDepthMax

)

Sets the maximum penetration depth of the linear plastic-viscoelastic normal force.

Parameters

[in]

penetrationDepthMax

the maximum penetration depth of the linear plastic-viscoelastic normal force.

{
    penetrationDepthMax_ = penetrationDepthMax;
}

References penetrationDepthMax_.

Referenced by setPlasticParameters(), and ParticleParticleInteractionWithPlasticForces::setupInitialConditions().

setPlasticParameters()

void LinearPlasticViscoelasticNormalSpecies::setPlasticParameters	(	Mdouble	loadingStiffness,
		Mdouble	unloadingStiffnessMax,
		Mdouble	cohesionStiffness,
		Mdouble	penetrationDepthMax
	)

Sets all parameters of the linear plastic-viscoelastic normal force at once.

Parameters

[in]	loadingStiffness	the loading stiffness of the linear plastic-viscoelastic normal force.
[in]	unloadingStiffnessMax	the maximum unloading stiffness of the linear plastic-viscoelastic normal force.
[in]	cohesionStiffness	the cohesive stiffness of the linear plastic-viscoelastic normal force.
[in]	penetrationDepthMax	the maximum penetration depth of the linear plastic-viscoelastic normal force.

{
    if (loadingStiffness <= 0 || unloadingStiffnessMax < loadingStiffness || cohesionStiffness < 0 ||
        penetrationDepthMax < 0 || penetrationDepthMax > 1)
    {
        logger(ERROR,"Error: arguments of setPlasticParameters do not make sense\n %%%%%",
                loadingStiffness <= 0, unloadingStiffnessMax < loadingStiffness, cohesionStiffness < 0,
                penetrationDepthMax < 0, penetrationDepthMax > 1);
    }
    setLoadingStiffness(loadingStiffness);
    setUnloadingStiffnessMax(unloadingStiffnessMax);
    setCohesionStiffness(cohesionStiffness);
    setPenetrationDepthMax(penetrationDepthMax);
}

References ERROR, logger, setCohesionStiffness(), setLoadingStiffness(), setPenetrationDepthMax(), and setUnloadingStiffnessMax().

setRestitutionCoefficient()

void LinearPlasticViscoelasticNormalSpecies::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 constant restitution is enabled, the restitution coefficient is mass-independent.

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

References dissipation_, BaseNormalForce::getConstantRestitution(), getLoadingStiffness(), mathsFunc::log(), constants::sqr_pi, and mathsFunc::square().

Referenced by setStiffnessAndRestitutionCoefficient().

setStiffnessAndRestitutionCoefficient()

void LinearPlasticViscoelasticNormalSpecies::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]	mass	effective particle mass, \(\frac{2}{1/m1+1/m2}\) If constant restitution is enabled, the restitution coefficient is mass-independent.

{
    if (getConstantRestitution()) mass = 1;
    loadingStiffness_ = stiffness;
    setRestitutionCoefficient(eps, mass);
}

References BaseNormalForce::getConstantRestitution(), loadingStiffness_, and setRestitutionCoefficient().

setUnloadingStiffnessMax()

void LinearPlasticViscoelasticNormalSpecies::setUnloadingStiffnessMax

(

Mdouble

unloadingStiffnessMax

)

Sets the maximum unloading stiffness of the linear plastic-viscoelastic normal force.

Parameters

[in]

unloadingStiffnessMax

the maximum unloading stiffness of the linear plastic-viscoelastic normal force.

{
    unloadingStiffnessMax_ = unloadingStiffnessMax;
}

References unloadingStiffnessMax_.

Referenced by setPlasticParameters(), and ParticleParticleInteractionWithPlasticForces::setupInitialConditions().

write()

void LinearPlasticViscoelasticNormalSpecies::write

(

std::ostream &

os

)

const

Writes the species properties to an output stream.

Parameters

[out]

output

stream (typically the restart file)

{
    os << " loadingStiffness " << loadingStiffness_;
    os << " maxUnloadingStiffness " << unloadingStiffnessMax_;
    if (doConstantUnloadingStiffness_) os << " doConstantUnloadingStiffness " << doConstantUnloadingStiffness_;
    os << " cohesionStiffness " << cohesionStiffness_;
    os << " maxPenetration " << penetrationDepthMax_;
    os << " dissipation " << dissipation_;
}

References cohesionStiffness_, dissipation_, doConstantUnloadingStiffness_, loadingStiffness_, penetrationDepthMax_, and unloadingStiffnessMax_.

Member Data Documentation

cohesionStiffness_

Mdouble LinearPlasticViscoelasticNormalSpecies::cohesionStiffness_

private

the adhesive spring constant (k^c) for plastic deformations

Referenced by computeBondNumberMax(), getCohesionStiffness(), LinearPlasticViscoelasticNormalSpecies(), mix(), read(), setCohesionStiffness(), and write().

dissipation_

Mdouble LinearPlasticViscoelasticNormalSpecies::dissipation_

private

linear dissipation coefficient

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

doConstantUnloadingStiffness_

bool LinearPlasticViscoelasticNormalSpecies::doConstantUnloadingStiffness_ = false

private

Referenced by getDoConstantUnloadingStiffness(), LinearPlasticViscoelasticNormalSpecies(), mix(), read(), setDoConstantUnloadingStiffness(), and write().

loadingStiffness_

Mdouble LinearPlasticViscoelasticNormalSpecies::loadingStiffness_

private

(normal) spring constant (k_1)

Referenced by getCollisionTime(), getLoadingStiffness(), LinearPlasticViscoelasticNormalSpecies(), mix(), read(), setCollisionTimeAndRestitutionCoefficient(), setLoadingStiffness(), setStiffnessAndRestitutionCoefficient(), and write().

penetrationDepthMax_

Mdouble LinearPlasticViscoelasticNormalSpecies::penetrationDepthMax_

private

the depth (relative to the normalized radius) at which k_2^max is used (phi_f)

Referenced by computeBondNumberMax(), getPenetrationDepthMax(), LinearPlasticViscoelasticNormalSpecies(), mix(), read(), setPenetrationDepthMax(), and write().

unloadingStiffnessMax_

Mdouble LinearPlasticViscoelasticNormalSpecies::unloadingStiffnessMax_

private

the maximum elastic constant (k_2^max) for plastic deformations

Referenced by computeBondNumberMax(), computeTimeStep(), getUnloadingStiffnessMax(), LinearPlasticViscoelasticNormalSpecies(), mix(), read(), setCollisionTimeAndRestitutionCoefficient(), setUnloadingStiffnessMax(), and write().

---

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

• LinearPlasticViscoelasticNormalSpecies.h
• LinearPlasticViscoelasticNormalSpecies.cc