LagrangianObjectiveRates Namespace Reference

Objective-stress-rate updates as stateless free functions. More...

Classes
struct	Inputs
	Per-qp quantities a rate reads. More...
struct	Outputs
	Per-qp outputs a rate produces. More...

Functions
Outputs	truesdell (const Inputs &in, bool need_jacobian)
	sigma_{n+1} = J(dL)^{-1} (sigma_n + Deltasigma). Truesdell rate. More...
Outputs	jaumann (const Inputs &in, bool need_jacobian)
	sigma_{n+1} = J(dW)^{-1} (sigma_n + Deltasigma). Jaumann rate. More...
Outputs	greenNaghdi (const Inputs &in, bool need_jacobian)
	sigma_{n+1} = J(dO)^{-1} (sigma_n + Deltasigma), with dO built from the polar rotation increment. More...
Outputs	rashid (const Inputs &in, bool need_jacobian)
	sigma_{n+1} = r_hat (sigma_n + Deltasigma) r_hat^T, r_hat = exp(Deltaw). More...
Outputs	compute (const MooseEnum &rate, const Inputs &in, bool need_jacobian)
	Dispatch to the rate selected by the objective_rate enum (truesdell / jaumann / green_naghdi / rashid). More...

Detailed Description

Objective-stress-rate updates as stateless free functions.

Each rate integrates the constitutive small-stress increment into the cumulative Cauchy stress using its objective-rate advection and, when requested, returns the consistent tangent d(sigma_cauchy)/d(dL) plus the eigenstrain sensitivity. The rates are pure functions of an explicit Inputs bundle – no coupling to the material that gathers them – so they can be unit tested in isolation and dispatched by a switch (composition, not a class hierarchy).

Function Documentation

compute()

Outputs LagrangianObjectiveRates::compute	(	const MooseEnum &	rate,
		const Inputs &	in,
		bool	need_jacobian
	)

Dispatch to the rate selected by the objective_rate enum (truesdell / jaumann / green_naghdi / rashid).

Errors on an unknown value.

Definition at line 290 of file LagrangianObjectiveRate.C.

Referenced by calculate(), ComputeLagrangianObjectiveStress::computeQpCauchyStress(), KKSPhaseConcentrationMultiPhaseMaterial::computeQpProperties(), KKSPhaseConcentrationMaterial::computeQpProperties(), and TEST().

{
  const std::string s = rate;
  if (s == "truesdell")
    return truesdell(in, need_jacobian);
  if (s == "jaumann")
    return jaumann(in, need_jacobian);
  if (s == "green_naghdi")
    return greenNaghdi(in, need_jacobian);
  if (s == "rashid")
    return rashid(in, need_jacobian);
  mooseError("Unknown objective_rate value: ", s);
}

greenNaghdi()

Outputs LagrangianObjectiveRates::greenNaghdi	(	const Inputs &	in,
		bool	need_jacobian
	)

sigma_{n+1} = J(dO)^{-1} (sigma_n + Deltasigma), with dO built from the polar rotation increment.

Definition at line 197 of file LagrangianObjectiveRate.C.

Referenced by compute(), and TEST().

{
  usingTensorIndices(i, j, k, l, m);

  const RankTwoTensor I = RankTwoTensor::Identity();
  const RankTwoTensor dR = in.rotation * in.rotation_old.transpose() - I;
  const RankTwoTensor dO = dR * in.inv_df;

  Outputs out;
  if (!need_jacobian)
  {
    out.cauchy_stress = advectStressSolve(in.cauchy_stress_old + in.dS, dO);
    return out;
  }

  auto [S, Jinv] = advectStress(in.cauchy_stress_old + in.dS, dO);
  out.cauchy_stress = S;
  out.dcauchy_stress_d_eigenstrain = -Jinv * in.small_jacobian;

  const RankFourTensor & d_R_d_F = in.d_rotation_d_F;
  const RankFourTensor d_F_d_dL = in.d_dL_d_F.inverse();
  const RankTwoTensor T = in.rotation_old.transpose() * in.inv_df;

  const RankFourTensor d_invdf_d_F = -in.inv_df.times<i, k, l, j>(in.inv_def_grad);
  const RankFourTensor d_invdf_d_dL = d_invdf_d_F * d_F_d_dL;
  const RankFourTensor d_dO_d_invdf = dR.times<i, k, j, l>(I);

  const RankFourTensor d_dO_d_dL =
      T.times<m, j, i, m, k, l>(d_R_d_F * d_F_d_dL) + d_dO_d_invdf * d_invdf_d_dL;
  const RankFourTensor U = stressAdvectionDerivative(S) * d_dO_d_dL;
  out.cauchy_jacobian = cauchyJacobian(Jinv, in.small_jacobian, U);
  return out;
}

jaumann()

Outputs LagrangianObjectiveRates::jaumann	(	const Inputs &	in,
		bool	need_jacobian
	)

sigma_{n+1} = J(dW)^{-1} (sigma_n + Deltasigma). Jaumann rate.

Definition at line 174 of file LagrangianObjectiveRate.C.

Referenced by compute(), and TEST().

{
  Outputs out;
  if (!need_jacobian)
  {
    out.cauchy_stress = advectStressSolve(in.cauchy_stress_old + in.dS, in.dW);
    return out;
  }

  auto [S, Jinv] = advectStress(in.cauchy_stress_old + in.dS, in.dW);
  out.cauchy_stress = S;
  out.dcauchy_stress_d_eigenstrain = -Jinv * in.small_jacobian;

  const RankFourTensor d_dW_d_dL = in.d_dW_d_F * in.d_dL_d_F.inverse();
  const RankFourTensor U = stressAdvectionDerivative(S) * d_dW_d_dL;
  out.cauchy_jacobian = cauchyJacobian(Jinv, in.small_jacobian, U);
  return out;
}

rashid()

Outputs LagrangianObjectiveRates::rashid	(	const Inputs &	in,
		bool	need_jacobian
	)

sigma_{n+1} = r_hat (sigma_n + Deltasigma) r_hat^T, r_hat = exp(Deltaw).

See rashid_project/plan_outline.pdf Sec.3.2.

Definition at line 235 of file LagrangianObjectiveRate.C.

Referenced by compute(), and TEST().

{
  usingTensorIndices(i_, j_, k_, l_, m_, n_);

  // r_hat = exp(Deltaw). Skip its R4 derivative when we don't need the Jacobian.
  RankFourTensor d_rhat_d_dW;
  const RankTwoTensor rhat = rotationFromVorticity(in.dW, need_jacobian ? &d_rhat_d_dW : nullptr);
  const RankTwoTensor rhatT = rhat.transpose();

  // sigma_{n+1} = r_hat (sigma_n + Deltasigma) r_hat^T   (eq. 22)
  const RankTwoTensor S_inner = in.cauchy_stress_old + in.dS;
  Outputs out;
  out.cauchy_stress = rhat * S_inner * rhatT;

  if (!need_jacobian)
    return out;

  // J^{-1}_{ijkl} = r_hat_ik r_hat_jl   (eq. 24), the rank-4 (r_hat (x) r_hat) sandwich. Used for
  // the eigenstrain Jacobian and as the "outer" operator for the constitutive piece. We name the
  // dummy "middle pair" k, l here (output indices i, j, k, l) -- when chained via
  // RankFourTensor::operator*, the k, l contract against small_jacobian's first pair, as desired.
  const RankFourTensor J_inv = rhat.times<i_, k_, j_, l_>(rhat);

  // dsigma/d(eigenstrain) = -J^{-1} : small_jacobian.
  // (mechanical_strain = total_strain - eigenstrain, hence the minus.)
  out.dcauchy_stress_d_eigenstrain = -(J_inv * in.small_jacobian);

  // Chain rule pieces for dsigma/d(dL):
  //   d(Deltaw)/d(dL) = d(dW)/dF * inverse(d(dL)/dF)
  //   d(Deltad)/d(dL) = I^(4) - d(Deltaw)/d(dL)   (Deltad + Deltaw = dL by construction).
  //   d(r_hat)/d(dL)  = d(r_hat)/d(Deltaw) * d(Deltaw)/d(dL).
  const RankFourTensor d_F_d_dL = in.d_dL_d_F.inverse();
  const RankFourTensor d_dW_d_dL = in.d_dW_d_F * d_F_d_dL;
  const RankFourTensor d_dD_d_dL = RankFourTensor::IdentityFour() - d_dW_d_dL;
  const RankFourTensor d_rhat_d_dL = d_rhat_d_dW * d_dW_d_dL;

  // Rotation pieces of dsigma/d(dL):
  //   T1_{ijkl} = (d_rhat_d_dL)_{imkl} * (S r_hat^T)_{mj}
  //   T2_{ijkl} = (r_hat S)_{im} * (d_rhat_d_dL)_{jmkl}
  const RankTwoTensor SR = S_inner * rhatT; // S r_hat^T  (shape (m, j))
  const RankTwoTensor RS = rhat * S_inner;  // r_hat S    (shape (i, m))
  const RankFourTensor T1 = SR.times<m_, j_, i_, m_, k_, l_>(d_rhat_d_dL);
  const RankFourTensor T2 = RS.times<i_, m_, j_, m_, k_, l_>(d_rhat_d_dL);

  // Constitutive piece: J^{-1} : (small_jacobian * d(Deltad)/d(dL)).
  const RankFourTensor T3 = J_inv * (in.small_jacobian * d_dD_d_dL);

  out.cauchy_jacobian = T1 + T2 + T3;
  return out;
}

truesdell()

Outputs LagrangianObjectiveRates::truesdell	(	const Inputs &	in,
		bool	need_jacobian
	)

sigma_{n+1} = J(dL)^{-1} (sigma_n + Deltasigma). Truesdell rate.

Definition at line 152 of file LagrangianObjectiveRate.C.

Referenced by compute(), and TEST().

{
  Outputs out;
  if (!need_jacobian)
  {
    out.cauchy_stress = advectStressSolve(in.cauchy_stress_old + in.dS, in.dL);
    return out;
  }

  auto [S, Jinv] = advectStress(in.cauchy_stress_old + in.dS, in.dL);
  out.cauchy_stress = S;
  out.dcauchy_stress_d_eigenstrain = -Jinv * in.small_jacobian;

  const RankFourTensor U = stressAdvectionDerivative(S);
  out.cauchy_jacobian = cauchyJacobian(Jinv, in.small_jacobian, U);
  return out;
}