void
FiniteStrainHyperElasticViscoPlastic::computeElasticStrain()
{
RankTwoTensor iden;
iden.addIa(1.0);
_ee = 0.5 * (_ce[_qp]-iden);
}
/**
* Get unitary flow tensor in deviatoric direction, modified Cam-Clay
*/
void
RedbackMechMaterialCC::getFlowTensor(const RankTwoTensor & sig, Real q, Real p, Real pc, RankTwoTensor & flow_tensor)
{
if (pc > 0)
pc *= -1;
flow_tensor = 3.0 * sig.deviatoric() / (_slope_yield_surface * _slope_yield_surface);
flow_tensor.addIa((2.0 * p - pc) / 3.0); //(p > 0 ? 1:-1)
// TODO: do we need to normalise? If so, do we need the sqrt(3/2) factor?
// flow_tensor /= std::pow(2.0/3.0,0.5)*flow_tensor.L2norm();
}
void
FiniteStrainHyperElasticViscoPlastic::computeElasticPlasticDeformGrad()
{
RankTwoTensor iden;
iden.addIa(1.0);
RankTwoTensor val;
for (unsigned int i = 0; i < _num_flow_rate_uos; ++i)
val += _flow_rate(i) * _flow_dirn[i] * _dt_substep;
_fp_tmp_inv = _fp_tmp_old_inv * (iden - val);
_fp_tmp_inv = std::pow(_fp_tmp_inv.det(), -1.0/3.0) * _fp_tmp_inv;
_fe = _dfgrd_tmp * _fp_tmp_inv;
}
/**
* Get flow tensor in deviatoric direction, modified Cam-Clay
*/
void
RedbackMechMaterialCC::getFlowTensor(const RankTwoTensor & sig,
Real /*q*/,
Real p,
Real /*q_y*/,
Real /*p_y*/,
Real yield_stress,
RankTwoTensor & flow_tensor)
{
Real pc = -yield_stress;
flow_tensor = 3.0 * sig.deviatoric() / (_slope_yield_surface * _slope_yield_surface);
flow_tensor.addIa((2.0 * p - pc - 2*_shift_ellipse) / 3.0);
}
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();
}
}
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();
}
bool
TensorMechanicsPlasticJ2::returnMap(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
{
if (!(_use_custom_returnMap))
return TensorMechanicsPlasticModel::returnMap(trial_stress,
intnl_old,
E_ijkl,
ep_plastic_tolerance,
returned_stress,
returned_intnl,
dpm,
delta_dp,
yf,
trial_stress_inadmissible);
yf.resize(1);
Real yf_orig = yieldFunction(trial_stress, intnl_old);
yf[0] = yf_orig;
if (yf_orig < _f_tol)
{
// the trial_stress is admissible
trial_stress_inadmissible = false;
return true;
}
trial_stress_inadmissible = true;
Real mu = E_ijkl(0, 1, 0, 1);
// Perform a Newton-Raphson to find dpm when
// residual = 3*mu*dpm - trial_equivalent_stress + yieldStrength(intnl_old + dpm) = 0
Real trial_equivalent_stress = yf_orig + yieldStrength(intnl_old);
Real residual;
Real jac;
dpm[0] = 0;
unsigned int iter = 0;
do
{
residual = 3.0 * mu * dpm[0] - trial_equivalent_stress + yieldStrength(intnl_old + dpm[0]);
jac = 3.0 * mu + dyieldStrength(intnl_old + dpm[0]);
dpm[0] += -residual / jac;
if (iter > _max_iters) // not converging
return false;
iter++;
} while (residual * residual > _f_tol * _f_tol);
// set the returned values
yf[0] = 0;
returned_intnl = intnl_old + dpm[0];
RankTwoTensor nn = 1.5 * trial_stress.deviatoric() /
trial_equivalent_stress; // = dyieldFunction_dstress(trial_stress, intnl_old) =
// the normal to the yield surface, at the trial
// stress
returned_stress = 2.0 / 3.0 * nn * yieldStrength(returned_intnl);
returned_stress.addIa(1.0 / 3.0 * trial_stress.trace());
delta_dp = nn * dpm[0];
return true;
}
