/* Take increments in strain and calculate new Particle: strains, rotation strain,
stresses, strain energy,
dvij are (gradient rates X time increment) to give deformation gradient change
For Axisymmetry: x->R, y->Z, z->theta, np==AXISYMMEtRIC_MPM, otherwise dvzz=0
This material tracks pressure and stores deviatoric stress only in particle stress tensor
*/
void ClampedNeohookean::MPMConstitutiveLaw(MPMBase *mptr,Matrix3 du,double delTime,int np,void *properties,
ResidualStrains *res,int historyOffset) const
{
// Update total deformation gradient, and calculate trial B
Tensor Btrial;
double detDF = IncrementDeformation(mptr,du,&Btrial,np);
// global J
double J = detDF * mptr->GetHistoryDble(J_History,historyOffset);
mptr->SetHistoryDble(J_History,J,historyOffset);
// convert Btrial to matrix to get eigenvalues and check for clamping
Matrix3 Belas(Btrial.xx,Btrial.xy,Btrial.xz,
Btrial.xy,Btrial.yy,Btrial.yz,
Btrial.xz,Btrial.yz,Btrial.zz);
if(np!=THREED_MPM) Belas.setIs2D(true);
// get Eigenvalues and Eigenvectors
Vector lam2 = Belas.Eigenvalues();
// clamp eigenvalues if needed
bool clamped = false;
if(lam2.x<lamMin2 || lam2.x>lamMax2 || lam2.y<lamMin2 || lam2.y>lamMax2 || lam2.z<lamMin2 || lam2.z>lamMax2)
clamped = true;
// Get Je and Jp, adjusting if clamped
double Je,Jp;
Matrix3 Ucol;
if(clamped)
{ // Find Belas = U.LAM.UT
Ucol = Belas.Eigenvectors(lam2);
// clamp values now
if(lam2.x<lamMin2)
lam2.x = lamMin2;
else if(lam2.x>lamMax2)
lam2.x = lamMax2;
if(lam2.y<lamMin2)
lam2.y = lamMin2;
else if(lam2.y>lamMax2)
lam2.y = lamMax2;
if(lam2.z<lamMin2)
lam2.z = lamMin2;
else if(lam2.z>lamMax2)
lam2.z = lamMax2;
Matrix3 UcolT = Ucol.Transpose();
Matrix3 Lam(lam2.x,0.,0.,lam2.y,lam2.z);
Matrix3 LamUcolT = Lam*UcolT;
Belas = Ucol*LamUcolT;
// get Je and Jp
Je = sqrt(lam2.x*lam2.y*lam2.z);
Jp = J/Je;
mptr->SetHistoryDble(JP_HISTORY,Jp,historyOffset);
}
else
{ Jp = mptr->GetHistoryDble(JP_HISTORY,historyOffset);
Je = J/Jp;
if(elasticModel==ELASTIC_DISNEY)
Ucol = Belas.Eigenvectors(lam2);
}
// store B elastic
Tensor *sp=mptr->GetStressTensor();
Tensor *B = mptr->GetAltStrainTensor();
B->xx = Belas(0,0);
B->yy = Belas(1,1);
B->zz = Belas(2,2);
B->xy = Belas(0,1);
if(np==THREED_MPM)
{ B->xz = Belas(0,2);
B->yz = Belas(1,2);
}
// change mechanical properties by hardening
double arg = exp(hardening*(1.-Jp));
double altGsp = pr.Gsp*arg;
double altLamesp = pr.Lamesp*arg;
// account for residual stresses
double dJres = GetIncrementalResJ(mptr,res);
double Jres = dJres*mptr->GetHistoryDble(J_History+1,historyOffset);
mptr->SetHistoryDble(J_History+1,Jres,historyOffset);
double resStretch = pow(Jres,1./3.);
double Jres23 = resStretch*resStretch;
// account for residual stresses relative to elastic J
double Jeff = Je/Jres;
// for incremental energy, store initial stress and pressure
Tensor *sporig=mptr->GetStressTensor();
Tensor st0 = *sporig;
double Pfinal,p0=mptr->GetPressure();
if(elasticModel==ELASTIC_DISNEY)
{ // Use model from Disney paper
// Get Cauchy stress/rho0
double sig[3][3];
double lam[3];
lam[0]=sqrt(lam2.x)/resStretch;
lam[1]=sqrt(lam2.y)/resStretch;
lam[2]=sqrt(lam2.z)/resStretch;
for(int i=0;i<3;i++)
{ for(int j=i;j<3;j++)
{ sig[i][j] = 0.;
for(int k=0;k<3;k++)
{ sig[i][j] += (2.*altGsp*lam[k]*(lam[k]-1)/Jeff + altLamesp*(Jeff-1))*Ucol(i,k)*Ucol(j,k);
}
}
}
// update pressure (*J to get Kirchoff pressure)
Pfinal = -J*(sig[0][0]+sig[1][1]+sig[2][2])/3.;
mptr->SetPressure(Pfinal);
// get and set deviatoric stress
// find eviatoric (Kirchoff stress)/rho0 = deviatoric (Cauchy stress)J/rho0
sp->xx = J*sig[0][0]+Pfinal;
sp->yy = J*sig[1][1]+Pfinal;
sp->zz = J*sig[2][2]+Pfinal;
sp->xy = J*sig[0][1];
if(np==THREED_MPM)
{ sp->xz = J*sig[0][2];
sp->yz = J*sig[1][2];
}
}
else
{ // Use standard neo-Hookean law
// update pressure (*J to get Kirchoff pressure)
Pfinal = -J*(GetVolumetricTerms(Jeff,altLamesp) + (altGsp/Jeff)*((B->xx+B->yy+B->zz)/(3.*Jres23) - 1.));
mptr->SetPressure(Pfinal);
// Account for density change in specific stress
// i.e.. Get (Kirchoff Stress)/rho0
double GJeff = J*resStretch*altGsp/Je; // = J*(Jres^(1/3) G/Je) to get Kirchoff
// find deviatoric (Kirchoff stress)/rho0 = deviatoric (Cauchy stress)J/rho0
double I1third = (B->xx+B->yy+B->zz)/3.;
sp->xx = GJeff*(B->xx-I1third);
sp->yy = GJeff*(B->yy-I1third);
sp->zz = GJeff*(B->zz-I1third);
sp->xy = GJeff*B->xy;
if(np==THREED_MPM)
{ sp->xz = GJeff*B->xz;
sp->yz = GJeff*B->yz;
}
}
// work and residual energies
double delV = 1. - 1./detDF; // total volume change
double avgP = 0.5*(p0+Pfinal);
double dilEnergy = -avgP*delV;
// incremental residual energy
double delVres = 1. - 1./dJres;
double resEnergy = -avgP*delVres;
// incremental work energy = shear energy
double shearEnergy = 0.5*((sp->xx+st0.xx)*du(0,0) + (sp->yy+st0.yy)*du(1,1) + (sp->zz+st0.zz)*du(2,2)+
(sp->xy+st0.xy)*(du(0,1)+du(1,0)));
if(np==THREED_MPM)
{ shearEnergy += 0.5*((sp->xz+st0.xz)*(du(0,2)+du(2,0)) + (sp->yz+st0.yz)*(du(1,2)+du(2,1)));
}
// strain energy
double dU = dilEnergy + shearEnergy;
mptr->AddWorkEnergyAndResidualEnergy(dU,resEnergy);
// thermodynamics heat and temperature
// Should find energy dissipated by plasticity and add in third term
IncrementHeatEnergy(mptr,res->dT,0.,0.);
}
/* Take increments in strain and calculate new Particle: strains, rotation strain,
stresses, strain energy,
dvij are (gradient rates X time increment) to give deformation gradient change
For Axisymmetry: x->R, y->Z, z->theta, np==AXISYMMEtRIC_MPM, otherwise dvzz=0
This material tracks pressure and stores deviatoric stress only in particle stress
tensor
*/
void HEIsotropic::MPMConstitutiveLaw(MPMBase *mptr,Matrix3 du,double delTime,int np,void *properties,
ResidualStrains *res,int historyOffset) const
{
HEPlasticProperties *p = (HEPlasticProperties *)properties;
// store initial stress
Tensor *sp = mptr->GetStressTensor();
Tensor st0 = *sp;
// Compute Elastic Predictor
// ============================================
// Update total deformation gradient, and calculate trial B
Tensor Btrial;
double detdF = IncrementDeformation(mptr,du,&Btrial,np);
// Deformation gradients and Cauchy tensor differ in plane stress and plane strain
// This code handles plane strain, axisymmetric, and 3D - Plane stress is blocked
double J = detdF * mptr->GetHistoryDble(J_History,historyOffset);
mptr->SetHistoryDble(J_History,J,historyOffset); // Stocking J
// J is determinant of F (or sqrt root of determinant of B), Jeff is normalized to residual stretch
double dJres = GetIncrementalResJ(mptr,res);
double Jres = dJres * mptr->GetHistoryDble(J_History+1,historyOffset);
mptr->SetHistoryDble(J_History+1,Jres,historyOffset);
double Jeff = J/Jres;
// Get hydrostatic stress component in subroutine
double dTq0 = 0.,dispEnergy = 0.;
UpdatePressure(mptr,J,detdF,np,Jeff,delTime,p,res,dJres,historyOffset,dTq0,dispEnergy);
// Others constants
double J23 = pow(J, 2./3.)/Jres;
// find Trial (Cauchy stress)/rho0
// (Trial_s/rho0 = Trial_s*rho/(rho*rho0) = (Trial_tau*rho/rho0^2) = (1/J)*(Trial_tau/rho0)
Tensor stk = GetTrialDevStressTensor(&Btrial,J*J23,np,p->Gred);
// Checking for plastic loading
// ============================================
// Get magnitude of the deviatoric stress tensor
// ||s|| = sqrt(s.s)
// Set alpint for particle
HardeningAlpha alpha;
plasticLaw->UpdateTrialAlpha(mptr,np,&alpha,historyOffset);
// Trial stress state
double magnitude_strial = GetMagnitudeS(&stk,np);
double gyld = plasticLaw->GetYield(mptr,np,delTime,&alpha,p->hardProps);
double ftrial = magnitude_strial-SQRT_TWOTHIRDS*gyld;
//cout << " #magnitude_strial = "<< magnitude_strial<< " GetYield = "<< gyld<< " ftrial = "<< ftrial<< endl;
//cout << " #yldred = "<< yldred << " Epred = "<< Epred << " gyld = "<< gyld <<" alpint = "<< alpint<< " ftrial = "<< ftrial<< endl;
// these will be needed for elastic or plastic
Tensor *pB = mptr->GetAltStrainTensor();
//============================
// TEST
//============================
if(ftrial<=0.)
{ // if elastic
//============================
// save on particle
*pB = Btrial;
// Get specifique stress i.e. (Cauchy Stress)/rho = J*(Cauchy Stress)/rho0 = (Kirchoff Stress)/rho0
// The deviatoric stress was calculated as (Cauchy Stress)/rho, so need to scale by J to get correct stress
sp->xx = J*stk.xx;
sp->yy = J*stk.yy;
sp->xy = J*stk.xy;
sp->zz = J*stk.zz;
// work energy per unit mass (U/(rho0 V0)) and we are using
// W(F) as the energy density per reference volume V0 (U/V0) and not current volume V
double workEnergy = 0.5*((st0.xx+sp->xx)*du(0,0)
+ (st0.yy+sp->yy)*du(1,1)
+ (st0.zz+sp->zz)*du(2,2)
+ (st0.xy+sp->xy)*(du(1,0)+du(0,1)));
if(np==THREED_MPM)
{ sp->xz = J*stk.xz;
sp->yz = J*stk.yz;
workEnergy += 0.5*((st0.yz+sp->yz)*(du(2,1)+du(1,2))
+ (st0.xz+sp->xz)*(du(2,0)+du(0,2)));
}
mptr->AddWorkEnergy(workEnergy);
// residual energy or sigma.deres - it is zero here for isotropic material
// because deviatoric stress is traceless and deres has zero shear terms
// residual energy due to pressure was added in the pressure update
// heat energy is Cv(dT-dTq0) - dPhi, all from pressure update
IncrementHeatEnergy(mptr,res->dT,dTq0,dispEnergy);
// give material chance to update history variables that change in elastic updates
plasticLaw->ElasticUpdateFinished(mptr,np,delTime,historyOffset);
return;
}
// Plastic behavior - Return Mapping algorithm
//=====================================================
// if plastic
// JAN: Use hardening law method (which can now use other laws too)
double Ie1bar = (Btrial.xx+Btrial.yy+Btrial.zz)/(3.*J23);
double MUbar = Jres*p->Gred*Ie1bar;
// Find lambda for this plastic state
double dlambda = plasticLaw->SolveForLambdaBracketed(mptr,np,magnitude_strial,&stk,
MUbar,1.,1.,delTime,&alpha,p->hardProps,historyOffset);
// update deviatoric stress (need to scale by J to get to Kirchoff stress/rho
Tensor nk = GetNormalTensor(&stk,magnitude_strial,np);
//cout << "nk.xx = " << nk.xx << "nk.xy = " << nk.xy << endl;
double twoMuLam = 2.*MUbar*dlambda;
sp->xx = J*(stk.xx - twoMuLam*nk.xx);
sp->yy = J*(stk.yy - twoMuLam*nk.yy);
sp->zz = J*(stk.zz - twoMuLam*nk.zz);
sp->xy = J*(stk.xy - twoMuLam*nk.xy);
if(np == THREED_MPM)
{ sp->xz = J*(stk.xz - twoMuLam*nk.xz);
sp->yz = J*(stk.yz - twoMuLam*nk.yz);
}
// save on particle
double twoThirdsLamI1bar = 2.*dlambda*Ie1bar;
pB->xx = Btrial.xx - twoThirdsLamI1bar*nk.xx;
pB->yy = Btrial.yy - twoThirdsLamI1bar*nk.yy;
pB->zz = Btrial.zz - twoThirdsLamI1bar*nk.zz;
pB->xy = Btrial.xy - twoThirdsLamI1bar*nk.xy;
if(np == THREED_MPM)
{ pB->xz = Btrial.xz - twoThirdsLamI1bar*nk.xz;
pB->yz = Btrial.yz - twoThirdsLamI1bar*nk.yz;
}
/* Old method collecting B from stresses
pB->xx = (sp->xx/p->Gred+Ie1bar)*J23;
pB->yy = (sp->yy/p->Gred+Ie1bar)*J23;
pB->zz = (sp->zz/p->Gred+Ie1bar)*J23;
pB->xy = sp->xy*J23/p->Gred;
if(np == THREED_MPM)
{ pB->xz = sp->xz*J23/p->Gred;
pB->yz = sp->yz*J23/p->Gred;
}
*/
// strain energy per unit mass (U/(rho0 V0)) and we are using
double workEnergy = 0.5*((st0.xx+sp->xx)*du(0,0)
+ (st0.yy+sp->yy)*du(1,1)
+ (st0.zz+sp->zz)*du(2,2)
+ (st0.xy+sp->xy)*(du(1,0)+du(0,1)));
if(np==THREED_MPM)
{ workEnergy += 0.5*((st0.yz+sp->yz)*(du(2,1)+du(1,2))
+ (st0.xz+sp->xz)*(du(2,0)+du(0,2)));
}
// total work
mptr->AddWorkEnergy(workEnergy);
// residual energy or sigma.deres - it is zero here for isotropic material
// because deviatoric stress is traceless and deres has zero shear terms
// residual energy due to pressure was added in the pressure update
// Plastic work increment per unit mass (dw/(rho0 V0)) (nJ/g)
dispEnergy += dlambda*(sp->xx*nk.xx + sp->yy*nk.yy + sp->zz*nk.zz + 2.*sp->xy*nk.xy);
if(np==THREED_MPM) dispEnergy += 2.*dlambda*(sp->xz*nk.xz + sp->yz*nk.yz);
// Subtract q.dalpha to get final disispated energy per unit mass (dPhi/(rho0 V0)) (nJ/g)
dispEnergy -= dlambda*SQRT_TWOTHIRDS*plasticLaw->GetYieldIncrement(mptr,np,delTime,&alpha,p->hardProps);
// The cumulative dissipated energy is tracked in plastic energy
mptr->AddPlastEnergy(dispEnergy);
// heat energy is Cv(dT-dTq0) - dPhi
IncrementHeatEnergy(mptr,res->dT,dTq0,dispEnergy);
// update internal variables in the plastic law
plasticLaw->UpdatePlasticInternal(mptr,np,&alpha,historyOffset);
}
/* Take increments in strain and calculate new Particle: strains, rotation strain,
stresses, strain energy,
dvij are (gradient rates X time increment) to give deformation gradient change
For Axisymmetry: x->R, y->Z, z->theta, np==AXISYMMETRIC_MPM, otherwise dvzz=0
This material tracks pressure and stores deviatoric stress only in particle stress
tensor
*/
void Neohookean::MPMConstitutiveLaw(MPMBase *mptr,Matrix3 du,double delTime,int np,void *properties,
ResidualStrains *res,int historyOffset) const
{
// Update strains and rotations and Left Cauchy strain
double detDf = IncrementDeformation(mptr,du,NULL,np);
// get pointer to new left Cauchy strain
Tensor *B = mptr->GetAltStrainTensor();
// account for residual stresses
double dJres = GetIncrementalResJ(mptr,res);
double Jres = dJres*mptr->GetHistoryDble(J_History+1,historyOffset);
mptr->SetHistoryDble(J_History+1,Jres,historyOffset);
double resStretch = pow(Jres,1./3.);
double Jres23 = resStretch*resStretch;
// Deformation gradients and Cauchy tensor differ in plane stress
if(np==PLANE_STRESS_MPM)
{ // Find B->zz required to have zero stress in z direction
double arg = B->xx*B->yy - B->xy*B->xy;
double xn;
Tensor *ep=mptr->GetStrainTensor();
switch(UofJOption)
{ case J_MINUS_1_SQUARED:
{ double a = pr.Lamesp*arg + pr.Gsp*pow(Jres,4./3.);
double b = pr.Lamesp*sqrt(arg);
xn = Jres*(b + sqrt(b*b + 4.*pr.Gsp*a))/(2.*a);
xn *= xn;
break;
}
case LN_J_SQUARED:
{ xn = B->zz;
double fx,fxp,xnp1,Jres23 = pow(Jres,2./3.);
int iter=1;
while(iter<20)
{ // get f and df/dxn
fx = pr.Gsp*(xn-Jres23) + 0.5*pr.Lamesp*Jres23*log(xn*arg/(Jres*Jres));
fxp = pr.Gsp + pr.Lamesp*Jres23/(2*xn);
// new prediction for solution
xnp1 = xn - fx/fxp;
if(fabs(xn-xnp1)<1e-10) break;
xn = xnp1;
iter+=1;
}
break;
}
case HALF_J_SQUARED_MINUS_1_MINUS_LN_J:
default:
xn = Jres*Jres*(pr.Lamesp+2.*pr.Gsp)/(pr.Lamesp*arg+2.*pr.Gsp*pow(Jres,4./3.));
break;
}
// Done and xn = new B->zz = Fzz^2 = dFzz*(old Bzz)*dFzz = dFzz^2*(old Bzz),
// and Fzz = dFzz*(old Fzz) = 1 + ep->zz
//cout << xn << "," << pow(Jres,2./3.)*pr.Lamesp*(xn*arg/(Jres*Jres)-1.) + 2.*pr.Gsp*(xn-pow(Jres,2./3.)) << endl;;
double dFzz = sqrt(xn/B->zz);
B->zz = xn;
// particle strain ezz now known
ep->zz = dFzz*(1.+ep->zz) - 1.;
// incremental J changes
detDf *= dFzz;
}
// Increment J and save it in history data
double J = detDf*mptr->GetHistoryDble(J_History,historyOffset);
mptr->SetHistoryDble(J_History,J,historyOffset);
// for incremental energy, store initial stress
Tensor *sporig=mptr->GetStressTensor();
Tensor st0 = *sporig;
// account for residual stresses
double Jeff = J/Jres;
// update pressure
double p0=mptr->GetPressure();
double Pterm = J*GetVolumetricTerms(Jeff,pr.Lamesp) + Jres*pr.Gsp*((B->xx+B->yy+B->zz)/(3.*Jres23) - 1.);
// artifical viscosity
double delV = 1. - 1./detDf; // total volume change
double QAVred = 0.,AVEnergy=0.;
if(delV<0. && artificialViscosity)
{ QAVred = GetArtificalViscosity(delV/delTime,sqrt(pr.Ksp)*J);
if(ConductionTask::AVHeating) AVEnergy = fabs(QAVred*delV);
}
double Pfinal = -Pterm + QAVred;
// set the pressure
mptr->SetPressure(Pfinal);
// incremental energy - dilational part
double avgP = 0.5*(p0+Pfinal);
double dilEnergy = -avgP*delV;
// incremental residual energy
double delVres = 1. - 1./dJres;
double resEnergy = -avgP*delVres;
// Account for density change in specific stress
// i.e.. Get (Kirchoff Stress)/rho0
double GJeff = resStretch*pr.Gsp; // = J*(Jres^(1/3) G/J) to get Kirchoff
// find deviatoric (Cauchy stress)J/rho0 = deviatoric (Kirchoff stress)/rho0
Tensor *sp=mptr->GetStressTensor();
double I1third = (B->xx+B->yy+B->zz)/3.;
sp->xx = GJeff*(B->xx-I1third);
sp->yy = GJeff*(B->yy-I1third);
sp->zz = GJeff*(B->zz-I1third);
sp->xy = GJeff*B->xy;
if(np==THREED_MPM)
{ sp->xz = GJeff*B->xz;
sp->yz = GJeff*B->yz;
}
// incremental work energy = shear energy
double shearEnergy = 0.5*((sp->xx+st0.xx)*du(0,0) + (sp->yy+st0.yy)*du(1,1) + (sp->zz+st0.zz)*du(2,2)+
(sp->xy+st0.xy)*(du(0,1)+du(1,0)));
if(np==THREED_MPM)
{ shearEnergy += 0.5*((sp->xz+st0.xz)*(du(0,2)+du(2,0)) + (sp->yz+st0.yz)*(du(1,2)+du(2,1)));
}
// strain energy
double dU = dilEnergy + shearEnergy;
mptr->AddWorkEnergyAndResidualEnergy(dU,resEnergy);
// particle isentropic temperature increment
double Kratio; // = rho_0 K/(rho K_0)
double Jeff1third = pow(Jeff,1./3.);
double Gterm = pr.Gsp*(1. - Jeff1third*Jeff1third + 2./(3.*Jeff1third));
switch(UofJOption)
{ case J_MINUS_1_SQUARED:
Kratio = pr.Lamesp+Jeff + Gterm;
break;
case LN_J_SQUARED:
Kratio = pr.Lamesp*(1-log(Jeff))/(Jeff*Jeff) + Gterm;
break;
case HALF_J_SQUARED_MINUS_1_MINUS_LN_J:
default:
Kratio = 0.5*(Jeff + 1./Jeff);
break;
}
Kratio /= pr.Ksp;
double dTq0 = -J*Kratio*gamma0*mptr->pPreviousTemperature*delV;
// thermodynamics heat and temperature
IncrementHeatEnergy(mptr,res->dT,dTq0,QAVred);
}
// Apply Constitutive law, check np to know what type
void TaitLiquid::MPMConstitutiveLaw(MPMBase *mptr,Matrix3 du,double delTime,int np,void *properties,
ResidualStrains *res,int historyOffset) const
{
#ifdef NO_SHEAR_MODEL
// get incremental deformation gradient
const Matrix3 dF = du.Exponential(incrementalDefGradTerms);
// decompose dF into dR and dU
Matrix3 dR;
Matrix3 dU = dF.RightDecompose(&dR,NULL);
// current deformation gradient
double detdF = dF.determinant();
Matrix3 pF = mptr->GetDeformationGradientMatrix();
Matrix3 F = dR*pF;
if(np==THREED_MPM)
F.Scale(pow(detdF,1./3.));
else
F.Scale2D(sqrt(detdF));
// new deformation matrix with volume change onle
mptr->SetDeformationGradientMatrix(F);
#else
#ifdef ELASTIC_B_MODEL
// get incremental deformation gradient
const Matrix3 dF = du.Exponential(incrementalDefGradTerms);
double detdF = dF.determinant();
// current deformation gradient
Matrix3 pF = mptr->GetDeformationGradientMatrix();
// new deformation matrix
const Matrix3 F = dF*pF;
mptr->SetDeformationGradientMatrix(F);
#else
// Update total deformation gradient, and calculate trial B
double detdF = IncrementDeformation(mptr,du,NULL,np);
#endif
#endif
// Get new J and save result on the particle
double J = detdF * mptr->GetHistoryDble(J_History,historyOffset);
mptr->SetHistoryDble(J_History,J,historyOffset);
#ifdef ELASTIC_B_MODEL
// store pressure strain as elastic B
Tensor *pB = mptr->GetAltStrainTensor() ;
if(np==THREED_MPM || np==AXISYMMETRIC_MPM)
{ double J23 = pow(J,2./3.);
pB->xx = J23;
pB->yy = J23;
pB->zz = J23;
}
else
{ pB->xx = J;
pB->yy = J;
}
#endif
// account for residual stresses
double dJres = GetIncrementalResJ(mptr,res);
double Jres = dJres * mptr->GetHistoryDble(J_History+1,historyOffset);
mptr->SetHistoryDble(J_History+1,Jres,historyOffset);
double Jeff = J/Jres;
// new Kirchhoff pressure (over rho0) from Tait equation
double p0=mptr->GetPressure();
double pressure = J*TAIT_C*Ksp*(exp((1.-Jeff)/TAIT_C)-1.);
mptr->SetPressure(pressure);
// incremental energy per unit mass - dilational part
double avgP = 0.5*(p0+pressure);
double delV = 1. - 1./detdF;
double workEnergy = -avgP*delV;
// incremental residual energy per unit mass
double delVres = 1. - 1./dJres;
double resEnergy = -avgP*delVres;
// viscosity term = 2 eta (0.5(grad v) + 0.5*(grad V)^T - (1/3) tr(grad v) I) = 2 eta dev(grad v)
// (i.e., deviatoric part of the symmetric strain tensor, 2 is for conversion to engineering shear strain)
// simple shear rate = |2 dev(grad v)|
Matrix3 shear;
double c[3][3];
double shearRate;
c[0][0] = (2.*du(0,0)-du(1,1)-du(2,2))/3.;
c[1][1] = (2.*du(1,1)-du(0,0)-du(2,2))/3.;
c[2][2] = (2.*du(2,2)-du(0,0)-du(1,1))/3.;
c[0][1] = 0.5*(du(0,1)+du(1,0));
c[1][0] = c[0][1];
shearRate = c[0][0]*c[0][0] + c[1][1]*c[1][1] + c[2][2]*c[2][2]
+ 2.*c[0][1]*c[0][1];
if(np==THREED_MPM)
{ c[0][2] = 0.5*(du(0,2)+du(2,0));
c[2][0] = c[0][2];
c[1][2] = 0.5*(du(1,2)+du(2,1));
c[2][1] = c[1][2];
shearRate += 2.*(c[0][2]*c[0][2] + c[1][2]*c[1][2]);
shear.set(c);
}
else
shear.set(c[0][0],c[0][1],c[1][0],c[1][1],c[2][2]);
shearRate = 2.*sqrt(shearRate)/delTime;
// Store shear rate
mptr->SetHistoryDble(J_History+2,shearRate,historyOffset);
// Get effective visocisy
double twoetaspRate = 0.;
if(numViscosity==1)
{ twoetaspRate = TwoEtasp[0];
}
else
{ shearRate = log10(shearRate);
if(shearRate < logShearRate[0])
twoetaspRate = TwoEtasp[0];
else if(shearRate > logShearRate[numViscosity-1])
twoetaspRate = TwoEtasp[numViscosity-1];
else
{ // interpolate
for(int i=1;i<numViscosity;i++)
{ if(shearRate <= logShearRate[i])
{ // between i-1 and i
double fract = (logShearRate[i]-shearRate)/(logShearRate[i]-logShearRate[i-1]);
twoetaspRate = fract*TwoEtasp[i-1] + (1.-fract)*TwoEtasp[i];
break;
}
}
}
}
// Get Kirchoff shear stress (over rho0)
shear.Scale(J*twoetaspRate/delTime);
// update deviatoric stress
Tensor *sp=mptr->GetStressTensor();
sp->xx = shear(0,0);
sp->yy = shear(1,1);
sp->zz = shear(2,2);
sp->xy = shear(0,1);
if(np==THREED_MPM)
{ sp->xz = shear(0,2);
sp->yz = shear(1,2);
}
// shear work per unit mass = tau.du = tau.tau*delTime/twoetaspRate
double shearWork = sp->xx*sp->xx + sp->yy*sp->yy + sp->zz*sp->zz + 2.*sp->xy*sp->xy;
if(np==THREED_MPM) shearWork += 2.*(sp->xz*sp->xz + sp->yz*sp->yz);
shearWork *= delTime/twoetaspRate;
mptr->AddWorkEnergyAndResidualEnergy(workEnergy+shearWork,resEnergy);
// particle isentropic temperature increment dT/T = - J (K/K0) gamma0 Delta(V)/V
// Delta(V)/V = 1. - 1/detdF (total volume)
double Kratio = Jeff*(1.+pressure/(TAIT_C*Ksp));
double dTq0 = -J*Kratio*gamma0*mptr->pPreviousTemperature*delV;
// heat energy is Cv (dT - dTq0) -dPhi
// Here do Cv (dT - dTq0)
// dPhi = shearWork is lost due to shear term
IncrementHeatEnergy(mptr,res->dT,dTq0,shearWork);
}
/* Take increments in strain and calculate new Particle: strains, rotation strain,
stresses, strain energy,
dvij are (gradient rates X time increment) to give deformation gradient change
For Axisymmetry: x->R, y->Z, z->theta, np==AXISYMMETRIC_MPM, otherwise dvzz=0
This material tracks pressure and stores deviatoric stress only in particle stress
tensor
*/
void Mooney::MPMConstitutiveLaw(MPMBase *mptr,Matrix3 du,double delTime,int np,void *properties,
ResidualStrains *res,int historyOffset) const
{
// incremental energy, store initial stress
Tensor *sporig=mptr->GetStressTensor();
Tensor st0 = *sporig;
// Update strains and rotations and Left Cauchy strain
double detDf = IncrementDeformation(mptr,du,NULL,np);
// get pointer to new left Cauchy strain
Tensor *B = mptr->GetAltStrainTensor();
// account for residual stresses
double dJres = GetIncrementalResJ(mptr,res);
double Jres = dJres*mptr->GetHistoryDble(J_History+1,historyOffset);
mptr->SetHistoryDble(J_History+1,Jres,historyOffset);
// Deformation gradients and Cauchy tensor differ in plane stress
if(np==PLANE_STRESS_MPM)
{ // Find B->zz required to have zero stress in z direction
// fixed arguments
double arg = B->xx*B->yy - B->xy*B->xy;
double arg12 = sqrt(arg);
double arg16 = pow(arg,1./6.);
double arg2 = B->xx+B->yy;
// Newton-Rapheson starting at B.zz = 1
// In tests finds answer in 3 or less steps
Tensor *ep=mptr->GetStrainTensor();
double xn16,xn12,xnp1,xn = (1.+ep->zz)*(1.+ep->zz);
double fx,fxp,J13,J0,J2,Jeff;
int iter=1;
double mJ2P,mdJ2PdJ;
// solution for B.zz in xn and J = sqrt(xn*arg) with dJ/dxn = arg/(2 sqrt(xn*arg))
// Solving f=0 where f = 3J^2 Kterm + Jres*G1(2*xn-arg2)J^(1/3) + Jres*G2(xn*arg2 - 2*arg)/J^(1/3)
// where J^(1/3) = (xn*arg)^(1/6)
// df/dxn = d(3J^2 Kterm)/dJ dJ/dxn
// + Jres*G1((14*xn-arg2)/(6*xn))J^(1/3)
// + Jres*G2((5*xn*arg2+2*arg)/(6*xn))/J^(1/3)
while(iter<20)
{ xn16 = pow(xn,1./6.);
xn12 = sqrt(xn);
J13 = xn16*arg16;
J0 = xn12*arg12;
J2 = J0*J0;
Jeff = J0/Jres;
// get f and df/dxn
GetNewtonPressureTerms(Jeff, Ksp, mJ2P, mdJ2PdJ);
fx = 3.*Jres*mJ2P + G1sp*(2.*xn-arg2)*J13 + G2sp*(xn*arg2-2.*arg)/J13;
fxp = (1.5*J0/xn)*mdJ2PdJ + G1sp*J13*(14.*xn-arg2)/(6.*xn) + G2sp*(2.*arg+5.*xn*arg2)/(6.*J13*xn);
// new prediction for solution
xnp1 = xn - fx/fxp;
//cout << iter << ": " << xn << "," << xnp1 << "," << fabs(xn-xnp1) << endl;
if(fabs(xn-xnp1)<1e-10) break;
xn = xnp1;
iter+=1;
}
if(iter>=20) cout << "# Not enough iterations in plane stress Mooney-Rivlin material" << endl;
// Done and xn = new B->zz = Fzz^2 = dFzz*(old Bzz)*dFzz = dFzz^2*(old Bzz),
// and Fzz = dFzz*(old Fzz) = 1 + ep->zz
double dFzz = sqrt(xn/B->zz);
B->zz = xn;
// particle strain ezz now known
ep->zz = dFzz*(1.+ep->zz) - 1.;
// incremental J changes
detDf *= dFzz;
}
// Increment J and save it in history data
double J = detDf*mptr->GetHistoryDble(J_History,historyOffset);
mptr->SetHistoryDble(J_History,J,historyOffset);
// account for residual stresses
double Jeff = J/Jres;
// update pressure
double p0=mptr->GetPressure();
double Kterm = J*GetVolumetricTerms(Jeff,Ksp); // times J to get Kirchoff stress
// artifical viscosity
double delV = 1. - 1./detDf; // total volume change
double QAVred = 0.,AVEnergy=0.;
if(delV<0. && artificialViscosity)
{ QAVred = GetArtificalViscosity(delV/delTime,sqrt(Ksp*J),mptr);
if(ConductionTask::AVHeating) AVEnergy = fabs(QAVred*delV);
}
double Pfinal = -Kterm + QAVred;
// set the pressure
mptr->SetPressure(Pfinal);
// incremental energy - dilational part
double avgP = 0.5*(p0+Pfinal);
double dilEnergy = -avgP*delV;
// incremental residual energy
double delVres = 1. - 1./dJres;
double resEnergy = -avgP*delVres;
// Account for density change in specific stress
// i.e.. Get (Cauchy Stress)/rho = J*(Cauchy Stress)/rho0 = (Kirchoff Stress)/rho0
double J23 = pow(J, 2./3.);
double J43 = J23*J23;
double JforG1 = J23/Jres; // J^(5/3)/(Jres J) = J^(2/3)/Jres to get Kirchoff stress
double JforG2 = J43/Jres; // J^(7/3)/(Jres J) = J^(4/3)/Jres to get Kirchoff stress
//JforG1 *= Jres; // this uses Jeff to get Kirchoff stress
//JforG2 *= Jres; // this uses Jeff to get Kirchoff stress
// find deviatoric (Cauchy stress)J/rho0 = deviatoric (Kirchoff stress)/rho0
Tensor *sp=mptr->GetStressTensor();
sp->xx = (2*B->xx-B->yy-B->zz)*G1sp/(3.*JforG1)
+ (B->xx*(B->yy+B->zz)-2*B->yy*B->zz-B->xy*B->xy)*G2sp/(3.*JforG2);
sp->yy = (2*B->yy-B->xx-B->zz)*G1sp/(3.*JforG1)
+ (B->yy*(B->xx+B->zz)-2*B->xx*B->zz-B->xy*B->xy)*G2sp/(3.*JforG2);
sp->zz = (2*B->zz-B->xx-B->yy)*G1sp/(3.*JforG1)
+ (B->zz*(B->xx+B->yy)-2*B->xx*B->yy+2.*B->xy*B->xy)*G2sp/(3.*JforG2);
sp->xy = B->xy*G1sp/JforG1 + (B->zz*B->xy)*G2sp/JforG2;
if(np==THREED_MPM)
{ sp->xx += (2.*B->yz*B->yz-B->xz*B->xz)*G2sp/(3.*JforG2);
sp->yy += (2.*B->xz*B->xz-B->yz*B->yz)*G2sp/(3.*JforG2);
sp->zz -= (B->xz*B->xz+B->yz*B->yz)*G2sp/(3.*JforG2);
sp->xy -= B->xz*B->yz*G2sp/JforG2;
sp->xz = B->xz*G1sp/JforG1 + (B->yy*B->xz-B->xy*B->yz)*G2sp/JforG2;
sp->yz = B->yz*G1sp/JforG1 + (B->xx*B->yz-B->xy*B->xz)*G2sp/JforG2;
}
// incremental work energy = shear energy
double shearEnergy = 0.5*((sp->xx+st0.xx)*du(0,0) + (sp->yy+st0.yy)*du(1,1) + (sp->zz+st0.zz)*du(2,2)+
(sp->xy+st0.xy)*(du(0,1)+du(1,0)));
if(np==THREED_MPM)
{ shearEnergy += 0.5*((sp->xz+st0.xz)*(du(0,2)+du(2,0)) + (sp->yz+st0.yz)*(du(1,2)+du(2,1)));
}
// strain energy
double dU = dilEnergy + shearEnergy;
mptr->AddWorkEnergyAndResidualEnergy(dU,resEnergy);
// thermodynamics depends on whether or not this is a rubber
double dTq0;
if(rubber)
{ // convert internal energy to temperature change
dTq0 = dU/GetHeatCapacity(mptr);
}
else
{ // elastic particle isentropic temperature increment
double Kratio; // = rho_0 K/(rho K_0)
switch(UofJOption)
{ case J_MINUS_1_SQUARED:
Kratio = Jeff;
break;
case LN_J_SQUARED:
Kratio = (1-log(Jeff))/(Jeff*Jeff);
break;
case HALF_J_SQUARED_MINUS_1_MINUS_LN_J:
default:
Kratio = 0.5*(Jeff + 1./Jeff);
break;
}
dTq0 = -J*Kratio*gamma0*mptr->pPreviousTemperature*delV;
}
IncrementHeatEnergy(mptr,res->dT,dTq0,QAVred);
}
