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
ComputeRSphericalFiniteStrain::computeProperties()
{
// Method from Rashid, 1993
RankTwoTensor ave_Fhat;
Real ave_dfgrd_det = 0.0;
for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
{
// Deformation gradient calculation in cylindrical 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 cylindrical coords
A -= Fbar;
// Fbar = ( I + gradUold)
Fbar.addIa(1.0);
// Incremental deformation gradient _Fhat = I + A Fbar^-1
_Fhat[_qp] = A * Fbar.inverse();
_Fhat[_qp].addIa(1.0);
computeQpStrain();
}
}
bool
FlowRateModel::computeDflowrateDstress(RankTwoTensor & dflowrate_dstress,
const RankTwoTensor & pk2,
const RankTwoTensor & ce,
const std::vector<Real> & internal_var,
const unsigned int start_index,
const unsigned int /*size*/) const
{
RankTwoTensor pk2_dev = computePK2Deviatoric(pk2, ce);
Real eqv_stress = computeEqvStress(pk2_dev, ce);
Real sigy = _flow_stress_uo.value(internal_var[start_index]);
Real dflowrate_dseqv = _ref_flow_rate * _flow_rate_exponent * std::pow(eqv_stress/sigy,_flow_rate_exponent-1) * 1/sigy;
if (dflowrate_dseqv > _flow_rate_tol)
{
#ifdef DEBUG
mooseWarning("dflowrate_dseqv greater than " << _flow_rate_tol << " " << dflowrate_dseqv << " " << eqv_stress << " " << sigy );
#endif
return false;
}
RankTwoTensor tau = pk2_dev * ce;
RankTwoTensor dseqv_dpk2dev;
dseqv_dpk2dev.zero();
if (eqv_stress > 0)
dseqv_dpk2dev = 3/(2 * eqv_stress) * tau * ce;
RankTwoTensor ce_inv = ce.inverse();
RankFourTensor dpk2dev_dpk2;
for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
for (unsigned int k = 0; k < LIBMESH_DIM; ++k)
for (unsigned int l = 0; l < LIBMESH_DIM; ++l)
{
dpk2dev_dpk2(i, j, k, l) = 0.0;
if (i==k && j==l)
dpk2dev_dpk2(i, j, k, l) = 1.0;
dpk2dev_dpk2(i, j, k, l) -= ce_inv(i, j) * ce(k, l)/3.0;
}
dflowrate_dstress = dflowrate_dseqv * dpk2dev_dpk2.transposeMajor() * dseqv_dpk2dev;
return true;
}
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();
}
RankTwoTensor
HEVPFlowRatePowerLawJ2::computePK2Deviatoric(const RankTwoTensor & pk2,
const RankTwoTensor & ce) const
{
return pk2 - (pk2.doubleContraction(ce) * ce.inverse()) / 3.0;
}
void
ComputeFiniteStrain::computeQpIncrements(RankTwoTensor & total_strain_increment, RankTwoTensor & rotation_increment)
{
switch (_decomposition_method)
{
case DecompMethod::TaylorExpansion:
{
// inverse of _Fhat
RankTwoTensor invFhat(_Fhat[_qp].inverse());
// A = I - _Fhat^-1
RankTwoTensor A(RankTwoTensor::initIdentity);
A -= invFhat;
// Cinv - I = A A^T - A - A^T;
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 + ...
total_strain_increment = -Cinv_I * 0.5 + Cinv_I * Cinv_I * 0.25;
const Real a[3] = {
invFhat(1, 2) - invFhat(2, 1),
invFhat(2, 0) - invFhat(0, 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;
const Real p = trFhatinv_1 * trFhatinv_1 / 4.0;
// cos theta_a
const Real C1 = std::sqrt(p + 3.0 * std::pow(p, 2.0) * (1.0 - (p + q)) / std::pow(p + q, 2.0) - 2.0 * std::pow(p, 3.0) * (1.0 - (p + q)) / std::pow(p + q, 3.0));
Real C2;
if (q > 0.01)
// (1-cos theta_a)/4q
C2 = (1.0 - C1) / (4.0 * q);
else
//alternate form for small q
C2 = 0.125 + q * 0.03125 * (std::pow(p, 2.0) - 12.0 * (p - 1.0)) / std::pow(p, 2.0)
+ std::pow(q, 2.0) * (p - 2.0) * (std::pow(p, 2.0) - 10.0 * p + 32.0) / std::pow(p, 3.0)
+ std::pow(q, 3.0) * (1104.0 - 992.0 * p + 376.0 * std::pow(p, 2.0) - 72.0 * std::pow(p, 3.0) + 5.0 * std::pow(p, 4.0)) / (512.0 * std::pow(p, 4.0));
const Real C3 = 0.5 * std::sqrt((p * q * (3.0 - q) + std::pow(p, 3.0) + std::pow(q, 2.0)) / std::pow(p + q, 3.0)); //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 = R_incr.transpose();
break;
}
case DecompMethod::EigenSolution:
{
std::vector<Real> e_value(3);
RankTwoTensor e_vector, N1, N2, N3;
RankTwoTensor Chat = _Fhat[_qp].transpose() * _Fhat[_qp];
Chat.symmetricEigenvaluesEigenvectors(e_value, e_vector);
const Real lambda1 = std::sqrt(e_value[0]);
const Real lambda2 = std::sqrt(e_value[1]);
const Real lambda3 = std::sqrt(e_value[2]);
N1.vectorOuterProduct(e_vector.column(0), e_vector.column(0));
N2.vectorOuterProduct(e_vector.column(1), e_vector.column(1));
N3.vectorOuterProduct(e_vector.column(2), e_vector.column(2));
RankTwoTensor Uhat = N1 * lambda1 + N2 * lambda2 + N3 * lambda3;
RankTwoTensor invUhat(Uhat.inverse());
rotation_increment = _Fhat[_qp] * invUhat;
total_strain_increment = N1 * std::log(lambda1) + N2 * std::log(lambda2) + N3 * std::log(lambda3);
break;
}
default:
mooseError("ComputeFiniteStrain Error: Pass valid decomposition type: TaylorExpansion or EigenSolution.");
}
}
RankTwoTensor
testnewExampleMaterial::computePK2Deviatoric(const RankTwoTensor & pk2, const RankTwoTensor & ce) const
{
return pk2 - (pk2.doubleContraction(ce) * ce.inverse())/3.0;
}
RankTwoTensor
testnewExampleMaterial::computeLp(const RankTwoTensor & fp_dot, const RankTwoTensor & fp) const
{
return fp_dot*fp.inverse();
}