Enforce equilibrium with an updated Lagrangian formulation. More...

#include <UpdatedLagrangianStressDivergence.h>

Inheritance diagram for UpdatedLagrangianStressDivergenceBase< G >:

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

typedef std::vector< int >	JvarMap

Public Member Functions
	UpdatedLagrangianStressDivergenceBase (const InputParameters &parameters)

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

template<>
InputParameters	validParams ()

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

virtual void	computeOffDiagJacobian (unsigned int jvar) override

unsigned int	mapJvarToCvar (unsigned int jvar)

int	mapJvarToCvar (unsigned int jvar, const JvarMap &jvar_map)

bool	mapJvarToCvar (unsigned int jvar, unsigned int &cvar)

const JvarMap &	getJvarMap ()

const JvarMap &	getParameterJvarMap (std::string parameter_name)

Static Public Member Functions
static InputParameters	baseParams ()

static InputParameters	validParams ()

Protected Member Functions
virtual RankTwoTensor	gradTest (unsigned int component) override

virtual RankTwoTensor	gradTrial (unsigned int component) override

virtual void	precalculateJacobianDisplacement (unsigned int component) override
	Prepare the average shape function gradients for stabilization. More...

virtual Real	computeQpResidual () override

virtual Real	computeQpJacobianDisplacement (unsigned int alpha, unsigned int beta) override

virtual Real	computeQpJacobianTemperature (unsigned int cvar) override

virtual Real	computeQpJacobianOutOfPlaneStrain () override

virtual void	precalculateJacobian () override

virtual void	precalculateOffDiagJacobian (unsigned int jvar) override

virtual Real	computeQpJacobian () override

virtual Real	computeQpOffDiagJacobian (unsigned int jvar) override

RankTwoTensor	deltaPK1NonLocalFBar (const RankTwoTensor &delta_F_avg) const
	Non-local F-bar contribution to deltaPK1 at the current `_qp`, given the perturbation `delta_F_avg` of the element-average F. More...

bool	hasGuaranteedMaterialProperty (const MaterialPropertyName &prop, Guarantee guarantee)

Protected Attributes
const MaterialProperty< RankTwoTensor > &	_stress
	The Cauchy stress. More...

const MaterialProperty< RankFourTensor > &	_material_jacobian

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


Assembly &	_assembly_undisplaced

const VariablePhiGradient &	_grad_phi_undisplaced

const MooseArray< Real > &	_JxW_undisplaced

const MooseArray< Real > &	_coord_undisplaced

const MooseArray< Point > &	_q_point_undisplaced

Private Member Functions
virtual RankTwoTensor	gradTrialUnstabilized (unsigned int component)
	The unstabilized trial function gradient. More...

Detailed Description

template<class G>
class UpdatedLagrangianStressDivergenceBase< G >

Enforce equilibrium with an updated Lagrangian formulation.

This class enforces equilibrium when used in conjunction with the corresponding strain calculator (CalculateStrainLagrangianKernel) and with either a stress calculator that provides the Cauchy stress ("stress") and the appropriate "cauchy_jacobian", which needs to be the derivative of the increment in Cauchy stress with respect to the increment in the spatial velocity gradient.

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

use_displaced_mesh must be true for large deformation kinematics The kernel enforces this with an error

Definition at line 32 of file UpdatedLagrangianStressDivergence.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

◆ UpdatedLagrangianStressDivergenceBase()

template<class G >

UpdatedLagrangianStressDivergenceBase< G >::UpdatedLagrangianStressDivergenceBase ( const InputParameters & parameters )

Definition at line 15 of file UpdatedLagrangianStressDivergence.C.

   : LagrangianStressDivergenceBase(parameters),
     _stress(getMaterialPropertyByName<RankTwoTensor>(_base_name + "cauchy_stress")),
     _material_jacobian(getMaterialPropertyByName<RankFourTensor>(_base_name + "cauchy_jacobian")),
 
     // Assembly quantities in the reference frame for stabilization
     _assembly_undisplaced(_fe_problem.assembly(_tid, this->_sys.number())),
     _grad_phi_undisplaced(_assembly_undisplaced.gradPhi()),
     _JxW_undisplaced(_assembly_undisplaced.JxW()),
     _coord_undisplaced(_assembly_undisplaced.coordTransformation()),
     _q_point_undisplaced(_assembly_undisplaced.qPoints())
 {
   // The use_displaced_mesh <-> large_kinematics consistency check lives in initialSetup(), since
   // large_kinematics is now derived from the strain calculator's guarantee (not available in the
   // constructor).
 
   // TODO: add weak plane stress support
   if (_out_of_plane_strain)
     mooseError("The UpdatedLagrangianStressDivergence kernels do not yet support the weak plane "
                "stress formulation. Please use the TotalLagrangianStressDivergecen kernels.");
 
   // The UL push-forward in `precalculateJacobianDisplacement` uses `_F_avg` (= avg(F_ust))
   // for the spatial-to-reference frame mapping; combining it with the incremental F-bar
   // chain (which expects `_avg_grad_trial` to represent deltaf_avg, not deltaF_avg) hasn't been
   // worked out yet. Use Total Lagrangian for incremental F-bar.
   if (_stabilize_strain && _F_bar_mode == FBarMode::Incremental)
     mooseError("`F_bar_mode = incremental` is not yet supported with the UpdatedLagrangian "
                "kernels; use TotalLagrangianStressDivergence (or `F_bar_mode = total`).");
 }

Member Function Documentation

◆ baseParams()

template<class G >

static InputParameters UpdatedLagrangianStressDivergenceBase< G >::baseParams ( )

inlinestatic

Definition at line 35 of file UpdatedLagrangianStressDivergence.h.

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

   {
     InputParameters params = LagrangianStressDivergenceBase::validParams();
     return params;
   }

◆ 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 UpdatedLagrangianStressDivergenceBase< G >::computeQpJacobianDisplacement	(	unsigned int	alpha,
		unsigned int	beta
	)

overrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 104 of file UpdatedLagrangianStressDivergence.C.

 {
   const auto grad_test = gradTest(alpha);
   const auto grad_trial = gradTrialUnstabilized(beta);
 
   //           J^{alpha beta} = J^{alpha beta}_material + J^{alpha beta}_geometric
   //  J^{alpha beta}_material = phi^alpha : T : d(dL)/d(grad u) * grad_trial
   // J^{alpha beta}_geometric = sigma_{ij} (phi^alpha_{k, k} psi^beta_{i, j} -
   //                                        phi^alpha_{k, j} psi^beta_{i, k})
 
   // Local contribution to delta(F_ust): pull the spatial trial gradient back through the
   // literal n+1 deformation gradient (use_displaced_mesh = true uses F_actual, regardless
   // of alpha or F-bar), then chain to F_ust via _d_F_d_grad_u (= alpha * I^(4)).
   const RankTwoTensor delta_grad_u_local =
       _large_kinematics ? grad_trial * _F_actual[_qp] : grad_trial;
   const RankTwoTensor delta_F_ust_local = _d_F_d_grad_u[_qp] * delta_grad_u_local;
 
   // Non-local F-bar contribution to delta(F_avg): _avg_grad_trial is stored as
   // avg(gradTrial_reference) * F_avg^{-1} (see precalculateJacobianDisplacement). Multiply
   // by F_avg to recover the reference-frame averaged gradient, then chain to F_ust the
   // same way.
   RankTwoTensor delta_F_avg;
   if (_stabilize_strain)
   {
     const RankTwoTensor delta_grad_u_avg =
         _large_kinematics ? _avg_grad_trial[beta][_j] * _F_avg[_qp] : _avg_grad_trial[beta][_j];
     delta_F_avg = _d_F_d_grad_u[_qp] * delta_grad_u_avg;
   }
 
   // Stabilized delta(F_stab) through the F-bar tangent. With F-bar off, the partials are
   // _d_F_stab_d_F_ust = I^(4) and _d_F_stab_d_F_avg = 0, so this reduces to delta_F_ust_local.
   const RankTwoTensor delta_F_stab =
       _d_F_stab_d_F_ust[_qp] * delta_F_ust_local + _d_F_stab_d_F_avg[_qp] * delta_F_avg;
 
   const RankTwoTensor delta_dL = _d_deformation_gradient_increment_d_F[_qp] * delta_F_stab;
 
   // The material jacobian
   Real J = grad_test.doubleContraction(_material_jacobian[_qp] * delta_dL);
 
   // The geometric jacobian (no F-bar stabilization in this term)
   if (_large_kinematics)
   {
     J += _stress[_qp].doubleContraction(grad_test) * grad_trial.trace() -
          _stress[_qp].doubleContraction(grad_test * grad_trial);
   }
 
   return J;
 }

◆ computeQpJacobianOutOfPlaneStrain()

template<class G >

virtual Real UpdatedLagrangianStressDivergenceBase< G >::computeQpJacobianOutOfPlaneStrain ( )

inlineoverrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 51 of file UpdatedLagrangianStressDivergence.h.

51 { return 0; }

◆ computeQpJacobianTemperature()

template<class G >

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

overrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 156 of file UpdatedLagrangianStressDivergence.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];
 
   RankFourTensor C = _material_jacobian[_qp];
   RankFourTensor Csym = 0.5 * (C + C.transposeMajor().transposeIj().transposeMajor());
 
   return -(Csym * total_deigen).doubleContraction(gradTest(_alpha)) * _temperature->phi()[_j][_qp];
 }

◆ computeQpOffDiagJacobian()

Real LagrangianStressDivergenceBase::computeQpOffDiagJacobian ( unsigned int jvar )

overrideprotectedvirtualinherited

Reimplemented in TotalLagrangianWeakPlaneStress.

Definition at line 210 of file LagrangianStressDivergenceBase.C.

 {
   // Bail if jvar not coupled
   if (getJvarMap()[jvar] < 0)
     return 0.0;
 
   // Off diagonal terms for other displacements
   for (auto beta : make_range(_ndisp))
     if (jvar == _disp_nums[beta])
       return computeQpJacobianDisplacement(_alpha, beta);
 
   // Off diagonal temperature term due to eigenstrain
   if (_temperature && jvar == _temperature->number())
     return computeQpJacobianTemperature(mapJvarToCvar(jvar));
 
   // Off diagonal term due to weak plane stress
   if (_out_of_plane_strain && jvar == _out_of_plane_strain->number())
     return computeQpJacobianOutOfPlaneStrain();
 
   return 0;
 }

◆ computeQpResidual()

template<class G >

Real UpdatedLagrangianStressDivergenceBase< G >::computeQpResidual ( )

overrideprotectedvirtual

Definition at line 97 of file UpdatedLagrangianStressDivergence.C.

 {
   return gradTest(_alpha).doubleContraction(_stress[_qp]);
 }

◆ deltaPK1NonLocalFBar()

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

protectedinherited

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

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

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

Definition at line 197 of file LagrangianStressDivergenceBase.C.

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

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

◆ gradTest()

template<class G >

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

overrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 48 of file UpdatedLagrangianStressDivergence.C.

 {
   // 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 UpdatedLagrangianStressDivergenceBase< G >::gradTrial ( unsigned int component )

overrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 56 of file UpdatedLagrangianStressDivergence.C.

 {
   // F-bar stabilization is handled explicitly in computeQpJacobianDisplacement via the stored
   // partial derivatives _d_F_stab_d_F_ust and _d_F_stab_d_F_avg, so gradTrial always returns
   // the unstabilized spatial gradient.
   return gradTrialUnstabilized(component);
 }

◆ gradTrialUnstabilized()

template<class G >

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

privatevirtual

The unstabilized trial function gradient.

F-bar stabilization is handled explicitly in computeQpJacobianDisplacement via the strain-calculator F-bar partials, so the UL kernel does not need a separate gradTrialStabilized helper.

Definition at line 66 of file UpdatedLagrangianStressDivergence.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]);
 }

◆ 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/2]

template<class G >

virtual void UpdatedLagrangianStressDivergenceBase< G >::initialSetup ( )

overridevirtual

Derive _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee.

Reimplemented from LagrangianStressDivergenceBase.

◆ initialSetup() [2/2]

template<>

void UpdatedLagrangianStressDivergenceBase< GradientOperatorCartesian >::initialSetup ( )

inlinevirtual

Derive _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee.

Reimplemented from LagrangianStressDivergenceBase.

Definition at line 88 of file UpdatedLagrangianStressDivergence.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.");
 
   // The updated Lagrangian kernel integrates on the displaced mesh iff large kinematics is on;
   // large_kinematics is derived from the strain calculator, so validate the pairing here.
   if (_large_kinematics && !getParam<bool>("use_displaced_mesh"))
     mooseError("The UpdatedLagrangianStressDivergence kernels require use_displaced_mesh = true "
                "for large_kinematics = true");
   if (!_large_kinematics && getParam<bool>("use_displaced_mesh"))
     mooseError("The UpdatedLagrangianStressDivergence kernels require use_displaced_mesh = false "
                "for large_kinematics = false");
 }

◆ precalculateJacobian()

void LagrangianStressDivergenceBase::precalculateJacobian ( )

overrideprotectedvirtualinherited

Reimplemented in TotalLagrangianStressDivergenceBase< G >, and TotalLagrangianWeakPlaneStress.

Definition at line 161 of file LagrangianStressDivergenceBase.C.

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

 {
   // Skip if we are not doing stabilization
   if (!_stabilize_strain)
     return;
 
   // We need the gradients of shape functions in the reference frame
   _fe_problem.prepareShapes(_var.number(), _tid);
   _avg_grad_trial[_alpha].resize(_phi.size());
   precalculateJacobianDisplacement(_alpha);
 }

◆ precalculateJacobianDisplacement()

template<class G >

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

overrideprotectedvirtual

Prepare the average shape function gradients for stabilization.

Implements LagrangianStressDivergenceBase.

Definition at line 74 of file UpdatedLagrangianStressDivergence.C.

 {
   // For updated Lagrangian, the averaging is taken on the reference frame. If large kinematics is
   // used, the averaged gradients should be pushed forward to the current frame.
   for (auto j : make_range(_phi.size()))
   {
     _avg_grad_trial[component][j] = StabilizationUtils::elementAverage(
         [this, component, j](unsigned int qp)
         {
           return G::gradOp(
               component, _grad_phi_undisplaced[j][qp], _phi[j][qp], _q_point_undisplaced[qp]);
         },
         _JxW_undisplaced,
         _coord_undisplaced);
     if (_large_kinematics)
       // Push forward to the current frame.
       // The average deformation gradient is the same at all qps.
       _avg_grad_trial[component][j] *= _F_avg[0].inverse();
   }
 }

◆ precalculateOffDiagJacobian()

void LagrangianStressDivergenceBase::precalculateOffDiagJacobian ( unsigned int jvar )

overrideprotectedvirtualinherited

Reimplemented in TotalLagrangianStressDivergenceBase< G >.

Definition at line 174 of file LagrangianStressDivergenceBase.C.

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

 {
   // Skip if we are not doing stabilization
   if (!_stabilize_strain)
     return;
 
   for (auto beta : make_range(_ndisp))
     if (jvar == _disp_nums[beta])
     {
       // We need the gradients of shape functions in the reference frame
       _fe_problem.prepareShapes(jvar, _tid);
       _avg_grad_trial[beta].resize(_phi.size());
       precalculateJacobianDisplacement(beta);
     }
 }

◆ validParams() [1/2]

template<class G >

static InputParameters UpdatedLagrangianStressDivergenceBase< G >::validParams ( )

static

◆ validParams() [2/2]

template<>

InputParameters UpdatedLagrangianStressDivergenceBase< GradientOperatorCartesian >::validParams ( )

inline

Definition at line 78 of file UpdatedLagrangianStressDivergence.h.

 {
   InputParameters params = UpdatedLagrangianStressDivergenceBase::baseParams();
   params.addClassDescription(
       "Enforce equilibrium with an updated Lagrangian formulation in Cartesian coordinates.");
   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.

◆ _assembly_undisplaced

template<class G >

Assembly& UpdatedLagrangianStressDivergenceBase< G >::_assembly_undisplaced

protected

Definition at line 62 of file UpdatedLagrangianStressDivergence.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 TotalLagrangianWeakPlaneStress::computeQpOffDiagJacobian(), HomogenizedTotalLagrangianStressDivergence::computeScalarOffDiagJacobian(), HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian(), LagrangianStressDivergenceBase::precalculateJacobian(), and LagrangianStressDivergenceBase::precalculateOffDiagJacobian().

◆ _avg_test_phi_cross

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

protectedinherited

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

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

Definition at line 141 of file LagrangianStressDivergenceBase.h.

◆ _base_name

const std::string LagrangianStressDivergenceBase::_base_name

protectedinherited

Prepend to the material properties.

Definition at line 106 of file LagrangianStressDivergenceBase.h.

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

◆ _coord_undisplaced

template<class G >

const MooseArray<Real>& UpdatedLagrangianStressDivergenceBase< G >::_coord_undisplaced

protected

Definition at line 65 of file UpdatedLagrangianStressDivergence.h.

◆ _d_deformation_gradient_increment_d_F

const MaterialProperty<RankFourTensor>& LagrangianStressDivergenceBase::_d_deformation_gradient_increment_d_F

protectedinherited

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

Definition at line 177 of file LagrangianStressDivergenceBase.h.

◆ _d_F_d_grad_u

const MaterialProperty<RankFourTensor>& LagrangianStressDivergenceBase::_d_F_d_grad_u

protectedinherited

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

Definition at line 180 of file LagrangianStressDivergenceBase.h.

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

◆ _d_F_stab_d_F_avg

const MaterialProperty<RankFourTensor>& LagrangianStressDivergenceBase::_d_F_stab_d_F_avg

protectedinherited

Definition at line 190 of file LagrangianStressDivergenceBase.h.

Referenced by HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian().

◆ _d_F_stab_d_F_ust

const MaterialProperty<RankFourTensor>& LagrangianStressDivergenceBase::_d_F_stab_d_F_ust

protectedinherited

Partials of the F-bar-stabilized deformation gradient.

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

Definition at line 189 of file LagrangianStressDivergenceBase.h.

Referenced by HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian().

◆ _d_nl_fbar

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

protectedinherited

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

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

Definition at line 212 of file LagrangianStressDivergenceBase.h.

Referenced by LagrangianStressDivergenceBase::LagrangianStressDivergenceBase().

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

◆ _F

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F

protectedinherited

The actual (stabilized) deformation gradient.

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

Definition at line 170 of file LagrangianStressDivergenceBase.h.

Referenced by HomogenizedTotalLagrangianStressDivergence::computeScalarResidual().

◆ _F_actual

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F_actual

protectedinherited

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

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

Definition at line 174 of file LagrangianStressDivergenceBase.h.

◆ _F_avg

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F_avg

protectedinherited

The element-average deformation gradient.

Definition at line 152 of file LagrangianStressDivergenceBase.h.

◆ _F_bar_mode

const FBarMode LagrangianStressDivergenceBase::_F_bar_mode

protectedinherited

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

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

Definition at line 103 of file LagrangianStressDivergenceBase.h.

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

◆ _f_inv

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_f_inv

protectedinherited

The inverse increment deformation gradient.

Definition at line 155 of file LagrangianStressDivergenceBase.h.

◆ _F_inv

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F_inv

protectedinherited

The inverse deformation gradient.

Definition at line 158 of file LagrangianStressDivergenceBase.h.

◆ _F_ust

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F_ust

protectedinherited

The unmodified deformation gradient.

Definition at line 144 of file LagrangianStressDivergenceBase.h.

◆ _F_ust_det

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

protectedinherited

Definition at line 166 of file LagrangianStressDivergenceBase.h.

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

◆ _F_ust_inv

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

protectedinherited

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

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

Definition at line 165 of file LagrangianStressDivergenceBase.h.

Referenced by LagrangianStressDivergenceBase::LagrangianStressDivergenceBase().

◆ _F_ust_old

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F_ust_old

protectedinherited

Old unstabilized deformation gradient.

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

Definition at line 149 of file LagrangianStressDivergenceBase.h.

◆ _grad_phi_undisplaced

template<class G >

const VariablePhiGradient& UpdatedLagrangianStressDivergenceBase< G >::_grad_phi_undisplaced

protected

Definition at line 63 of file UpdatedLagrangianStressDivergence.h.

◆ _JxW_undisplaced

template<class G >

const MooseArray<Real>& UpdatedLagrangianStressDivergenceBase< G >::_JxW_undisplaced

protected

Definition at line 64 of file UpdatedLagrangianStressDivergence.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().

◆ _material_jacobian

template<class G >

const MaterialProperty<RankFourTensor>& UpdatedLagrangianStressDivergenceBase< G >::_material_jacobian

protected

Definition at line 58 of file UpdatedLagrangianStressDivergence.h.

◆ _ndisp

const unsigned int LagrangianStressDivergenceBase::_ndisp

protectedinherited

Total number of displacements/size of residual vector.

Definition at line 112 of file LagrangianStressDivergenceBase.h.

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

◆ _out_of_plane_strain

const MooseVariable* LagrangianStressDivergenceBase::_out_of_plane_strain

protectedinherited

Out-of-plane strain, if provided.

Definition at line 196 of file LagrangianStressDivergenceBase.h.

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

◆ _q_point_undisplaced

template<class G >

const MooseArray<Point>& UpdatedLagrangianStressDivergenceBase< G >::_q_point_undisplaced

protected

Definition at line 66 of file UpdatedLagrangianStressDivergence.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.

◆ _stress

template<class G >

const MaterialProperty<RankTwoTensor>& UpdatedLagrangianStressDivergenceBase< G >::_stress

protected

The Cauchy stress.

Definition at line 54 of file UpdatedLagrangianStressDivergence.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/UpdatedLagrangianStressDivergence.h
solid_mechanics/src/kernels/lagrangian/UpdatedLagrangianStressDivergence.C

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

template<class G> class UpdatedLagrangianStressDivergenceBase< G >

Member Enumeration Documentation

◆ FBarMode

Constructor & Destructor Documentation

◆ UpdatedLagrangianStressDivergenceBase()

Member Function Documentation

◆ baseParams()

◆ computeQpJacobian()

◆ computeQpJacobianDisplacement()

◆ computeQpJacobianOutOfPlaneStrain()

◆ computeQpJacobianTemperature()

◆ computeQpOffDiagJacobian()

◆ computeQpResidual()

◆ deltaPK1NonLocalFBar()

◆ gradTest()

◆ gradTrial()

◆ gradTrialUnstabilized()

◆ hasGuaranteedMaterialProperty()

◆ initialSetup() [1/2]

◆ initialSetup() [2/2]

◆ precalculateJacobian()

◆ precalculateJacobianDisplacement()

◆ precalculateOffDiagJacobian()

◆ validParams() [1/2]

◆ validParams() [2/2]

Member Data Documentation

◆ _alpha

◆ _assembly_undisplaced

◆ _avg_grad_spatial_phi

◆ _avg_grad_spatial_test

◆ _avg_grad_trial

◆ _avg_test_phi_cross

◆ _base_name

◆ _coord_undisplaced

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

◆ _dcauchy_stress_d_eigenstrain

◆ _deigenstrain_dargs

◆ _disp_nums

◆ _F

◆ _F_actual

◆ _F_avg

◆ _F_bar_mode

◆ _f_inv

◆ _F_inv

◆ _F_ust

◆ _F_ust_det

◆ _F_ust_inv

◆ _F_ust_old

◆ _grad_phi_undisplaced

◆ _JxW_undisplaced

◆ _large_kinematics

◆ _material_jacobian

◆ _ndisp

◆ _out_of_plane_strain

◆ _q_point_undisplaced

◆ _stabilize_strain

◆ _stress

◆ _temperature

template<class G>
class UpdatedLagrangianStressDivergenceBase< G >