void Law2_ScGeom_FrictPhys_CundallStrack::go(shared_ptr<IGeom>& ig, shared_ptr<IPhys>& ip, Interaction* contact){
int id1 = contact->getId1(), id2 = contact->getId2();
ScGeom* geom= static_cast<ScGeom*>(ig.get());
FrictPhys* phys = static_cast<FrictPhys*>(ip.get());
if(geom->penetrationDepth <0){
if (neverErase) {
phys->shearForce = Vector3r::Zero();
phys->normalForce = Vector3r::Zero();}
else scene->interactions->requestErase(contact);
return;}
Real& un=geom->penetrationDepth;
phys->normalForce=phys->kn*std::max(un,(Real) 0)*geom->normal;
Vector3r& shearForce = geom->rotate(phys->shearForce);
const Vector3r& shearDisp = geom->shearIncrement();
shearForce -= phys->ks*shearDisp;
Real maxFs = phys->normalForce.squaredNorm()*std::pow(phys->tangensOfFrictionAngle,2);
if (!scene->trackEnergy && !traceEnergy){//Update force but don't compute energy terms (see below))
// PFC3d SlipModel, is using friction angle. CoulombCriterion
if( shearForce.squaredNorm() > maxFs ){
Real ratio = sqrt(maxFs) / shearForce.norm();
shearForce *= ratio;}
} else {
//almost the same with additional Vector3r instatinated for energy tracing,
//duplicated block to make sure there is no cost for the instanciation of the vector when traceEnergy==false
if(shearForce.squaredNorm() > maxFs){
Real ratio = sqrt(maxFs) / shearForce.norm();
Vector3r trialForce=shearForce;//store prev force for definition of plastic slip
//define the plastic work input and increment the total plastic energy dissipated
shearForce *= ratio;
Real dissip=((1/phys->ks)*(trialForce-shearForce))/*plastic disp*/ .dot(shearForce)/*active force*/;
if (traceEnergy) plasticDissipation += dissip;
else if(dissip>0) scene->energy->add(dissip,"plastDissip",plastDissipIx,/*reset*/false);
}
// compute elastic energy as well
scene->energy->add(0.5*(phys->normalForce.squaredNorm()/phys->kn+phys->shearForce.squaredNorm()/phys->ks),"elastPotential",elastPotentialIx,/*reset at every timestep*/true);
}
if (!scene->isPeriodic && !sphericalBodies) {
State* de1 = Body::byId(id1,scene)->state.get();
State* de2 = Body::byId(id2,scene)->state.get();
applyForceAtContactPoint(-phys->normalForce-shearForce, geom->contactPoint, id1, de1->se3.position, id2, de2->se3.position);}
else {//we need to use correct branches in the periodic case, the following apply for spheres only
Vector3r force = -phys->normalForce-shearForce;
scene->forces.addForce(id1,force);
scene->forces.addForce(id2,-force);
scene->forces.addTorque(id1,(geom->radius1-0.5*geom->penetrationDepth)* geom->normal.cross(force));
scene->forces.addTorque(id2,(geom->radius2-0.5*geom->penetrationDepth)* geom->normal.cross(force));
}
}
void Law2_ScGeom6D_CohFrictPhys_CohesionMoment::go(shared_ptr<IGeom>& ig, shared_ptr<IPhys>& ip, Interaction* contact)
{
const Real& dt = scene->dt;
const int &id1 = contact->getId1();
const int &id2 = contact->getId2();
ScGeom6D* currentContactGeometry = YADE_CAST<ScGeom6D*> (ig.get());
CohFrictPhys* currentContactPhysics = YADE_CAST<CohFrictPhys*> (ip.get());
Vector3r& shearForce = currentContactPhysics->shearForce;
if (contact->isFresh(scene)) shearForce = Vector3r::Zero();
Real un = currentContactGeometry->penetrationDepth;
Real Fn = currentContactPhysics->kn*(un-currentContactPhysics->unp);
if (currentContactPhysics->fragile && (-Fn)> currentContactPhysics->normalAdhesion) {
// BREAK due to tension
scene->interactions->requestErase(contact); return;
} else {
if ((-Fn)> currentContactPhysics->normalAdhesion) {//normal plasticity
Fn=-currentContactPhysics->normalAdhesion;
currentContactPhysics->unp = un+currentContactPhysics->normalAdhesion/currentContactPhysics->kn;
if (currentContactPhysics->unpMax && currentContactPhysics->unp<currentContactPhysics->unpMax)
scene->interactions->requestErase(contact); return;
}
currentContactPhysics->normalForce = Fn*currentContactGeometry->normal;
State* de1 = Body::byId(id1,scene)->state.get();
State* de2 = Body::byId(id2,scene)->state.get();
///////////////////////// CREEP START ///////////
if (shear_creep) shearForce -= currentContactPhysics->ks*(shearForce*dt/creep_viscosity);
///////////////////////// CREEP END ////////////
Vector3r& shearForce = currentContactGeometry->rotate(currentContactPhysics->shearForce);
const Vector3r& dus = currentContactGeometry->shearIncrement();
//Linear elasticity giving "trial" shear force
shearForce -= currentContactPhysics->ks*dus;
Real Fs = currentContactPhysics->shearForce.norm();
Real maxFs = currentContactPhysics->shearAdhesion;
if (!currentContactPhysics->cohesionDisablesFriction || maxFs==0)
maxFs += Fn*currentContactPhysics->tangensOfFrictionAngle;
maxFs = std::max((Real) 0, maxFs);
if (Fs > maxFs) {//Plasticity condition on shear force
if (currentContactPhysics->fragile && !currentContactPhysics->cohesionBroken) {
currentContactPhysics->SetBreakingState();
maxFs = max((Real) 0, Fn*currentContactPhysics->tangensOfFrictionAngle);
}
maxFs = maxFs / Fs;
Vector3r trialForce=shearForce;
shearForce *= maxFs;
Real dissip=((1/currentContactPhysics->ks)*(trialForce-shearForce))/*plastic disp*/ .dot(shearForce)/*active force*/;
if(dissip>0) scene->energy->add(dissip,"plastDissip",plastDissipIx,/*reset*/false);
if (Fn<0) currentContactPhysics->normalForce = Vector3r::Zero();//Vector3r::Zero()
}
applyForceAtContactPoint(-currentContactPhysics->normalForce-shearForce, currentContactGeometry->contactPoint, id1, de1->se3.position, id2, de2->se3.position);
/// Moment law ///
if (currentContactPhysics->momentRotationLaw && (!currentContactPhysics->cohesionBroken || always_use_moment_law)) {
if (!useIncrementalForm){
if (twist_creep) {
Real viscosity_twist = creep_viscosity * std::pow((2 * std::min(currentContactGeometry->radius1,currentContactGeometry->radius2)),2) / 16.0;
Real angle_twist_creeped = currentContactGeometry->getTwist() * (1 - dt/viscosity_twist);
Quaternionr q_twist(AngleAxisr(currentContactGeometry->getTwist(),currentContactGeometry->normal));
Quaternionr q_twist_creeped(AngleAxisr(angle_twist_creeped,currentContactGeometry->normal));
Quaternionr q_twist_delta(q_twist_creeped * q_twist.conjugate());
currentContactGeometry->twistCreep = currentContactGeometry->twistCreep * q_twist_delta;
}
currentContactPhysics->moment_twist = (currentContactGeometry->getTwist()*currentContactPhysics->ktw)*currentContactGeometry->normal;
currentContactPhysics->moment_bending = currentContactGeometry->getBending() * currentContactPhysics->kr;
}
else{ // Use incremental formulation to compute moment_twis and moment_bending (no twist_creep is applied)
if (twist_creep) throw std::invalid_argument("Law2_ScGeom6D_CohFrictPhys_CohesionMoment: no twis creep is included if the incremental form for the rotations is used.");
Vector3r relAngVel = currentContactGeometry->getRelAngVel(de1,de2,dt);
// *** Bending ***//
Vector3r relAngVelBend = relAngVel - currentContactGeometry->normal.dot(relAngVel)*currentContactGeometry->normal; // keep only the bending part
Vector3r relRotBend = relAngVelBend*dt; // relative rotation due to rolling behaviour
// incremental formulation for the bending moment (as for the shear part)
Vector3r& momentBend = currentContactPhysics->moment_bending;
momentBend = currentContactGeometry->rotate(momentBend); // rotate moment vector (updated)
momentBend = momentBend-currentContactPhysics->kr*relRotBend;
// ----------------------------------------------------------------------------------------
// *** Torsion ***//
Vector3r relAngVelTwist = currentContactGeometry->normal.dot(relAngVel)*currentContactGeometry->normal;
Vector3r relRotTwist = relAngVelTwist*dt; // component of relative rotation along n FIXME: sign?
// incremental formulation for the torsional moment
Vector3r& momentTwist = currentContactPhysics->moment_twist;
momentTwist = currentContactGeometry->rotate(momentTwist); // rotate moment vector (updated)
momentTwist = momentTwist-currentContactPhysics->ktw*relRotTwist; // FIXME: sign?
}
/// Plasticity ///
// limit rolling moment to the plastic value, if required
Real RollMax = currentContactPhysics->maxRollPl*currentContactPhysics->normalForce.norm();
if (RollMax>0.){ // do we want to apply plasticity?
LOG_WARN("If :yref:`CohesiveFrictionalContactLaw::useIncrementalForm` is false, then plasticity would not be applied correctly (the total formulation would not reproduce irreversibility).");
Real scalarRoll = currentContactPhysics->moment_bending.norm();
if (scalarRoll>RollMax){ // fix maximum rolling moment
Real ratio = RollMax/scalarRoll;
currentContactPhysics->moment_bending *= ratio;
}
}
// limit twisting moment to the plastic value, if required
Real TwistMax = currentContactPhysics->maxTwistMoment.norm();
if (TwistMax>0.){ // do we want to apply plasticity?
LOG_WARN("If :yref:`CohesiveFrictionalContactLaw::useIncrementalForm` is false, then plasticity would not be applied correctly (the total formulation would not reproduce irreversibility).");
Real scalarTwist= currentContactPhysics->moment_twist.norm();
if (scalarTwist>TwistMax){ // fix maximum rolling moment
Real ratio = TwistMax/scalarTwist;
currentContactPhysics->moment_twist *= ratio;
}
}
// Apply moments now
Vector3r moment = currentContactPhysics->moment_twist + currentContactPhysics->moment_bending;
scene->forces.addTorque(id1,-moment);
scene->forces.addTorque(id2, moment);
}
/// Moment law END ///
}
}
bool Law2_ScGeom_MindlinPhys_Mindlin::go(shared_ptr<IGeom>& ig, shared_ptr<IPhys>& ip, Interaction* contact){
const Real& dt = scene->dt; // get time step
Body::id_t id1 = contact->getId1(); // get id body 1
Body::id_t id2 = contact->getId2(); // get id body 2
State* de1 = Body::byId(id1,scene)->state.get();
State* de2 = Body::byId(id2,scene)->state.get();
ScGeom* scg = static_cast<ScGeom*>(ig.get());
MindlinPhys* phys = static_cast<MindlinPhys*>(ip.get());
const shared_ptr<Body>& b1=Body::byId(id1,scene);
const shared_ptr<Body>& b2=Body::byId(id2,scene);
bool useDamping=(phys->betan!=0. || phys->betas!=0. || phys->alpha!=0.);
bool LinDamp=true;
if (phys->alpha!=0.) {LinDamp=false;} // use non linear damping
// tangential and normal stiffness coefficients, recomputed from betan,betas at every step
Real cn=0, cs=0;
/****************/
/* NORMAL FORCE */
/****************/
Real uN = scg->penetrationDepth; // get overlapping
if (uN<0) {
if (neverErase) {phys->shearForce = phys->normalForce = Vector3r::Zero(); phys->kn=phys->ks=0; return true;}
else return false;
}
/* Hertz-Mindlin's formulation (PFC)
Note that the normal stiffness here is a secant value (so as it is cannot be used in the GSTS)
In the first place we get the normal force and then we store kn to be passed to the GSTS */
Real Fn = phys->kno*std::pow(uN,1.5); // normal Force (scalar)
if (includeAdhesion) {
Fn -= phys->adhesionForce; // include adhesion force to account for the effect of Van der Waals interactions
phys->isAdhesive = (Fn<0); // set true the bool to count the number of adhesive contacts
}
phys->normalForce = Fn*scg->normal; // normal Force (vector)
if (calcEnergy){
Real R=scg->radius1*scg->radius2/(scg->radius1+scg->radius2);
phys->radius=pow((Fn+(includeAdhesion?phys->adhesionForce:0.))*pow(R,3/2.)/phys->kno,1/3.); // attribute not used anywhere, we do not need it
}
/*******************************/
/* TANGENTIAL NORMAL STIFFNESS */
/*******************************/
phys->kn = 3./2.*phys->kno*std::pow(uN,0.5); // here we store the value of kn to compute the time step
/******************************/
/* TANGENTIAL SHEAR STIFFNESS */
/******************************/
phys->ks = phys->kso*std::pow(uN,0.5); // get tangential stiffness (this is a tangent value, so we can pass it to the GSTS)
/************************/
/* DAMPING COEFFICIENTS */
/************************/
// Inclusion of local damping if requested
// viscous damping is defined for both linear and non-linear elastic case
if (useDamping && LinDamp){
Real mbar = (!b1->isDynamic() && b2->isDynamic()) ? de2->mass : ((!b2->isDynamic() && b1->isDynamic()) ? de1->mass : (de1->mass*de2->mass / (de1->mass + de2->mass))); // get equivalent mass if both bodies are dynamic, if not set it equal to the one of the dynamic body
//Real mbar = de1->mass*de2->mass / (de1->mass + de2->mass); // equivalent mass
Real Cn_crit = 2.*sqrt(mbar*phys->kn); // Critical damping coefficient (normal direction)
Real Cs_crit = 2.*sqrt(mbar*phys->ks); // Critical damping coefficient (shear direction)
// Note: to compare with the analytical solution you provide cn and cs directly (since here we used a different method to define c_crit)
cn = Cn_crit*phys->betan; // Damping normal coefficient
cs = Cs_crit*phys->betas; // Damping tangential coefficient
if(phys->kn<0 || phys->ks<0){ cerr<<"Negative stiffness kn="<<phys->kn<<" ks="<<phys->ks<<" for ##"<<b1->getId()<<"+"<<b2->getId()<<", step "<<scene->iter<<endl; }
}
else if (useDamping){ // (see Tsuji, 1992)
Real mbar = (!b1->isDynamic() && b2->isDynamic()) ? de2->mass : ((!b2->isDynamic() && b1->isDynamic()) ? de1->mass : (de1->mass*de2->mass / (de1->mass + de2->mass))); // get equivalent mass if both bodies are dynamic, if not set it equal to the one of the dynamic body
cn = phys->alpha*sqrt(mbar)*pow(uN,0.25); // normal viscous coefficient, see also [Antypov2011] eq. 10
cs = cn; // same value for shear viscous coefficient
}
/***************/
/* SHEAR FORCE */
/***************/
Vector3r& shearElastic = phys->shearElastic; // reference for shearElastic force
// Define shifts to handle periodicity
const Vector3r shift2 = scene->isPeriodic ? scene->cell->intrShiftPos(contact->cellDist): Vector3r::Zero();
const Vector3r shiftVel = scene->isPeriodic ? scene->cell->intrShiftVel(contact->cellDist): Vector3r::Zero();
// 1. Rotate shear force
shearElastic = scg->rotate(shearElastic);
Vector3r prev_FsElastic = shearElastic; // save shear force at previous time step
// 2. Get incident velocity, get shear and normal components
Vector3r incidentV = scg->getIncidentVel(de1, de2, dt, shift2, shiftVel, preventGranularRatcheting);
Vector3r incidentVn = scg->normal.dot(incidentV)*scg->normal; // contact normal velocity
Vector3r incidentVs = incidentV - incidentVn; // contact shear velocity
// 3. Get shear force (incrementally)
shearElastic = shearElastic - phys->ks*(incidentVs*dt);
/**************************************/
/* VISCOUS DAMPING (Normal direction) */
/**************************************/
// normal force must be updated here before we apply the Mohr-Coulomb criterion
if (useDamping){ // get normal viscous component
phys->normalViscous = cn*incidentVn;
Vector3r normTemp = phys->normalForce - phys->normalViscous; // temporary normal force
// viscous force should not exceed the value of current normal force, i.e. no attraction force should be permitted if particles are non-adhesive
// if particles are adhesive, then fixed the viscous force at maximum equal to the adhesion force
// *** enforce normal force to zero if no adhesion is permitted ***
if (phys->adhesionForce==0.0 || !includeAdhesion){
if (normTemp.dot(scg->normal)<0.0){
phys->normalForce = Vector3r::Zero();
phys->normalViscous = phys->normalViscous + normTemp; // normal viscous force is such that the total applied force is null - it is necessary to compute energy correctly!
}
else{phys->normalForce -= phys->normalViscous;}
}
else if (includeAdhesion && phys->adhesionForce!=0.0){
// *** limit viscous component to the max adhesive force ***
if (normTemp.dot(scg->normal)<0.0 && (phys->normalViscous.norm() > phys->adhesionForce) ){
Real normVisc = phys->normalViscous.norm(); Vector3r normViscVector = phys->normalViscous/normVisc;
phys->normalViscous = phys->adhesionForce*normViscVector;
phys->normalForce -= phys->normalViscous;
}
// *** apply viscous component - in the presence of adhesion ***
else {phys->normalForce -= phys->normalViscous;}
}
if (calcEnergy) {normDampDissip += phys->normalViscous.dot(incidentVn*dt);} // calc dissipation of energy due to normal damping
}
/*************************************/
/* SHEAR DISPLACEMENT (elastic only) */
/*************************************/
Vector3r& us_elastic = phys->usElastic;
us_elastic = scg->rotate(us_elastic); // rotate vector
Vector3r prevUs_el = us_elastic; // store previous elastic shear displacement (already rotated)
us_elastic -= incidentVs*dt; // add shear increment
/****************************************/
/* SHEAR DISPLACEMENT (elastic+plastic) */
/****************************************/
Vector3r& us_total = phys->usTotal;
us_total = scg->rotate(us_total); // rotate vector
Vector3r prevUs_tot = us_total; // store previous total shear displacement (already rotated)
us_total -= incidentVs*dt; // add shear increment NOTE: this vector is not passed into the failure criterion, hence it holds also the plastic part of the shear displacement
bool noShearDamp = false; // bool to decide whether we need to account for shear damping dissipation or not
/********************/
/* MOHR-COULOMB law */
/********************/
phys->isSliding=false;
phys->shearViscous=Vector3r::Zero(); // reset so that during sliding, the previous values is not there
Fn = phys->normalForce.norm();
if (!includeAdhesion) {
Real maxFs = Fn*phys->tangensOfFrictionAngle;
if (shearElastic.squaredNorm() > maxFs*maxFs){
phys->isSliding=true;
noShearDamp = true; // no damping is added in the shear direction, hence no need to account for shear damping dissipation
Real ratio = maxFs/shearElastic.norm();
shearElastic *= ratio; phys->shearForce = shearElastic; /*store only elastic shear displacement*/ us_elastic*= ratio;
if (calcEnergy) {frictionDissipation += (us_total-prevUs_tot).dot(shearElastic);} // calculate energy dissipation due to sliding behavior
}
else if (useDamping){ // add current contact damping if we do not slide and if damping is requested
phys->shearViscous = cs*incidentVs; // get shear viscous component
phys->shearForce = shearElastic - phys->shearViscous;}
else if (!useDamping) {phys->shearForce = shearElastic;} // update the shear force at the elastic value if no damping is present and if we passed MC
}
else { // Mohr-Coulomb formulation adpated due to the presence of adhesion (see Thornton, 1991).
Real maxFs = phys->tangensOfFrictionAngle*(phys->adhesionForce+Fn); // adhesionForce already included in normalForce (above)
if (shearElastic.squaredNorm() > maxFs*maxFs){
phys->isSliding=true;
noShearDamp = true; // no damping is added in the shear direction, hence no need to account for shear damping dissipation
Real ratio = maxFs/shearElastic.norm(); shearElastic *= ratio; phys->shearForce = shearElastic; /*store only elastic shear displacement*/ us_elastic *= ratio;
if (calcEnergy) {frictionDissipation += (us_total-prevUs_tot).dot(shearElastic);} // calculate energy dissipation due to sliding behavior
}
else if (useDamping){ // add current contact damping if we do not slide and if damping is requested
phys->shearViscous = cs*incidentVs; // get shear viscous component
phys->shearForce = shearElastic - phys->shearViscous;}
else if (!useDamping) {phys->shearForce = shearElastic;} // update the shear force at the elastic value if no damping is present and if we passed MC
}
/************************/
/* SHEAR ELASTIC ENERGY */
/************************/
// NOTE: shear elastic energy calculation must come after the MC criterion, otherwise displacements and forces are not updated
if (calcEnergy) {
shearEnergy += (us_elastic-prevUs_el).dot((shearElastic+prev_FsElastic)/2.); // NOTE: no additional energy if we perform sliding since us_elastic and prevUs_el will hold the same value (in fact us_elastic is only keeping the elastic part). We work out the area of the trapezium.
}
/**************************************************/
/* VISCOUS DAMPING (energy term, shear direction) */
/**************************************************/
if (useDamping){ // get normal viscous component (the shear one is calculated inside Mohr-Coulomb criterion, see above)
if (calcEnergy) {if (!noShearDamp) {shearDampDissip += phys->shearViscous.dot(incidentVs*dt);}} // calc energy dissipation due to viscous linear damping
}
/****************/
/* APPLY FORCES */
/****************/
if (!scene->isPeriodic)
applyForceAtContactPoint(-phys->normalForce - phys->shearForce, scg->contactPoint , id1, de1->se3.position, id2, de2->se3.position);
else { // in scg we do not wrap particles positions, hence "applyForceAtContactPoint" cannot be used
Vector3r force = -phys->normalForce - phys->shearForce;
scene->forces.addForce(id1,force);
scene->forces.addForce(id2,-force);
scene->forces.addTorque(id1,(scg->radius1-0.5*scg->penetrationDepth)* scg->normal.cross(force));
scene->forces.addTorque(id2,(scg->radius2-0.5*scg->penetrationDepth)* scg->normal.cross(force));
}
/********************************************/
/* MOMENT CONTACT LAW */
/********************************************/
if (includeMoment){
// *** Bending ***//
// new code to compute relative particle rotation (similar to the way the shear is computed)
// use scg function to compute relAngVel
Vector3r relAngVel = scg->getRelAngVel(de1,de2,dt);
//Vector3r relAngVel = (b2->state->angVel-b1->state->angVel);
Vector3r relAngVelBend = relAngVel - scg->normal.dot(relAngVel)*scg->normal; // keep only the bending part
Vector3r relRot = relAngVelBend*dt; // relative rotation due to rolling behaviour
// incremental formulation for the bending moment (as for the shear part)
Vector3r& momentBend = phys->momentBend;
momentBend = scg->rotate(momentBend); // rotate moment vector (updated)
momentBend = momentBend-phys->kr*relRot; // add incremental rolling to the rolling vector
// ----------------------------------------------------------------------------------------
// *** Torsion ***//
Vector3r relAngVelTwist = scg->normal.dot(relAngVel)*scg->normal;
Vector3r relRotTwist = relAngVelTwist*dt; // component of relative rotation along n
// incremental formulation for the torsional moment
Vector3r& momentTwist = phys->momentTwist;
momentTwist = scg->rotate(momentTwist); // rotate moment vector (updated)
momentTwist = momentTwist-phys->ktw*relRotTwist;
#if 0
// code to compute the relative particle rotation
if (includeMoment){
Real rMean = (scg->radius1+scg->radius2)/2.;
// sliding motion
Vector3r duS1 = scg->radius1*(phys->prevNormal-scg->normal);
Vector3r duS2 = scg->radius2*(scg->normal-phys->prevNormal);
// rolling motion
Vector3r duR1 = scg->radius1*dt*b1->state->angVel.cross(scg->normal);
Vector3r duR2 = -scg->radius2*dt*b2->state->angVel.cross(scg->normal);
// relative position of the old contact point with respect to the new one
Vector3r relPosC1 = duS1+duR1;
Vector3r relPosC2 = duS2+duR2;
Vector3r duR = (relPosC1+relPosC2)/2.; // incremental displacement vector (same radius is temporarily assumed)
// check wheter rolling will be present, if not do nothing
Vector3r x=scg->normal.cross(duR);
Vector3r normdThetaR(Vector3r::Zero()); // initialize
if(x.squaredNorm()==0) { /* no rolling */ }
else {
Vector3r normdThetaR = x/x.norm(); // moment unit vector
phys->dThetaR = duR.norm()/rMean*normdThetaR;} // incremental rolling
// incremental formulation for the bending moment (as for the shear part)
Vector3r& momentBend = phys->momentBend;
momentBend = scg->rotate(momentBend); // rotate moment vector
momentBend = momentBend+phys->kr*phys->dThetaR; // add incremental rolling to the rolling vector FIXME: is the sign correct?
#endif
// check plasticity condition (only bending part for the moment)
Real MomentMax = phys->maxBendPl*phys->normalForce.norm();
Real scalarMoment = phys->momentBend.norm();
if (MomentMax>0){
if(scalarMoment > MomentMax)
{
Real ratio = MomentMax/scalarMoment; // to fix the moment to its yielding value
phys->momentBend *= ratio;
}
}
// apply moments
Vector3r moment = phys->momentTwist+phys->momentBend;
scene->forces.addTorque(id1,-moment);
scene->forces.addTorque(id2,moment);
}
return true;
// update variables
//phys->prevNormal = scg->normal;
}
// The following code was moved from Ip2_FrictMat_FrictMat_MindlinCapillaryPhys.cpp
void Ip2_FrictMat_FrictMat_MindlinCapillaryPhys::go( const shared_ptr<Material>& b1 //FrictMat
, const shared_ptr<Material>& b2 // FrictMat
, const shared_ptr<Interaction>& interaction)
{
if(interaction->phys) return; // no updates of an already existing contact necessary
shared_ptr<MindlinCapillaryPhys> contactPhysics(new MindlinCapillaryPhys());
interaction->phys = contactPhysics;
FrictMat* mat1 = YADE_CAST<FrictMat*>(b1.get());
FrictMat* mat2 = YADE_CAST<FrictMat*>(b2.get());
/* from interaction physics */
Real Ea = mat1->young;
Real Eb = mat2->young;
Real Va = mat1->poisson;
Real Vb = mat2->poisson;
Real fa = mat1->frictionAngle;
Real fb = mat2->frictionAngle;
/* from interaction geometry */
GenericSpheresContact* scg = YADE_CAST<GenericSpheresContact*>(interaction->geom.get());
Real Da = scg->refR1>0 ? scg->refR1 : scg->refR2;
Real Db = scg->refR2;
//Vector3r normal=scg->normal; //The variable set but not used
/* calculate stiffness coefficients */
Real Ga = Ea/(2*(1+Va));
Real Gb = Eb/(2*(1+Vb));
Real G = (Ga+Gb)/2; // average of shear modulus
Real V = (Va+Vb)/2; // average of poisson's ratio
Real E = Ea*Eb/((1.-std::pow(Va,2))*Eb+(1.-std::pow(Vb,2))*Ea); // Young modulus
Real R = Da*Db/(Da+Db); // equivalent radius
Real Rmean = (Da+Db)/2.; // mean radius
Real Kno = 4./3.*E*sqrt(R); // coefficient for normal stiffness
Real Kso = 2*sqrt(4*R)*G/(2-V); // coefficient for shear stiffness
Real frictionAngle = std::min(fa,fb);
Real Adhesion = 4.*Mathr::PI*R*gamma; // calculate adhesion force as predicted by DMT theory
/* pass values calculated from above to MindlinCapillaryPhys */
contactPhysics->tangensOfFrictionAngle = std::tan(frictionAngle);
//mindlinPhys->prevNormal = scg->normal; // used to compute relative rotation
contactPhysics->kno = Kno; // this is just a coeff
contactPhysics->kso = Kso; // this is just a coeff
contactPhysics->adhesionForce = Adhesion;
contactPhysics->kr = krot;
contactPhysics->ktw = ktwist;
contactPhysics->maxBendPl = eta*Rmean; // does this make sense? why do we take Rmean?
/* compute viscous coefficients */
if(en && betan) throw std::invalid_argument("Ip2_FrictMat_FrictMat_MindlinCapillaryPhys: only one of en, betan can be specified.");
if(es && betas) throw std::invalid_argument("Ip2_FrictMat_FrictMat_MindlinCapillaryPhys: only one of es, betas can be specified.");
// en or es specified, just compute alpha, otherwise alpha remains 0
if(en || es){
Real logE = log((*en)(mat1->id,mat2->id));
contactPhysics->alpha = -sqrt(5/6.)*2*logE/sqrt(pow(logE,2)+pow(Mathr::PI,2))*sqrt(2*E*sqrt(R)); // (see Tsuji, 1992)
}
// betan specified, use that value directly; otherwise give zero
else{
contactPhysics->betan=betan ? (*betan)(mat1->id,mat2->id) : 0;
contactPhysics->betas=betas ? (*betas)(mat1->id,mat2->id) : contactPhysics->betan;
}
};
void Law2_ScGeom_CFpmPhys_CohesiveFrictionalPM::go(shared_ptr<IGeom>& ig, shared_ptr<IPhys>& ip, Interaction* contact){
ScGeom* geom = static_cast<ScGeom*>(ig.get());
CFpmPhys* phys = static_cast<CFpmPhys*>(ip.get());
const int &id1 = contact->getId1();
const int &id2 = contact->getId2();
Body* b1 = Body::byId(id1,scene).get();
Body* b2 = Body::byId(id2,scene).get();
Real displN = geom->penetrationDepth; // NOTE: the sign for penetrationdepth is different from ScGeom and Dem3DofGeom: geom->penetrationDepth>0 when spheres interpenetrate
Real Dtensile=phys->FnMax/phys->kn;
Real Dsoftening = phys->strengthSoftening*Dtensile;
/*to set the equilibrium distance between all cohesive elements when they first meet -> allows one to work with initial stress-free assembly*/
if ( contact->isFresh(scene) ) { phys->initD = displN; phys->normalForce = Vector3r::Zero(); phys->shearForce = Vector3r::Zero();}
Real D = displN - phys->initD; // interparticular distance is computed depending on the equilibrium distance
/* Determination of interaction */
if (D < 0){ //spheres do not touch
if (!phys->isCohesive){ scene->interactions->requestErase(contact); return; } // destroy the interaction before calculation
if ((phys->isCohesive) && (abs(D) > (Dtensile + Dsoftening))) { // spheres are bonded and the interacting distance is greater than the one allowed ny the defined cohesion
phys->isCohesive=false;
// update body state with the number of broken bonds
CFpmState* st1=dynamic_cast<CFpmState*>(b1->state.get());
CFpmState* st2=dynamic_cast<CFpmState*>(b2->state.get());
st1->numBrokenCohesive+=1;
st2->numBrokenCohesive+=1;
//// the same thing but from ConcretePM
//const shared_ptr<Body>& body1=Body::byId(contact->getId1(),scene), body2=Body::byId(contact->getId2(),scene); assert(body1); assert(body2);
//const shared_ptr<CFpmState>& st1=YADE_PTR_CAST<CFpmState>(body1->state), st2=YADE_PTR_CAST<CFpmState>(body2->state);
//{ boost::mutex::scoped_lock lock(st1->updateMutex); st1->numBrokenCohesive+=1; }
//{ boost::mutex::scoped_lock lock(st2->updateMutex); st2->numBrokenCohesive+=1; }
// end of update
scene->interactions->requestErase(contact); return;
}
}
/*NormalForce*/
Real Fn=0, Dsoft=0;
if ((D < 0) && (abs(D) > Dtensile)) { //to take into account strength softening
Dsoft = D+Dtensile; // Dsoft<0 for a negative value of Fn (attractive force)
Fn = -(phys->FnMax+(phys->kn/phys->strengthSoftening)*Dsoft); // computes FnMax - FnSoftening
}
else {
Fn = phys->kn*D;
}
phys->normalForce = Fn*geom->normal; // NOTE normal is position2-position1 - It is directed from particle1 to particle2
/*ShearForce*/
Vector3r& shearForce = phys->shearForce;
// using scGeom function rotateAndGetShear
State* st1 = Body::byId(id1,scene)->state.get();
State* st2 = Body::byId(id2,scene)->state.get();
geom->rotate(phys->shearForce);
const Vector3r& dus = geom->shearIncrement();
//Linear elasticity giving "trial" shear force
shearForce -= phys->ks*dus;
// needed for the next timestep
phys->prevNormal = geom->normal;
/* Morh-Coulomb criterion */
Real maxFs = phys->FsMax + Fn*phys->tanFrictionAngle;
if (shearForce.squaredNorm() > maxFs*maxFs){
shearForce*=maxFs/shearForce.norm(); // to fix the shear force to its yielding value
}
/* Apply forces */
Vector3r f = phys->normalForce + shearForce;
// these lines to adapt to periodic boundary conditions (NOTE applyForceAtContactPoint computes torque induced by normal and shear force too)
if (!scene->isPeriodic)
applyForceAtContactPoint(f , geom->contactPoint , id2, st2->se3.position, id1, st1->se3.position);
else { // in scg we do not wrap particles positions, hence "applyForceAtContactPoint" cannot be used when scene is periodic
scene->forces.addForce(id1,-f);
scene->forces.addForce(id2,f);
scene->forces.addTorque(id1,(geom->radius1-0.5*geom->penetrationDepth)* geom->normal.cross(-f));
scene->forces.addTorque(id2,(geom->radius2-0.5*geom->penetrationDepth)* geom->normal.cross(-f));
}
/* Moment Rotation Law */
// NOTE this part could probably be computed in ScGeom to avoid copy/paste multiplication !!!
Quaternionr delta( b1->state->ori * phys->initialOrientation1.conjugate() *phys->initialOrientation2 * b2->state->ori.conjugate()); delta.normalize(); //relative orientation
AngleAxisr aa(delta); // axis of rotation - this is the Moment direction UNIT vector; angle represents the power of resistant ELASTIC moment
if(aa.angle() > Mathr::PI) aa.angle() -= Mathr::TWO_PI; // angle is between 0 and 2*pi, but should be between -pi and pi
phys->cumulativeRotation = aa.angle();
//Find angle*axis. That's all. But first find angle about contact normal. Result is scalar. Axis is contact normal.
Real angle_twist(aa.angle() * aa.axis().dot(geom->normal) ); //rotation about normal
Vector3r axis_twist(angle_twist * geom->normal);
Vector3r moment_twist(axis_twist * phys->kr);
Vector3r axis_bending(aa.angle()*aa.axis() - axis_twist); //total rotation minus rotation about normal
Vector3r moment_bending(axis_bending * phys->kr);
Vector3r moment = moment_twist + moment_bending;
Real MomentMax = phys->maxBend*std::fabs(phys->normalForce.norm());
Real scalarMoment = moment.norm();
/*Plastic moment */
if(scalarMoment > MomentMax)
{
Real ratio = 0;
ratio *= MomentMax/scalarMoment; // to fix the moment to its yielding value
moment *= ratio;
moment_twist *= ratio;
moment_bending *= ratio;
}
phys->moment_twist = moment_twist;
phys->moment_bending = moment_bending;
scene->forces.addTorque(id1,-moment);
scene->forces.addTorque(id2, moment);
}
void Law2_ScGeom6D_InelastCohFrictPhys_CohesionMoment::go(shared_ptr<IGeom>& ig, shared_ptr<IPhys>& ip, Interaction* contact)
{
// cout<<"Law2_ScGeom6D_InelastCohFrictPhys_CohesionMoment"<<endl;
const Real& dt = scene->dt;
const int &id1 = contact->getId1();
const int &id2 = contact->getId2();
ScGeom6D* geom = YADE_CAST<ScGeom6D*> (ig.get());
InelastCohFrictPhys* phys = YADE_CAST<InelastCohFrictPhys*> (ip.get());
Vector3r& shearForce = phys->shearForce;
cout<<"id1= "<<id1<<" id2= "<<id2<<endl;
if (contact->isFresh(scene)) shearForce = Vector3r::Zero();
///Tension-Compresion///
Real un = geom->penetrationDepth;
Real Fn = phys->knT*(un);
//FIXME: Check signs on TESTS
State* de1 = Body::byId(id1,scene)->state.get();
State* de2 = Body::byId(id2,scene)->state.get();
if(!(phys->isBrokenT)){
/// Tension ///
if(un<=0){
if((un>= -(phys->dElT)) && !onplastT){
Fn = phys->knT*(un);
// cout<<"TENSION ELASTIC Fn= "<<Fn<<" un= "<<un<<endl;
}
if(un< -(phys->dElT) || onplastT){
onplastT = true;
Fn = phys->knT*(-phys->dElT) + phys->crpT*(un+phys->dElT);
// cout<<"TENSION PLASTIC Fn= "<<Fn<<" un= "<<un<<" normalF= "<<phys->normalForce.norm()<<endl;
if(phys->unloadedT ||(-phys->normalForce.norm()<=Fn)){
Fn = phys->knT*(-phys->dElT)+ phys->crpT*(lastPlastUn+phys->dElT) + phys->unldT*(un-lastPlastUn);
phys->unloadedT = true;
// cout<<"TENSION PLASTIC unloading Fn= "<<Fn<<" un= "<<un<<endl;
if(un<=lastPlastUn){ // Recovers creep after unload and reload
phys->unloadedT=false;
Fn = phys->knT*(-phys->dElT) + phys->crpT*(un+phys->dElT);
// cout<<"TENSION PLASTIC load aftr unld Fn= "<<Fn<<" un= "<<un<<" LPun= "<<lastPlastUn<<endl;
}
} // Unloading:: //FIXME: ?? Check Fn Sign
else{// loading, applying Creeping
lastPlastUn = un;
// cout<<"TENSION PLASTIC Creep Fn= "<<Fn<<" un= "<<un<<endl;
if (un<-phys->epsMaxT){ // Plastic rupture //
Fn = 0.0;
phys->isBrokenT = true;
// cout<<"TENSION PLASTIC creep BROKEN Fn= "<<Fn<<" un= "<<un<<endl;
}
}
}
}
/// Compresion ///
if(un>0){
if((un<=phys->dElC) && !onplastT){
Fn = phys->knC*(un);
// cout<<"COMPRESION ELASTIC Fn= "<<Fn<<" un= "<<un<<endl;
}
if(un>phys->dElC || onplastT){
onplastT = true;
Fn = phys->knC*(phys->dElC) + phys->crpT*(un-phys->dElC);
if(phys->unloadedC || (phys->normalForce.norm()>=Fn)){
Fn = phys->knC*(phys->dElC)+ phys->crpT*(lastPlastUn-phys->dElC) + phys->unldT*(un-lastPlastUn);
phys->unloadedC = true;
// cout<<"COMPRESION PLASTIC unloading Fn= "<<Fn<<" un= "<<un<<endl;
if(un>=lastPlastUn){ // Recovers creep after unload and reload
phys->unloadedC=false;
Fn = phys->knC*(phys->dElC) + phys->crpT*(un-phys->dElC);
// cout<<"COMPRESION PLASTIC load aftr unld Fn= "<<Fn<<" un= "<<un<<" LPun= "<<lastPlastUn<<endl;
}
} // Unloading:: //FIXME: Verify Fn Sign
else{// loading, applying Creeping
lastPlastUn = un;
// cout<<"COMPRESION PLASTIC Creep Fn= "<<Fn<<" un= "<<un<<endl;
// Fn stills Fn = phys->crpT*(un-phys->unp) ;}
if (un>phys->epsMaxC){ // Plastic rupture //
Fn = 0.0;
phys->isBrokenT = true;
// cout<<"COMPRESION PLASTIC creep BROKEN Fn= "<<Fn<<" un= "<<un<<endl;
}
}
}
}
phys->normalForce = Fn*geom->normal;
}
// if ((-Fn)> phys->normalAdhesion) {//normal plasticity
// Fn=-phys->normalAdhesion;
// phys->unp = un+phys->normalAdhesion/phys->kn;
// if (phys->unpMax && phys->unp<phys->unpMax)
// scene->interactions->requestErase(contact); return;
// }
// cout<<"Tension-Comp normalF= "<<phys->normalForce<<endl;
///end tension-compresion///
///Shear/// ELASTOPLASTIC perfect law TO BE DONE
//FIXME:: TO DO::Shear ElastoPlastic perfect LAW
///////////////////////// CREEP START ///////////
if (shear_creep) shearForce -= phys->ks*(shearForce*dt/creep_viscosity);
///////////////////////// CREEP END ////////////
shearForce = geom->rotate(phys->shearForce);
const Vector3r& dus = geom->shearIncrement();
//Linear elasticity giving "trial" shear force
shearForce -= phys->ks*dus;
Real Fs = phys->shearForce.norm();
Real maxFs = phys->shearAdhesion;
if (!phys->cohesionDisablesFriction || maxFs==0)
maxFs += Fn*phys->tangensOfFrictionAngle;
maxFs = std::max((Real) 0, maxFs);
if (Fs > maxFs) {//Plasticity condition on shear force
// cout<<"Plastshear ShearAdh= "<<phys->shearAdhesion<<endl;
if (phys->fragile && !phys->cohesionBroken) {
phys->SetBreakingState();
maxFs = max((Real) 0, Fn*phys->tangensOfFrictionAngle);
}
maxFs = maxFs / Fs;
Vector3r trialForce=shearForce;
shearForce *= maxFs;
if (unlikely(scene->trackEnergy)){
Real dissip=((1/phys->ks)*(trialForce-shearForce))/*plastic disp*/ .dot(shearForce)/*active force*/;
if(dissip>0) scene->energy->add(dissip,"plastDissip",plastDissipIx,/*reset*/false);}
if (Fn<0) phys->normalForce = Vector3r::Zero();//Vector3r::Zero()
}
// cout<<"Fs= "<<Fs<<" maxFs= "<<maxFs<<endl;
//Apply the force
applyForceAtContactPoint(-phys->normalForce-shearForce, geom->contactPoint, id1, de1->se3.position, id2, de2->se3.position + (scene->isPeriodic ? scene->cell->intrShiftPos(contact->cellDist): Vector3r::Zero()));
// Vector3r force = -phys->normalForce-shearForce;
// scene->forces.addForce(id1,force);
// scene->forces.addForce(id2,-force);
// scene->forces.addTorque(id1,(geom->radius1-0.5*geom->penetrationDepth)* geom->normal.cross(force));
// scene->forces.addTorque(id2,(geom->radius2-0.5*geom->penetrationDepth)* geom->normal.cross(force));
/// end Shear ///
/// Moment law ///
/// Bending///
if(!(phys->isBrokenB)){
Vector3r relAngVel = geom->getRelAngVel(de1,de2,dt);
Vector3r relAngVelBend = relAngVel - geom->normal.dot(relAngVel)*geom->normal; // keep only the bending part
Vector3r relRotBend = relAngVelBend*dt; // relative rotation due to rolling behaviour
Vector3r& momentBend = phys->moment_bending;
momentBend = geom->rotate(momentBend); // rotate moment vector (updated)
//To check if in elastic zone in current iteration
Real BendValue = (phys->moment_bending-phys->kr*relRotBend).norm();
Real MaxElastB = phys->maxElastB;
bool elasticBState = (BendValue<=MaxElastB);
if(!onplastB && elasticBState){
momentBend = momentBend-phys->kr*relRotBend;
// cout<<"BENDING Elastic"<<" momentB= "<<momentBend<<endl;
}else{ ///Bending Plasticity///
onplastB = true;
BendValue = (phys->moment_bending-phys->crpB*relRotBend).norm();
// cout<<"BENDING Plastic"<<" momentB= "<<momentBend<<endl;
// Unloading:: RelRotBend > 0 ::::
if(phys->unloadedB || phys->moment_bending.norm()>=BendValue){
momentBend = momentBend-phys->unldB*relRotBend;
phys->unloadedB = true;
// cout<<"BENDING Plastic UNLD"<<" momentB= "<<momentBend<<endl;
if(BendValue>=lastPlastBend){phys->unloadedB = false;}
}
else{
momentBend = momentBend-phys->crpB*relRotBend;// loading, applying Creeping
Vector3r AbsRot = de1->rot()-de2->rot();
Real AbsBending = (AbsRot - geom->normal.dot(AbsRot)*geom->normal).norm();
lastPlastBend= BendValue;
if (AbsBending>phys->phBMax){ // Plastic rupture //FIXME: This line is not ok, need to find the compare the total(or just plastic) angular displacement to PhBmax, true meaning of relRotBend??
momentBend = Vector3r(0,0,0);
phys->isBrokenB = true;
// cout<<"BENDING Plastic BREAK"<<" momentB= "<<momentBend<<endl;
}
}
}
phys->moment_bending = momentBend;
}
///Twist///
if(!(phys->isBrokenTw)){
Vector3r relAngVel = geom->getRelAngVel(de1,de2,dt);
Vector3r relAngVelTwist = geom->normal.dot(relAngVel)*geom->normal;
Vector3r relRotTwist = relAngVelTwist*dt; // component of relative rotation along n FIXME: sign?
Vector3r& momentTwist = phys->moment_twist;
momentTwist = geom->rotate(momentTwist); // rotate moment vector (updated)
//To check if in elastic zone in current iteration
Real TwistValue = (phys->moment_twist-phys->kt*relRotTwist).norm();
Real MaxElastTw = phys->maxElastTw;
bool elasticTwState = (TwistValue<=MaxElastTw);
if (!onplastTw && elasticTwState){
momentTwist = momentTwist-phys->kt*relRotTwist; // FIXME: sign?
// cout<<"TWIST Elast"<<" momentTwist="<<momentTwist<<endl;
}else { ///Twist Plasticity///
onplastTw = true;
TwistValue = (phys->moment_twist-phys->crpTw*relRotTwist).norm();
// cout<<"TWIST Plast"<<endl;
if (phys->unloadedTw || phys->moment_twist.norm()>=TwistValue){// Unloading:: RelRotTwist > 0
momentTwist = momentTwist-phys->unldTw*relRotTwist;
phys->unloadedTw = true;
// cout<<"TWIST Plast UNLD"<<endl;
if(TwistValue>=lastPlastTw){phys->unloadedTw = false;}
}
else{momentTwist = momentTwist-phys->crpTw*relRotTwist;// loading, applying Creeping
Vector3r AbsRot = de1->rot()-de2->rot();
Real AbsTwist = (geom->normal.dot(AbsRot)*geom->normal).norm();
lastPlastTw= TwistValue;
// cout<<"TWIST Creep momentTwist="<<momentTwist<<" AbsTwist="<<AbsTwist<<endl;
if (AbsTwist>phys->phTwMax){ // Plastic rupture //FIXME: This line is not ok, need to find the compare the total(or just plastic) angular displacement to PhBmax, true meaning of relRotBend??
momentTwist = Vector3r(0,0,0);
phys->isBrokenTw = true;
}
}
}
phys->moment_twist = momentTwist;
}
// cout<<"moment Twist= "<<phys->moment_twist<<endl;
// Apply moments now
Vector3r moment = phys->moment_twist + phys->moment_bending;
scene->forces.addTorque(id1,-moment);
scene->forces.addTorque(id2, moment);
/// Moment law END ///
}
void Law2_ScGeom_WirePhys_WirePM::go(shared_ptr<IGeom>& ig, shared_ptr<IPhys>& ip, Interaction* contact){
LOG_TRACE( "Law2_ScGeom_WirePhys_WirePM::go - contact law" );
ScGeom* geom = static_cast<ScGeom*>(ig.get());
WirePhys* phys = static_cast<WirePhys*>(ip.get());
const int &id1 = contact->getId1();
const int &id2 = contact->getId2();
Body* b1 = Body::byId(id1,scene).get();
Body* b2 = Body::byId(id2,scene).get();
Real displN = geom->penetrationDepth; // NOTE: ScGeom -> penetrationDepth>0 when spheres interpenetrate, and therefore, for wire always negative
/* get reference to values since values are updated/changed in order to take unloading into account */
vector<Vector2r> &DFValues = phys->displForceValues;
vector<Real> &kValues = phys->stiffnessValues;
Real kn = phys->kn;
Real D = displN - phys->initD; // interparticular distance is computed depending on the equilibrium distance
/* check whether the particles are linked or not */
if ( !phys->isLinked ) { // destroy the interaction before calculation
scene->interactions->requestErase(contact);
return;
}
if ( (phys->isLinked) && (D < DFValues.back()(0)) ) { // spheres are linked but failure because of reaching maximal admissible displacement
phys->isLinked=false;
// update body state with the number of broken links
WireState* st1=dynamic_cast<WireState*>(b1->state.get());
WireState* st2=dynamic_cast<WireState*>(b2->state.get());
st1->numBrokenLinks+=1;
st2->numBrokenLinks+=1;
scene->interactions->requestErase(contact);
return;
}
/* compute normal force Fn */
Real Fn = 0.;
if ( D > DFValues[0](0) ) { // unloading
LOG_TRACE("WirePM: Unloading");
Fn = kn * (D-phys->plastD);
}
else { // loading
LOG_TRACE("WirePM: Loading");
for (unsigned int i=1; i<DFValues.size(); i++) {
if ( D > DFValues[i](0) ) {
Fn = DFValues[i-1](1) + (D-DFValues[i-1](0))*kValues[i-1];
phys->plastD = D - Fn/kn;
// update values for unloading
DFValues[0](0) = D;
DFValues[0](1) = Fn;
break;
}
}
}
/* compression forces cannot be applied to wires */
if (Fn > 0.) Fn = 0.;
TRVAR3( displN, D, Fn );
phys->normalForce = Fn*geom->normal; // NOTE: normal is position2-position1 - It is directed from particle1 to particle2
/* compute a limit value to check how far the interaction is from failing */
Real limitFactor = 0.;
if (Fn < 0.) limitFactor = fabs(D/(DFValues.back()(0)));
phys->limitFactor = limitFactor;
State* st1 = Body::byId(id1,scene)->state.get();
State* st2 = Body::byId(id2,scene)->state.get();
/* apply forces */
Vector3r f = phys->normalForce;
// these lines to adapt to periodic boundary conditions
if ( !scene->isPeriodic )
applyForceAtContactPoint(f , geom->contactPoint , id2, st2->se3.position, id1, st1->se3.position);
else { // in scg we do not wrap particles positions, hence "applyForceAtContactPoint" cannot be used when scene is periodic
scene->forces.addForce(id1,-f);
scene->forces.addForce(id2,f);
}
/* set shear force to zero */
phys->shearForce = Vector3r::Zero();
}
bool Law2_ScGeom6D_CohFrictPhys_CohesionMoment::go(shared_ptr<IGeom>& ig, shared_ptr<IPhys>& ip, Interaction* contact)
{
const Real& dt = scene->dt;
const int &id1 = contact->getId1();
const int &id2 = contact->getId2();
ScGeom6D* geom = YADE_CAST<ScGeom6D*> (ig.get());
CohFrictPhys* phys = YADE_CAST<CohFrictPhys*> (ip.get());
Vector3r& shearForce = phys->shearForce;
if (contact->isFresh(scene)) shearForce = Vector3r::Zero();
Real un = geom->penetrationDepth;
Real Fn = phys->kn*(un-phys->unp);
if (phys->fragile && (-Fn)> phys->normalAdhesion) {
// BREAK due to tension
return false;
} else {
if ((-Fn)> phys->normalAdhesion) {//normal plasticity
Fn=-phys->normalAdhesion;
phys->unp = un+phys->normalAdhesion/phys->kn;
if (phys->unpMax>=0 && -phys->unp>phys->unpMax) // Actually unpMax should be defined as a function of the average particule sizes for instance
return false;
}
phys->normalForce = Fn*geom->normal;
State* de1 = Body::byId(id1,scene)->state.get();
State* de2 = Body::byId(id2,scene)->state.get();
///////////////////////// CREEP START ///////////
if (shear_creep) shearForce -= phys->ks*(shearForce*dt/creep_viscosity);
///////////////////////// CREEP END ////////////
Vector3r& shearForce = geom->rotate(phys->shearForce);
const Vector3r& dus = geom->shearIncrement();
//Linear elasticity giving "trial" shear force
shearForce -= phys->ks*dus;
Real Fs = phys->shearForce.norm();
Real maxFs = phys->shearAdhesion;
if (!phys->cohesionDisablesFriction || maxFs==0)
maxFs += Fn*phys->tangensOfFrictionAngle;
maxFs = std::max((Real) 0, maxFs);
if (Fs > maxFs) {//Plasticity condition on shear force
if (phys->fragile && !phys->cohesionBroken) {
phys->SetBreakingState();
maxFs = max((Real) 0, Fn*phys->tangensOfFrictionAngle);
}
maxFs = maxFs / Fs;
Vector3r trialForce=shearForce;
shearForce *= maxFs;
if (scene->trackEnergy || traceEnergy){
Real sheardissip=((1/phys->ks)*(trialForce-shearForce))/*plastic disp*/ .dot(shearForce)/*active force*/;
if(sheardissip>0) {
plasticDissipation+=sheardissip;
if (scene->trackEnergy) scene->energy->add(sheardissip,"shearDissip",shearDissipIx,/*reset*/false);}
}
if (Fn<0) phys->normalForce = Vector3r::Zero();//Vector3r::Zero()
}
//Apply the force
applyForceAtContactPoint(-phys->normalForce-shearForce, geom->contactPoint, id1, de1->se3.position, id2, de2->se3.position + (scene->isPeriodic ? scene->cell->intrShiftPos(contact->cellDist): Vector3r::Zero()));
/// Moment law ///
if (phys->momentRotationLaw && (!phys->cohesionBroken || always_use_moment_law)) {
if (!useIncrementalForm){
if (twist_creep) {
Real viscosity_twist = creep_viscosity * std::pow((2 * std::min(geom->radius1,geom->radius2)),2) / 16.0;
Real angle_twist_creeped = geom->getTwist() * (1 - dt/viscosity_twist);
Quaternionr q_twist(AngleAxisr(geom->getTwist(),geom->normal));
Quaternionr q_twist_creeped(AngleAxisr(angle_twist_creeped,geom->normal));
Quaternionr q_twist_delta(q_twist_creeped * q_twist.conjugate());
geom->twistCreep = geom->twistCreep * q_twist_delta;
}
phys->moment_twist = (geom->getTwist()*phys->ktw)*geom->normal;
phys->moment_bending = geom->getBending() * phys->kr;
}
else{ // Use incremental formulation to compute moment_twis and moment_bending (no twist_creep is applied)
if (twist_creep) throw std::invalid_argument("Law2_ScGeom6D_CohFrictPhys_CohesionMoment: no twis creep is included if the incremental form for the rotations is used.");
Vector3r relAngVel = geom->getRelAngVel(de1,de2,dt);
// *** Bending ***//
Vector3r relAngVelBend = relAngVel - geom->normal.dot(relAngVel)*geom->normal; // keep only the bending part
Vector3r relRotBend = relAngVelBend*dt; // relative rotation due to rolling behaviour
// incremental formulation for the bending moment (as for the shear part)
Vector3r& momentBend = phys->moment_bending;
momentBend = geom->rotate(momentBend); // rotate moment vector (updated)
momentBend = momentBend-phys->kr*relRotBend;
// ----------------------------------------------------------------------------------------
// *** Torsion ***//
Vector3r relAngVelTwist = geom->normal.dot(relAngVel)*geom->normal;
Vector3r relRotTwist = relAngVelTwist*dt; // component of relative rotation along n FIXME: sign?
// incremental formulation for the torsional moment
Vector3r& momentTwist = phys->moment_twist;
momentTwist = geom->rotate(momentTwist); // rotate moment vector (updated)
momentTwist = momentTwist-phys->ktw*relRotTwist; // FIXME: sign?
}
/// Plasticity ///
// limit rolling moment to the plastic value, if required
if (phys->maxRollPl>=0.){ // do we want to apply plasticity?
Real RollMax = phys->maxRollPl*phys->normalForce.norm();
if (!useIncrementalForm) LOG_WARN("If :yref:`Law2_ScGeom6D_CohFrictPhys_CohesionMoment::useIncrementalForm` is false, then plasticity will not be applied correctly (the total formulation would not reproduce irreversibility).");
Real scalarRoll = phys->moment_bending.norm();
if (scalarRoll>RollMax){ // fix maximum rolling moment
Real ratio = RollMax/scalarRoll;
phys->moment_bending *= ratio;
if (scene->trackEnergy){
Real bendingdissip=((1/phys->kr)*(scalarRoll-RollMax)*RollMax)/*active force*/;
if(bendingdissip>0) scene->energy->add(bendingdissip,"bendingDissip",bendingDissipIx,/*reset*/false);}
}
}
// limit twisting moment to the plastic value, if required
if (phys->maxTwistPl>=0.){ // do we want to apply plasticity?
Real TwistMax = phys->maxTwistPl*phys->normalForce.norm();
if (!useIncrementalForm) LOG_WARN("If :yref:`Law2_ScGeom6D_CohFrictPhys_CohesionMoment::useIncrementalForm` is false, then plasticity will not be applied correctly (the total formulation would not reproduce irreversibility).");
Real scalarTwist= phys->moment_twist.norm();
if (scalarTwist>TwistMax){ // fix maximum rolling moment
Real ratio = TwistMax/scalarTwist;
phys->moment_twist *= ratio;
if (scene->trackEnergy){
Real twistdissip=((1/phys->ktw)*(scalarTwist-TwistMax)*TwistMax)/*active force*/;
if(twistdissip>0) scene->energy->add(twistdissip,"twistDissip",twistDissipIx,/*reset*/false);}
}
}
// Apply moments now
Vector3r moment = phys->moment_twist + phys->moment_bending;
scene->forces.addTorque(id1,-moment);
scene->forces.addTorque(id2, moment);
}
/// Moment law END ///
}
return true;
}
void Law2_Dem3DofGeom_RockPMPhys_Rpm::go(shared_ptr<IGeom>& ig, shared_ptr<IPhys>& ip, Interaction* contact){
Dem3DofGeom* geom=static_cast<Dem3DofGeom*>(ig.get());
RpmPhys* phys=static_cast<RpmPhys*>(ip.get());
Real displN=geom->displacementN();
const Real& crossSection=phys->crossSection;
Real& epsN=phys->epsN;
Vector3r& epsT=phys->epsT;
Real& sigmaN=phys->sigmaN;
Vector3r& sigmaT=phys->sigmaT;
const Real& E = phys->E;
const Real& G = phys->G;
Real& Fn=phys->Fn;
Vector3r& Fs=phys->Fs;
if(displN<=0){
/**Normal Interaction*/
epsN=geom->strainN();
epsT=geom->strainT();
sigmaN=E*epsN;
Fn=sigmaN*crossSection; phys->normalForce=Fn*geom->normal;
sigmaT=G*epsT;
/**Check, whether the shear stress more, than normal force multiplicated to tanFrictionAngle*/
Real maxFsSq = phys->normalForce.squaredNorm()*phys->tanFrictionAngle*phys->tanFrictionAngle;
if(sigmaT.squaredNorm()>maxFsSq) {
sigmaT*=sqrt(maxFsSq/(sigmaT.squaredNorm()));
}
Fs=sigmaT*crossSection;
phys->shearForce = Fs;
/**Normal Interaction*/
applyForceAtContactPoint(phys->normalForce + phys->shearForce, geom->contactPoint, contact->getId1(), geom->se31.position, contact->getId2(), geom->se32.position);
if ((phys->isCohesive)&&(displN<(-phys->lengthMaxCompression))) {
phys->isCohesive = false; ///Destruction
}
return;
} else {
/**If spheres do not touch, check, whether they are cohesive*/
if (phys->isCohesive) {
/**If the distance
* between spheres more than critical and they are cohesive,
* we delete the interaction
* Destruction.
**/
if (displN>(phys->lengthMaxTension)) {
scene->interactions->requestErase(contact);
return;
} else {
/**If the distance
* between spheres less than critical and they are cohesive,
* we aply additional forces to keep particles together.
**/
phys->normalForce=phys->kn*displN*geom->normal;
applyForceAtContactPoint(phys->normalForce, geom->contactPoint, contact->getId1(), geom->se31.position, contact->getId2(), geom->se32.position);
return;
}
} else {
/**
* Delete interactions
*/
scene->interactions->requestErase(contact);
return;
}
}
}
