RankFourTensor
TensorMechanicsPlasticTensileMulti::consistentTangentOperator(const RankTwoTensor & trial_stress, const RankTwoTensor & stress, const Real & intnl,
const RankFourTensor & E_ijkl, const std::vector<Real> & cumulative_pm) const
{
if (!_use_custom_cto)
return TensorMechanicsPlasticModel::consistentTangentOperator(trial_stress, stress, intnl, E_ijkl, cumulative_pm);
mooseAssert(cumulative_pm.size() == 3, "TensorMechanicsPlasticTensileMulti size of cumulative_pm should be 3 but it is " << cumulative_pm.size());
if (cumulative_pm[2] <= 0) // All cumulative_pm are non-positive, so this is admissible
return E_ijkl;
// Need the eigenvalues at the returned configuration
std::vector<Real> eigvals;
stress.symmetricEigenvalues(eigvals);
// need to rotate to and from principal stress space
// using the eigenvectors of the trial configuration
// (not the returned configuration).
std::vector<Real> trial_eigvals;
RankTwoTensor trial_eigvecs;
trial_stress.symmetricEigenvaluesEigenvectors(trial_eigvals, trial_eigvecs);
// The returnMap will have returned to the Tip, Edge or
// Plane. The consistentTangentOperator describes the
// change in stress for an arbitrary change in applied
// strain. I assume that the change in strain will not
// change the type of return (Tip remains Tip, Edge remains
// Edge, Plane remains Plane).
// I assume isotropic elasticity.
//
// The consistent tangent operator is a little different
// than cases where no rotation to principal stress space
// is made during the returnMap. Let S_ij be the stress
// in original coordinates, and s_ij be the stress in the
// principal stress coordinates, so that
// s_ij = diag(eigvals[0], eigvals[1], eigvals[2])
// We want dS_ij under an arbitrary change in strain (ep->ep+dep)
// dS = S(ep+dep) - S(ep)
// = R(ep+dep) s(ep+dep) R(ep+dep)^T - R(ep) s(ep) R(ep)^T
// Here R = the rotation to principal-stress space, ie
// R_ij = eigvecs[i][j] = i^th component of j^th eigenvector
// Expanding to first order in dep,
// dS = R(ep) (s(ep+dep) - s(ep)) R(ep)^T
// + dR/dep s(ep) R^T + R(ep) s(ep) dR^T/dep
// The first line is all that is usually calculated in the
// consistent tangent operator calculation, and is called
// cto below.
// The second line involves changes in the eigenvectors, and
// is called sec below.
RankFourTensor cto;
Real hard = dtensile_strength(intnl);
Real la = E_ijkl(0,0,1,1);
Real mu = 0.5*(E_ijkl(0,0,0,0) - la);
if (cumulative_pm[1] <= 0)
{
// only cumulative_pm[2] is positive, so this is return to the Plane
Real denom = hard + la + 2*mu;
Real al = la*la/denom;
Real be = la*(la + 2*mu)/denom;
Real ga = hard*(la + 2*mu)/denom;
std::vector<Real> comps(9);
comps[0] = comps[4] = la + 2*mu - al;
comps[1] = comps[3] = la - al;
comps[2] = comps[5] = comps[6] = comps[7] = la - be;
comps[8] = ga;
cto.fillFromInputVector(comps, RankFourTensor::principal);
}
else if (cumulative_pm[0] <= 0)
{
// both cumulative_pm[2] and cumulative_pm[1] are positive, so Edge
Real denom = 2*hard + 2*la + 2*mu;
Real al = hard*2*la/denom;
Real be = hard*(2*la + 2*mu)/denom;
std::vector<Real> comps(9);
comps[0] = la + 2*mu - 2*la*la/denom;
comps[1] = comps[2] = al;
comps[3] = comps[6] = al;
comps[4] = comps[5] = comps[7] = comps[8] = be;
cto.fillFromInputVector(comps, RankFourTensor::principal);
}
else
{
// all cumulative_pm are positive, so Tip
Real denom = 3*hard + 3*la + 2*mu;
std::vector<Real> comps(2);
comps[0] = hard*(3*la + 2*mu)/denom;
comps[1] = 0;
cto.fillFromInputVector(comps, RankFourTensor::symmetric_isotropic);
}
cto.rotate(trial_eigvecs);
// drdsig = change in eigenvectors under a small stress change
// drdsig(i,j,m,n) = dR(i,j)/dS_mn
// The formula below is fairly easily derived:
// S R = R s, so taking the variation
// dS R + S dR = dR s + R ds, and multiplying by R^T
// R^T dS R + R^T S dR = R^T dR s + ds .... (eqn 1)
// I demand that RR^T = 1 = R^T R, and also that
// (R+dR)(R+dR)^T = 1 = (R+dT)^T (R+dR), which means
// that dR = R*c, for some antisymmetric c, so Eqn1 reads
// R^T dS R + s c = c s + ds
// Grabbing the components of this gives ds/dS (already
// in RankTwoTensor), and c, which is:
// dR_ik/dS_mn = drdsig(i, k, m, n) = trial_eigvecs(m, b)*trial_eigvecs(n, k)*trial_eigvecs(i, b)/(trial_eigvals[k] - trial_eigvals[b]);
// (sum over b!=k).
RankFourTensor drdsig;
for (unsigned k = 0 ; k < 3 ; ++k)
for (unsigned b = 0 ; b < 3 ; ++b)
{
if (b == k)
continue;
for (unsigned m = 0 ; m < 3 ; ++m)
for (unsigned n = 0 ; n < 3 ; ++n)
for (unsigned i = 0 ; i < 3 ; ++i)
drdsig(i, k, m, n) += trial_eigvecs(m, b)*trial_eigvecs(n, k)*trial_eigvecs(i, b)/(trial_eigvals[k] - trial_eigvals[b]);
}
// With diagla = diag(eigvals[0], eigvals[1], digvals[2])
// The following implements
// ans(i, j, a, b) += (drdsig(i, k, m, n)*trial_eigvecs(j, l)*diagla(k, l) + trial_eigvecs(i, k)*drdsig(j, l, m, n)*diagla(k, l))*E_ijkl(m, n, a, b);
// (sum over k, l, m and n)
RankFourTensor ans;
for (unsigned i = 0 ; i < 3 ; ++i)
for (unsigned j = 0 ; j < 3 ; ++j)
for (unsigned a = 0 ; a < 3 ; ++a)
for (unsigned k = 0 ; k < 3 ; ++k)
for (unsigned m = 0 ; m < 3 ; ++m)
ans(i, j, a, a) += (drdsig(i, k, m, m)*trial_eigvecs(j, k) + trial_eigvecs(i, k)*drdsig(j, k, m, m))*eigvals[k]*la; //E_ijkl(m, n, a, b) = la*(m==n)*(a==b);
for (unsigned i = 0 ; i < 3 ; ++i)
for (unsigned j = 0 ; j < 3 ; ++j)
for (unsigned a = 0 ; a < 3 ; ++a)
for (unsigned b = 0 ; b < 3 ; ++b)
for (unsigned k = 0 ; k < 3 ; ++k)
{
ans(i, j, a, b) += (drdsig(i, k, a, b)*trial_eigvecs(j, k) + trial_eigvecs(i, k)*drdsig(j, k, a, b))*eigvals[k]*mu; //E_ijkl(m, n, a, b) = mu*(m==a)*(n==b)
ans(i, j, a, b) += (drdsig(i, k, b, a)*trial_eigvecs(j, k) + trial_eigvecs(i, k)*drdsig(j, k, b, a))*eigvals[k]*mu; //E_ijkl(m, n, a, b) = mu*(m==b)*(n==a)
}
return cto + ans;
}
