//Jacobian for stress update algorithm void FiniteStrainRatePlasticMaterial::getJac(const RankTwoTensor & sig, const RankFourTensor & E_ijkl, Real flow_incr, Real yield_stress, RankFourTensor & dresid_dsig) { unsigned i, j, k ,l; RankTwoTensor sig_dev, flow_tensor, flow_dirn,fij; RankTwoTensor dfi_dft; RankFourTensor dft_dsig, dfd_dft, dfd_dsig, dfi_dsig; Real sig_eqv; Real f1, f2, f3; Real dfi_dseqv; sig_dev = sig.deviatoric(); sig_eqv = getSigEqv(sig); getFlowTensor(sig, yield_stress, flow_tensor); flow_dirn = flow_tensor; dfi_dseqv = _ref_pe_rate * _dt * _exponent * std::pow(macaulayBracket(sig_eqv / yield_stress - 1.0), _exponent - 1.0) / yield_stress; for (i = 0; i < 3; ++i) for (j = 0; j < 3; ++j) for (k = 0; k < 3; ++k) for (l = 0; l < 3; ++l) dfi_dsig(i,j,k,l) = flow_dirn(i,j) * flow_dirn(k,l) * dfi_dseqv; //d_flow_increment/d_sig f1 = 0.0; f2 = 0.0; f3 = 0.0; if (sig_eqv > 1e-8) { f1 = 3.0 / (2.0 * sig_eqv); f2 = f1 / 3.0; f3 = 9.0 / (4.0 * std::pow(sig_eqv, 3.0)); } for (i = 0; i < 3; ++i) for (j = 0; j < 3; ++j) for (k = 0; k < 3; ++k) for (l = 0; l < 3; ++l) dft_dsig(i,j,k,l) = f1 * deltaFunc(i,k) * deltaFunc(j,l) - f2 * deltaFunc(i,j) * deltaFunc(k,l) - f3 * sig_dev(i,j) * sig_dev(k,l); //d_flow_dirn/d_sig - 2nd part dfd_dsig = dft_dsig; //d_flow_dirn/d_sig dresid_dsig = E_ijkl.invSymm() + dfd_dsig * flow_incr + dfi_dsig; //Jacobian }
void RedbackMechMaterialCC::getJac(const RankTwoTensor & sig, const RankFourTensor & E_ijkl, Real flow_incr, Real sig_eqv, Real pressure, Real p_yield_stress, Real q_yield_stress, Real pc, RankFourTensor & dresid_dsig) { unsigned i, j, k, l; RankTwoTensor sig_dev, flow_dirn_vol, flow_dirn_dev, fij, flow_dirn, flow_tensor; RankTwoTensor dfi_dft; RankFourTensor dfd_dsig, dfi_dsig; Real f1, f2; Real dfi_dseqv_dev, dfi_dseqv_vol, dfi_dseqv; pc *= -1; sig_dev = sig.deviatoric(); dfi_dseqv = getDerivativeFlowIncrement(sig, pressure, sig_eqv, pc, q_yield_stress, p_yield_stress); getFlowTensor(sig, sig_eqv, pressure, pc, flow_dirn); /* The following calculates the tensorial derivative (Jacobian) of the residual with respect to stress, dr_dsig * It consists of two terms: The first is * dr_dsig = (dfi_dseqv_dev*flow_dirn_dev(k,l)) * flow_dirn_dev(i,j) * which is the tensorial product of the flow increment tensor times the flow direction tensor * * The second is the product of the flow increment tensor times the derivative of the flow direction tensor * with respect to the stress tensor. See also REDBACK's documentation * */ // This loop calculates the first term for (i = 0; i < 3; ++i) for (j = 0; j < 3; ++j) for (k = 0; k < 3; ++k) for (l = 0; l < 3; ++l) dfi_dsig(i, j, k, l) = flow_dirn(i, j) * flow_dirn(k, l) * dfi_dseqv; // Real flow_tensor_norm = flow_dirn.L2norm(); // This loop calculates the second term. Read REDBACK's documentation // (same as J2 plasticity case) f1 = 0.0; f2 = 0.0; if (sig_eqv > 1e-8) { f1 = 3.0 / (_slope_yield_surface * _slope_yield_surface); f2 = 2.0 / 9.0 - 1.0 / (_slope_yield_surface * _slope_yield_surface); } for (i = 0; i < 3; ++i) for (j = 0; j < 3; ++j) for (k = 0; k < 3; ++k) for (l = 0; l < 3; ++l) dfd_dsig(i, j, k, l) = f1 * deltaFunc(i, k) * deltaFunc(j, l) - f2 * deltaFunc(i, j) * deltaFunc(k, l); // d_flow_dirn/d_sig - 2nd part (J2 plasticity) // dfd_dsig = dft_dsig1/flow_tensor_norm - 3.0 * dft_dsig2 / // (2*sig_eqv*flow_tensor_norm*flow_tensor_norm*flow_tensor_norm); //d_flow_dirn/d_sig // TODO: check if the previous two lines (i.e normalizing the flow vector) should be activated or not. Currently we // are using the non-unitary flow vector dresid_dsig = E_ijkl.invSymm() + dfd_dsig * flow_incr + dfi_dsig; // Jacobian }
void RedbackMechMaterialCC::getJac(const RankTwoTensor & sig, const RankFourTensor & E_ijkl, Real flow_incr, Real sig_eqv, Real pressure, Real p_yield_stress, Real q_yield_stress, Real yield_stress, RankFourTensor & dresid_dsig) { unsigned i, j, k, l; RankTwoTensor sig_dev, flow_dirn_vol, flow_dirn_dev, fij, flow_dirn, flow_tensor; RankTwoTensor dfi_dft; RankFourTensor dfd_dsig, dfi_dsig; Real f1, f2, f3; Real dfi_dp, dfi_dseqv; Real pc = -yield_stress; sig_dev = sig.deviatoric(); getDerivativeFlowIncrement(dfi_dp, dfi_dseqv, sig, pressure, sig_eqv, pc, q_yield_stress, p_yield_stress); getFlowTensor(sig, sig_eqv, pressure, q_yield_stress, p_yield_stress, yield_stress, flow_dirn); /* The following calculates the tensorial derivative (Jacobian) of the *residual with respect to stress, dr_dsig * It consists of two terms: The first is * dr_dsig = (dfi_dseqv_dev*flow_dirn_dev(k,l)) * flow_dirn_dev(i,j) * which is the tensorial product of the flow increment tensor times the flow *direction tensor * * The second is the product of the flow increment tensor times the derivative *of the flow direction tensor * with respect to the stress tensor. See also REDBACK's documentation * */ f1 = 0.0; f2 = 0.0; f3 = 0.0; if (sig_eqv > 1e-10) { f1 = 3.0 / (_slope_yield_surface * _slope_yield_surface); f2 = 2.0 / 9.0 - 1.0 / (_slope_yield_surface * _slope_yield_surface); f3 = 3.0 / (2.0 * sig_eqv); } // This loop calculates the first term for (i = 0; i < 3; ++i) for (j = 0; j < 3; ++j) for (k = 0; k < 3; ++k) for (l = 0; l < 3; ++l) dfi_dsig(i, j, k, l) = flow_dirn(i, j) * (f3 * sig_dev(k, l) * dfi_dseqv + dfi_dp * deltaFunc(k, l) / 3.0); // This loop calculates the second term. for (i = 0; i < 3; ++i) for (j = 0; j < 3; ++j) for (k = 0; k < 3; ++k) for (l = 0; l < 3; ++l) dfd_dsig(i, j, k, l) = f1 * deltaFunc(i, k) * deltaFunc(j, l) + f2 * deltaFunc(i, j) * deltaFunc(k, l); dresid_dsig = E_ijkl.invSymm() + dfd_dsig * flow_incr + dfi_dsig; // Jacobian }