void
MisesMat :: giveFirstPKStressVector_3d(FloatArray &answer,
GaussPoint *gp,
const FloatArray &totalDefGradOOFEM,
TimeStep *tStep)
{
MisesMatStatus *status = static_cast< MisesMatStatus * >( this->giveStatus(gp) );
double kappa, dKappa, yieldValue, mi;
FloatMatrix F, oldF, invOldF;
FloatArray s;
F.beMatrixForm(totalDefGradOOFEM); //(method assumes full 3D)
kappa = status->giveCumulativePlasticStrain();
oldF.beMatrixForm( status->giveFVector() );
invOldF.beInverseOf(oldF);
//relative deformation radient
FloatMatrix f;
f.beProductOf(F, invOldF);
//compute elastic predictor
FloatMatrix trialLeftCauchyGreen, help;
f.times( 1./cbrt(f.giveDeterminant()) );
help.beProductOf(f, status->giveTempLeftCauchyGreen());
trialLeftCauchyGreen.beProductTOf(help, f);
FloatMatrix E;
E.beTProductOf(F, F);
E.at(1, 1) -= 1.0;
E.at(2, 2) -= 1.0;
E.at(3, 3) -= 1.0;
E.times(0.5);
FloatArray e;
e.beSymVectorFormOfStrain(E);
FloatArray leftCauchyGreen;
FloatArray leftCauchyGreenDev;
double leftCauchyGreenVol;
leftCauchyGreen.beSymVectorFormOfStrain(trialLeftCauchyGreen);
leftCauchyGreenVol = computeDeviatoricVolumetricSplit(leftCauchyGreenDev, leftCauchyGreen);
FloatArray trialStressDev;
applyDeviatoricElasticStiffness(trialStressDev, leftCauchyGreenDev, G / 2.);
s = trialStressDev;
//check for plastic loading
double trialS = computeStressNorm(trialStressDev);
double sigmaY = sig0 + H * kappa;
//yieldValue = sqrt(3./2.)*trialS-sigmaY;
yieldValue = trialS - sqrt(2. / 3.) * sigmaY;
//store deviatoric trial stress(reused by algorithmic stiffness)
status->letTrialStressDevBe(trialStressDev);
//the return-mapping algorithm
double J = F.giveDeterminant();
mi = leftCauchyGreenVol * G;
if ( yieldValue > 0 ) {
//dKappa =sqrt(3./2.)* yieldValue/(H + 3.*mi);
//kappa = kappa + dKappa;
//trialStressDev.times(1-sqrt(6.)*mi*dKappa/trialS);
dKappa = ( yieldValue / ( 2 * mi ) ) / ( 1 + H / ( 3 * mi ) );
FloatArray n = trialStressDev;
n.times(2 * mi * dKappa / trialS);
////return map
s.beDifferenceOf(trialStressDev, n);
kappa += sqrt(2. / 3.) * dKappa;
//update of intermediate configuration
trialLeftCauchyGreen.beMatrixForm(s);
trialLeftCauchyGreen.times(1.0 / G);
trialLeftCauchyGreen.at(1, 1) += leftCauchyGreenVol;
trialLeftCauchyGreen.at(2, 2) += leftCauchyGreenVol;
trialLeftCauchyGreen.at(2, 2) += leftCauchyGreenVol;
trialLeftCauchyGreen.times(J * J);
}
//addition of the elastic mean stress
FloatMatrix kirchhoffStress;
kirchhoffStress.beMatrixForm(s);
kirchhoffStress.at(1, 1) += 1. / 2. * K * ( J * J - 1 );
kirchhoffStress.at(2, 2) += 1. / 2. * K * ( J * J - 1 );
kirchhoffStress.at(3, 3) += 1. / 2. * K * ( J * J - 1 );
FloatMatrix iF, Ep(3, 3), S;
FloatArray vF, vS, ep;
//transform Kirchhoff stress into Second Piola - Kirchhoff stress
iF.beInverseOf(F);
help.beProductOf(iF, kirchhoffStress);
S.beProductTOf(help, iF);
this->computeGLPlasticStrain(F, Ep, trialLeftCauchyGreen, J);
ep.beSymVectorFormOfStrain(Ep);
vS.beSymVectorForm(S);
vF.beVectorForm(F);
answer.beVectorForm(kirchhoffStress);
status->setTrialStressVol(mi);
status->letTempLeftCauchyGreenBe(trialLeftCauchyGreen);
status->setTempCumulativePlasticStrain(kappa);
status->letTempStressVectorBe(answer);
status->letTempStrainVectorBe(e);
status->letTempPlasticStrainBe(ep);
status->letTempPVectorBe(answer);
status->letTempFVectorBe(vF);
}
void
MisesMat :: performPlasticityReturn(GaussPoint *gp, const FloatArray &totalStrain)
{
MisesMatStatus *status = static_cast< MisesMatStatus * >( this->giveStatus(gp) );
double kappa;
FloatArray plStrain;
FloatArray fullStress;
// get the initial plastic strain and initial kappa from the status
plStrain = status->givePlasticStrain();
kappa = status->giveCumulativePlasticStrain();
// === radial return algorithm ===
if ( totalStrain.giveSize() == 1 ) {
LinearElasticMaterial *lmat = this->giveLinearElasticMaterial();
double E = lmat->give('E', gp);
/*trial stress*/
fullStress.resize(6);
fullStress.at(1) = E * ( totalStrain.at(1) - plStrain.at(1) );
double trialS = fabs(fullStress.at(1));
/*yield function*/
double yieldValue = trialS - (sig0 + H * kappa);
// === radial return algorithm ===
if ( yieldValue > 0 ) {
double dKappa = yieldValue / ( H + E );
kappa += dKappa;
plStrain.at(1) += dKappa * signum( fullStress.at(1) );
plStrain.at(2) -= 0.5 * dKappa * signum( fullStress.at(1) );
plStrain.at(3) -= 0.5 * dKappa * signum( fullStress.at(1) );
fullStress.at(1) -= dKappa * E * signum( fullStress.at(1) );
}
} else {
// elastic predictor
FloatArray elStrain = totalStrain;
elStrain.subtract(plStrain);
FloatArray elStrainDev;
double elStrainVol;
elStrainVol = computeDeviatoricVolumetricSplit(elStrainDev, elStrain);
FloatArray trialStressDev;
applyDeviatoricElasticStiffness(trialStressDev, elStrainDev, G);
/**************************************************************/
double trialStressVol = 3 * K * elStrainVol;
/**************************************************************/
// store the deviatoric and trial stress (reused by algorithmic stiffness)
status->letTrialStressDevBe(trialStressDev);
status->setTrialStressVol(trialStressVol);
// check the yield condition at the trial state
double trialS = computeStressNorm(trialStressDev);
double yieldValue = sqrt(3./2.) * trialS - (sig0 + H * kappa);
if ( yieldValue > 0. ) {
// increment of cumulative plastic strain
double dKappa = yieldValue / ( H + 3. * G );
kappa += dKappa;
FloatArray dPlStrain;
// the following line is equivalent to multiplication by scaling matrix P
applyDeviatoricElasticCompliance(dPlStrain, trialStressDev, 0.5);
// increment of plastic strain
plStrain.add(sqrt(3. / 2.) * dKappa / trialS, dPlStrain);
// scaling of deviatoric trial stress
trialStressDev.times(1. - sqrt(6.) * G * dKappa / trialS);
}
// assemble the stress from the elastically computed volumetric part
// and scaled deviatoric part
computeDeviatoricVolumetricSum(fullStress, trialStressDev, trialStressVol);
}
// store the effective stress in status
status->letTempEffectiveStressBe(fullStress);
// store the plastic strain and cumulative plastic strain
status->letTempPlasticStrainBe(plStrain);
status->setTempCumulativePlasticStrain(kappa);
}
// returns the stress vector in 3d stress space
// computed from the previous plastic strain and current total strain
void
MisesMat :: performPlasticityReturn(GaussPoint *gp, const FloatArray &totalStrain)
{
double kappa, yieldValue, dKappa;
FloatArray reducedStress;
FloatArray strain, plStrain;
MaterialMode mode = gp->giveMaterialMode();
MisesMatStatus *status = static_cast< MisesMatStatus * >( this->giveStatus(gp) );
StressVector fullStress(mode);
this->initTempStatus(gp);
this->initGpForNewStep(gp);
// get the initial plastic strain and initial kappa from the status
status->givePlasticStrain(plStrain);
kappa = status->giveCumulativePlasticStrain();
// === radial return algorithm ===
if ( mode == _1dMat ) {
LinearElasticMaterial *lmat = this->giveLinearElasticMaterial();
double E = lmat->give('E', gp);
/*trial stress*/
fullStress.at(1) = E * ( totalStrain.at(1) - plStrain.at(1) );
double sigmaY = sig0 + H * kappa;
double trialS = fullStress.at(1);
trialS = fabs(trialS);
/*yield function*/
yieldValue = trialS - sigmaY;
// === radial return algorithm ===
if ( yieldValue > 0 ) {
dKappa = yieldValue / ( H + E );
kappa += dKappa;
fullStress.at(1) = fullStress.at(1) - dKappa *E *signum( fullStress.at(1) );
plStrain.at(1) = plStrain.at(1) + dKappa *signum( fullStress.at(1) );
}
} else if ( ( mode == _PlaneStrain ) || ( mode == _3dMat ) ) {
// elastic predictor
StrainVector elStrain(totalStrain, mode);
elStrain.subtract(plStrain);
StrainVector elStrainDev(mode);
double elStrainVol;
elStrain.computeDeviatoricVolumetricSplit(elStrainDev, elStrainVol);
StressVector trialStressDev(mode);
elStrainDev.applyDeviatoricElasticStiffness(trialStressDev, G);
/**************************************************************/
double trialStressVol;
trialStressVol = 3 * K * elStrainVol;
/**************************************************************/
// store the deviatoric and trial stress (reused by algorithmic stiffness)
status->letTrialStressDevBe(trialStressDev);
status->setTrialStressVol(trialStressVol);
// check the yield condition at the trial state
double trialS = trialStressDev.computeStressNorm();
double sigmaY = sig0 + H * kappa;
yieldValue = sqrt(3. / 2.) * trialS - sigmaY;
if ( yieldValue > 0. ) {
// increment of cumulative plastic strain
dKappa = yieldValue / ( H + 3. * G );
kappa += dKappa;
StrainVector dPlStrain(mode);
// the following line is equivalent to multiplication by scaling matrix P
trialStressDev.applyDeviatoricElasticCompliance(dPlStrain, 0.5);
// increment of plastic strain
dPlStrain.times(sqrt(3. / 2.) * dKappa / trialS);
plStrain.add(dPlStrain);
// scaling of deviatoric trial stress
trialStressDev.times(1. - sqrt(6.) * G * dKappa / trialS);
}
// assemble the stress from the elastically computed volumetric part
// and scaled deviatoric part
double stressVol = 3. * K * elStrainVol;
trialStressDev.computeDeviatoricVolumetricSum(fullStress, stressVol);
}
// store the effective stress in status
status->letTempEffectiveStressBe(fullStress);
// store the plastic strain and cumulative plastic strain
status->letTempPlasticStrainBe(plStrain);
status->setTempCumulativePlasticStrain(kappa);
}
