LagrangianStressDivergenceBase Class Reference

Base class of the "Lagrangian" kernel system. More...

#include <LagrangianStressDivergenceBase.h>

Inheritance diagram for LagrangianStressDivergenceBase:

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

Public Member Functions
	LagrangianStressDivergenceBase (const InputParameters &parameters)
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 ()

Protected Member Functions
virtual RankTwoTensor	gradTest (unsigned int component)=0
virtual RankTwoTensor	gradTrial (unsigned int component)=0
virtual void	initialSetup () override
	Derive _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee. More...
virtual void	precalculateJacobian () override
virtual void	precalculateOffDiagJacobian (unsigned int jvar) override
virtual void	precalculateJacobianDisplacement (unsigned int component)=0
	Prepare the average shape function gradients for stabilization. More...
virtual Real	computeQpJacobian () override
virtual Real	computeQpOffDiagJacobian (unsigned int jvar) override
virtual Real	computeQpJacobianDisplacement (unsigned int alpha, unsigned int beta)=0
virtual Real	computeQpJacobianTemperature (unsigned int cvar)=0
virtual Real	computeQpJacobianOutOfPlaneStrain ()=0
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
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

Detailed Description

Base class of the "Lagrangian" kernel system.

This class provides a common structure for the "new" tensor_mechanics kernel system. The goals for this new system are 1) Always-correct jacobians 2) A cleaner material interface

This class provides common input properties and helper methods, most of the math has to be done in the subclasses

Definition at line 29 of file LagrangianStressDivergenceBase.h.

Member Enumeration Documentation

FBarMode

enum LagrangianStressDivergenceBase::FBarMode

strong

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

LagrangianStressDivergenceBase()

LagrangianStressDivergenceBase::LagrangianStressDivergenceBase

(

const InputParameters &

parameters

)

Definition at line 57 of file LagrangianStressDivergenceBase.C.

  : JvarMapKernelInterface<DerivativeMaterialInterface<KernelScalarBase>>(parameters),
    GuaranteeConsumer(this),
    // Derived from the strain calculator's guarantee in initialSetup(); the local parameter is
    // deprecated and only consulted for a consistency cross-check.
    _large_kinematics(false),
    _stabilize_strain(getParam<bool>("stabilize_strain")),
    _F_bar_mode(getParam<MooseEnum>("F_bar_mode") == "incremental" ? FBarMode::Incremental
                                                                   : FBarMode::Total),
    _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
    _alpha(getParam<unsigned int>("component")),
    _ndisp(coupledComponents("displacements")),
    _disp_nums(_ndisp),
    _avg_grad_trial(_ndisp),
    _avg_grad_spatial_phi(_ndisp),
    _avg_test_phi_cross(3, std::vector<std::vector<std::vector<Real>>>(3)),
    _F_ust(
        getMaterialPropertyByName<RankTwoTensor>(_base_name + "unstabilized_deformation_gradient")),
    _F_ust_old(getMaterialPropertyOldByName<RankTwoTensor>(_base_name +
                                                           "unstabilized_deformation_gradient")),
    _F_avg(getMaterialPropertyByName<RankTwoTensor>(_base_name + "average_deformation_gradient")),
    _f_inv(getMaterialPropertyByName<RankTwoTensor>(_base_name +
                                                    "inverse_incremental_deformation_gradient")),
    _F_inv(getMaterialPropertyByName<RankTwoTensor>(_base_name + "inverse_deformation_gradient")),
    _F(getMaterialPropertyByName<RankTwoTensor>(_base_name + "deformation_gradient")),
    _F_actual(getMaterialPropertyByName<RankTwoTensor>(_base_name + "actual_deformation_gradient")),
    _d_deformation_gradient_increment_d_F(getMaterialPropertyByName<RankFourTensor>(
        _base_name + "d_spatial_deformation_gradient_increment_d_deformation_gradient")),
    _d_F_d_grad_u(getMaterialPropertyByName<RankFourTensor>(
        _base_name + "d_deformation_gradient_d_grad_displacement")),
    _d_F_stab_d_F_ust(
        getMaterialPropertyByName<RankFourTensor>(_base_name + "d_F_stab_d_F_unstabilized")),
    _d_F_stab_d_F_avg(
        getMaterialPropertyByName<RankFourTensor>(_base_name + "d_F_stab_d_F_average")),
    _temperature(isCoupled("temperature") ? getVar("temperature", 0) : nullptr),
    _out_of_plane_strain(isCoupled("out_of_plane_strain") ? getVar("out_of_plane_strain", 0)
                                                          : nullptr)
{
  // Do the vector coupling of the displacements
  for (unsigned int i = 0; i < _ndisp; i++)
    _disp_nums[i] = coupled("displacements", i);

  // We need to use identical discretizations for all displacement components
  auto order_x = getVar("displacements", 0)->order();
  for (unsigned int i = 1; i < _ndisp; i++)
  {
    if (getVar("displacements", i)->order() != order_x)
      mooseError("The Lagrangian StressDivergence kernels require equal "
                 "order interpolation for all displacements.");
  }

  // fetch eigenstrain derivatives
  const auto nvar = _coupled_moose_vars.size();
  _deigenstrain_dargs.resize(nvar);
  for (std::size_t i = 0; i < nvar; ++i)
    for (auto eigenstrain_name : getParam<std::vector<MaterialPropertyName>>("eigenstrain_names"))
      _deigenstrain_dargs[i].push_back(&getMaterialPropertyDerivative<RankTwoTensor>(
          eigenstrain_name, _coupled_moose_vars[i]->name()));

  // The direct-chain temperature off-diagonal Jacobian needs d_sigma/d_eigenstrain. Only
  // fetch it when eigenstrains are coupled -- otherwise the temperature Jacobian short-
  // circuits to zero and this property would be a needless dependency that other Cauchy-
  // providing materials would have to publish.
  if (!getParam<std::vector<MaterialPropertyName>>("eigenstrain_names").empty())
    _dcauchy_stress_d_eigenstrain =
        &getMaterialPropertyByName<RankFourTensor>(_base_name + "dcauchy_stress_d_eigenstrain");

  // The F-bar spatial push-forward consumes F_ust^{-1}/det(F_ust) published by the strain calc.
  // Fetch them (and thereby mark them active for the strain material's isPropertyActive gate)
  // only when stabilization is on -- the only mode where the push-forward runs.
  if (_stabilize_strain)
  {
    _F_ust_inv = &getMaterialPropertyByName<RankTwoTensor>(
        _base_name + "inverse_unstabilized_deformation_gradient");
    _F_ust_det =
        &getMaterialPropertyByName<Real>(_base_name + "det_unstabilized_deformation_gradient");
    _d_nl_fbar = &getMaterialPropertyByName<RankFourTensor>(_base_name + "d_nl_fbar_operator");
  }
}

Member Function Documentation

computeQpJacobian()

Real LagrangianStressDivergenceBase::computeQpJacobian ( )

overrideprotectedvirtual

Reimplemented in TotalLagrangianWeakPlaneStress.

Definition at line 191 of file LagrangianStressDivergenceBase.C.

{
  return computeQpJacobianDisplacement(_alpha, _alpha);
}

computeQpJacobianDisplacement()

virtual Real LagrangianStressDivergenceBase::computeQpJacobianDisplacement ( unsigned int  alpha, unsigned int  beta  )

protectedpure virtual

Implemented in UpdatedLagrangianStressDivergenceBase< G >, and TotalLagrangianStressDivergenceBase< G >.

Referenced by computeQpJacobian(), and computeQpOffDiagJacobian().

computeQpJacobianOutOfPlaneStrain()

virtual Real LagrangianStressDivergenceBase::computeQpJacobianOutOfPlaneStrain ( )

protectedpure virtual

Implemented in UpdatedLagrangianStressDivergenceBase< G >, and TotalLagrangianStressDivergenceBase< G >.

Referenced by computeQpOffDiagJacobian().

computeQpJacobianTemperature()

virtual Real LagrangianStressDivergenceBase::computeQpJacobianTemperature ( unsigned int  cvar )

protectedpure virtual

Implemented in UpdatedLagrangianStressDivergenceBase< G >, and TotalLagrangianStressDivergenceBase< G >.

Referenced by computeQpOffDiagJacobian().

computeQpOffDiagJacobian()

Real LagrangianStressDivergenceBase::computeQpOffDiagJacobian ( unsigned int  jvar )

overrideprotectedvirtual

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

deltaPK1NonLocalFBar()

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

protected

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

virtual RankTwoTensor LagrangianStressDivergenceBase::gradTest ( unsigned int  component )

protectedpure virtual

Implemented in UpdatedLagrangianStressDivergenceBase< G >, and TotalLagrangianStressDivergenceBase< G >.

gradTrial()

virtual RankTwoTensor LagrangianStressDivergenceBase::gradTrial ( unsigned int  component )

protectedpure virtual

Implemented in UpdatedLagrangianStressDivergenceBase< G >, and TotalLagrangianStressDivergenceBase< G >.

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

void LagrangianStressDivergenceBase::initialSetup ( )

overrideprotectedvirtual

Derive _large_kinematics from the strain calculator's LARGE_KINEMATICS guarantee.

Reimplemented in UpdatedLagrangianStressDivergenceBase< G >, UpdatedLagrangianStressDivergenceBase< G >, TotalLagrangianStressDivergenceBase< G >, TotalLagrangianStressDivergenceBase< G >, TotalLagrangianStressDivergenceBase< G >, and TotalLagrangianStressDivergenceBase< G >.

Definition at line 138 of file LagrangianStressDivergenceBase.C.

Referenced by TotalLagrangianStressDivergenceBase< G >::initialSetup(), and UpdatedLagrangianStressDivergenceBase< G >::initialSetup().

{
  JvarMapKernelInterface<DerivativeMaterialInterface<KernelScalarBase>>::initialSetup();

  // Derive the kinematics regime from the strain calculator's LARGE_KINEMATICS guarantee -- the
  // single source of truth. hasGuaranteedMaterialProperty is block-restricted (per subdomain) and
  // keyed by the base_name-prefixed deformation_gradient, so a given base_name resolves against its
  // own strain calculator.
  _large_kinematics = hasGuaranteedMaterialProperty(_base_name + "deformation_gradient",
                                                    Guarantee::LARGE_KINEMATICS);

  // The deprecated local parameter must not silently disagree with the strain calculator.
  if (isParamSetByUser("large_kinematics") &&
      getParam<bool>("large_kinematics") != _large_kinematics)
    paramError("large_kinematics",
               "large_kinematics disagrees with the ComputeLagrangianStrain calculator (which "
               "computes ",
               _large_kinematics ? "large" : "small",
               " kinematics). large_kinematics is deprecated here; set it only on the strain "
               "calculator.");
}

precalculateJacobian()

void LagrangianStressDivergenceBase::precalculateJacobian ( )

overrideprotectedvirtual

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

virtual void LagrangianStressDivergenceBase::precalculateJacobianDisplacement ( unsigned int  component )

protectedpure virtual

Prepare the average shape function gradients for stabilization.

Implemented in UpdatedLagrangianStressDivergenceBase< G >, and TotalLagrangianStressDivergenceBase< G >.

Referenced by precalculateJacobian(), and precalculateOffDiagJacobian().

precalculateOffDiagJacobian()

void LagrangianStressDivergenceBase::precalculateOffDiagJacobian ( unsigned int  jvar )

overrideprotectedvirtual

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

InputParameters LagrangianStressDivergenceBase::validParams ( )

static

Definition at line 14 of file LagrangianStressDivergenceBase.C.

Referenced by TotalLagrangianStressDivergenceBase< G >::baseParams(), and UpdatedLagrangianStressDivergenceBase< G >::baseParams().

{
  InputParameters params = KernelScalarBase::validParams();

  params.addRequiredParam<unsigned int>("component", "Which direction this kernel acts in");
  params.addRequiredCoupledVar("displacements", "The displacement components");

  params.addDeprecatedParam<bool>(
      "large_kinematics",
      false,
      "Use large displacement kinematics",
      "large_kinematics is no longer set on the stress-divergence kernel; it is derived from the "
      "ComputeLagrangianStrain calculator (the single source of truth) via the LARGE_KINEMATICS "
      "guarantee. Remove it here and set it only on the strain calculator.");
  params.addParam<bool>("stabilize_strain", false, "Average the volumetric strains");
  MooseEnum F_bar_mode("total incremental", "total");
  params.addParam<MooseEnum>(
      "F_bar_mode",
      F_bar_mode,
      "Which F gets the F-bar volumetric correction (must match the strain calc's setting). "
      "'total' (default) reproduces existing behavior; 'incremental' makes the F-bar element-"
      "average operate on the incremental F so cumulative strain matches OLD's "
      "`ComputeFiniteStrain` + `volumetric_locking_correction = true`.");

  params.addParam<std::string>("base_name", "Material property base name");

  params.addCoupledVar("temperature",
                       "The name of the temperature variable used in the "
                       "ComputeThermalExpansionEigenstrain.  (Not required for "
                       "simulations without temperature coupling.)");

  params.addParam<std::vector<MaterialPropertyName>>(
      "eigenstrain_names",
      {},
      "List of eigenstrains used in the strain calculation. Used for computing their derivatives "
      "for off-diagonal Jacobian terms.");

  params.addCoupledVar("out_of_plane_strain",
                       "The out-of-plane strain variable for weak plane stress formulation.");

  return params;
}

Member Data Documentation

_alpha

const unsigned int LagrangianStressDivergenceBase::_alpha

protected

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

Definition at line 109 of file LagrangianStressDivergenceBase.h.

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

_avg_grad_spatial_phi

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

protected

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

protected

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

protected

Definition at line 120 of file LagrangianStressDivergenceBase.h.

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

_avg_test_phi_cross

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

protected

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

protected

Prepend to the material properties.

Definition at line 106 of file LagrangianStressDivergenceBase.h.

Referenced by initialSetup(), and LagrangianStressDivergenceBase().

_d_deformation_gradient_increment_d_F

const MaterialProperty<RankFourTensor>& LagrangianStressDivergenceBase::_d_deformation_gradient_increment_d_F

protected

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

protected

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

protected

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

protected

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

protected

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

_dcauchy_stress_d_eigenstrain

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

protected

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

_deigenstrain_dargs

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

protected

Eigenstrain derivatives wrt generate coupleds.

Definition at line 199 of file LagrangianStressDivergenceBase.h.

Referenced by LagrangianStressDivergenceBase().

_disp_nums

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

protected

The displacement numbers.

Definition at line 115 of file LagrangianStressDivergenceBase.h.

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

_F

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F

protected

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

protected

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

protected

The element-average deformation gradient.

Definition at line 152 of file LagrangianStressDivergenceBase.h.

_F_bar_mode

const FBarMode LagrangianStressDivergenceBase::_F_bar_mode

protected

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

protected

The inverse increment deformation gradient.

Definition at line 155 of file LagrangianStressDivergenceBase.h.

_F_inv

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F_inv

protected

The inverse deformation gradient.

Definition at line 158 of file LagrangianStressDivergenceBase.h.

_F_ust

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F_ust

protected

The unmodified deformation gradient.

Definition at line 144 of file LagrangianStressDivergenceBase.h.

_F_ust_det

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

protected

Definition at line 166 of file LagrangianStressDivergenceBase.h.

Referenced by deltaPK1NonLocalFBar(), and LagrangianStressDivergenceBase().

_F_ust_inv

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

protected

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

_F_ust_old

const MaterialProperty<RankTwoTensor>& LagrangianStressDivergenceBase::_F_ust_old

protected

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

protected

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(), deltaPK1NonLocalFBar(), and initialSetup().

_ndisp

const unsigned int LagrangianStressDivergenceBase::_ndisp

protected

Total number of displacements/size of residual vector.

Definition at line 112 of file LagrangianStressDivergenceBase.h.

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

_out_of_plane_strain

const MooseVariable* LagrangianStressDivergenceBase::_out_of_plane_strain

protected

Out-of-plane strain, if provided.

Definition at line 196 of file LagrangianStressDivergenceBase.h.

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

_stabilize_strain

const bool LagrangianStressDivergenceBase::_stabilize_strain

protected

If true calculate the deformation gradient derivatives for F_bar.

Definition at line 98 of file LagrangianStressDivergenceBase.h.

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

_temperature

const MooseVariable* LagrangianStressDivergenceBase::_temperature

protected

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

Definition at line 193 of file LagrangianStressDivergenceBase.h.

Referenced by computeQpOffDiagJacobian().

---

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

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