void
StressDivergenceTensors::computeFiniteDeformJacobian()
{
const RankTwoTensor I(RankTwoTensor::initIdentity);
const RankFourTensor II_ijkl = I.mixedProductIkJl(I);
// Bring back to unrotated config
const RankTwoTensor unrotated_stress =
(*_rotation_increment)[_qp].transpose() * _stress[_qp] * (*_rotation_increment)[_qp];
// Incremental deformation gradient Fhat
const RankTwoTensor Fhat =
(*_deformation_gradient)[_qp] * (*_deformation_gradient_old)[_qp].inverse();
const RankTwoTensor Fhatinv = Fhat.inverse();
const RankTwoTensor rot_times_stress = (*_rotation_increment)[_qp] * unrotated_stress;
const RankFourTensor dstress_drot =
I.mixedProductIkJl(rot_times_stress) + I.mixedProductJkIl(rot_times_stress);
const RankFourTensor rot_rank_four =
(*_rotation_increment)[_qp].mixedProductIkJl((*_rotation_increment)[_qp]);
const RankFourTensor drot_dUhatinv = Fhat.mixedProductIkJl(I);
const RankTwoTensor A = I - Fhatinv;
// Ctilde = Chat^-1 - I
const RankTwoTensor Ctilde = A * A.transpose() - A - A.transpose();
const RankFourTensor dCtilde_dFhatinv =
-I.mixedProductIkJl(A) - I.mixedProductJkIl(A) + II_ijkl + I.mixedProductJkIl(I);
// Second order approximation of Uhat - consistent with strain increment definition
// const RankTwoTensor Uhat = I - 0.5 * Ctilde - 3.0/8.0 * Ctilde * Ctilde;
RankFourTensor dUhatinv_dCtilde =
0.5 * II_ijkl - 1.0 / 8.0 * (I.mixedProductIkJl(Ctilde) + Ctilde.mixedProductIkJl(I));
RankFourTensor drot_dFhatinv = drot_dUhatinv * dUhatinv_dCtilde * dCtilde_dFhatinv;
drot_dFhatinv -= Fhat.mixedProductIkJl((*_rotation_increment)[_qp].transpose());
_finite_deform_Jacobian_mult[_qp] = dstress_drot * drot_dFhatinv;
const RankFourTensor dstrain_increment_dCtilde =
-0.5 * II_ijkl + 0.25 * (I.mixedProductIkJl(Ctilde) + Ctilde.mixedProductIkJl(I));
_finite_deform_Jacobian_mult[_qp] +=
rot_rank_four * _Jacobian_mult[_qp] * dstrain_increment_dCtilde * dCtilde_dFhatinv;
_finite_deform_Jacobian_mult[_qp] += Fhat.mixedProductJkIl(_stress[_qp]);
const RankFourTensor dFhat_dFhatinv = -Fhat.mixedProductIkJl(Fhat.transpose());
const RankTwoTensor dJ_dFhatinv = dFhat_dFhatinv.innerProductTranspose(Fhat.ddet());
// Component from Jacobian derivative
_finite_deform_Jacobian_mult[_qp] += _stress[_qp].outerProduct(dJ_dFhatinv);
// Derivative of Fhatinv w.r.t. undisplaced coordinates
const RankTwoTensor Finv = (*_deformation_gradient)[_qp].inverse();
const RankFourTensor dFhatinv_dGradu = -Fhatinv.mixedProductIkJl(Finv.transpose());
_finite_deform_Jacobian_mult[_qp] = _finite_deform_Jacobian_mult[_qp] * dFhatinv_dGradu;
}
void
ComputeRSphericalIncrementalStrain::computeTotalStrainIncrement(RankTwoTensor & total_strain_increment)
{
// Deformation gradient calculation in cylinderical coordinates
RankTwoTensor A; // Deformation gradient
RankTwoTensor Fbar; // Old Deformation gradient
// Step through calculating the current and old deformation gradients
// Only diagonal components are nonzero because this is a 1D material
// Note: x_disp is the radial displacement
A(0,0) = (*_grad_disp[0])[_qp](0);
Fbar(0,0) = (*_grad_disp_old[0])[_qp](0);
// The polar and azimuthal strains are functions of radial displacement
if (!MooseUtils::relativeFuzzyEqual(_q_point[_qp](0), 0.0))
{
A(1,1) = (*_disp[0])[_qp] / _q_point[_qp](0);
Fbar(1,1) = _disp_old_0[_qp] / _q_point[_qp](0);
}
// The polar and azimuthal strains are equalivalent in this 1D problem
A(2,2) = A(1,1);
Fbar(2,2) = Fbar(1,1);
// Gauss point deformation gradient
_deformation_gradient[_qp] = A;
_deformation_gradient[_qp].addIa(1.0);
// very nearly A = gradU - gradUold, adapted to cylinderical coords
A -= Fbar;
total_strain_increment = 0.5 * (A + A.transpose());
}
Real
stzRHEVPFlowRatePowerLawJ2::computeEqvStress(const RankTwoTensor & pk2_dev, const RankTwoTensor & ce) const
{
RankTwoTensor sdev = pk2_dev * ce;
Real val = sdev.doubleContraction(sdev.transpose());
return std::pow(1.0 * val, 0.5);
}
Real
FlowRateModel::computeEqvStress(const RankTwoTensor & pk2_dev, const RankTwoTensor & ce) const
{
RankTwoTensor sdev = pk2_dev * ce;
Real val = sdev.doubleContraction(sdev.transpose());
return std::pow(3.0 * val/2.0, 0.5);
}
void
CappedDruckerPragerCosseratStressUpdate::setStressAfterReturn(const RankTwoTensor & stress_trial,
Real p_ok,
Real q_ok,
Real /*gaE*/,
const std::vector<Real> & /*intnl*/,
const yieldAndFlow & /*smoothed_q*/,
const RankFourTensor & /*Eijkl*/,
RankTwoTensor & stress) const
{
// symm_stress is the symmetric part of the stress tensor.
// symm_stress = (s_ij+s_ji)/2 + de_ij tr(stress) / 3
// = q / q_trial * (s_ij^trial+s_ji^trial)/2 + de_ij p / 3
// = q / q_trial * (symm_stress_ij^trial - de_ij tr(stress^trial) / 3) + de_ij p / 3
const Real p_trial = stress_trial.trace();
RankTwoTensor symm_stress = RankTwoTensor(RankTwoTensor::initIdentity) / 3.0 *
(p_ok - (_in_q_trial == 0.0 ? 0.0 : p_trial * q_ok / _in_q_trial));
if (_in_q_trial > 0)
symm_stress += q_ok / _in_q_trial * 0.5 * (stress_trial + stress_trial.transpose());
stress = symm_stress + 0.5 * (stress_trial - stress_trial.transpose());
}
Real
RankTwoTensor::thirdInvariant() const
{
RankTwoTensor s = 0.5 * deviatoric();
s += s.transpose();
Real result = 0.0;
result = s(0, 0) * (s(1, 1) * s(2, 2) - s(2, 1) * s(1, 2));
result -= s(1, 0) * (s(0, 1) * s(2, 2) - s(2, 1) * s(0, 2));
result += s(2, 0) * (s(0, 1) * s(1, 2) - s(1, 1) * s(0, 2));
return result;
}
Real
CylindricalRankTwoAux::computeValue()
{
Point loc_from_center = _q_point[_qp] - _center_point;
Real theta = std::atan2(loc_from_center(1), loc_from_center(0));
RankTwoTensor R;
R(0, 0) = std::cos(theta);
R(0, 1) = std::sin(theta);
R(1, 0) = -std::sin(theta);
R(1, 1) = std::cos(theta);
RankTwoTensor rotated_tensor = R * _tensor[_qp] * R.transpose();
return rotated_tensor(_i, _j);
}
RankTwoTensor
RankTwoTensor::dthirdInvariant() const
{
RankTwoTensor s = 0.5 * deviatoric();
s += s.transpose();
RankTwoTensor d;
Real sec_over_three = secondInvariant() / 3.0;
d(0, 0) = s(1, 1) * s(2, 2) - s(2, 1) * s(1, 2) + sec_over_three;
d(0, 1) = s(2, 0) * s(1, 2) - s(1, 0) * s(2, 2);
d(0, 2) = s(1, 0) * s(2, 1) - s(2, 0) * s(1, 1);
d(1, 0) = s(2, 1) * s(0, 2) - s(0, 1) * s(2, 2);
d(1, 1) = s(0, 0) * s(2, 2) - s(2, 0) * s(0, 2) + sec_over_three;
d(1, 2) = s(2, 0) * s(0, 1) - s(0, 0) * s(2, 1);
d(2, 0) = s(0, 1) * s(1, 2) - s(1, 1) * s(0, 2);
d(2, 1) = s(1, 0) * s(0, 2) - s(0, 0) * s(1, 2);
d(2, 2) = s(0, 0) * s(1, 1) - s(1, 0) * s(0, 1) + sec_over_three;
return d;
}
RankFourTensor
RankTwoTensor::d2thirdInvariant() const
{
RankTwoTensor s = 0.5 * deviatoric();
s += s.transpose();
RankFourTensor d2;
for (unsigned int i = 0; i < N; ++i)
for (unsigned int j = 0; j < N; ++j)
for (unsigned int k = 0; k < N; ++k)
for (unsigned int l = 0; l < N; ++l)
{
d2(i, j, k, l) = (i==j)*s(k, l)/3.0 + (k==l)*s(i, j)/3.0;
//for (unsigned int a = 0; a < N; ++a)
// for (unsigned int b = 0; b < N; ++b)
// d2(i, j, k, l) += 0.5*(PermutationTensor::eps(i, k, a)*PermutationTensor::eps(j, l, b) + PermutationTensor::eps(i, l, a)*PermutationTensor::eps(j, k, b))*s(a, b);
}
// I'm not sure which is more readable: the above
// PermutationTensor stuff, or the stuff below.
// Anyway, they yield the same result, and so i leave
// both of them here to enlighten you!
d2(0, 0, 1, 1) += s(2, 2);
d2(0, 0, 1, 2) -= s(2, 1);
d2(0, 0, 2, 1) -= s(1, 2);
d2(0, 0, 2, 2) += s(1, 1);
d2(0, 1, 0, 1) -= s(2, 2)/2.0;
d2(0, 1, 1, 0) -= s(2, 2)/2.0;
d2(0, 1, 0, 2) += s(1, 2)/2.0;
d2(0, 1, 2, 0) += s(1, 2)/2.0;
d2(0, 1, 1, 2) += s(2, 0)/2.0;
d2(0, 1, 2, 1) += s(2, 0)/2.0;
d2(0, 1, 2, 2) -= s(1, 0);
d2(0, 2, 0, 1) += s(2, 1)/2.0;
d2(0, 2, 1, 0) += s(2, 1)/2.0;
d2(0, 2, 0, 2) -= s(1, 1)/2.0;
d2(0, 2, 2, 0) -= s(1, 1)/2.0;
d2(0, 2, 1, 1) -= s(2, 0);
d2(0, 2, 1, 2) += s(1, 0)/2.0;
d2(0, 2, 2, 1) += s(1, 0)/2.0;
d2(1, 0, 0, 1) -= s(2, 2)/2.0;
d2(1, 0, 1, 0) -= s(2, 2)/2.0;
d2(1, 0, 0, 2) += s(1, 2)/2.0;
d2(1, 0, 2, 0) += s(1, 2)/2.0;
d2(1, 0, 1, 2) += s(2, 0)/2.0;
d2(1, 0, 2, 1) += s(2, 0)/2.0;
d2(1, 0, 2, 2) -= s(1, 0);
d2(1, 1, 0, 0) += s(2, 2);
d2(1, 1, 0, 2) -= s(2, 0);
d2(1, 1, 2, 0) -= s(2, 0);
d2(1, 1, 2, 2) += s(0, 0);
d2(1, 2, 0, 0) -= s(2, 1);
d2(1, 2, 0, 1) += s(2, 0)/2.0;
d2(1, 2, 1, 0) += s(2, 0)/2.0;
d2(1, 2, 0, 2) += s(0, 1)/2.0;
d2(1, 2, 2, 0) += s(0, 1)/2.0;
d2(1, 2, 1, 2) -= s(0, 0)/2.0;
d2(1, 2, 2, 1) -= s(0, 0)/2.0;
d2(2, 0, 0, 1) += s(2, 1)/2.0;
d2(2, 0, 1, 0) += s(2, 1)/2.0;
d2(2, 0, 0, 2) -= s(1, 1)/2.0;
d2(2, 0, 2, 0) -= s(1, 1)/2.0;
d2(2, 0, 1, 1) -= s(2, 0);
d2(2, 0, 1, 2) += s(1, 0)/2.0;
d2(2, 0, 2, 1) += s(1, 0)/2.0;
d2(2, 1, 0, 0) -= s(2, 1);
d2(2, 1, 0, 1) += s(2, 0)/2.0;
d2(2, 1, 1, 0) += s(2, 0)/2.0;
d2(2, 1, 0, 2) += s(0, 1)/2.0;
d2(2, 1, 2, 0) += s(0, 1)/2.0;
d2(2, 1, 1, 2) -= s(0, 0)/2.0;
d2(2, 1, 2, 1) -= s(0, 0)/2.0;
d2(2, 2, 0, 0) += s(1, 1);
d2(2, 2, 0, 1) -= s(1, 0);
d2(2, 2, 1, 0) -= s(1, 0);
d2(2, 2, 1, 1) += s(0, 0);
return d2;
}
void
FiniteStrainMaterial::computeQpStrain(const RankTwoTensor & Fhat)
{
//Cinv - I = A A^T - A - A^T;
RankTwoTensor A; //A = I - Fhatinv
A.addIa(1.0);
A -= Fhat.inverse();
RankTwoTensor Cinv_I = A*A.transpose() - A - A.transpose();
//strain rate D from Taylor expansion, Chat = (-1/2(Chat^-1 - I) + 1/4*(Chat^-1 - I)^2 + ...
_strain_increment[_qp] = -Cinv_I*0.5 + Cinv_I*Cinv_I*0.25;
/*RankTwoTensor Chat = Fhat.transpose()*Fhat;
RankTwoTensor A = Chat;
A.addIa(-1.0);
RankTwoTensor B = Chat*0.25;
B.addIa(-0.75);
_strain_increment[_qp] = -B*A;*/
RankTwoTensor D = _strain_increment[_qp]/_t_step;
_strain_rate[_qp] = D;
//Calculate rotation R_incr
RankTwoTensor invFhat(Fhat.inverse());
std::vector<Real> a(3);
a[0] = invFhat(1,2) - invFhat(2,1);
a[1] = invFhat(2,0) - invFhat(0,2);
a[2] = invFhat(0,1) - invFhat(1,0);
Real q = (a[0]*a[0] + a[1]*a[1] + a[2]*a[2])/4.0;
Real trFhatinv_1 = invFhat.trace() - 1.0;
Real p = trFhatinv_1*trFhatinv_1/4.0;
// Real y = 1.0/((q + p)*(q + p)*(q + p));
/*Real C1 = std::sqrt(p * (1 + (p*(q+q+(q+p))) * (1-(q+p)) * y));
Real C2 = 0.125 + q * 0.03125 * (p*p - 12*(p-1)) / (p*p);
Real C3 = 0.5 * std::sqrt( (p*q*(3-q) + p*p*p + q*q)*y );
*/
Real C1 = std::sqrt(p + 3.0*p*p*(1.0 - (p + q))/((p+q)*(p+q)) - 2.0*p*p*p*(1-(p+q))/((p+q)*(p+q)*(p+q))); //cos theta_a
Real C2 = 0.0;
if (q > 0.01)
C2 = (1.0 - C1)/(4.0*q); // (1-cos theta_a)/4q
else //alternate form for small q
C2 = 0.125 + q*0.03125*(p*p - 12*(p-1))/(p*p) + q*q*(p - 2.0)*(p*p - 10.0*p + 32.0)/(p*p*p) + q*q*q*(1104.0 - 992.0*p + 376.0*p*p - 72*p*p*p + 5.0*p*p*p*p)/(512.0*p*p*p*p);
Real C3 = 0.5*std::sqrt((p*q*(3.0 - q) + p*p*p + q*q)/((p + q)*(p + q)*(p + q))); //sin theta_a/(2 sqrt(q))
//Calculate incremental rotation. Note that this value is the transpose of that from Rashid, 93, so we transpose it before storing
RankTwoTensor R_incr;
R_incr.addIa(C1);
for (unsigned int i=0; i<3; ++i)
for (unsigned int j = 0; j < 3; ++j)
R_incr(i,j) += C2*a[i]*a[j];
R_incr(0,1) += C3*a[2];
R_incr(0,2) -= C3*a[1];
R_incr(1,0) -= C3*a[2];
R_incr(1,2) += C3*a[0];
R_incr(2,0) += C3*a[1];
R_incr(2,1) -= C3*a[0];
_rotation_increment[_qp] = R_incr.transpose();
}
void
CappedDruckerPragerCosseratStressUpdate::consistentTangentOperator(
const RankTwoTensor & /*stress_trial*/,
Real /*p_trial*/,
Real /*q_trial*/,
const RankTwoTensor & stress,
Real /*p*/,
Real q,
Real gaE,
const yieldAndFlow & smoothed_q,
const RankFourTensor & Eijkl,
bool compute_full_tangent_operator,
RankFourTensor & cto) const
{
if (!compute_full_tangent_operator)
{
cto = Eijkl;
return;
}
RankFourTensor EAijkl;
for (unsigned i = 0; i < _tensor_dimensionality; ++i)
for (unsigned j = 0; j < _tensor_dimensionality; ++j)
for (unsigned k = 0; k < _tensor_dimensionality; ++k)
for (unsigned l = 0; l < _tensor_dimensionality; ++l)
{
cto(i, j, k, l) = 0.5 * (Eijkl(i, j, k, l) + Eijkl(j, i, k, l));
EAijkl(i, j, k, l) = 0.5 * (Eijkl(i, j, k, l) - Eijkl(j, i, k, l));
}
const RankTwoTensor s_over_q =
(q == 0.0 ? RankTwoTensor()
: (0.5 * (stress + stress.transpose()) -
stress.trace() * RankTwoTensor(RankTwoTensor::initIdentity) / 3.0) /
q);
const RankTwoTensor E_s_over_q = Eijkl.innerProductTranspose(s_over_q); // not symmetric in kl
const RankTwoTensor Ekl =
RankTwoTensor(RankTwoTensor::initIdentity).initialContraction(Eijkl); // symmetric in kl
for (unsigned i = 0; i < _tensor_dimensionality; ++i)
for (unsigned j = 0; j < _tensor_dimensionality; ++j)
for (unsigned k = 0; k < _tensor_dimensionality; ++k)
for (unsigned l = 0; l < _tensor_dimensionality; ++l)
{
cto(i, j, k, l) -= (i == j) * (1.0 / 3.0) *
(Ekl(k, l) * (1.0 - _dp_dpt) + 0.5 * E_s_over_q(k, l) * (-_dp_dqt));
cto(i, j, k, l) -=
s_over_q(i, j) * (Ekl(k, l) * (-_dq_dpt) + 0.5 * E_s_over_q(k, l) * (1.0 - _dq_dqt));
}
if (smoothed_q.dg[1] != 0.0)
{
const RankFourTensor Tijab = _Ehost * (gaE / _Epp) * smoothed_q.dg[1] * d2qdstress2(stress);
RankFourTensor inv = RankFourTensor(RankFourTensor::initIdentitySymmetricFour) + Tijab;
try
{
inv = inv.transposeMajor().invSymm();
}
catch (const MooseException & e)
{
// Cannot form the inverse, so probably at some degenerate place in stress space.
// Just return with the "best estimate" of the cto.
mooseWarning("CappedDruckerPragerCosseratStressUpdate: Cannot invert 1+T in consistent "
"tangent operator computation at quadpoint ",
_qp,
" of element ",
_current_elem->id());
return;
}
cto = (cto.transposeMajor() * inv).transposeMajor();
}
cto += EAijkl;
}
bool
TensorMechanicsPlasticTensileMulti::doReturnMap(const RankTwoTensor & trial_stress, const Real & intnl_old, const RankFourTensor & E_ijkl,
Real /*ep_plastic_tolerance*/, RankTwoTensor & returned_stress, Real & returned_intnl,
std::vector<Real> & dpm, RankTwoTensor & delta_dp, std::vector<Real> & yf,
bool & trial_stress_inadmissible) const
{
mooseAssert(dpm.size() == 3, "TensorMechanicsPlasticTensileMulti size of dpm should be 3 but it is " << dpm.size());
std::vector<Real> eigvals;
RankTwoTensor eigvecs;
trial_stress.symmetricEigenvaluesEigenvectors(eigvals, eigvecs);
eigvals[0] += _shift;
eigvals[2] -= _shift;
Real str = tensile_strength(intnl_old);
yf.resize(3);
yf[0] = eigvals[0] - str;
yf[1] = eigvals[1] - str;
yf[2] = eigvals[2] - str;
if (yf[0] <= _f_tol && yf[1] <= _f_tol && yf[2] <= _f_tol)
{
// purely elastic (trial_stress, intnl_old)
trial_stress_inadmissible = false;
return true;
}
trial_stress_inadmissible = true;
delta_dp.zero();
returned_stress.zero();
// In the following i often assume that E_ijkl is
// for an isotropic situation. This reduces FLOPS
// substantially which is important since the returnMap
// is potentially the most compute-intensive function
// of a simulation.
// In many comments i write the general expression, and
// i hope that might guide future coders if they are
// generalising to a non-istropic E_ijkl
// n[alpha] = E_ijkl*r[alpha]_kl expressed in principal stress space
// (alpha = 0, 1, 2, corresponding to the three surfaces)
// Note that in principal stress space, the flow
// directions are, expressed in 'vector' form,
// r[0] = (1,0,0), r[1] = (0,1,0), r[2] = (0,0,1).
// Similar for _n:
// so _n[0] = E_ij00*r[0], _n[1] = E_ij11*r[1], _n[2] = E_ij22*r[2]
// In the following I assume that the E_ijkl is
// for an isotropic situation.
// In the anisotropic situation, we couldn't express
// the flow directions as vectors in the same principal
// stress space as the stress: they'd be full rank-2 tensors
std::vector<std::vector<Real> > n(3);
for (unsigned i = 0 ; i < 3 ; ++i)
n[i].resize(3);
n[0][0] = E_ijkl(0,0,0,0);
n[0][1] = E_ijkl(1,1,0,0);
n[0][2] = E_ijkl(2,2,0,0);
n[1][0] = E_ijkl(0,0,1,1);
n[1][1] = E_ijkl(1,1,1,1);
n[1][2] = E_ijkl(2,2,1,1);
n[2][0] = E_ijkl(0,0,2,2);
n[2][1] = E_ijkl(1,1,2,2);
n[2][2] = E_ijkl(2,2,2,2);
// With non-zero Poisson's ratio and hardening
// it is not computationally cheap to know whether
// the trial stress will return to the tip, edge,
// or plane. The following is correct for zero
// Poisson's ratio and no hardening, and at least
// gives a not-completely-stupid guess in the
// more general case.
// trial_order[0] = type of return to try first
// trial_order[1] = type of return to try second
// trial_order[2] = type of return to try third
std::vector<int> trial_order(3);
if (yf[0] > 0) // all the yield functions are positive, since eigvals are ordered eigvals[0] <= eigvals[1] <= eigvals[2]
{
trial_order[0] = tip;
trial_order[1] = edge;
trial_order[2] = plane;
}
else if (yf[1] > 0) // two yield functions are positive
{
trial_order[0] = edge;
trial_order[1] = tip;
trial_order[2] = plane;
}
else
{
trial_order[0] = plane;
trial_order[1] = edge;
trial_order[2] = tip;
}
unsigned trial;
bool nr_converged;
for (trial = 0 ; trial < 3 ; ++trial)
{
switch (trial_order[trial])
{
case tip:
nr_converged = returnTip(eigvals, n, dpm, returned_stress, intnl_old, 0);
break;
case edge:
nr_converged = returnEdge(eigvals, n, dpm, returned_stress, intnl_old, 0);
break;
case plane:
nr_converged = returnPlane(eigvals, n, dpm, returned_stress, intnl_old, 0);
break;
}
str = tensile_strength(intnl_old + dpm[0] + dpm[1] + dpm[2]);
if (nr_converged && KuhnTuckerOK(returned_stress, dpm, str))
break;
}
if (trial == 3)
{
Moose::err << "Trial stress = \n";
trial_stress.print(Moose::err);
Moose::err << "Internal parameter = " << intnl_old << "\n";
mooseError("TensorMechanicsPlasticTensileMulti: FAILURE! You probably need to implement a line search\n");
// failure - must place yield function values at trial stress into yf
str = tensile_strength(intnl_old);
yf[0] = eigvals[0] - str;
yf[1] = eigvals[1] - str;
yf[2] = eigvals[2] - str;
return false;
}
// success
returned_intnl = intnl_old;
for (unsigned i = 0 ; i < 3 ; ++i)
{
yf[i] = returned_stress(i, i) - str;
delta_dp(i, i) = dpm[i];
returned_intnl += dpm[i];
}
returned_stress = eigvecs*returned_stress*(eigvecs.transpose());
delta_dp = eigvecs*delta_dp*(eigvecs.transpose());
return true;
}
bool
TensorMechanicsPlasticMohrCoulombMulti::doReturnMap(const RankTwoTensor & trial_stress, Real intnl_old, const RankFourTensor & E_ijkl,
Real ep_plastic_tolerance, RankTwoTensor & returned_stress, Real & returned_intnl,
std::vector<Real> & dpm, RankTwoTensor & delta_dp, std::vector<Real> & yf,
bool & trial_stress_inadmissible) const
{
mooseAssert(dpm.size() == 6, "TensorMechanicsPlasticMohrCoulombMulti size of dpm should be 6 but it is " << dpm.size());
std::vector<Real> eigvals;
RankTwoTensor eigvecs;
trial_stress.symmetricEigenvaluesEigenvectors(eigvals, eigvecs);
eigvals[0] += _shift;
eigvals[2] -= _shift;
Real sinphi = std::sin(phi(intnl_old));
Real cosphi = std::cos(phi(intnl_old));
Real coh = cohesion(intnl_old);
Real cohcos = coh*cosphi;
yieldFunctionEigvals(eigvals[0], eigvals[1], eigvals[2], sinphi, cohcos, yf);
if (yf[0] <= _f_tol && yf[1] <= _f_tol && yf[2] <= _f_tol && yf[3] <= _f_tol && yf[4] <= _f_tol && yf[5] <= _f_tol)
{
// purely elastic (trial_stress, intnl_old)
trial_stress_inadmissible = false;
return true;
}
trial_stress_inadmissible = true;
delta_dp.zero();
returned_stress = RankTwoTensor();
// these are the normals to the 6 yield surfaces, which are const because of the assumption of no psi hardening
std::vector<RealVectorValue> norm(6);
const Real sinpsi = std::sin(psi(intnl_old));
const Real oneminus = 0.5*(1 - sinpsi);
const Real oneplus = 0.5*(1 + sinpsi);
norm[0](0) = oneplus; norm[0](1) = -oneminus; norm[0](2) = 0;
norm[1](0) = -oneminus; norm[1](1) = oneplus; norm[1](2) = 0;
norm[2](0) = oneplus; norm[2](1) = 0; norm[2](2) = -oneminus;
norm[3](0) = -oneminus; norm[3](1) = 0; norm[3](2) = oneplus;
norm[4](0) = 0; norm[4](1) = oneplus; norm[4](2) = -oneminus;
norm[5](0) = 0; norm[5](1) = -oneminus; norm[5](2) = oneplus;
// the flow directions are these norm multiplied by Eijkl.
// I call the flow directions "n".
// In the following I assume that the Eijkl is
// for an isotropic situation. Then I don't have to
// rotate to the principal-stress frame, and i don't
// have to worry about strange off-diagonal things
std::vector<RealVectorValue> n(6);
for (unsigned ys = 0; ys < 6; ++ys)
for (unsigned i = 0; i < 3; ++i)
for (unsigned j = 0; j < 3; ++j)
n[ys](i) += E_ijkl(i,i,j,j)*norm[ys](j);
const Real mag_E = E_ijkl(0, 0, 0, 0);
// With non-zero Poisson's ratio and hardening
// it is not computationally cheap to know whether
// the trial stress will return to the tip, edge,
// or plane. The following at least
// gives a not-completely-stupid guess
// trial_order[0] = type of return to try first
// trial_order[1] = type of return to try second
// trial_order[2] = type of return to try third
// trial_order[3] = type of return to try fourth
// trial_order[4] = type of return to try fifth
// In the following the "binary" stuff indicates the
// deactive (0) and active (1) surfaces, eg
// 110100 means that surfaces 0, 1 and 3 are active
// and 2, 4 and 5 are deactive
const unsigned int number_of_return_paths = 5;
std::vector<int> trial_order(number_of_return_paths);
if (yf[1] > _f_tol && yf[3] > _f_tol && yf[5] > _f_tol)
{
trial_order[0] = tip110100;
trial_order[1] = edge010100;
trial_order[2] = plane000100;
trial_order[3] = edge000101;
trial_order[4] = tip010101;
}
else if (yf[1] <= _f_tol && yf[3] > _f_tol && yf[5] > _f_tol)
{
trial_order[0] = edge000101;
trial_order[1] = plane000100;
trial_order[2] = tip110100;
trial_order[3] = tip010101;
trial_order[4] = edge010100;
}
else if (yf[1] <= _f_tol && yf[3] > _f_tol && yf[5] <= _f_tol)
{
trial_order[0] = plane000100;
trial_order[1] = edge000101;
trial_order[2] = edge010100;
trial_order[3] = tip110100;
trial_order[4] = tip010101;
}
else
{
trial_order[0] = edge010100;
trial_order[1] = plane000100;
trial_order[2] = edge000101;
trial_order[3] = tip110100;
trial_order[4] = tip010101;
}
unsigned trial;
bool nr_converged = false;
bool kt_success = false;
std::vector<RealVectorValue> ntip(3);
std::vector<Real> dpmtip(3);
for (trial = 0; trial < number_of_return_paths; ++trial)
{
switch (trial_order[trial])
{
case tip110100:
for (unsigned int i = 0; i < 3; ++i)
{
ntip[0](i) = n[0](i);
ntip[1](i) = n[1](i);
ntip[2](i) = n[3](i);
}
kt_success = returnTip(eigvals, ntip, dpmtip, returned_stress, intnl_old, sinphi, cohcos, 0, nr_converged, ep_plastic_tolerance, yf);
if (nr_converged && kt_success)
{
dpm[0] = dpmtip[0];
dpm[1] = dpmtip[1];
dpm[3] = dpmtip[2];
dpm[2] = dpm[4] = dpm[5] = 0;
}
break;
case tip010101:
for (unsigned int i = 0; i < 3; ++i)
{
ntip[0](i) = n[1](i);
ntip[1](i) = n[3](i);
ntip[2](i) = n[5](i);
}
kt_success = returnTip(eigvals, ntip, dpmtip, returned_stress, intnl_old, sinphi, cohcos, 0, nr_converged, ep_plastic_tolerance, yf);
if (nr_converged && kt_success)
{
dpm[1] = dpmtip[0];
dpm[3] = dpmtip[1];
dpm[5] = dpmtip[2];
dpm[0] = dpm[2] = dpm[4] = 0;
}
break;
case edge000101:
kt_success = returnEdge000101(eigvals, n, dpm, returned_stress, intnl_old, sinphi, cohcos, 0, mag_E, nr_converged, ep_plastic_tolerance, yf);
break;
case edge010100:
kt_success = returnEdge010100(eigvals, n, dpm, returned_stress, intnl_old, sinphi, cohcos, 0, mag_E, nr_converged, ep_plastic_tolerance, yf);
break;
case plane000100:
kt_success = returnPlane(eigvals, n, dpm, returned_stress, intnl_old, sinphi, cohcos, 0, nr_converged, ep_plastic_tolerance, yf);
break;
}
if (nr_converged && kt_success)
break;
}
if (trial == number_of_return_paths)
{
sinphi = std::sin(phi(intnl_old));
cosphi = std::cos(phi(intnl_old));
coh = cohesion(intnl_old);
cohcos = coh*cosphi;
yieldFunctionEigvals(eigvals[0], eigvals[1], eigvals[2], sinphi, cohcos, yf);
Moose::err << "Trial stress = \n";
trial_stress.print(Moose::err);
Moose::err << "which has eigenvalues = " << eigvals[0] << " " << eigvals[1] << " " << eigvals[2] << "\n";
Moose::err << "and yield functions = " << yf[0] << " " << yf[1] << " " << yf[2] << " " << yf[3] << " " << yf[4] << " " << yf[5] << "\n";
Moose::err << "Internal parameter = " << intnl_old << "\n";
mooseError("TensorMechanicsPlasticMohrCoulombMulti: FAILURE! You probably need to implement a line search if your hardening is too severe, or you need to tune your tolerances (eg, yield_function_tolerance should be a little smaller than (young modulus)*ep_plastic_tolerance).\n");
return false;
}
// success
returned_intnl = intnl_old;
for (unsigned i = 0; i < 6; ++i)
returned_intnl += dpm[i];
for (unsigned i = 0; i < 6; ++i)
for (unsigned j = 0; j < 3; ++j)
delta_dp(j, j) += dpm[i]*norm[i](j);
returned_stress = eigvecs*returned_stress*(eigvecs.transpose());
delta_dp = eigvecs*delta_dp*(eigvecs.transpose());
return true;
}
void
TensorMechanicsPlasticTensileMulti::activeConstraints(const std::vector<Real> & f, const RankTwoTensor & stress, const Real & intnl, const RankFourTensor & Eijkl, std::vector<bool> & act, RankTwoTensor & returned_stress) const
{
act.assign(3, false);
if (f[0] <= _f_tol && f[1] <= _f_tol && f[2] <= _f_tol)
{
returned_stress = stress;
return;
}
returned_stress = RankTwoTensor();
std::vector<Real> eigvals;
RankTwoTensor eigvecs;
stress.symmetricEigenvaluesEigenvectors(eigvals, eigvecs);
eigvals[0] += _shift;
eigvals[2] -= _shift;
Real str = tensile_strength(intnl);
std::vector<Real> v(3);
v[0] = eigvals[0] - str;
v[1] = eigvals[1] - str;
v[2] = eigvals[2] - str;
// these are the normals to the 3 yield surfaces
std::vector<std::vector<Real> > n(3);
n[0].resize(3);
n[0][0] = 1 ; n[0][1] = 0 ; n[0][2] = 0;
n[1].resize(3);
n[1][0] = 0 ; n[1][1] = 1 ; n[1][2] = 0;
n[2].resize(3);
n[2][0] = 0 ; n[2][1] = 0 ; n[2][2] = 1;
// the flow directions are these n multiplied by Eijkl.
// I re-use the name "n" for the flow directions
// In the following I assume that the Eijkl is
// for an isotropic situation. This is the most
// common when using TensileMulti, and remember
// that the returned_stress need not be perfect
// anyway.
// I divide by E(0,0,0,0) so the n remain of order 1
Real ratio = Eijkl(1,1,0,0)/Eijkl(0,0,0,0);
n[0][1] = n[0][2] = ratio;
n[1][0] = n[1][2] = ratio;
n[2][0] = n[2][1] = ratio;
// 111 (tip)
// For tip-return to satisfy Kuhn-Tucker, we need
// v = alpha*n[0] + beta*n[1] * gamma*n[2]
// with alpha, beta, and gamma all being non-negative (they are
// the plasticity multipliers)
Real denom = triple(n[0], n[1], n[2]);
if (triple(v, n[0], n[1])/denom >= 0 && triple(v, n[1], n[2])/denom >= 0 && triple(v, n[2], n[0])/denom >= 0)
{
act[0] = act[1] = act[2] = true;
returned_stress(0, 0) = returned_stress(1, 1) = returned_stress(2, 2) = str;
returned_stress = eigvecs*returned_stress*(eigvecs.transpose());
return;
}
// 011 (edge)
std::vector<Real> n1xn2(3);
n1xn2[0] = n[1][1]*n[2][2] - n[1][2]*n[2][1];
n1xn2[1] = n[1][2]*n[2][0] - n[1][0]*n[2][2];
n1xn2[2] = n[1][0]*n[2][1] - n[1][1]*n[2][0];
// work out the point to which we would return, "a". It is defined by
// f1 = 0 = f2, and that (p - a).(n1 x n2) = 0, where "p" is the
// starting position (p = eigvals).
// In the following a = (a0, str, str)
Real pdotn1xn2 = dot(eigvals, n1xn2);
Real a0 = (-str*n1xn2[1] - str*n1xn2[2] + pdotn1xn2)/n1xn2[0];
// we need p - a = alpha*n1 + beta*n2, where alpha and beta are non-negative
// for Kuhn-Tucker to be satisfied
std::vector<Real> pminusa(3);
pminusa[0] = eigvals[0] - a0;
pminusa[1] = v[1];
pminusa[2] = v[2];
if ((pminusa[2] - pminusa[0])/(1.0 - ratio) >= 0 && (pminusa[1] - pminusa[0])/(1.0 - ratio) >= 0)
{
returned_stress(0, 0) = a0;
returned_stress(1, 1) = str;
returned_stress(2, 2) = str;
returned_stress = eigvecs*returned_stress*(eigvecs.transpose());
act[1] = act[2] = true;
return;
}
// 001 (plane)
// the returned point, "a", is defined by f2=0 and
// a = p - alpha*n2
Real alpha = (eigvals[2] - str)/n[2][2];
act[2] = true;
returned_stress(0, 0) = eigvals[0] - alpha*n[2][0];
returned_stress(1, 1) = eigvals[1] - alpha*n[2][1];
returned_stress(2, 2) = str;
returned_stress = eigvecs*returned_stress*(eigvecs.transpose());
return;
}
