Total Lagrangian formulation with all homogenization terms (one disp_xyz field and macro_gradient scalar) More...

#include <HomogenizedTotalLagrangianStressDivergence.h>

Inheritance diagram for HomogenizedTotalLagrangianStressDivergence:

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

typedef std::vector< int >	JvarMap

Public Member Functions
	HomogenizedTotalLagrangianStressDivergence (const InputParameters &parameters)

virtual std::set< std::string >	additionalROVariables () override
	Inform moose that this kernel covers the constraint scalar variable. More...

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

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

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

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

static InputParameters	baseParams ()

Protected Member Functions
virtual void	computeScalarResidual () override
	Method for computing the scalar part of residual for _kappa. More...

virtual void	computeScalarJacobian () override
	Method for computing the scalar variable part of Jacobian for d-_kappa-residual / d-_kappa. More...

virtual void	computeScalarOffDiagJacobian (const unsigned int jvar_num) override
	Method for computing an off-diagonal jacobian component d-_kappa-residual / d-jvar. More...

virtual Real	computeScalarQpOffDiagJacobian (const unsigned int jvar_num) override
	Method for computing an off-diagonal jacobian component at quadrature points. More...

virtual void	computeOffDiagJacobianScalarLocal (const unsigned int svar_num) override
	Method for computing an off-diagonal jacobian component d-_var-residual / d-svar. More...

virtual Real	computeQpOffDiagJacobianScalar (const unsigned int svar_num) override
	Method for computing d-_var-residual / d-svar at quadrature points. More...

const Homogenization::ConstraintMap &	cmap () const
	Get the constraint map. More...

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 bool	_use_off_diagonal
	Whether to use the off diagonal term. More...

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 Attributes
unsigned int	_m
	Indices for off-diagonal Jacobian components. More...

unsigned int	_n

Homogenization::ConstraintType	_ctype = Homogenization::ConstraintType::None
	Type of current homogenization constraint. More...

Detailed Description

Total Lagrangian formulation with all homogenization terms (one disp_xyz field and macro_gradient scalar)

Definition at line 17 of file HomogenizedTotalLagrangianStressDivergence.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

◆ HomogenizedTotalLagrangianStressDivergence()

HomogenizedTotalLagrangianStressDivergence::HomogenizedTotalLagrangianStressDivergence ( const InputParameters & parameters )

Definition at line 33 of file HomogenizedTotalLagrangianStressDivergence.C.

   : HomogenizationInterface<TotalLagrangianStressDivergence>(parameters),
     _use_off_diagonal(getParam<bool>("off_diagonal_jacobian"))
 {
 }

Member Function Documentation

◆ additionalROVariables()

std::set< std::string > HomogenizedTotalLagrangianStressDivergence::additionalROVariables ( )

overridevirtual

Inform moose that this kernel covers the constraint scalar variable.

Definition at line 41 of file HomogenizedTotalLagrangianStressDivergence.C.

 {
   // Add the scalar variable to the list of variables that this kernel contributes to
   std::set<std::string> vars = TotalLagrangianStressDivergence::additionalROVariables();
   vars.insert(_kappa_var_ptr->name());
   return vars;
 }

◆ baseParams()

template<class G >

InputParameters TotalLagrangianStressDivergenceBase< G >::baseParams ( )

staticinherited

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

◆ cmap()

const Homogenization::ConstraintMap& HomogenizationInterface< TotalLagrangianStressDivergence >::cmap ( ) const

inlineprotectedinherited

Get the constraint map.

Definition at line 46 of file HomogenizationInterface.h.

Referenced by computeOffDiagJacobianScalarLocal(), computeScalarJacobian(), computeScalarOffDiagJacobian(), and computeScalarResidual().

46 { return _cmap; }

HomogenizationInterface< TotalLagrangianStressDivergence >::_cmap

Homogenization::ConstraintMap _cmap

Constraint map.

Definition: HomogenizationInterface.h:50

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

◆ computeOffDiagJacobianScalarLocal()

void HomogenizedTotalLagrangianStressDivergence::computeOffDiagJacobianScalarLocal ( const unsigned int svar_num )

overrideprotectedvirtual

Method for computing an off-diagonal jacobian component d-_var-residual / d-svar.

svar is looped over all scalar variables, which herein is just _kappa

Definition at line 208 of file HomogenizedTotalLagrangianStressDivergence.C.

 {
   if (!_use_off_diagonal)
     return;
 
   // Just in case, skip any other scalar variables
   if (svar_num != _kappa_var)
     return;
 
   _local_ke.resize(_test.size(), _k_order);
 
   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
   {
     unsigned int l = 0;
     const auto dV = _JxW[_qp] * _coord[_qp];
     for (const auto & [indices, constraint] : cmap())
     {
       // copy constraint indices to protected variables to pass to Qp routine
       std::tie(_m, _n) = indices;
       _ctype = constraint.first;
       initScalarQpJacobian(svar_num);
       for (_i = 0; _i < _test.size(); _i++)
         _local_ke(_i, l) += dV * computeQpOffDiagJacobianScalar(svar_num);
       l++;
     }
   }
 
   addJacobian(
       _assembly, _local_ke, _var.dofIndices(), _kappa_var_ptr->dofIndices(), _var.scalingFactor());
 }

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

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

◆ computeQpOffDiagJacobianScalar()

Real HomogenizedTotalLagrangianStressDivergence::computeQpOffDiagJacobianScalar ( const unsigned int svar_num )

overrideprotectedvirtual

Method for computing d-_var-residual / d-svar at quadrature points.

Definition at line 241 of file HomogenizedTotalLagrangianStressDivergence.C.

Referenced by computeOffDiagJacobianScalarLocal().

 {
   // d(disp residual) / d(scalar_{m,n}) = int gradTest_alpha : d(PK1)/d(scalar_{m,n}) dV.
   // The macro_gradient adds to `_F` AFTER F-bar runs (in
   // `ComputeLagrangianStrainBase::computeQpProperties`), so scalar 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).
   return _dpk1_bypass_fbar[_qp].contractionKl(_m, _n, gradTest(_alpha));
 }

◆ computeQpResidual()

template<class G >

Real TotalLagrangianStressDivergenceBase< G >::computeQpResidual ( )

overrideprotectedvirtualinherited

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

◆ computeScalarJacobian()

void HomogenizedTotalLagrangianStressDivergence::computeScalarJacobian ( )

overrideprotectedvirtual

Method for computing the scalar variable part of Jacobian for d-_kappa-residual / d-_kappa.

Definition at line 102 of file HomogenizedTotalLagrangianStressDivergence.C.

 {
   if (_alpha != 0)
     return;
 
   _local_ke.resize(_k_order, _k_order);
 
   // only assemble scalar residual once; i.e. when handling the first displacement component
   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
   {
     initScalarQpJacobian(_kappa_var);
     const auto dV = _JxW[_qp] * _coord[_qp];
 
     // index for Jacobian row
     unsigned int h = 0;
 
     for (const auto & [indices1, constraint1] : cmap())
     {
       const auto [i, j] = indices1;
       const auto ctype = constraint1.first;
 
       // index for Jacobian col
       unsigned int m = 0;
 
       for (const auto & [indices2, constraint2] : cmap())
       {
         const auto [k, l] = indices2;
         if (ctype == Homogenization::ConstraintType::Stress)
           // Macro_grad <-> macro_grad: scalar perturbation bypasses F-bar (the
           // homogenization material adds to `_F` AFTER F-bar runs), so use the
           // bypass variant of pk1_jacobian.
           _local_ke(h, m++) += dV * (_dpk1_bypass_fbar[_qp](i, j, k, l));
         else if (ctype == Homogenization::ConstraintType::Strain)
         {
           if (_large_kinematics)
             _local_ke(h, m++) += dV * (Real(i == k && j == l));
           else
             _local_ke(h, m++) += dV * (0.5 * Real(i == k && j == l) + 0.5 * Real(i == l && j == k));
         }
         else
           mooseError("Unknown constraint type in Jacobian calculator!");
       }
       h++;
     }
   }
 
   addJacobian(_assembly,
               _local_ke,
               _kappa_var_ptr->dofIndices(),
               _kappa_var_ptr->dofIndices(),
               _kappa_var_ptr->scalingFactor());
 }

◆ computeScalarOffDiagJacobian()

void HomogenizedTotalLagrangianStressDivergence::computeScalarOffDiagJacobian ( const unsigned int jvar_num )

overrideprotectedvirtual

Method for computing an off-diagonal jacobian component d-_kappa-residual / d-jvar.

jvar is looped over all field variables, which herein is just disp_x and disp_y

Definition at line 156 of file HomogenizedTotalLagrangianStressDivergence.C.

 {
   if (!_use_off_diagonal)
     return;
 
   // ONLY assemble the contribution from _alpha component, which is connected with _var
   // The other components are handled by other kernel instances with other _alpha
   if (jvar_num != _var.number())
     return;
 
   const auto & jvar = getVariable(jvar_num);
   const auto jvar_size = jvar.phiSize();
   _local_ke.resize(_k_order, jvar_size);
 
   // The scalar<->disp Jacobian needs `_avg_grad_trial[_alpha]` populated (for the
   // non-local F-bar chain via `_d_F_stab_d_F_avg * deltaF_avg`). The base
   // `precalculateOffDiagJacobian` only does this when the off-diag jvar IS a
   // displacement; for the scalar-driven path it must be triggered explicitly.
   if (_stabilize_strain)
   {
     _fe_problem.prepareShapes(jvar_num, _tid);
     _avg_grad_trial[_alpha].resize(_phi.size());
     precalculateJacobianDisplacement(_alpha);
   }
 
   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
   {
     const auto dV = _JxW[_qp] * _coord[_qp];
 
     // index for Jacobian row
     unsigned int h = 0;
 
     for (const auto & [indices, constraint] : cmap())
     {
       std::tie(_m, _n) = indices;
       _ctype = constraint.first;
       initScalarQpOffDiagJacobian(jvar);
       for (_j = 0; _j < jvar_size; _j++)
         _local_ke(h, _j) += dV * computeScalarQpOffDiagJacobian(jvar_num);
       h++;
     }
   }
 
   addJacobian(_assembly,
               _local_ke,
               _kappa_var_ptr->dofIndices(),
               jvar.dofIndices(),
               _kappa_var_ptr->scalingFactor());
 }

◆ computeScalarQpOffDiagJacobian()

Real HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian ( const unsigned int jvar_num )

overrideprotectedvirtual

Method for computing an off-diagonal jacobian component at quadrature points.

Definition at line 253 of file HomogenizedTotalLagrangianStressDivergence.C.

Referenced by computeScalarOffDiagJacobian().

 {
   if (_ctype == Homogenization::ConstraintType::Stress)
   {
     // d(PK1_{m,n})/d(grad u_beta,j) -- local chain via _dpk1 (= dPK1/d(grad u) including
     // local F-bar effect via the sigma-chain through `_d_F_stab_d_F_ust`).
     Real J = _dpk1[_qp].contractionIj(_m, _n, gradTrial(_alpha));
 
     // Non-local F-bar contribution to PK1 component (m, n) via the shared helper --
     // same chain as the regular TL displacement Jacobian but contracted into the single
     // (m, n) entry rather than doubled with gradTest. 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[_alpha][_j];
       J += deltaPK1NonLocalFBar(delta_F_avg)(_m, _n);
     }
     return J;
   }
   else if (_ctype == Homogenization::ConstraintType::Strain)
   {
     // d(F_stab_{m,n})/d(disp_alpha_j) -- for F-bar on, the F-bar chain couples F_stab to
     // F_ust through both LOCAL (`_d_F_stab_d_F_ust`) and NON-LOCAL
     // (`_d_F_stab_d_F_avg * deltaF_avg`) routes. The old `Real(_m == _alpha) *
     // gradTrial(_m, _n)` form captured only the F-bar-off case correctly.
     const RankTwoTensor delta_F_ust_local = _d_F_d_grad_u[_qp] * gradTrialUnstabilized(_alpha);
     RankTwoTensor delta_F_stab = _d_F_stab_d_F_ust[_qp] * delta_F_ust_local;
     if (_stabilize_strain)
     {
       const RankTwoTensor delta_F_avg = _d_F_d_grad_u[_qp] * _avg_grad_trial[_alpha][_j];
       delta_F_stab += _d_F_stab_d_F_avg[_qp] * delta_F_avg;
     }
     if (_large_kinematics)
       return delta_F_stab(_m, _n);
     else
       return 0.5 * (delta_F_stab(_m, _n) + delta_F_stab(_n, _m));
   }
   else
     mooseError("Unknown constraint type in kernel calculation!");
 }

◆ computeScalarResidual()

void HomogenizedTotalLagrangianStressDivergence::computeScalarResidual ( )

overrideprotectedvirtual

Method for computing the scalar part of residual for _kappa.

Definition at line 50 of file HomogenizedTotalLagrangianStressDivergence.C.

 {
   if (_alpha != 0)
     return;
 
   std::vector<Real> scalar_residuals(_k_order);
 
   // only assemble scalar residual once; i.e. when handling the first displacement component
   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
   {
     initScalarQpResidual();
     const auto dV = _JxW[_qp] * _coord[_qp];
 
     // index for residual vector
     unsigned int h = 0;
 
     for (const auto & [indices, constraint] : cmap())
     {
       const auto [i, j] = indices;
       const auto [ctype, ctarget] = constraint;
       const auto cval = ctarget->value(_t, _q_point[_qp]);
 
       // value to be constrained
       Real val;
       if (_large_kinematics)
       {
         if (ctype == Homogenization::ConstraintType::Stress)
           val = _pk1[_qp](i, j);
         else if (ctype == Homogenization::ConstraintType::Strain)
           val = _F[_qp](i, j) - (Real(i == j));
         else
           mooseError("Unknown constraint type in the integral!");
       }
       else
       {
         if (ctype == Homogenization::ConstraintType::Stress)
           val = _pk1[_qp](i, j);
         else if (ctype == Homogenization::ConstraintType::Strain)
           val = 0.5 * (_F[_qp](i, j) + _F[_qp](j, i)) - (Real(i == j));
         else
           mooseError("Unknown constraint type in the integral!");
       }
 
       scalar_residuals[h++] += (val - cval) * dV;
     }
   }
 
   addResiduals(
       _assembly, scalar_residuals, _kappa_var_ptr->dofIndices(), _kappa_var_ptr->scalingFactor());
 }

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

overrideprotectedvirtualinherited

Implements LagrangianStressDivergenceBase.

Definition at line 36 of file TotalLagrangianStressDivergenceBase.C.

Referenced by 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 )

overrideprotectedvirtualinherited

Implements LagrangianStressDivergenceBase.

Definition at line 44 of file TotalLagrangianStressDivergenceBase.C.

Referenced by TotalLagrangianWeakPlaneStress::computeQpOffDiagJacobian(), and 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 )

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.

Referenced by 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

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.

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< 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() [2/4]

template<>

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() [3/4]

template<>

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

◆ precalculateJacobian()

template<class G >

void TotalLagrangianStressDivergenceBase< G >::precalculateJacobian ( )

overrideprotectedvirtualinherited

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 )

overrideprotectedvirtualinherited

Prepare the average shape function gradients for stabilization.

Implements LagrangianStressDivergenceBase.

Definition at line 63 of file TotalLagrangianStressDivergenceBase.C.

Referenced by 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 )

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

static

Definition at line 19 of file HomogenizedTotalLagrangianStressDivergence.C.

 {
   InputParameters params = HomogenizationInterface<TotalLagrangianStressDivergence>::validParams();
   params.addClassDescription("Total Lagrangian stress equilibrium kernel with "
                              "homogenization constraint Jacobian terms");
   params.renameCoupledVar(
       "scalar_variable", "macro_var", "Optional scalar field with the macro gradient");
 
   params.addParam<bool>(
       "off_diagonal_jacobian", true, "Include the off diagonal parts of the constraint Jacobian");
 
   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.

Referenced by LagrangianStressDivergenceBase::computeQpJacobian(), LagrangianStressDivergenceBase::computeQpOffDiagJacobian(), computeQpOffDiagJacobianScalar(), computeScalarJacobian(), computeScalarOffDiagJacobian(), computeScalarQpOffDiagJacobian(), 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(), computeScalarOffDiagJacobian(), 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().

◆ _ctype

Homogenization::ConstraintType HomogenizedTotalLagrangianStressDivergence::_ctype = Homogenization::ConstraintType::None

private

Type of current homogenization constraint.

Definition at line 69 of file HomogenizedTotalLagrangianStressDivergence.h.

Referenced by computeOffDiagJacobianScalarLocal(), computeScalarOffDiagJacobian(), and computeScalarQpOffDiagJacobian().

◆ _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 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 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 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().

◆ _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().

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

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

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

◆ _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 computeScalarJacobian(), computeScalarQpOffDiagJacobian(), computeScalarResidual(), LagrangianStressDivergenceBase::deltaPK1NonLocalFBar(), and LagrangianStressDivergenceBase::initialSetup().