#include <TotalLagrangianWeakPlaneStress.h>

Inheritance diagram for TotalLagrangianWeakPlaneStress:

Public Types
enum class	FBarMode { Total , Incremental }
	Mirrors `ComputeLagrangianStrainBase::FBarMode`. More...

typedef std::vector< int >	JvarMap

Public Member Functions
	TotalLagrangianWeakPlaneStress (const InputParameters &parameters)

virtual void	initialSetup () override
	Derive `_large_kinematics` from the strain calculator's LARGE_KINEMATICS guarantee.

void	initialSetup ()
	Derive `_large_kinematics` from the strain calculator's LARGE_KINEMATICS guarantee.

void	initialSetup ()
	Derive `_large_kinematics` from the strain calculator's LARGE_KINEMATICS guarantee.

void	initialSetup ()
	Derive `_large_kinematics` from the strain calculator's LARGE_KINEMATICS guarantee.

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	validParams ()

static InputParameters	baseParams ()

Protected Member Functions
virtual void	precalculateJacobian () override

virtual Real	computeQpResidual () override

virtual Real	computeQpJacobian () override

virtual Real	computeQpOffDiagJacobian (unsigned int jvar) override

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.

virtual void	precalculateResidual () override

virtual void	precalculateOffDiagJacobian (unsigned int jvar) 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`.

void	computeAverageGradientSpatialPhi (unsigned int beta)
	Compute element-averaged spatial gradient of trial functions for component `beta`, filling `_avg_grad_spatial_phi[beta]`.

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]`.

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.

Real	gradXPhiComponent (unsigned int component) const
	(grad_x phi_j)_component at the current `_qp`, same push-forward as `gradXTestComponent`.

virtual RankTwoTensor	gradTrialUnstabilized (unsigned int component)
	The unstabilized trial function gradient.

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.

bool	hasGuaranteedMaterialProperty (const MaterialPropertyName &prop, Guarantee guarantee)

Protected Attributes
const MaterialProperty< RankTwoTensor > &	_pk1
	The 1st Piola-Kirchhoff stress.

const MaterialProperty< RankFourTensor > &	_dpk1
	The derivative of the PK1 stress with respect to the deformation gradient (F that the stress material consumed, i.e.

const MaterialProperty< RankFourTensor > &	_dpk1_d_grad_u
	The derivative of the PK1 stress with respect to the displacement gradient (grad u_{n+1}).

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.

bool	_large_kinematics
	If true use large deformation kinematics.

const bool	_stabilize_strain
	If true calculate the deformation gradient derivatives for F_bar.

const FBarMode	_F_bar_mode
	What F gets F-bar volumetric correction (Total vs.

const std::string	_base_name
	Prepend to the material properties.

const unsigned int	_alpha
	Which component of the vector residual this kernel is responsible for.

const unsigned int	_ndisp
	Total number of displacements/size of residual vector.

std::vector< unsigned int >	_disp_nums
	The displacement numbers.

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`.

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.

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.

const MaterialProperty< RankTwoTensor > &	_F_ust
	The unmodified deformation gradient.

const MaterialProperty< RankTwoTensor > &	_F_ust_old
	Old unstabilized deformation gradient.

const MaterialProperty< RankTwoTensor > &	_F_avg
	The element-average deformation gradient.

const MaterialProperty< RankTwoTensor > &	_f_inv
	The inverse increment deformation gradient.

const MaterialProperty< RankTwoTensor > &	_F_inv
	The inverse deformation gradient.

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.

const MaterialProperty< Real > *	_F_ust_det = nullptr

const MaterialProperty< RankTwoTensor > &	_F
	The actual (stabilized) deformation gradient.

const MaterialProperty< RankTwoTensor > &	_F_actual
	The literal deformation gradient at n+1 (I + grad u_{n+1}), independent of alpha and F-bar.

const MaterialProperty< RankFourTensor > &	_d_deformation_gradient_increment_d_F
	Derivative of the spatial velocity gradient increment w.r.t. F_{n+1}.

const MaterialProperty< RankFourTensor > &	_d_F_d_grad_u
	Derivative of F_{n+1} w.r.t. the displacement gradient.

const MaterialProperty< RankFourTensor > &	_d_F_stab_d_F_ust
	Partials of the F-bar-stabilized deformation gradient.

const MaterialProperty< RankFourTensor > &	_d_F_stab_d_F_avg

const MooseVariable *	_temperature
	Temperature, if provided. This is used only to get the trial functions.

const MooseVariable *	_out_of_plane_strain
	Out-of-plane strain, if provided.

std::vector< std::vector< const MaterialProperty< RankTwoTensor > * > >	_deigenstrain_dargs
	Eigenstrain derivatives wrt generate coupleds.

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).

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).

const unsigned int	_n_args

Private Member Functions
void	populateLocalPK1Cache (unsigned int beta)
	Populate the per-(qp, j) caches consumed by `computeQpJacobianDisplacement`.

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

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.

std::vector< std::vector< RankTwoTensor > >	_grad_trial_cache
	Cached `gradTrialUnstabilized(beta)` per (qp, j) for the current column.

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.

std::vector< std::vector< RankTwoTensor > >	_dpk1_total_cache
	Local + non-local PK1 derivative per (qp, j): `_dpk1_grad_trial_cache + _delta_PK1_NL_cache`.

std::vector< Real >	_pk1_ddot_F_ust
	`pk1 : F_ust` per qp for the B-bar volumetric correction (see `cachePK1ContractionFUst`).

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.

const std::size_t	_jvar_max_size

JvarMap	_jvar_map

std::map< std::string, JvarMap >	_jvar_local_map

const InputParameters &	_gc_params
	Parameters of the object with this interface.

FEProblemBase *const	_gc_feproblem
	Reference to the FEProblemBase class.

BlockRestrictable *const	_gc_block_restrict
	Access block restrictions of the object with this interface.

Detailed Description

Definition at line 14 of file TotalLagrangianWeakPlaneStress.h.

Member Enumeration Documentation

◆ FBarMode

enum class 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

◆ TotalLagrangianWeakPlaneStress()

TotalLagrangianWeakPlaneStress::TotalLagrangianWeakPlaneStress ( const InputParameters & parameters )

Definition at line 27 of file TotalLagrangianWeakPlaneStress.C.

  : TotalLagrangianStressDivergence(parameters)
{
}

Member Function Documentation

◆ baseParams()

template<class G >

InputParameters TotalLagrangianStressDivergenceBase< G >::baseParams ( )

staticinherited

Definition at line 14 of file TotalLagrangianStressDivergenceBase.C.

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

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

◆ cachePK1ContractionFUst()

template<class G >

void TotalLagrangianStressDivergenceBase< G >::cachePK1ContractionFUst ( )

privateinherited

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 )

protectedinherited

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 ( )

protectedinherited

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 )

protectedinherited

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 TotalLagrangianWeakPlaneStress::computeQpJacobian ( )

overrideprotectedvirtual

Reimplemented from LagrangianStressDivergenceBase.

Definition at line 39 of file TotalLagrangianWeakPlaneStress.C.

{
  // Diagonal Jacobian: d(R_zz)/d(strain_zz_j) = test * d(PK1_{2,2})/d(strain_zz_j).
  // strain_zz feeds `_F[(2,2)]` AFTER F-bar runs, so strain_zz perturbations bypass
  // F-bar's chain. Use `_dpk1_bypass_fbar` (pk1_jacobian with the F-bar
  // `_d_F_stab_d_F_ust` factor REPLACED by identity in the sigma chain) for consistency.
  return _test[_i][_qp] * _dpk1_bypass_fbar[_qp](2, 2, 2, 2) * _phi[_j][_qp];
}

◆ computeQpJacobianDisplacement()

template<class G >

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

overrideprotectedvirtualinherited

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 ( )

overrideprotectedvirtualinherited

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 )

overrideprotectedvirtualinherited

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 TotalLagrangianWeakPlaneStress::computeQpOffDiagJacobian ( unsigned int jvar )

overrideprotectedvirtual

Reimplemented from LagrangianStressDivergenceBase.

Definition at line 49 of file TotalLagrangianWeakPlaneStress.C.

{
  for (auto beta : make_range(_ndisp))
    if (jvar == _disp_nums[beta])
    {
      // Local PK1_{2,2} Jacobian via _dpk1 (includes local F-bar through the sigma chain).
      // Displacement perturbations DO go through F-bar's chain, so use the regular
      // `_dpk1` (= pk1_jacobian WITH the F-bar local correction).
      Real J = _test[_i][_qp] * _dpk1[_qp].contractionIj(2, 2, gradTrial(beta));
 
      // Non-local F-bar contribution to PK1_{2,2}; helper handles the sigma-via-dL chain and
      // the wrap branch. Guarded on `_stabilize_strain` because `_avg_grad_trial` is only
      // populated when F-bar is on.
      if (_stabilize_strain)
      {
        const RankTwoTensor delta_F_avg = _d_F_d_grad_u[_qp] * _avg_grad_trial[beta][_j];
        J += _test[_i][_qp] * deltaPK1NonLocalFBar(delta_F_avg)(2, 2);
      }
      return J;
    }
 
  return 0;
}

◆ computeQpResidual()

Real TotalLagrangianWeakPlaneStress::computeQpResidual ( )

overrideprotectedvirtual

Reimplemented from TotalLagrangianStressDivergenceBase< G >.

Definition at line 33 of file TotalLagrangianWeakPlaneStress.C.

{
  return _test[_i][_qp] * _pk1[_qp](2, 2);
}

◆ 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.

{
  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;
}

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

◆ gradTest()

template<class G >

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

overrideprotectedvirtualinherited

Implements LagrangianStressDivergenceBase.

Definition at line 36 of file TotalLagrangianStressDivergenceBase.C.

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

Referenced by HomogenizedTotalLagrangianStressDivergence::computeQpOffDiagJacobianScalar().

◆ gradTrial()

template<class G >

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

overrideprotectedvirtualinherited

Implements LagrangianStressDivergenceBase.

Definition at line 44 of file TotalLagrangianStressDivergenceBase.C.

{
  // 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);
}

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

◆ gradTrialUnstabilized()

template<class G >

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

protectedvirtualinherited

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.

{
  // 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]);
}

Referenced by HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian().

◆ gradXPhiComponent()

template<class G >

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

protectedinherited

(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

protectedinherited

(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.

{
  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;
}

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

◆ initialSetup() [1/4]

void TotalLagrangianStressDivergenceBase< GradientOperatorCartesian >::initialSetup ( )

inlinevirtualinherited

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]

void TotalLagrangianStressDivergenceBase< GradientOperatorAxisymmetricCylindrical >::initialSetup ( )

virtualinherited

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]

void TotalLagrangianStressDivergenceBase< GradientOperatorCentrosymmetricSpherical >::initialSetup ( )

virtualinherited

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 ( )

overridevirtualinherited

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 )

privateinherited

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()

virtual void TotalLagrangianWeakPlaneStress::precalculateJacobian ( )

inlineoverrideprotectedvirtual

Reimplemented from TotalLagrangianStressDivergenceBase< G >.

Definition at line 22 of file TotalLagrangianWeakPlaneStress.h.

22{}

◆ precalculateJacobianDisplacement()

template<class G >

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

overrideprotectedvirtualinherited

Prepare the average shape function gradients for stabilization.

Implements LagrangianStressDivergenceBase.

Definition at line 63 of file TotalLagrangianStressDivergenceBase.C.

{
  // 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);
}

Referenced by HomogenizedTotalLagrangianStressDivergence::computeScalarOffDiagJacobian().

◆ precalculateOffDiagJacobian()

template<class G >

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

overrideprotectedvirtualinherited

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 ( )

overrideprotectedvirtualinherited

Definition at line 96 of file TotalLagrangianStressDivergenceBase.C.

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

◆ validParams()

InputParameters TotalLagrangianWeakPlaneStress::validParams ( )

static

Definition at line 15 of file TotalLagrangianWeakPlaneStress.C.

{
  InputParameters params = TotalLagrangianStressDivergence::validParams();
  params.addClassDescription("Plane stress kernel to provide out-of-plane strain contribution.");
  params.set<unsigned int>("component") = 0;
  params.suppressParameter<unsigned int>("component");
  params.suppressParameter<std::vector<VariableName>>("temperature");
  params.suppressParameter<std::vector<MaterialPropertyName>>("eigenstrain_names");
  params.suppressParameter<std::vector<VariableName>>("out_of_plane_strain");
  return params;
}

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.

◆ _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 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 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

privateinherited

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

privateinherited

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 LagrangianStressDivergenceBase::computeQpOffDiagJacobian(), computeQpOffDiagJacobian(), LagrangianStressDivergenceBase::LagrangianStressDivergenceBase(), and LagrangianStressDivergenceBase::precalculateOffDiagJacobian().

◆ _dpk1

template<class G >

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

protectedinherited

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 computeQpOffDiagJacobian(), and HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian().

◆ _dpk1_bypass_fbar

template<class G >

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

protectedinherited

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 computeQpJacobian(), HomogenizedTotalLagrangianStressDivergence::computeQpOffDiagJacobianScalar(), and HomogenizedTotalLagrangianStressDivergence::computeScalarJacobian().

◆ _dpk1_d_grad_u

template<class G >

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

protectedinherited

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

privateinherited

_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

privateinherited

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.

◆ _gc_block_restrict

BlockRestrictable* const GuaranteeConsumer::_gc_block_restrict

privateinherited

Access block restrictions of the object with this interface.

Definition at line 41 of file GuaranteeConsumer.h.

Referenced by GuaranteeConsumer::hasGuaranteedMaterialProperty().

◆ _gc_feproblem

FEProblemBase* const GuaranteeConsumer::_gc_feproblem

privateinherited

Reference to the FEProblemBase class.

Definition at line 38 of file GuaranteeConsumer.h.

Referenced by GuaranteeConsumer::hasGuaranteedMaterialProperty().

◆ _gc_params

const InputParameters& GuaranteeConsumer::_gc_params

privateinherited

Parameters of the object with this interface.

Definition at line 35 of file GuaranteeConsumer.h.

◆ _grad_trial_cache

template<class G >

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

privateinherited

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 LagrangianStressDivergenceBase::computeQpOffDiagJacobian(), 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

protectedinherited

The 1st Piola-Kirchhoff stress.

Definition at line 71 of file TotalLagrangianStressDivergenceBase.h.

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

◆ _pk1_ddot_F_ust

template<class G >

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

privateinherited

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.

◆ _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/TotalLagrangianWeakPlaneStress.h
solid_mechanics/src/kernels/lagrangian/TotalLagrangianWeakPlaneStress.C

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ FBarMode

Constructor & Destructor Documentation

◆ TotalLagrangianWeakPlaneStress()

Member Function Documentation

◆ baseParams()

◆ cachePK1ContractionFUst()

◆ computeAverageGradientSpatialPhi()

◆ computeAverageGradientSpatialTest()

◆ computeAvgTestPhiCross()

◆ computeQpJacobian()

◆ computeQpJacobianDisplacement()

◆ computeQpJacobianOutOfPlaneStrain()

◆ computeQpJacobianTemperature()

◆ computeQpOffDiagJacobian()

◆ computeQpResidual()

◆ deltaPK1NonLocalFBar()

◆ gradTest()

◆ gradTrial()

◆ gradTrialUnstabilized()

◆ gradXPhiComponent()

◆ gradXTestComponent()

◆ hasGuaranteedMaterialProperty()

◆ initialSetup() [1/4]

◆ initialSetup() [2/4]

◆ initialSetup() [3/4]

◆ initialSetup() [4/4]

◆ populateLocalPK1Cache()

◆ precalculateJacobian()

◆ precalculateJacobianDisplacement()

◆ precalculateOffDiagJacobian()

◆ precalculateResidual()

◆ validParams()

Member Data Documentation

◆ _alpha

◆ _avg_grad_spatial_phi

◆ _avg_grad_spatial_test

◆ _avg_grad_trial

◆ _avg_test_phi_cross

◆ _base_name

◆ _d_deformation_gradient_increment_d_F

◆ _d_F_d_grad_u

◆ _d_F_stab_d_F_avg

◆ _d_F_stab_d_F_ust

◆ _d_nl_fbar

◆ _dA_dU_cache

◆ _dcauchy_stress_d_eigenstrain

◆ _deigenstrain_dargs

◆ _delta_PK1_NL_cache

◆ _disp_nums

◆ _dpk1

◆ _dpk1_bypass_fbar

◆ _dpk1_d_grad_u

◆ _dpk1_grad_trial_cache

◆ _dpk1_total_cache

◆ _F

◆ _F_actual

◆ _F_avg

◆ _F_bar_mode

◆ _f_inv

◆ _F_inv

◆ _F_ust

◆ _F_ust_det

◆ _F_ust_inv

◆ _F_ust_old

◆ _gc_block_restrict

◆ _gc_feproblem

◆ _gc_params

◆ _grad_trial_cache

◆ _large_kinematics

◆ _ndisp

◆ _out_of_plane_strain