void MisesMat :: give3dLSMaterialStiffnessMatrix(FloatMatrix &answer, MatResponseMode mode, GaussPoint *gp, TimeStep *tStep) { MisesMatStatus *status = static_cast< MisesMatStatus * >( this->giveStatus(gp) ); // start from the elastic stiffness FloatMatrix I(6, 6); I.at(1, 1) = I.at(2, 2) = I.at(3, 3) = 1; I.at(4, 4) = I.at(5, 5) = I.at(6, 6) = 0.5; FloatArray delta(6); delta.at(1) = delta.at(2) = delta.at(3) = 1; FloatMatrix F; F.beMatrixForm( status->giveTempFVector() ); double J = F.giveDeterminant(); const FloatArray &trialStressDev = status->giveTrialStressDev(); double trialStressVol = status->giveTrialStressVol(); double trialS = computeStressNorm(trialStressDev); FloatArray n = trialStressDev; if ( trialS == 0 ) { n.resize(6); } else { n.times(1 / trialS); } FloatMatrix C; FloatMatrix help; help.beDyadicProductOf(delta, delta); C = help; help.times(-1. / 3.); FloatMatrix C1 = I; C1.add(help); C1.times(2 * trialStressVol); FloatMatrix n1, n2; n1.beDyadicProductOf(n, delta); n2.beDyadicProductOf(delta, n); help = n1; help.add(n2); C1.add(-2. / 3. * trialS, help); C.times(K * J * J); C.add(-K * ( J * J - 1 ), I); C.add(C1); ////////////////////////////////////////////////////////////////////////////////////////////////////////// FloatMatrix invF; FloatMatrix T(6, 6); invF.beInverseOf(F); ////////////////////////////////////////////////// //first row of pull back transformation matrix T.at(1, 1) = invF.at(1, 1) * invF.at(1, 1); T.at(1, 2) = invF.at(1, 2) * invF.at(1, 2); T.at(1, 3) = invF.at(1, 3) * invF.at(1, 3); T.at(1, 4) = 2. * invF.at(1, 2) * invF.at(1, 3); T.at(1, 5) = 2. * invF.at(1, 1) * invF.at(1, 3); T.at(1, 6) = 2. * invF.at(1, 1) * invF.at(1, 2); //second row of pull back transformation matrix T.at(2, 1) = invF.at(2, 1) * invF.at(2, 1); T.at(2, 2) = invF.at(2, 2) * invF.at(2, 2); T.at(2, 3) = invF.at(2, 3) * invF.at(2, 3); T.at(2, 4) = 2. * invF.at(2, 2) * invF.at(2, 3); T.at(2, 5) = 2. * invF.at(2, 1) * invF.at(2, 3); T.at(2, 6) = 2. * invF.at(2, 1) * invF.at(2, 2); //third row of pull back transformation matrix T.at(3, 1) = invF.at(3, 1) * invF.at(3, 1); T.at(3, 2) = invF.at(3, 2) * invF.at(3, 2); T.at(3, 3) = invF.at(3, 3) * invF.at(3, 3); T.at(3, 4) = 2. * invF.at(3, 2) * invF.at(3, 3); T.at(3, 5) = 2. * invF.at(3, 1) * invF.at(3, 3); T.at(3, 6) = 2. * invF.at(3, 1) * invF.at(3, 2); //fourth row of pull back transformation matrix T.at(4, 1) = invF.at(2, 1) * invF.at(3, 1); T.at(4, 2) = invF.at(2, 2) * invF.at(3, 2); T.at(4, 3) = invF.at(2, 3) * invF.at(3, 3); T.at(4, 4) = ( invF.at(2, 2) * invF.at(3, 3) + invF.at(2, 3) * invF.at(3, 2) ); T.at(4, 5) = ( invF.at(2, 1) * invF.at(3, 3) + invF.at(2, 3) * invF.at(3, 1) ); T.at(4, 6) = ( invF.at(2, 1) * invF.at(3, 2) + invF.at(2, 2) * invF.at(3, 1) ); //fifth row of pull back transformation matrix T.at(5, 1) = invF.at(1, 1) * invF.at(3, 1); T.at(5, 2) = invF.at(1, 2) * invF.at(3, 2); T.at(5, 3) = invF.at(1, 3) * invF.at(3, 3); T.at(5, 4) = ( invF.at(1, 2) * invF.at(3, 3) + invF.at(1, 3) * invF.at(3, 2) ); T.at(5, 5) = ( invF.at(1, 1) * invF.at(3, 3) + invF.at(1, 3) * invF.at(3, 1) ); T.at(5, 6) = ( invF.at(1, 1) * invF.at(3, 2) + invF.at(1, 2) * invF.at(3, 1) ); //sixth row of pull back transformation matrix T.at(6, 1) = invF.at(1, 1) * invF.at(2, 1); T.at(6, 2) = invF.at(1, 2) * invF.at(2, 2); T.at(6, 3) = invF.at(1, 3) * invF.at(2, 3); T.at(6, 4) = ( invF.at(1, 2) * invF.at(2, 3) + invF.at(1, 3) * invF.at(2, 2) ); T.at(6, 5) = ( invF.at(1, 1) * invF.at(2, 3) + invF.at(1, 3) * invF.at(2, 1) ); T.at(6, 6) = ( invF.at(1, 1) * invF.at(2, 2) + invF.at(1, 2) * invF.at(2, 1) ); /////////////////////////////////////////// if ( mode != TangentStiffness ) { help.beProductTOf(C, T); answer.beProductOf(T, help); return; } double kappa = status->giveCumulativePlasticStrain(); // increment of cumulative plastic strain as an indicator of plastic loading double dKappa = sqrt(3. / 2.) * ( status->giveTempCumulativePlasticStrain() - kappa ); //double dKappa = ( status->giveTempCumulativePlasticStrain() - kappa); if ( dKappa <= 0.0 ) { // elastic loading - elastic stiffness plays the role of tangent stiffness help.beProductTOf(C, T); answer.beProductOf(T, help); return; } // === plastic loading === //dKappa = dKappa*sqrt(3./2.); // trial deviatoric stress and its norm double beta0, beta1, beta2, beta3, beta4; if ( trialS == 0 ) { beta1 = 0; } else { beta1 = 2 * trialStressVol * dKappa / trialS; } if ( trialStressVol == 0 ) { beta0 = 0; beta2 = 0; beta3 = beta1; beta4 = 0; } else { beta0 = 1 + H / 3 / trialStressVol; beta2 = ( 1 - 1 / beta0 ) * 2. / 3. * trialS * dKappa / trialStressVol; beta3 = 1 / beta0 - beta1 + beta2; beta4 = ( 1 / beta0 - beta1 ) * trialS / trialStressVol; } FloatMatrix N; N.beDyadicProductOf(n, n); N.times(-2 * trialStressVol * beta3); C1.times(-beta1); FloatMatrix mN(3, 3); mN.at(1, 1) = n.at(1); mN.at(1, 2) = n.at(6); mN.at(1, 3) = n.at(5); mN.at(2, 1) = n.at(6); mN.at(2, 2) = n.at(2); mN.at(2, 3) = n.at(4); mN.at(3, 1) = n.at(5); mN.at(3, 2) = n.at(4); mN.at(3, 3) = n.at(3); FloatMatrix mN2; mN2.beProductOf(mN, mN); double volN2 = 1. / 3. * ( mN2.at(1, 1) + mN2.at(2, 2) + mN2.at(3, 3) ); FloatArray devN2(6); devN2.at(1) = mN2.at(1, 1) - volN2; devN2.at(2) = mN2.at(2, 2) - volN2; devN2.at(3) = mN2.at(3, 3) - volN2; devN2.at(4) = mN2.at(2, 3); devN2.at(5) = mN2.at(1, 3); devN2.at(6) = mN2.at(1, 2); FloatMatrix nonSymPart; nonSymPart.beDyadicProductOf(n, devN2); //symP.beTranspositionOf(nonSymPart); //symP.add(nonSymPart); //symP.times(1./2.); nonSymPart.times(-2 * trialStressVol * beta4); C.add(C1); C.add(N); C.add(nonSymPart); help.beProductTOf(C, T); answer.beProductOf(T, help); }