TotalLagrangianStressDivergenceBase< G > Class Template Reference

Enforce equilibrium with a total Lagrangian formulation. More...

#include <TotalLagrangianStressDivergenceBase.h>

Inheritance diagram for TotalLagrangianStressDivergenceBase< G >:

Public Types
enum	FBarMode { FBarMode::Total, FBarMode::Incremental }
	Mirrors ComputeLagrangianStrainBase::FBarMode. More...
typedef std::vector< int >	JvarMap

Public Member Functions
	TotalLagrangianStressDivergenceBase (const InputParameters &parameters)
virtual void	initialSetup () override
	Derive _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee. More...
template<>
InputParameters	validParams ()
template<>
void	initialSetup ()
	Derive _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee. More...
template<>
InputParameters	validParams ()
template<>
void	initialSetup ()
	Derive _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee. More...
template<>
InputParameters	validParams ()
template<>
void	initialSetup ()
	Derive _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee. More...
virtual void	computeOffDiagJacobian (unsigned int jvar) override
unsigned int	mapJvarToCvar (unsigned int jvar)
int	mapJvarToCvar (unsigned int jvar, const JvarMap &jvar_map)
bool	mapJvarToCvar (unsigned int jvar, unsigned int &cvar)
const JvarMap &	getJvarMap ()
const JvarMap &	getParameterJvarMap (std::string parameter_name)

Static Public Member Functions
static InputParameters	baseParams ()
static InputParameters	validParams ()

Protected Member Functions
virtual RankTwoTensor	gradTest (unsigned int component) override
virtual RankTwoTensor	gradTrial (unsigned int component) override
virtual void	precalculateJacobianDisplacement (unsigned int component) override
	Prepare the average shape function gradients for stabilization. More...
virtual void	precalculateResidual () override
virtual void	precalculateJacobian () override
virtual void	precalculateOffDiagJacobian (unsigned int jvar) override
virtual Real	computeQpResidual () override
virtual Real	computeQpJacobianDisplacement (unsigned int alpha, unsigned int beta) override
virtual Real	computeQpJacobianTemperature (unsigned int cvar) override
virtual Real	computeQpJacobianOutOfPlaneStrain () override
void	computeAverageGradientSpatialTest ()
	Compute element-averaged spatial gradient of test functions for component _alpha, filling _avg_grad_spatial_test. More...
void	computeAverageGradientSpatialPhi (unsigned int beta)
	Compute element-averaged spatial gradient of trial functions for component beta, filling _avg_grad_spatial_phi[beta]. More...
void	computeAvgTestPhiCross (unsigned int beta)
	Compute element-averaged cross product (grad_x test_i)_{b1} * (grad_x phi_j)_{b2} for b1, b2 in {_alpha, beta} (4 combinations), filling _avg_test_phi_cross[b1][b2][i][j]. More...
Real	gradXTestComponent (unsigned int component) const
	(grad_x test_i)_component at the current _qp, where the push-forward uses the unstabilized F (= F_actual at alpha = 1), consistent with the PK1 wrap. More...
Real	gradXPhiComponent (unsigned int component) const
	(grad_x phi_j)_component at the current _qp, same push-forward as gradXTestComponent. More...
virtual RankTwoTensor	gradTrialUnstabilized (unsigned int component)
	The unstabilized trial function gradient. More...
virtual Real	computeQpJacobian () override
virtual Real	computeQpOffDiagJacobian (unsigned int jvar) override
RankTwoTensor	deltaPK1NonLocalFBar (const RankTwoTensor &delta_F_avg) const
	Non-local F-bar contribution to deltaPK1 at the current _qp, given the perturbation delta_F_avg of the element-average F. More...
bool	hasGuaranteedMaterialProperty (const MaterialPropertyName &prop, Guarantee guarantee)

Protected Attributes
const MaterialProperty< RankTwoTensor > &	_pk1
	The 1st Piola-Kirchhoff stress. More...
const MaterialProperty< RankFourTensor > &	_dpk1
	The derivative of the PK1 stress with respect to the deformation gradient (F that the stress material consumed, i.e. More...
const MaterialProperty< RankFourTensor > &	_dpk1_d_grad_u
	The derivative of the PK1 stress with respect to the displacement gradient (grad u_{n+1}). More...
const MaterialProperty< RankFourTensor > &	_dpk1_bypass_fbar
	Variant of _dpk1 (= pk1_jacobian) computed WITHOUT the F-bar chain factor _d_F_stab_d_F_ust in the sigma-via-dL contribution. More...
bool	_large_kinematics
	If true use large deformation kinematics. More...
const bool	_stabilize_strain
	If true calculate the deformation gradient derivatives for F_bar. More...
const FBarMode	_F_bar_mode
	What F gets F-bar volumetric correction (Total vs. More...
const std::string	_base_name
	Prepend to the material properties. More...
const unsigned int	_alpha
	Which component of the vector residual this kernel is responsible for. More...
const unsigned int	_ndisp
	Total number of displacements/size of residual vector. More...
std::vector< unsigned int >	_disp_nums
	The displacement numbers. More...
std::vector< std::vector< RankTwoTensor > >	_avg_grad_trial
std::vector< Real >	_avg_grad_spatial_test
	Element-averaged spatial (deformed-frame) gradient of test functions for the kernel's component _alpha: _avg_grad_spatial_test[i] = (1/V_x) int_e (grad_x test_i)_alpha dV_x Used for OLD-compat B-bar volumetric correction in F_bar_mode = incremental. More...
std::vector< std::vector< Real > >	_avg_grad_spatial_phi
	Element-averaged spatial gradient of trial functions per component: _avg_grad_spatial_phi[component][j] = (1/V_x) int_e (grad_x phi_j)_component dV_x Populated alongside _avg_grad_spatial_test for the Jacobian's B-bar contribution. More...
std::vector< std::vector< std::vector< std::vector< Real > > > >	_avg_test_phi_cross
	Element-averaged cross product (on displaced mesh) of spatial test/trial gradients: avg_test_phi_cross[b1][b2][i][j] = (1/V_x) int_e (grad_x test_i){b1} * (grad_x phi_j)_{b2} dV_x Indexed by [b1][b2] in {0,1,2}^2. More...
const MaterialProperty< RankTwoTensor > &	_F_ust
	The unmodified deformation gradient. More...
const MaterialProperty< RankTwoTensor > &	_F_ust_old
	Old unstabilized deformation gradient. More...
const MaterialProperty< RankTwoTensor > &	_F_avg
	The element-average deformation gradient. More...
const MaterialProperty< RankTwoTensor > &	_f_inv
	The inverse increment deformation gradient. More...
const MaterialProperty< RankTwoTensor > &	_F_inv
	The inverse deformation gradient. More...
const MaterialProperty< RankTwoTensor > *	_F_ust_inv = nullptr
	F_ust^{-1} and det(F_ust) from the strain calculator, consumed by the F-bar spatial push-forward (grad_x = F_ust^{-T} grad_X, J_ust = det F_ust) on both the residual and Jacobian sweeps. More...
const MaterialProperty< Real > *	_F_ust_det = nullptr
const MaterialProperty< RankTwoTensor > &	_F
	The actual (stabilized) deformation gradient. More...
const MaterialProperty< RankTwoTensor > &	_F_actual
	The literal deformation gradient at n+1 (I + grad u_{n+1}), independent of alpha and F-bar. More...
const MaterialProperty< RankFourTensor > &	_d_deformation_gradient_increment_d_F
	Derivative of the spatial velocity gradient increment w.r.t. F_{n+1}. More...
const MaterialProperty< RankFourTensor > &	_d_F_d_grad_u
	Derivative of F_{n+1} w.r.t. the displacement gradient. More...
const MaterialProperty< RankFourTensor > &	_d_F_stab_d_F_ust
	Partials of the F-bar-stabilized deformation gradient. More...
const MaterialProperty< RankFourTensor > &	_d_F_stab_d_F_avg
const MooseVariable *	_temperature
	Temperature, if provided. This is used only to get the trial functions. More...
const MooseVariable *	_out_of_plane_strain
	Out-of-plane strain, if provided. More...
std::vector< std::vector< const MaterialProperty< RankTwoTensor > * > >	_deigenstrain_dargs
	Eigenstrain derivatives wrt generate coupleds. More...
const MaterialProperty< RankFourTensor > *	_dcauchy_stress_d_eigenstrain = nullptr
	Derivative of the Cauchy stress with respect to the eigenstrain (published by ComputeLagrangianObjectiveStress; can be overridden by other Cauchy-providing materials). More...
const MaterialProperty< RankFourTensor > *	_d_nl_fbar = nullptr
	Composed non-local F-bar operator D_nl = cauchy_jac : d(dL)/dF : d(F_stab)/d(F_avg), published per qp by the stress material (once per element, shared by all displacement kernels). More...
const unsigned int	_n_args

Private Member Functions
void	populateLocalPK1Cache (unsigned int beta)
	Populate the per-(qp, j) caches consumed by computeQpJacobianDisplacement. More...
void	cachePK1ContractionFUst ()
	Cache pk1 : F_ust per qp (the J * tr(sigma) factor of the B-bar volumetric correction). More...

Private Attributes
std::vector< std::vector< RankTwoTensor > >	_dpk1_grad_trial_cache
	_dpk1_d_grad_u[qp] * gradTrial(beta) per (qp, j) for the current Jacobian column's beta. More...
std::vector< std::vector< RankTwoTensor > >	_grad_trial_cache
	Cached gradTrialUnstabilized(beta) per (qp, j) for the current column. More...
std::vector< std::vector< RankTwoTensor > >	_delta_PK1_NL_cache
	Fully wrapped non-local F-bar contribution to deltaPK1 per (qp, j) for the current column: _d_nl_fbar[qp] * (_d_F_d_grad_u[qp] * _avg_grad_trial[beta][j]) then PK1-wrapped via the strain calc's det(F_ust) / F_ust^{-1} properties in large kinematics. More...
std::vector< std::vector< RankTwoTensor > >	_dpk1_total_cache
	Local + non-local PK1 derivative per (qp, j): _dpk1_grad_trial_cache + _delta_PK1_NL_cache. More...
std::vector< Real >	_pk1_ddot_F_ust
	pk1 : F_ust per qp for the B-bar volumetric correction (see cachePK1ContractionFUst). More...
std::vector< std::vector< Real > >	_dA_dU_cache
	d(pk1 : F_ust)/dU per (qp, j) for the current column – the B-bar Jacobian's dA/dU term. More...

Detailed Description

template<class G>
class TotalLagrangianStressDivergenceBase< G >

Enforce equilibrium with a total Lagrangian formulation.

This class enforces equilibrium when used in conjunction with the corresponding strain calculator (CalculateStrainLagrangianKernel) and with either a stress calculator that provides the 1st PK stress ("pk1_stress") and the derivative of the 1st PK stress with respect to the deformation gradient ("pk1_jacobian")

This kernel should be used with the new "ComputeLagrangianStressBase" stress update system and the "ComputeLagrangianStrain" system for strains.

Definition at line 27 of file TotalLagrangianStressDivergenceBase.h.

Member Enumeration Documentation

FBarMode

enum LagrangianStressDivergenceBase::FBarMode

stronginherited

Mirrors ComputeLagrangianStrainBase::FBarMode.

Replicated here (rather than included) so this header doesn't need to pull in the templated strain header.

Enumerator
Total
Incremental

Definition at line 39 of file LagrangianStressDivergenceBase.h.

  {
    Total,
    Incremental
  };

Constructor & Destructor Documentation

TotalLagrangianStressDivergenceBase()

template<class G >

TotalLagrangianStressDivergenceBase< G >::TotalLagrangianStressDivergenceBase

(

const InputParameters &

parameters

)

Definition at line 23 of file TotalLagrangianStressDivergenceBase.C.

  : LagrangianStressDivergenceBase(parameters),
    _pk1(getMaterialPropertyByName<RankTwoTensor>(_base_name + "pk1_stress")),
    _dpk1(getMaterialPropertyByName<RankFourTensor>(_base_name + "pk1_jacobian")),
    _dpk1_d_grad_u(getMaterialPropertyByName<RankFourTensor>(_base_name + "dpk1_d_grad_u")),
    _dpk1_bypass_fbar(
        getMaterialPropertyByName<RankFourTensor>(_base_name + "pk1_jacobian_bypass_fbar"))
{
}

Member Function Documentation

baseParams()

template<class G >

InputParameters TotalLagrangianStressDivergenceBase< G >::baseParams ( )

static

Definition at line 14 of file TotalLagrangianStressDivergenceBase.C.

Referenced by TotalLagrangianStressDivergenceBase< G >::validParams().

{
  InputParameters params = LagrangianStressDivergenceBase::validParams();
  // This kernel requires use_displaced_mesh to be off
  params.suppressParameter<bool>("use_displaced_mesh");
  return params;
}

cachePK1ContractionFUst()

template<class G >

void TotalLagrangianStressDivergenceBase< G >::cachePK1ContractionFUst ( )

private

Cache pk1 : F_ust per qp (the J * tr(sigma) factor of the B-bar volumetric correction).

Column-independent, so it is hoisted out of the per-(_i) residual loop and the per-(_i, _j, component) Jacobian loop. Gated on F_bar_mode = incremental.

Definition at line 108 of file TotalLagrangianStressDivergenceBase.C.

{
  const unsigned int n_qp = _qrule->n_points();
  _pk1_ddot_F_ust.assign(n_qp, 0.0);
  for (const auto qp : make_range(n_qp))
    _pk1_ddot_F_ust[qp] = _pk1[qp].doubleContraction(_F_ust[qp]);
}

computeAverageGradientSpatialPhi()

template<class G >

void TotalLagrangianStressDivergenceBase< G >::computeAverageGradientSpatialPhi ( unsigned int  beta )

protected

Compute element-averaged spatial gradient of trial functions for component beta, filling _avg_grad_spatial_phi[beta].

Used for the B-bar Jacobian contribution.

Definition at line 273 of file TotalLagrangianStressDivergenceBase.C.

{
  // Same structure as computeAverageGradientSpatialTest, but for trial functions and component
  // beta.
  _avg_grad_spatial_phi[beta].assign(_phi.size(), 0.0);
  Real V_x = 0.0;
  for (unsigned int qp = 0; qp < _qrule->n_points(); ++qp)
  {
    const Real J = _large_kinematics ? (*_F_ust_det)[qp] : 1.0;
    const Real w = J * _JxW[qp] * _coord[qp];
    V_x += w;
    const RankTwoTensor F_inv = _large_kinematics ? (*_F_ust_inv)[qp] : RankTwoTensor::Identity();
    for (unsigned int j = 0; j < _phi.size(); ++j)
    {
      Real g_x = 0.0;
      for (unsigned int k = 0; k < 3; ++k)
        g_x += _grad_phi[j][qp](k) * F_inv(k, beta);
      _avg_grad_spatial_phi[beta][j] += g_x * w;
    }
  }
  for (unsigned int j = 0; j < _phi.size(); ++j)
    _avg_grad_spatial_phi[beta][j] /= V_x;
}

computeAverageGradientSpatialTest()

template<class G >

void TotalLagrangianStressDivergenceBase< G >::computeAverageGradientSpatialTest ( )

protected

Compute element-averaged spatial gradient of test functions for component _alpha, filling _avg_grad_spatial_test.

Used for the OLD-compat B-bar volumetric correction.

Definition at line 245 of file TotalLagrangianStressDivergenceBase.C.

{
  // _avg_grad_spatial_test[i] = (1/V_x) int (grad_x test_i)_alpha dV_x
  //                           = (sum_qp (grad_X test_i)_j (F_ust^{-1})_{j, _alpha} * J_ust * w)
  //                             / (sum_qp J_ust * w),  w = JxW * coord
  // For small kinematics, F_ust = I, J_ust = 1, reducing to OLD's element-averaged grad_test.
  _avg_grad_spatial_test.assign(_test.size(), 0.0);
  Real V_x = 0.0;
  for (unsigned int qp = 0; qp < _qrule->n_points(); ++qp)
  {
    const Real J = _large_kinematics ? (*_F_ust_det)[qp] : 1.0;
    const Real w = J * _JxW[qp] * _coord[qp];
    V_x += w;
    const RankTwoTensor F_inv = _large_kinematics ? (*_F_ust_inv)[qp] : RankTwoTensor::Identity();
    for (unsigned int i = 0; i < _test.size(); ++i)
    {
      Real g_x = 0.0;
      for (unsigned int j = 0; j < 3; ++j)
        g_x += _grad_test[i][qp](j) * F_inv(j, _alpha);
      _avg_grad_spatial_test[i] += g_x * w;
    }
  }
  for (unsigned int i = 0; i < _test.size(); ++i)
    _avg_grad_spatial_test[i] /= V_x;
}

computeAvgTestPhiCross()

template<class G >

void TotalLagrangianStressDivergenceBase< G >::computeAvgTestPhiCross ( unsigned int  beta )

protected

Compute element-averaged cross product (grad_x test_i)_{b1} * (grad_x phi_j)_{b2} for b1, b2 in {_alpha, beta} (4 combinations), filling _avg_test_phi_cross[b1][b2][i][j].

Used by the non-local B-bar Jacobian contribution from d(avg_grad_spatial_test)/dU. beta is the displacement component of the trial-side variable in this Jacobian column; only the four (_alpha, _alpha), (_alpha, beta), (beta, _alpha), (beta, beta) entries are populated (others are left untouched / unread).

Definition at line 299 of file TotalLagrangianStressDivergenceBase.C.

{
  // Populate the cross-products
  //   _avg_test_phi_cross[b1][b2][i][j] = (1/V_x) int (grad_x test_i)_{b1} * (grad_x phi_j)_{b2}
  //   dV_x
  // for the 4 combinations of (b1, b2) in {_alpha, beta}. The d(avg_grad_spatial_test)/dU
  // term in the B-bar Jacobian needs both (alpha, beta) and (beta, alpha) entries; the
  // diagonal (alpha == beta) collapses to a single combination.
  const unsigned int n_test = _test.size();
  const unsigned int n_phi = _phi.size();
  std::vector<unsigned int> bs = {_alpha};
  if (beta != _alpha)
    bs.push_back(beta);
  // Zero out and resize the affected slots
  for (auto b1 : bs)
    for (auto b2 : bs)
    {
      _avg_test_phi_cross[b1][b2].assign(n_test, std::vector<Real>(n_phi, 0.0));
    }
  Real V_x = 0.0;
  // Cache (grad_x test_i)_{b1} and (grad_x phi_j)_{b2} per qp to avoid recomputing for
  // each (i, j) pair.
  std::vector<std::vector<Real>> gx_test(bs.size(), std::vector<Real>(n_test, 0.0));
  std::vector<std::vector<Real>> gx_phi(bs.size(), std::vector<Real>(n_phi, 0.0));
  for (unsigned int qp = 0; qp < _qrule->n_points(); ++qp)
  {
    const Real J = _large_kinematics ? (*_F_ust_det)[qp] : 1.0;
    const Real w = J * _JxW[qp] * _coord[qp];
    V_x += w;
    const RankTwoTensor F_inv = _large_kinematics ? (*_F_ust_inv)[qp] : RankTwoTensor::Identity();
    for (unsigned int bi = 0; bi < bs.size(); ++bi)
    {
      const unsigned int b = bs[bi];
      for (unsigned int i = 0; i < n_test; ++i)
      {
        Real g = 0.0;
        for (unsigned int k = 0; k < 3; ++k)
          g += _grad_test[i][qp](k) * F_inv(k, b);
        gx_test[bi][i] = g;
      }
      for (unsigned int j = 0; j < n_phi; ++j)
      {
        Real g = 0.0;
        for (unsigned int k = 0; k < 3; ++k)
          g += _grad_phi[j][qp](k) * F_inv(k, b);
        gx_phi[bi][j] = g;
      }
    }
    for (unsigned int b1i = 0; b1i < bs.size(); ++b1i)
      for (unsigned int b2i = 0; b2i < bs.size(); ++b2i)
      {
        const unsigned int b1 = bs[b1i];
        const unsigned int b2 = bs[b2i];
        auto & dest = _avg_test_phi_cross[b1][b2];
        for (unsigned int i = 0; i < n_test; ++i)
          for (unsigned int j = 0; j < n_phi; ++j)
            dest[i][j] += gx_test[b1i][i] * gx_phi[b2i][j] * w;
      }
  }
  for (auto b1 : bs)
    for (auto b2 : bs)
    {
      auto & dest = _avg_test_phi_cross[b1][b2];
      for (unsigned int i = 0; i < n_test; ++i)
        for (unsigned int j = 0; j < n_phi; ++j)
          dest[i][j] /= V_x;
    }
}

computeQpJacobian()

Real LagrangianStressDivergenceBase::computeQpJacobian ( )

overrideprotectedvirtualinherited

Reimplemented in TotalLagrangianWeakPlaneStress.

Definition at line 191 of file LagrangianStressDivergenceBase.C.

{
  return computeQpJacobianDisplacement(_alpha, _alpha);
}

computeQpJacobianDisplacement()

template<class G >

Real TotalLagrangianStressDivergenceBase< G >::computeQpJacobianDisplacement ( unsigned int  alpha, unsigned int  beta  )

overrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 398 of file TotalLagrangianStressDivergenceBase.C.

{
  // gradTest(alpha) feeds the local Jacobian contraction below.
  const RankTwoTensor grad_test = gradTest(alpha);

  // Local (+ non-local F-bar) Jacobian: J_{alpha beta} = gradTest_alpha : dPK1_total, where
  // dPK1_total = dPK1/d(grad u) * grad_phi_beta (local) plus the wrapped non-local F-bar
  // perturbation. Both pieces depend only on (qp, j) and are precomputed and pre-summed into
  // `_dpk1_total_cache` by `populateLocalPK1Cache(beta)`, so a single contraction covers both.
  // Without stabilization there is no non-local piece, so the local cache is contracted directly.
  Real J = grad_test.doubleContraction(_stabilize_strain ? _dpk1_total_cache[_qp][_j]
                                                         : _dpk1_grad_trial_cache[_qp][_j]);

  // OLD-compat B-bar volumetric correction Jacobian (only in `F_bar_mode = incremental`).
  // The residual added the term R_extra = (PK1:F_ust)/3 * (avg_T - T_alpha) summed over qps.
  // Linearizing per (i, j, alpha, beta):
  //   J_extra_qp = (1/3) * d(PK1:F_ust)/dU * (avg_T - T_alpha)
  //              + (1/3) * (PK1:F_ust) * (d(avg_T)/dU - dT_alpha/dU)
  // with derivatives in U (the trial-DOF for component beta at node j):
  //   d(PK1:F_ust)/dU|qp = (dPK1_local + dPK1_NL) : F_ust + PK1 : dF_ust_local
  //     dPK1_local = _dpk1_grad_trial_cache[_qp][_j]      (cached above)
  //     dPK1_NL    = d_PK1_NL                             (cached above)
  //     dF_ust     = _grad_trial_cache[_qp][_j]           (cached unstabilized trial)
  //   dT_alpha/dU|qp  = -(grad_x test_i)_beta * (grad_x phi_j)_alpha            (local cross)
  //   d(avg_T)/dU = avgCross(alpha, beta) - avgCross(beta, alpha) - avg_T(i) *
  //   avg_grad_spatial_phi[beta][j]
  //     avgCross(b1, b2) = _avg_test_phi_cross[b1][b2][i][j]         (precomputed)
  if (_stabilize_strain && _F_bar_mode == FBarMode::Incremental)
  {
    // A_qp (= pk1:F_ust/3, per qp) and dA_dU (per qp, j) are precomputed in
    // `cachePK1ContractionFUst` / `populateLocalPK1Cache` -- no double contractions here.
    const Real A_qp = _pk1_ddot_F_ust[_qp] / 3.0;
    const Real avg_T = _avg_grad_spatial_test[_i];
    const Real T_alpha = gradXTestComponent(alpha);
    const Real B = avg_T - T_alpha;

    const Real dA_dU = _dA_dU_cache[_qp][_j];

    // dB/dU: -dT_alpha/dU + d(avg_T)/dU
    // dT_alpha/dU = -(grad_x test_i)_beta * (grad_x phi_j)_alpha  (local cross at _qp)
    const Real T_beta_i = gradXTestComponent(beta);
    const Real phi_alpha_j = gradXPhiComponent(alpha);
    const Real dT_alpha_dU = -T_beta_i * phi_alpha_j;

    const Real avg_cross_ab = _avg_test_phi_cross[alpha][beta][_i][_j];
    const Real avg_cross_ba = _avg_test_phi_cross[beta][alpha][_i][_j];
    const Real d_avg_T_dU = avg_cross_ab - avg_cross_ba - avg_T * _avg_grad_spatial_phi[beta][_j];

    const Real dB_dU = d_avg_T_dU - dT_alpha_dU;
    J += dA_dU * B + A_qp * dB_dU;
  }

  return J;
}

computeQpJacobianOutOfPlaneStrain()

template<class G >

Real TotalLagrangianStressDivergenceBase< G >::computeQpJacobianOutOfPlaneStrain ( )

overrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 487 of file TotalLagrangianStressDivergenceBase.C.

{
  // d(R_disp_alpha)/d(strain_zz_j) at qp = gradTest_alpha : d(PK1)/d(strain_zz_j).
  // strain_zz feeds `_F[(2,2)]` AFTER F-bar runs in `ComputeLagrangianWPSStrain`, so
  // strain_zz perturbations bypass F-bar's chain. Use `_dpk1_bypass_fbar` (= the
  // pk1_jacobian variant computed with the F-bar `_d_F_stab_d_F_ust` factor REPLACED
  // by identity in the sigma chain) for a consistent Jacobian.
  return _dpk1_bypass_fbar[_qp].contractionKl(2, 2, gradTest(_alpha)) *
         _out_of_plane_strain->phi()[_j][_qp];
}

computeQpJacobianTemperature()

template<class G >

Real TotalLagrangianStressDivergenceBase< G >::computeQpJacobianTemperature ( unsigned int  cvar )

overrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 456 of file TotalLagrangianStressDivergenceBase.C.

{
  // Multiple eigenstrains may depend on the same coupled var
  RankTwoTensor total_deigen;
  for (const auto deigen_darg : _deigenstrain_dargs[cvar])
    total_deigen += (*deigen_darg)[_qp];

  // No eigenstrain -> no temperature coupling. Short-circuit before dereferencing the
  // d_sigma/d_eigenstrain property (only fetched when eigenstrains are coupled; see
  // LagrangianStressDivergenceBase ctor).
  if (total_deigen.L2norm() == 0.0)
    return 0.0;

  // Direct chain through the constitutive update. The stress material publishes
  //   d_sigma/d_eigenstrain   (= -Jinv * small_jacobian for the objective-rate path,
  //                            with the sign convention that an eigenstrain increase
  //                            reduces the mechanical strain).
  // We then wrap to PK1 the same way the residual does:
  //   dP/dT = det(F) * dsigma/dT * F^{-T}   (large kinematics)
  //   dP/dT = dsigma/dT                     (small kinematics, P == sigma by convention)
  const RankTwoTensor dsigma_dT = (*_dcauchy_stress_d_eigenstrain)[_qp] * total_deigen;
  RankTwoTensor dP_dT;
  if (_large_kinematics)
    dP_dT = _F[_qp].det() * dsigma_dT * _F_inv[_qp].transpose();
  else
    dP_dT = dsigma_dT;
  return dP_dT.doubleContraction(gradTest(_alpha)) * _temperature->phi()[_j][_qp];
}

computeQpOffDiagJacobian()

Real LagrangianStressDivergenceBase::computeQpOffDiagJacobian ( unsigned int  jvar )

overrideprotectedvirtualinherited

Reimplemented in TotalLagrangianWeakPlaneStress.

Definition at line 210 of file LagrangianStressDivergenceBase.C.

{
  // Bail if jvar not coupled
  if (getJvarMap()[jvar] < 0)
    return 0.0;

  // Off diagonal terms for other displacements
  for (auto beta : make_range(_ndisp))
    if (jvar == _disp_nums[beta])
      return computeQpJacobianDisplacement(_alpha, beta);

  // Off diagonal temperature term due to eigenstrain
  if (_temperature && jvar == _temperature->number())
    return computeQpJacobianTemperature(mapJvarToCvar(jvar));

  // Off diagonal term due to weak plane stress
  if (_out_of_plane_strain && jvar == _out_of_plane_strain->number())
    return computeQpJacobianOutOfPlaneStrain();

  return 0;
}

computeQpResidual()

template<class G >

Real TotalLagrangianStressDivergenceBase< G >::computeQpResidual ( )

overrideprotectedvirtual

Reimplemented in TotalLagrangianWeakPlaneStress.

Definition at line 370 of file TotalLagrangianStressDivergenceBase.C.

{
  Real result = gradTest(_alpha).doubleContraction(_pk1[_qp]);

  // OLD-compat B-bar volumetric correction (only in `F_bar_mode = incremental`, the explicit
  // OLD-compat mode). This adds
  //   int (tr sigma / 3) * (avg_grad_x test - grad_x test)_alpha dV_x
  // expressed in reference-frame integration as
  //   sum_qp ((PK1 : F_ust) / 3) * (avg_grad_spatial_test[_i] - grad_x_test_alpha) * JxW * coord
  // (the J = det(F_ust) factor is already absorbed into `PK1 : F_ust = J * tr sigma`).
  // Without this term, PK1 = det(F_ust) sigma F_ust^{-T} reproduces OLD's `sigma : grad_x test`
  // term but not OLD's vol-locking correction; for uniform sigma that's harmless (the integral
  // vanishes per element) but for non-uniform sigma -- e.g. mixed-component Dirichlet BCs producing
  // non-affine equilibrium with plasticity + a kinematic decomposition that gives spatially varying
  // sigma -- it drives the converged displacement away from OLD's. Scoped to incremental mode
  // because (a) that's the documented OLD-compat F-bar mode and (b) the existing `total` mode tests
  // are calibrated to the F-bar-in-sigma-only formulation (adding the B-bar term there would be
  // a separate behavior change).
  if (_stabilize_strain && _F_bar_mode == FBarMode::Incremental)
  {
    const Real PK1_F_over_3 = _pk1_ddot_F_ust[_qp] / 3.0;
    result += PK1_F_over_3 * (_avg_grad_spatial_test[_i] - gradXTestComponent(_alpha));
  }
  return result;
}

deltaPK1NonLocalFBar()

RankTwoTensor LagrangianStressDivergenceBase::deltaPK1NonLocalFBar ( const RankTwoTensor &  delta_F_avg ) const

protectedinherited

Non-local F-bar contribution to deltaPK1 at the current _qp, given the perturbation delta_F_avg of the element-average F.

Implements the shared chain deltaF_stab_NL = _d_F_stab_d_F_avg * deltaF_avg deltadL_NL = _d_deformation_gradient_increment_d_F * deltaF_stab_NL deltasigma_NL = _cauchy_jacobian * deltadL_NL deltaPK1_NL = det(F_ust) * deltasigma_NL * F_ust^{-T} (large kinematics) = deltasigma_NL (small kinematics, PK1 == sigma) Returns zero when F-bar is off (!_stabilize_strain). Used by the TL displacement Jacobian, the WPS off-diag Jacobian, and the homogenization scalar<->disp Jacobian – anywhere the disp perturbation chains through F-bar's non-local route.

Consumes the strain/stress material's per-qp _d_nl_fbar operator so the inner (test, trial) loop pays only one R4*R2 (and, in the large-kinematics branch, one R2*R2*R2 PK1 wrap) per call instead of three R4*R2 chains plus a per-call 3x3 inverse.

Definition at line 197 of file LagrangianStressDivergenceBase.C.

Referenced by TotalLagrangianWeakPlaneStress::computeQpOffDiagJacobian(), and HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian().

{
  if (!_stabilize_strain)
    return RankTwoTensor();
  // `_d_nl_fbar` (the composed non-local operator) and F_ust^{-1}/det come from the stress and
  // strain materials as per-qp properties -- no kernel-side cache to refresh.
  const RankTwoTensor delta_sigma_nl = (*_d_nl_fbar)[_qp] * delta_F_avg;
  if (_large_kinematics)
    return (*_F_ust_det)[_qp] * delta_sigma_nl * (*_F_ust_inv)[_qp].transpose();
  return delta_sigma_nl;
}

gradTest()

template<class G >

RankTwoTensor TotalLagrangianStressDivergenceBase< G >::gradTest ( unsigned int  component )

overrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 36 of file TotalLagrangianStressDivergenceBase.C.

Referenced by HomogenizedTotalLagrangianStressDivergence::computeQpOffDiagJacobianScalar().

{
  // F-bar doesn't modify the test function
  return G::gradOp(component, _grad_test[_i][_qp], _test[_i][_qp], _q_point[_qp]);
}

gradTrial()

template<class G >

RankTwoTensor TotalLagrangianStressDivergenceBase< G >::gradTrial ( unsigned int  component )

overrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 44 of file TotalLagrangianStressDivergenceBase.C.

Referenced by TotalLagrangianWeakPlaneStress::computeQpOffDiagJacobian(), and HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian().

{
  // After the F_ust-wrap architectural change, pk1_jacobian = dPK1/d(F_ust) already
  // contains the local F-bar contribution (via the sigma-chain through
  // `_d_F_stab_d_F_ust`). The trial gradient is always unstabilized; the non-local F-bar
  // Jacobian contribution is added explicitly in `computeQpJacobianDisplacement`.
  return gradTrialUnstabilized(component);
}

gradTrialUnstabilized()

template<class G >

RankTwoTensor TotalLagrangianStressDivergenceBase< G >::gradTrialUnstabilized ( unsigned int  component )

protectedvirtual

The unstabilized trial function gradient.

Exposed (protected, not private) so subclasses like HomogenizedTotalLagrangianStressDivergence can use it directly for the macro-var <-> disp off-diagonal Jacobian chain.

Definition at line 55 of file TotalLagrangianStressDivergenceBase.C.

Referenced by HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian().

{
  // Without F-bar stabilization, simply return the gradient of the trial functions
  return G::gradOp(component, _grad_phi[_j][_qp], _phi[_j][_qp], _q_point[_qp]);
}

gradXPhiComponent()

template<class G >

Real TotalLagrangianStressDivergenceBase< G >::gradXPhiComponent ( unsigned int  component ) const

protected

(grad_x phi_j)_component at the current _qp, same push-forward as gradXTestComponent.

Definition at line 232 of file TotalLagrangianStressDivergenceBase.C.

{
  if (!_large_kinematics)
    return _grad_phi[_j][_qp](component);
  const RankTwoTensor & F_inv = (*_F_ust_inv)[_qp];
  Real out = 0.0;
  for (unsigned int j = 0; j < 3; ++j)
    out += _grad_phi[_j][_qp](j) * F_inv(j, component);
  return out;
}

gradXTestComponent()

template<class G >

Real TotalLagrangianStressDivergenceBase< G >::gradXTestComponent ( unsigned int  component ) const

protected

(grad_x test_i)_component at the current _qp, where the push-forward uses the unstabilized F (= F_actual at alpha = 1), consistent with the PK1 wrap.

Definition at line 216 of file TotalLagrangianStressDivergenceBase.C.

{
  // (grad_x test_i)_component = (grad_X test_i)_j (F_ust^{-1})_{j, component}
  // Push-forward via F_ust (= F_actual at alpha=1) matches the PK1 wrap. F_ust^{-1} is a
  // material property (computed once per qp by the strain calc), not recomputed here.
  if (!_large_kinematics)
    return _grad_test[_i][_qp](component);
  const RankTwoTensor & F_inv = (*_F_ust_inv)[_qp];
  Real out = 0.0;
  for (unsigned int j = 0; j < 3; ++j)
    out += _grad_test[_i][_qp](j) * F_inv(j, component);
  return out;
}

hasGuaranteedMaterialProperty()

bool GuaranteeConsumer::hasGuaranteedMaterialProperty ( const MaterialPropertyName &  prop, Guarantee  guarantee  )

protectedinherited

Definition at line 28 of file GuaranteeConsumer.C.

Referenced by ComputeFiniteStrainElasticStress::computeQpStress(), ADComputeSmearedCrackingStress::initialSetup(), ComputeSmearedCrackingStress::initialSetup(), ComputeLinearElasticPFFractureStress::initialSetup(), CriticalTimeStep::initialSetup(), ComputeStVenantKirchhoffStress::initialSetup(), ComputeMultipleInelasticStressBase::initialSetup(), ADComputeMultipleInelasticStress::initialSetup(), LagrangianStressDivergenceBase::initialSetup(), and ComputeLagrangianStressBase::initialSetup().

{
  if (!_gc_feproblem->startedInitialSetup())
    mooseError("hasGuaranteedMaterialProperty() needs to be called in initialSetup()");

  // Reference to MaterialWarehouse for testing and retrieving block ids
  const auto & warehouse = _gc_feproblem->getMaterialWarehouse();

  // Complete set of ids that this object is active
  const auto & ids = (_gc_block_restrict && _gc_block_restrict->blockRestricted())
                         ? _gc_block_restrict->blockIDs()
                         : _gc_feproblem->mesh().meshSubdomains();

  // Loop over each id for this object
  for (const auto & id : ids)
  {
    // If block materials exist, look if any issue the required guarantee
    if (warehouse.hasActiveBlockObjects(id))
    {
      const std::vector<std::shared_ptr<MaterialBase>> & mats = warehouse.getActiveBlockObjects(id);
      for (const auto & mat : mats)
      {
        const auto & mat_props = mat->getSuppliedItems();
        if (mat_props.count(prop_name))
        {
          auto guarantee_mat = dynamic_cast<GuaranteeProvider *>(mat.get());
          if (guarantee_mat && !guarantee_mat->hasGuarantee(prop_name, guarantee))
          {
            // we found at least one material on the set of block we operate on
            // that does _not_ provide the requested guarantee
            return false;
          }
        }
      }
    }
  }

  return true;
}

initialSetup() [1/4]

template<>

void TotalLagrangianStressDivergenceBase< GradientOperatorCartesian >::initialSetup ( )

inlinevirtual

Derive _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee.

Reimplemented from LagrangianStressDivergenceBase.

Definition at line 26 of file TotalLagrangianStressDivergence.h.

{
  // Derives _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee.
  LagrangianStressDivergenceBase::initialSetup();

  if (getBlockCoordSystem() != Moose::COORD_XYZ)
    mooseError("This kernel should only act in Cartesian coordinates.");
}

initialSetup() [2/4]

template<>

void TotalLagrangianStressDivergenceBase< GradientOperatorAxisymmetricCylindrical >::initialSetup ( )

virtual

Derive _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee.

Reimplemented from LagrangianStressDivergenceBase.

Definition at line 26 of file TotalLagrangianStressDivergenceAxisymmetricCylindrical.h.

{
  // Derives _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee.
  LagrangianStressDivergenceBase::initialSetup();

  if (getBlockCoordSystem() != Moose::COORD_RZ)
    mooseError("This kernel should only act in axisymmetric cylindrical coordinates.");
}

initialSetup() [3/4]

template<>

void TotalLagrangianStressDivergenceBase< GradientOperatorCentrosymmetricSpherical >::initialSetup ( )

virtual

Derive _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee.

Reimplemented from LagrangianStressDivergenceBase.

Definition at line 26 of file TotalLagrangianStressDivergenceCentrosymmetricSpherical.h.

{
  // Derives _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee.
  LagrangianStressDivergenceBase::initialSetup();

  if (getBlockCoordSystem() != Moose::COORD_RSPHERICAL)
    mooseError("This kernel should only act in centrosymmetric spherical coordinates.");
}

initialSetup() [4/4]

template<class G >

virtual void TotalLagrangianStressDivergenceBase< G >::initialSetup ( )

overridevirtual

Derive _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee.

Reimplemented from LagrangianStressDivergenceBase.

populateLocalPK1Cache()

template<class G >

void TotalLagrangianStressDivergenceBase< G >::populateLocalPK1Cache ( unsigned int  beta )

private

Populate the per-(qp, j) caches consumed by computeQpJacobianDisplacement.

beta is fixed across a single Jacobian column, so the R4*R2 chain _dpk1_d_grad_u[qp] * gradTrial(beta), the cached unstabilized trial gradient, and (when _stabilize_strain == true) the fully wrapped non-local F-bar PK1 perturbation can all be computed once per (qp, j) instead of once per (qp, _i, _j). Called from precalculateJacobian (with beta = _alpha) and precalculateOffDiagJacobian(jvar) (with the matched beta).

Definition at line 155 of file TotalLagrangianStressDivergenceBase.C.

{
  const unsigned int n_qp = _qrule->n_points();
  const unsigned int n_phi = _phi.size();
  _dpk1_grad_trial_cache.assign(n_qp, std::vector<RankTwoTensor>(n_phi));
  _grad_trial_cache.assign(n_qp, std::vector<RankTwoTensor>(n_phi));
  if (_stabilize_strain)
  {
    _delta_PK1_NL_cache.assign(n_qp, std::vector<RankTwoTensor>(n_phi));
    _dpk1_total_cache.assign(n_qp, std::vector<RankTwoTensor>(n_phi));
  }

  // B-bar volumetric correction (incremental mode only): cache the column-independent
  // `pk1 : F_ust` per qp and the per-(qp, j) `dA/dU` term so the Jacobian inner loop reads
  // scalars instead of recomputing three double contractions per (_i, _j, component).
  const bool bbar = _stabilize_strain && _F_bar_mode == FBarMode::Incremental;
  if (bbar)
  {
    cachePK1ContractionFUst();
    _dA_dU_cache.assign(n_qp, std::vector<Real>(n_phi));
  }

  for (unsigned int qp = 0; qp < n_qp; ++qp)
  {
    const RankFourTensor & dpk1 = _dpk1_d_grad_u[qp];
    const RankFourTensor & dFdGU = _d_F_d_grad_u[qp];
    for (unsigned int j = 0; j < n_phi; ++j)
    {
      // gradTrial == gradTrialUnstabilized in TL (line ~50); single cache feeds both consumers.
      const RankTwoTensor grad_trial = G::gradOp(beta, _grad_phi[j][qp], _phi[j][qp], _q_point[qp]);
      _grad_trial_cache[qp][j] = grad_trial;
      _dpk1_grad_trial_cache[qp][j] = dpk1 * grad_trial;
      if (_stabilize_strain)
      {
        // Compose the full non-local F-bar PK1 perturbation:
        //   deltasigma_NL = D_nl[qp] * (_d_F_d_grad_u[qp] * _avg_grad_trial[beta][j])
        //   deltaPK1_NL = det(F_ust) * deltasigma_NL * F_ust^{-T}   (large kinematics)
        //           = deltasigma_NL                              (small kinematics)
        // D_nl (`_d_nl_fbar`), det(F_ust), and F_ust^{-1} are all per-qp material properties
        // from the stress/strain materials -- no kernel-side cache.
        const RankTwoTensor delta_F_avg = dFdGU * _avg_grad_trial[beta][j];
        const RankTwoTensor delta_sigma_nl = (*_d_nl_fbar)[qp] * delta_F_avg;
        if (_large_kinematics)
          _delta_PK1_NL_cache[qp][j] =
              (*_F_ust_det)[qp] * delta_sigma_nl * (*_F_ust_inv)[qp].transpose();
        else
          _delta_PK1_NL_cache[qp][j] = delta_sigma_nl;
        // Local + non-local PK1 derivative: the single tensor the disp Jacobian contracts against.
        _dpk1_total_cache[qp][j] = _dpk1_grad_trial_cache[qp][j] + _delta_PK1_NL_cache[qp][j];
      }
      // dA/dU = [ (dPK1_local + dPK1_NL) : F_ust + pk1 : dF_ust ] / 3, all per (qp, j).
      if (bbar)
        _dA_dU_cache[qp][j] = (_dpk1_total_cache[qp][j].doubleContraction(_F_ust[qp]) +
                               _pk1[qp].doubleContraction(_grad_trial_cache[qp][j])) /
                              3.0;
    }
  }
}

precalculateJacobian()

template<class G >

void TotalLagrangianStressDivergenceBase< G >::precalculateJacobian ( )

overrideprotectedvirtual

Reimplemented from LagrangianStressDivergenceBase.

Reimplemented in TotalLagrangianWeakPlaneStress.

Definition at line 118 of file TotalLagrangianStressDivergenceBase.C.

{
  LagrangianStressDivergenceBase::precalculateJacobian();
  // Populate the per-(qp, j) local PK1 chain cache for the diagonal column (beta = _alpha).
  // Runs regardless of `_stabilize_strain` because the local chain is always needed; the
  // helper itself only touches `_avg_grad_trial` when stab is on.
  populateLocalPK1Cache(_alpha);
  if (_stabilize_strain && _F_bar_mode == FBarMode::Incremental)
  {
    computeAverageGradientSpatialTest();
    computeAverageGradientSpatialPhi(_alpha);
    computeAvgTestPhiCross(_alpha);
  }
}

precalculateJacobianDisplacement()

template<class G >

void TotalLagrangianStressDivergenceBase< G >::precalculateJacobianDisplacement ( unsigned int  component )

overrideprotectedvirtual

Prepare the average shape function gradients for stabilization.

Implements LagrangianStressDivergenceBase.

Definition at line 63 of file TotalLagrangianStressDivergenceBase.C.

Referenced by HomogenizedTotalLagrangianStressDivergence::computeScalarOffDiagJacobian().

{
  // For total Lagrangian, the averaging is taken on the reference frame regardless of geometric
  // nonlinearity. The stored quantity is what the strain calc's `_d_F_stab_d_F_avg` contracts
  // with: deltaF_avg in `F_bar_mode = total`, deltaf_avg in `F_bar_mode = incremental`.
  //   total:        avg_q(grad_phi[j][q])           -> deltaF_avg per DOF
  //   incremental:  avg_q(grad_phi[j][q] * F_ust_old[q]^{-1})
  //                                                  -> deltaf_avg per DOF
  //                 (since f_ust = F_ust * F_ust_old^{-1} and F_ust_old is fixed w.r.t. the
  //                  current Newton iterate's disp, so deltaf_ust = deltaF_ust * F_ust_old^{-1}).
  const bool incremental = (_F_bar_mode == FBarMode::Incremental);
  // F_ust_old[qp]^{-1} depends only on qp, but the average below runs once per trial DOF j.
  // Precompute the per-qp inverse once instead of re-inverting the 3x3 for every (qp, j).
  std::vector<RankTwoTensor> f_ust_old_inv;
  if (incremental)
  {
    f_ust_old_inv.resize(_qrule->n_points());
    for (const auto qp : make_range(_qrule->n_points()))
      f_ust_old_inv[qp] = _F_ust_old[qp].inverse();
  }
  for (auto j : make_range(_phi.size()))
    _avg_grad_trial[component][j] = StabilizationUtils::elementAverage(
        [this, component, j, incremental, &f_ust_old_inv](unsigned int qp)
        {
          const RankTwoTensor g = G::gradOp(component, _grad_phi[j][qp], _phi[j][qp], _q_point[qp]);
          return incremental ? g * f_ust_old_inv[qp] : g;
        },
        _JxW,
        _coord);
}

precalculateOffDiagJacobian()

template<class G >

void TotalLagrangianStressDivergenceBase< G >::precalculateOffDiagJacobian ( unsigned int  jvar )

overrideprotectedvirtual

Reimplemented from LagrangianStressDivergenceBase.

Definition at line 135 of file TotalLagrangianStressDivergenceBase.C.

{
  LagrangianStressDivergenceBase::precalculateOffDiagJacobian(jvar);
  // Populate the per-(qp, j) local PK1 chain cache for the matched off-diagonal beta.
  for (auto beta : make_range(_ndisp))
    if (jvar == _disp_nums[beta])
    {
      populateLocalPK1Cache(beta);
      if (_stabilize_strain && _F_bar_mode == FBarMode::Incremental)
      {
        computeAverageGradientSpatialTest();
        computeAverageGradientSpatialPhi(beta);
        computeAvgTestPhiCross(beta);
      }
      break;
    }
}

precalculateResidual()

template<class G >

void TotalLagrangianStressDivergenceBase< G >::precalculateResidual ( )

overrideprotectedvirtual

Definition at line 96 of file TotalLagrangianStressDivergenceBase.C.

{
  LagrangianStressDivergenceBase::precalculateResidual();
  if (_stabilize_strain && _F_bar_mode == FBarMode::Incremental)
  {
    computeAverageGradientSpatialTest();
    cachePK1ContractionFUst();
  }
}

validParams() [1/4]

template<>

InputParameters TotalLagrangianStressDivergenceBase< GradientOperatorCartesian >::validParams ( )

inline

Definition at line 16 of file TotalLagrangianStressDivergence.h.

{
  InputParameters params = TotalLagrangianStressDivergenceBase::baseParams();
  params.addClassDescription(
      "Enforce equilibrium with a total Lagrangian formulation in Cartesian coordinates.");
  return params;
}

validParams() [2/4]

template<>

InputParameters TotalLagrangianStressDivergenceBase< GradientOperatorAxisymmetricCylindrical >::validParams ( )

inline

Definition at line 16 of file TotalLagrangianStressDivergenceAxisymmetricCylindrical.h.

{
  InputParameters params = TotalLagrangianStressDivergenceBase::baseParams();
  params.addClassDescription("Enforce equilibrium with a total Lagrangian formulation in "
                             "axisymmetric cylindrical coordinates.");
  return params;
}

validParams() [3/4]

template<>

InputParameters TotalLagrangianStressDivergenceBase< GradientOperatorCentrosymmetricSpherical >::validParams ( )

inline

Definition at line 16 of file TotalLagrangianStressDivergenceCentrosymmetricSpherical.h.

{
  InputParameters params = TotalLagrangianStressDivergenceBase::baseParams();
  params.addClassDescription("Enforce equilibrium with a total Lagrangian formulation in "
                             "centrosymmetric spherical coordinates.");
  return params;
}

validParams() [4/4]

template<class G >

static InputParameters TotalLagrangianStressDivergenceBase< G >::validParams ( )

static

Referenced by TotalLagrangianWeakPlaneStress::validParams().

Member Data Documentation

_alpha

const unsigned int LagrangianStressDivergenceBase::_alpha

protectedinherited

Which component of the vector residual this kernel is responsible for.

Definition at line 109 of file LagrangianStressDivergenceBase.h.

Referenced by LagrangianStressDivergenceBase::computeQpJacobian(), LagrangianStressDivergenceBase::computeQpOffDiagJacobian(), HomogenizedTotalLagrangianStressDivergence::computeQpOffDiagJacobianScalar(), HomogenizedTotalLagrangianStressDivergence::computeScalarJacobian(), HomogenizedTotalLagrangianStressDivergence::computeScalarOffDiagJacobian(), HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian(), HomogenizedTotalLagrangianStressDivergence::computeScalarResidual(), and LagrangianStressDivergenceBase::precalculateJacobian().

_avg_grad_spatial_phi

std::vector<std::vector<Real> > LagrangianStressDivergenceBase::_avg_grad_spatial_phi

protectedinherited

Element-averaged spatial gradient of trial functions per component: _avg_grad_spatial_phi[component][j] = (1/V_x) int_e (grad_x phi_j)_component dV_x Populated alongside _avg_grad_spatial_test for the Jacobian's B-bar contribution.

Definition at line 134 of file LagrangianStressDivergenceBase.h.

_avg_grad_spatial_test

std::vector<Real> LagrangianStressDivergenceBase::_avg_grad_spatial_test

protectedinherited

Element-averaged spatial (deformed-frame) gradient of test functions for the kernel's component _alpha: _avg_grad_spatial_test[i] = (1/V_x) int_e (grad_x test_i)_alpha dV_x Used for OLD-compat B-bar volumetric correction in F_bar_mode = incremental.

Populated by the TL kernel's precalculateResidual / precalculateJacobian overrides when _stabilize_strain == true. The trial-function analog is published per (component, j) in _avg_grad_spatial_phi and used by the Jacobian.

Definition at line 129 of file LagrangianStressDivergenceBase.h.

_avg_grad_trial

std::vector<std::vector<RankTwoTensor> > LagrangianStressDivergenceBase::_avg_grad_trial

protectedinherited

Definition at line 120 of file LagrangianStressDivergenceBase.h.

Referenced by TotalLagrangianWeakPlaneStress::computeQpOffDiagJacobian(), HomogenizedTotalLagrangianStressDivergence::computeScalarOffDiagJacobian(), HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian(), LagrangianStressDivergenceBase::precalculateJacobian(), and LagrangianStressDivergenceBase::precalculateOffDiagJacobian().

_avg_test_phi_cross

std::vector<std::vector<std::vector<std::vector<Real> > > > LagrangianStressDivergenceBase::_avg_test_phi_cross

protectedinherited

Element-averaged cross product (on displaced mesh) of spatial test/trial gradients: avg_test_phi_cross[b1][b2][i][j] = (1/V_x) int_e (grad_x test_i){b1} * (grad_x phi_j)_{b2} dV_x Indexed by [b1][b2] in {0,1,2}^2.

Only the (b1, b2) entries needed for the current Jacobian call are populated by the TL kernel's computeAvgTestPhiCross(beta) helper. Used for the B-bar Jacobian's non-local term (d(avg_grad_spatial_test)/dU).

Definition at line 141 of file LagrangianStressDivergenceBase.h.

_base_name

const std::string LagrangianStressDivergenceBase::_base_name

protectedinherited

Prepend to the material properties.

Definition at line 106 of file LagrangianStressDivergenceBase.h.

Referenced by LagrangianStressDivergenceBase::initialSetup(), and LagrangianStressDivergenceBase::LagrangianStressDivergenceBase().

_d_deformation_gradient_increment_d_F

const MaterialProperty<RankFourTensor>& LagrangianStressDivergenceBase::_d_deformation_gradient_increment_d_F

protectedinherited

Derivative of the spatial velocity gradient increment w.r.t. F_{n+1}.

Definition at line 177 of file LagrangianStressDivergenceBase.h.

_d_F_d_grad_u

const MaterialProperty<RankFourTensor>& LagrangianStressDivergenceBase::_d_F_d_grad_u

protectedinherited

Derivative of F_{n+1} w.r.t. the displacement gradient.

Definition at line 180 of file LagrangianStressDivergenceBase.h.

Referenced by TotalLagrangianWeakPlaneStress::computeQpOffDiagJacobian(), and HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian().

_d_F_stab_d_F_avg

const MaterialProperty<RankFourTensor>& LagrangianStressDivergenceBase::_d_F_stab_d_F_avg

protectedinherited

Definition at line 190 of file LagrangianStressDivergenceBase.h.

Referenced by HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian().

_d_F_stab_d_F_ust

const MaterialProperty<RankFourTensor>& LagrangianStressDivergenceBase::_d_F_stab_d_F_ust

protectedinherited

Partials of the F-bar-stabilized deformation gradient.

Used by the UL kernel to assemble the F-bar Jacobian contribution. For F-bar off, _d_F_stab_d_F_ust = I^(4) and _d_F_stab_d_F_avg = 0, so the kernel chain reduces to the unstabilized case. TL also uses _d_F_stab_d_F_avg directly for the non-local F-bar Jacobian contribution to PK1 (since after the F_ust-wrap architectural change PK1 = det(F_ust) sigma F_ust^{-T} no longer contains the non-local F-bar effect – it has to enter through the sigma-via-dL chain explicitly).

Definition at line 189 of file LagrangianStressDivergenceBase.h.

Referenced by HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian().

_d_nl_fbar

const MaterialProperty<RankFourTensor>* LagrangianStressDivergenceBase::_d_nl_fbar = nullptr

protectedinherited

Composed non-local F-bar operator D_nl = cauchy_jac : d(dL)/dF : d(F_stab)/d(F_avg), published per qp by the stress material (once per element, shared by all displacement kernels).

deltaPK1NonLocalFBar(deltaF_avg) collapses to one R4*R2 contraction against it. Fetched only when _stabilize_strain (nullptr otherwise).

Definition at line 212 of file LagrangianStressDivergenceBase.h.

Referenced by LagrangianStressDivergenceBase::LagrangianStressDivergenceBase().

_dA_dU_cache

template<class G >

std::vector<std::vector<Real> > TotalLagrangianStressDivergenceBase< G >::_dA_dU_cache

private

d(pk1 : F_ust)/dU per (qp, j) for the current column – the B-bar Jacobian's dA/dU term.

Depends on (qp, j) and the column beta, so it is hoisted out of the per-(_i, _j) loop into populateLocalPK1Cache. Populated only when F_bar_mode = incremental.

Definition at line 142 of file TotalLagrangianStressDivergenceBase.h.

_dcauchy_stress_d_eigenstrain

const MaterialProperty<RankFourTensor>* LagrangianStressDivergenceBase::_dcauchy_stress_d_eigenstrain = nullptr

protectedinherited

Derivative of the Cauchy stress with respect to the eigenstrain (published by ComputeLagrangianObjectiveStress; can be overridden by other Cauchy-providing materials).

Only fetched when eigenstrains are coupled, since only the temperature off-diagonal Jacobian needs it. Will be nullptr otherwise; subclasses that consume it must guard accordingly.

Definition at line 206 of file LagrangianStressDivergenceBase.h.

Referenced by LagrangianStressDivergenceBase::LagrangianStressDivergenceBase().

_deigenstrain_dargs

std::vector<std::vector<const MaterialProperty<RankTwoTensor> *> > LagrangianStressDivergenceBase::_deigenstrain_dargs

protectedinherited

Eigenstrain derivatives wrt generate coupleds.

Definition at line 199 of file LagrangianStressDivergenceBase.h.

Referenced by LagrangianStressDivergenceBase::LagrangianStressDivergenceBase().

_delta_PK1_NL_cache

template<class G >

std::vector<std::vector<RankTwoTensor> > TotalLagrangianStressDivergenceBase< G >::_delta_PK1_NL_cache

private

Fully wrapped non-local F-bar contribution to deltaPK1 per (qp, j) for the current column: _d_nl_fbar[qp] * (_d_F_d_grad_u[qp] * _avg_grad_trial[beta][j]) then PK1-wrapped via the strain calc's det(F_ust) / F_ust^{-1} properties in large kinematics.

Populated only when _stabilize_strain == true; replaces the per-call deltaPK1NonLocalFBar(...) invocation in TL's displacement Jacobian.

Definition at line 127 of file TotalLagrangianStressDivergenceBase.h.

_disp_nums

std::vector<unsigned int> LagrangianStressDivergenceBase::_disp_nums

protectedinherited

The displacement numbers.

Definition at line 115 of file LagrangianStressDivergenceBase.h.

Referenced by TotalLagrangianWeakPlaneStress::computeQpOffDiagJacobian(), LagrangianStressDivergenceBase::computeQpOffDiagJacobian(), LagrangianStressDivergenceBase::LagrangianStressDivergenceBase(), and LagrangianStressDivergenceBase::precalculateOffDiagJacobian().

_dpk1

template<class G >

const MaterialProperty<RankFourTensor>& TotalLagrangianStressDivergenceBase< G >::_dpk1

protected

The derivative of the PK1 stress with respect to the deformation gradient (F that the stress material consumed, i.e.

the alpha-weighted F under the generalized midpoint rule). Used by the homogenization macro-var Jacobian path, which couples to F directly.

Definition at line 76 of file TotalLagrangianStressDivergenceBase.h.

Referenced by TotalLagrangianWeakPlaneStress::computeQpOffDiagJacobian(), and HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian().

_dpk1_bypass_fbar

template<class G >

const MaterialProperty<RankFourTensor>& TotalLagrangianStressDivergenceBase< G >::_dpk1_bypass_fbar

protected

Variant of _dpk1 (= pk1_jacobian) computed WITHOUT the F-bar chain factor _d_F_stab_d_F_ust in the sigma-via-dL contribution.

Used for coupled variables that add to _F AFTER F-bar runs (out-of-plane strain in WPS, homogenization macro_grad) – those perturbations bypass F-bar's chain, so the sigma side of dPK1/d(F_ust) must NOT include the F-bar local correction.

Definition at line 89 of file TotalLagrangianStressDivergenceBase.h.

Referenced by TotalLagrangianWeakPlaneStress::computeQpJacobian(), HomogenizedTotalLagrangianStressDivergence::computeQpOffDiagJacobianScalar(), and HomogenizedTotalLagrangianStressDivergence::computeScalarJacobian().

_dpk1_d_grad_u

template<class G >

const MaterialProperty<RankFourTensor>& TotalLagrangianStressDivergenceBase< G >::_dpk1_d_grad_u

protected

The derivative of the PK1 stress with respect to the displacement gradient (grad u_{n+1}).

Equals _dpk1 * _d_F_d_grad_u, populated in ComputeLagrangianStressBase::computeQpProperties. Used by the TL displacement Jacobian so the kernel does not need to know about the generalized-alpha kinematic policy.

Definition at line 82 of file TotalLagrangianStressDivergenceBase.h.

_dpk1_grad_trial_cache

template<class G >

std::vector<std::vector<RankTwoTensor> > TotalLagrangianStressDivergenceBase< G >::_dpk1_grad_trial_cache

private

_dpk1_d_grad_u[qp] * gradTrial(beta) per (qp, j) for the current Jacobian column's beta.

Used by the main local PK1 chain and (in F_bar_mode = incremental) the B-bar Jacobian's local PK1 derivative – gradTrial == gradTrialUnstabilized in TL so a single cache covers both consumers.

Definition at line 115 of file TotalLagrangianStressDivergenceBase.h.

_dpk1_total_cache

template<class G >

std::vector<std::vector<RankTwoTensor> > TotalLagrangianStressDivergenceBase< G >::_dpk1_total_cache

private

Local + non-local PK1 derivative per (qp, j): _dpk1_grad_trial_cache + _delta_PK1_NL_cache.

The displacement Jacobian contracts gradTest against this single tensor instead of the local and non-local pieces separately, halving the per-(_i, _j) double contractions. Populated only when _stabilize_strain == true (otherwise the Jacobian uses the local cache).

Definition at line 133 of file TotalLagrangianStressDivergenceBase.h.

_F

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F

protectedinherited

The actual (stabilized) deformation gradient.

With the generalized midpoint rule this is the alpha-weighted F, NOT the literal F at n+1.

Definition at line 170 of file LagrangianStressDivergenceBase.h.

Referenced by HomogenizedTotalLagrangianStressDivergence::computeScalarResidual().

_F_actual

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F_actual

protectedinherited

The literal deformation gradient at n+1 (I + grad u_{n+1}), independent of alpha and F-bar.

Used by the UL kernel to convert spatial gradients to reference-frame gradients.

Definition at line 174 of file LagrangianStressDivergenceBase.h.

_F_avg

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F_avg

protectedinherited

The element-average deformation gradient.

Definition at line 152 of file LagrangianStressDivergenceBase.h.

_F_bar_mode

const FBarMode LagrangianStressDivergenceBase::_F_bar_mode

protectedinherited

What F gets F-bar volumetric correction (Total vs.

Incremental). Must match the strain calc's F_bar_mode. Incremental mode changes how _avg_grad_trial is computed so the non-local F-bar chain captures deltaf_avg (= avg of deltaF_ust * F_ust_old^{-1}) instead of deltaF_avg.

Definition at line 103 of file LagrangianStressDivergenceBase.h.

Referenced by UpdatedLagrangianStressDivergenceBase< G >::UpdatedLagrangianStressDivergenceBase().

_f_inv

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_f_inv

protectedinherited

The inverse increment deformation gradient.

Definition at line 155 of file LagrangianStressDivergenceBase.h.

_F_inv

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F_inv

protectedinherited

The inverse deformation gradient.

Definition at line 158 of file LagrangianStressDivergenceBase.h.

_F_ust

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F_ust

protectedinherited

The unmodified deformation gradient.

Definition at line 144 of file LagrangianStressDivergenceBase.h.

_F_ust_det

const MaterialProperty<Real>* LagrangianStressDivergenceBase::_F_ust_det = nullptr

protectedinherited

Definition at line 166 of file LagrangianStressDivergenceBase.h.

Referenced by LagrangianStressDivergenceBase::deltaPK1NonLocalFBar(), and LagrangianStressDivergenceBase::LagrangianStressDivergenceBase().

_F_ust_inv

const MaterialProperty<RankTwoTensor>* LagrangianStressDivergenceBase::_F_ust_inv = nullptr

protectedinherited

F_ust^{-1} and det(F_ust) from the strain calculator, consumed by the F-bar spatial push-forward (grad_x = F_ust^{-T} grad_X, J_ust = det F_ust) on both the residual and Jacobian sweeps.

Fetched only when _stabilize_strain (nullptr otherwise). The strain material computes them once per qp (shared by all displacement kernels), replacing the former per-kernel F_ust-inverse/det cache and the per-test/trial recomputation.

Definition at line 165 of file LagrangianStressDivergenceBase.h.

Referenced by LagrangianStressDivergenceBase::LagrangianStressDivergenceBase().

_F_ust_old

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F_ust_old

protectedinherited

Old unstabilized deformation gradient.

Only consulted in F_bar_mode = incremental for the kernel's element-average of grad_phi * F_ust_old^{-1}. Always fetched (cheap) so the kernel doesn't need conditional property bookkeeping.

Definition at line 149 of file LagrangianStressDivergenceBase.h.

_grad_trial_cache

template<class G >

std::vector<std::vector<RankTwoTensor> > TotalLagrangianStressDivergenceBase< G >::_grad_trial_cache

private

Cached gradTrialUnstabilized(beta) per (qp, j) for the current column.

Used by the B-bar Jacobian branch (F_bar_mode = incremental). Cheap to store and avoids the per-(_i, _j) G::gradOp call.

Definition at line 120 of file TotalLagrangianStressDivergenceBase.h.

_large_kinematics

bool LagrangianStressDivergenceBase::_large_kinematics

protectedinherited

If true use large deformation kinematics.

Derived in initialSetup() from the strain calculator's LARGE_KINEMATICS guarantee (single source of truth); the kernel's own large_kinematics parameter is deprecated.

Definition at line 95 of file LagrangianStressDivergenceBase.h.

Referenced by HomogenizedTotalLagrangianStressDivergence::computeScalarJacobian(), HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian(), HomogenizedTotalLagrangianStressDivergence::computeScalarResidual(), LagrangianStressDivergenceBase::deltaPK1NonLocalFBar(), and LagrangianStressDivergenceBase::initialSetup().

_ndisp

const unsigned int LagrangianStressDivergenceBase::_ndisp

protectedinherited

Total number of displacements/size of residual vector.

Definition at line 112 of file LagrangianStressDivergenceBase.h.

Referenced by TotalLagrangianWeakPlaneStress::computeQpOffDiagJacobian(), LagrangianStressDivergenceBase::computeQpOffDiagJacobian(), LagrangianStressDivergenceBase::LagrangianStressDivergenceBase(), and LagrangianStressDivergenceBase::precalculateOffDiagJacobian().

_out_of_plane_strain

const MooseVariable* LagrangianStressDivergenceBase::_out_of_plane_strain

protectedinherited

Out-of-plane strain, if provided.

Definition at line 196 of file LagrangianStressDivergenceBase.h.

Referenced by LagrangianStressDivergenceBase::computeQpOffDiagJacobian(), and UpdatedLagrangianStressDivergenceBase< G >::UpdatedLagrangianStressDivergenceBase().

_pk1

template<class G >

const MaterialProperty<RankTwoTensor>& TotalLagrangianStressDivergenceBase< G >::_pk1

protected

The 1st Piola-Kirchhoff stress.

Definition at line 71 of file TotalLagrangianStressDivergenceBase.h.

Referenced by TotalLagrangianWeakPlaneStress::computeQpResidual(), and HomogenizedTotalLagrangianStressDivergence::computeScalarResidual().

_pk1_ddot_F_ust

template<class G >

std::vector<Real> TotalLagrangianStressDivergenceBase< G >::_pk1_ddot_F_ust

private

pk1 : F_ust per qp for the B-bar volumetric correction (see cachePK1ContractionFUst).

Populated only when F_bar_mode = incremental.

Definition at line 137 of file TotalLagrangianStressDivergenceBase.h.

_stabilize_strain

const bool LagrangianStressDivergenceBase::_stabilize_strain

protectedinherited

If true calculate the deformation gradient derivatives for F_bar.

Definition at line 98 of file LagrangianStressDivergenceBase.h.

Referenced by TotalLagrangianWeakPlaneStress::computeQpOffDiagJacobian(), HomogenizedTotalLagrangianStressDivergence::computeScalarOffDiagJacobian(), HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian(), LagrangianStressDivergenceBase::deltaPK1NonLocalFBar(), LagrangianStressDivergenceBase::LagrangianStressDivergenceBase(), LagrangianStressDivergenceBase::precalculateJacobian(), LagrangianStressDivergenceBase::precalculateOffDiagJacobian(), and UpdatedLagrangianStressDivergenceBase< G >::UpdatedLagrangianStressDivergenceBase().

_temperature

const MooseVariable* LagrangianStressDivergenceBase::_temperature

protectedinherited

Temperature, if provided. This is used only to get the trial functions.

Definition at line 193 of file LagrangianStressDivergenceBase.h.

Referenced by LagrangianStressDivergenceBase::computeQpOffDiagJacobian().

---

The documentation for this class was generated from the following files:

• solid_mechanics/include/kernels/lagrangian/TotalLagrangianStressDivergenceBase.h
• solid_mechanics/src/kernels/lagrangian/TotalLagrangianStressDivergenceBase.C