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); }