Calculate strains to use the MOOSE materials with the Lagrangian kernels. More...

#include <ComputeLagrangianStrainBase.h>

Inheritance diagram for ComputeLagrangianStrainBase< G >:

Public Types
enum	KinematicApproximation { KinematicApproximation::Linear, KinematicApproximation::Quadratic, KinematicApproximation::RashidApproximate, KinematicApproximation::RashidEigen }
	Approximation used to convert the inverse incremental deformation gradient `f^{-1}` into the increment in the spatial velocity gradient (and its symmetric / skew parts). More...

enum	FBarMode { FBarMode::Total, FBarMode::Incremental }
	What F gets F-bar volumetric correction applied to. More...

enum	TEST_TYPE

typedef DataFileName	DataFileParameterType

Public Member Functions
	ComputeLagrangianStrainBase (const InputParameters &parameters)

virtual void	initialSetup () override

template<>
InputParameters	validParams ()

template<>
void	initialSetup ()

template<>
InputParameters	validParams ()

template<>
void	initialSetup ()

template<>
InputParameters	validParams ()

template<>
void	initialSetup ()

virtual const dof_id_type &	getElementID (const std::string &id_parameter_name, unsigned int comp=0) const override

dof_id_type	getElementID (const Elem *elem, unsigned int elem_id_index) const

virtual const dof_id_type &	getElementIDNeighbor (const std::string &id_parameter_name, unsigned int comp=0) const override

virtual const dof_id_type &	getElementIDByName (const std::string &id_parameter_name) const override

virtual const dof_id_type &	getElementIDNeighborByName (const std::string &id_parameter_name) const override

MaterialBase &	getMaterial (const std::string &name)

MaterialBase &	getMaterialByName (const std::string &name, bool no_warn=false, bool no_dep=false)

MaterialBase &	getMaterialByName (const std::string &name, bool no_warn=false)

MaterialBase &	getMaterialByName (const std::string &name, bool no_warn=false)

virtual bool	isBoundaryMaterial () const override

virtual const std::unordered_set< unsigned int > &	getMatPropDependencies () const override

virtual void	subdomainSetup () override

	CreateMooseEnumClass (ConstantTypeEnum, NONE, ELEMENT, SUBDOMAIN)

bool	ghostable () const override final

virtual void	resolveOptionalProperties () override

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty (const std::string &name)

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty ()

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty (const std::string &name)

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty ()

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty (const std::string &name)

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty ()

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialPropertyByName (const std::string &prop_name)

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialPropertyByName (const std::string &prop_name)

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialPropertyByName (const std::string &prop_name)

const MaterialProperty< T > &	getZeroMaterialProperty (Ts... args)

const MaterialProperty< T > &	getZeroMaterialProperty (Ts... args)

const MaterialProperty< T > &	getZeroMaterialProperty (Ts... args)

virtual void	initStatefulProperties (const unsigned int n_points)

virtual bool	isInterfaceMaterial ()

virtual void	resetProperties ()

virtual void	computePropertiesAtQp (unsigned int qp)

const MaterialProperty< T > &	getZeroMaterialPropertyByName (Ts... args)

virtual const std::set< std::string > &	getRequestedItems () override

virtual const std::set< std::string > &	getSuppliedItems () override

const std::set< unsigned int > &	getSuppliedPropIDs () const

void	checkStatefulSanity () const

std::set< OutputName >	getOutputs ()

bool	hasStatefulProperties () const

bool	hasRestoredProperties () const

void	setFaceInfo (const FaceInfo &fi)

void	setActiveProperties (const std::unordered_set< unsigned int > &needed_props)

bool	hasActiveProperties ()

bool	forceStatefulInit () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecatedNoTrace (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

const std::vector< SubdomainName > &	blocks () const

unsigned int	numBlocks () const

virtual const std::set< SubdomainID > &	blockIDs () const

unsigned int	blocksMaxDimension () const

bool	hasBlocks (const SubdomainName &name) const

bool	hasBlocks (const std::vector< SubdomainName > &names) const

bool	hasBlocks (const std::set< SubdomainName > &names) const

bool	hasBlocks (SubdomainID id) const

bool	hasBlocks (const std::vector< SubdomainID > &ids) const

bool	hasBlocks (const std::set< SubdomainID > &ids) const

bool	isBlockSubset (const std::set< SubdomainID > &ids) const

bool	isBlockSubset (const std::vector< SubdomainID > &ids) const

bool	hasBlockMaterialProperty (const std::string &prop_name)

const std::set< SubdomainID > &	meshBlockIDs () const

virtual bool	blockRestricted () const

virtual void	checkVariable (const MooseVariableFieldBase &variable) const

virtual const std::set< BoundaryID > &	boundaryIDs () const

const std::vector< BoundaryName > &	boundaryNames () const

unsigned int	numBoundaryIDs () const

bool	hasBoundary (const BoundaryName &name) const

bool	hasBoundary (const std::vector< BoundaryName > &names) const

bool	hasBoundary (const BoundaryID &id) const

bool	hasBoundary (const std::vector< BoundaryID > &ids, TEST_TYPE type=ALL) const

bool	hasBoundary (const std::set< BoundaryID > &ids, TEST_TYPE type=ALL) const

bool	isBoundarySubset (const std::set< BoundaryID > &ids) const

bool	isBoundarySubset (const std::vector< BoundaryID > &ids) const

bool	hasBoundaryMaterialProperty (const std::string &prop_name) const

virtual bool	boundaryRestricted () const

const std::set< BoundaryID > &	meshBoundaryIDs () const

virtual bool	checkVariableBoundaryIntegrity () const

virtual void	timestepSetup ()

virtual void	jacobianSetup ()

virtual void	residualSetup ()

virtual void	customSetup (const ExecFlagType &)

const ExecFlagEnum &	getExecuteOnEnum () const

const std::set< MooseVariableFieldBase *> &	getMooseVariableDependencies () const

std::set< MooseVariableFieldBase *>	checkAllVariables (const DofObjectType &dof_object, const std::set< MooseVariableFieldBase * > &vars_to_omit={})

virtual std::set< MooseVariableFieldBase *>	checkVariables (const libMesh::Node &node, const std::set< MooseVariableFieldBase * > &vars_to_check)

std::set< MooseVariableFieldBase *>	checkVariables (const libMesh::Elem &element, const std::set< MooseVariableFieldBase * > &vars_to_check)

void	addMooseVariableDependency (MooseVariableFieldBase *var)

void	addMooseVariableDependency (const std::vector< MooseVariableFieldBase * > &vars)

const std::vector< MooseVariableScalar *> &	getCoupledMooseScalarVars ()

const std::set< TagID > &	getScalarVariableCoupleableVectorTags () const

const std::set< TagID > &	getScalarVariableCoupleableMatrixTags () const

const Function &	getFunction (const std::string &name) const

const Function &	getFunctionByName (const FunctionName &name) const

bool	hasFunction (const std::string &param_name) const

bool	hasFunctionByName (const FunctionName &name) const

Moose::Kokkos::Function	getKokkosFunction (const std::string &name) const

const T &	getKokkosFunction (const std::string &name) const

Moose::Kokkos::Function	getKokkosFunctionByName (const FunctionName &name) const

const T &	getKokkosFunctionByName (const FunctionName &name) const

bool	hasKokkosFunction (const std::string &param_name) const

bool	hasKokkosFunctionByName (const FunctionName &name) const

UserObjectName	getUserObjectName (const std::string &param_name) const

const T &	getUserObject (const std::string &param_name, bool is_dependency=true) const

const T &	getUserObjectByName (const UserObjectName &object_name, bool is_dependency=true) const

const UserObjectBase &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObjectBase &	getUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) const

bool	isImplicit ()

Moose::StateArg	determineState () const

bool	isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessorByName (const PostprocessorName &name) const

std::size_t	coupledPostprocessors (const std::string &param_name) const

const PostprocessorName &	getPostprocessorName (const std::string &param_name, const unsigned int index=0) const

const VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const

bool	hasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const

bool	hasVectorPostprocessor (const std::string &param_name) const

bool	hasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

bool	hasVectorPostprocessorByName (const VectorPostprocessorName &name) const

const VectorPostprocessorName &	getVectorPostprocessorName (const std::string &param_name) const

virtual void	meshChanged ()

void	buildOutputHideVariableList (std::set< std::string > variable_names)

void	setRandomResetFrequency (ExecFlagType exec_flag)

unsigned long	getRandomLong () const

Real	getRandomReal () const

unsigned int	getSeed (std::size_t id)

unsigned int	getMasterSeed () const

bool	isNodal () const

ExecFlagType	getResetOnTime () const

void	setRandomDataPointer (RandomData *random_data)

virtual unsigned int	getElementIDIndex (const std::string &id_parameter_name, unsigned int comp=0) const

virtual unsigned int	getElementIDIndexByName (const std::string &id_name) const

bool	hasElementID (const std::string &id_name) const

dof_id_type	maxElementID (unsigned int elem_id_index) const

dof_id_type	minElementID (unsigned int elem_id_index) const

bool	areElemIDsIdentical (const std::string &id_name1, const std::string &id_name2) const

std::unordered_map< dof_id_type, std::set< dof_id_type > >	getElemIDMapping (const std::string &id_name1, const std::string &id_name2) const

std::set< dof_id_type >	getAllElemIDs (unsigned int elem_id_index) const

std::set< dof_id_type >	getElemIDsOnBlocks (unsigned int elem_id_index, const std::set< SubdomainID > &blks) const

const std::unordered_map< std::string, std::vector< MooseVariableFieldBase *> > &	getCoupledVars () const

const std::vector< MooseVariableFieldBase *> &	getCoupledMooseVars () const

const std::vector< MooseVariable *> &	getCoupledStandardMooseVars () const

const std::vector< VectorMooseVariable *> &	getCoupledVectorMooseVars () const

const std::vector< ArrayMooseVariable *> &	getCoupledArrayMooseVars () const

void	addFEVariableCoupleableVectorTag (TagID tag)

void	addFEVariableCoupleableMatrixTag (TagID tag)

std::set< TagID > &	getFEVariableCoupleableVectorTags ()

const std::set< TagID > &	getFEVariableCoupleableVectorTags () const

std::set< TagID > &	getFEVariableCoupleableMatrixTags ()

const std::set< TagID > &	getFEVariableCoupleableMatrixTags () const

auto &	getWritableCoupledVariables () const

bool	hasWritableCoupledVariables () const

const ADVariableValue *	getADDefaultValue (const std::string &var_name) const

const ADVectorVariableValue *	getADDefaultVectorValue (const std::string &var_name) const

const ADVariableGradient &	getADDefaultGradient () const

const ADVectorVariableGradient &	getADDefaultVectorGradient () const

const ADVariableSecond &	getADDefaultSecond () const

const ADVectorVariableCurl &	getADDefaultCurl () const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledVectorTagGradientByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledVectorTagGradientsByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagNodalValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagNodalValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagDofValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagDofValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledVectorTagGradient (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledVectorTagGradients (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagNodalValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagNodalValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagDofValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagDofValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorTagVectorGradientByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorTagVectorGradientsByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorNodalValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorNodalValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorDofValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorDofValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorTagVectorGradient (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorTagVectorGradients (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorNodalValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorNodalValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorDofValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorDofValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VariableValue	kokkosCoupledValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledValues (const std::string &var_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradient (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradients (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValues (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValues (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledValuesOld (const std::string &var_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradientOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradientsOld (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValuesOld (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValuesOld (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledValuesOlder (const std::string &var_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradientOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradientsOlder (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValuesOlder (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValuesOlder (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledDots (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalDots (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradient (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValues (const std::string &var_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradients (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValues (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValues (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradientOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValuesOld (const std::string &var_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradientsOld (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValuesOld (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValuesOld (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradientOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValuesOlder (const std::string &var_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradientsOlder (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValuesOlder (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValuesOlder (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDots (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalDots (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledVectorTagGradientByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledVectorTagGradientsByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagNodalValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagNodalValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagDofValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagDofValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledVectorTagGradient (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledVectorTagGradients (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagNodalValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagNodalValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagDofValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagDofValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValues (const std::string &var_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradient (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradients (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValues (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValues (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValuesOld (const std::string &var_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradientOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradientsOld (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValuesOld (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValuesOld (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValuesOlder (const std::string &var_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradientOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradientsOlder (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValuesOlder (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValuesOlder (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDots (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalDots (const std::string &var_name) const

Moose::Kokkos::Scalar< const Real >	kokkosCoupledDotDu (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosZeroValue () const

Moose::Kokkos::VariableGradient	kokkosZeroGradient () const

Moose::Kokkos::VariableValue	kokkosZeroNodalValue () const

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, MaterialData &material_data, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialProperty (const std::string &name, MaterialData &material_data, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialProperty (const std::string &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialProperty (const std::string &name, const unsigned int state=0)

const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name, MaterialData &material_data)

const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name)

const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data, const unsigned int state)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const std::string &name, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const std::string &name, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const std::string &prop_name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const std::string &prop_name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const std::string &prop_name)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const std::string &prop_name)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const std::string &prop_name)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const std::string &prop_name)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const std::string &prop_name)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const std::string &prop_name)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyByName (const std::string &prop_name_in)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOldByName (const std::string &prop_name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOlderByName (const std::string &prop_name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialProperty (const std::string &name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOld (const std::string &name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOlder (const std::string &name)

std::pair< const MaterialProperty< T > *, std::set< SubdomainID > >	getBlockMaterialProperty (const MaterialPropertyName &name)

std::pair< Moose::Kokkos::MaterialProperty< T, dimension >, std::set< SubdomainID > >	getKokkosBlockMaterialProperty (const MaterialPropertyName &name)

std::set< SubdomainID >	getMaterialPropertyBlocks (const std::string &name)

std::vector< SubdomainName >	getMaterialPropertyBlockNames (const std::string &name)

std::set< BoundaryID >	getMaterialPropertyBoundaryIDs (const std::string &name)

std::vector< BoundaryName >	getMaterialPropertyBoundaryNames (const std::string &name)

void	checkBlockAndBoundaryCompatibility (std::shared_ptr< MaterialBase > discrete)

std::unordered_map< SubdomainID, std::vector< MaterialBase *> >	buildRequiredMaterials (bool allow_stateful=true)

void	statefulPropertiesAllowed (bool)

virtual bool	getMaterialPropertyCalled () const

const GenericMaterialProperty< T, is_ad > &	getPossiblyConstantGenericMaterialPropertyByName (const MaterialPropertyName &prop_name, MaterialData &material_data, const unsigned int state)

const GenericOptionalMaterialProperty< T, is_ad > &	getGenericOptionalMaterialProperty (const std::string &name, const unsigned int state=0)

const GenericOptionalMaterialProperty< T, is_ad > &	getGenericOptionalMaterialProperty (const std::string &name, const unsigned int state=0)

const OptionalMaterialProperty< T > &	getOptionalMaterialProperty (const std::string &name, const unsigned int state=0)

const OptionalMaterialProperty< T > &	getOptionalMaterialProperty (const std::string &name, const unsigned int state=0)

const OptionalADMaterialProperty< T > &	getOptionalADMaterialProperty (const std::string &name)

const OptionalADMaterialProperty< T > &	getOptionalADMaterialProperty (const std::string &name)

const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOld (const std::string &name)

const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOld (const std::string &name)

const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOlder (const std::string &name)

const OptionalMaterialProperty< T > &	getOptionalMaterialPropertyOlder (const std::string &name)

MaterialProperty< T > &	declarePropertyByName (const std::string &prop_name)

MaterialProperty< T > &	declarePropertyByName (const std::string &prop_name)

MaterialProperty< T > &	declareProperty (const std::string &name)

MaterialProperty< T > &	declareProperty (const std::string &name)

ADMaterialProperty< T > &	declareADPropertyByName (const std::string &prop_name)

ADMaterialProperty< T > &	declareADPropertyByName (const std::string &prop_name)

ADMaterialProperty< T > &	declareADProperty (const std::string &name)

ADMaterialProperty< T > &	declareADProperty (const std::string &name)

auto &	declareGenericProperty (const std::string &prop_name)

auto &	declareGenericProperty (const std::string &prop_name)

GenericMaterialProperty< T, is_ad > &	declareGenericPropertyByName (const std::string &prop_name)

GenericMaterialProperty< T, is_ad > &	declareGenericPropertyByName (const std::string &prop_name)

const Distribution &	getDistribution (const std::string &name) const

const T &	getDistribution (const std::string &name) const

const Distribution &	getDistribution (const std::string &name) const

const T &	getDistribution (const std::string &name) const

const Distribution &	getDistributionByName (const DistributionName &name) const

const T &	getDistributionByName (const std::string &name) const

const Distribution &	getDistributionByName (const DistributionName &name) const

const T &	getDistributionByName (const std::string &name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

bool	isVectorPostprocessorDistributed (const std::string &param_name) const

bool	isVectorPostprocessorDistributed (const std::string &param_name) const

bool	isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const

bool	isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const

bool	hasMaterialProperty (const std::string &name)

bool	hasMaterialProperty (const std::string &name)

bool	hasMaterialPropertyByName (const std::string &name)

bool	hasMaterialPropertyByName (const std::string &name)

bool	hasADMaterialProperty (const std::string &name)

bool	hasADMaterialProperty (const std::string &name)

bool	hasADMaterialPropertyByName (const std::string &name)

bool	hasADMaterialPropertyByName (const std::string &name)

bool	hasKokkosMaterialProperty (const std::string &name)

bool	hasKokkosMaterialProperty (const std::string &name)

bool	hasKokkosMaterialPropertyByName (const std::string &name)

bool	hasKokkosMaterialPropertyByName (const std::string &name)

bool	hasGenericMaterialProperty (const std::string &name)

bool	hasGenericMaterialProperty (const std::string &name)

bool	hasGenericMaterialPropertyByName (const std::string &name)

bool	hasGenericMaterialPropertyByName (const std::string &name)

PenetrationLocator &	getPenetrationLocator (const BoundaryName &primary, const BoundaryName &secondary, Order order)

PenetrationLocator &	getQuadraturePenetrationLocator (const BoundaryName &primary, const BoundaryName &secondary, Order order)

NearestNodeLocator &	getNearestNodeLocator (const BoundaryName &primary, const BoundaryName &secondary)

NearestNodeLocator &	getQuadratureNearestNodeLocator (const BoundaryName &primary, const BoundaryName &secondary)

bool	requiresGeometricSearch () const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

bool	hasGuarantee (const MaterialPropertyName &prop_name, Guarantee guarantee)

Static Public Member Functions
static InputParameters	baseParams ()

static InputParameters	validParams ()

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

static std::deque< MaterialBase *>	buildRequiredMaterials (const Consumers &mat_consumers, const std::vector< std::shared_ptr< MaterialBase >> &mats, const bool allow_stateful)

static bool	restricted (const std::set< BoundaryID > &ids)

static void	sort (typename std::vector< T > &vector)

static void	sortDFS (typename std::vector< T > &vector)

static void	cyclicDependencyError (CyclicDependencyException< T2 > &e, const std::string &header, NameFunc &&name_func)

static void	cyclicDependencyError (CyclicDependencyException< T2 > &e, const std::string &header)

static std::string	deduceFunctorName (const std::string &name, const InputParameters &params)

Public Attributes
	ALL

	ANY

	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

static constexpr PropertyValue::id_type	default_property_id

static constexpr PropertyValue::id_type	zero_property_id

Protected Types
enum	QP_Data_Type

Protected Member Functions
virtual void	initQpStatefulProperties () override

virtual void	computeProperties () override

virtual void	computeQpProperties () override

virtual void	computeQpIncrementalStrains (const RankTwoTensor &dL)
	Calculate the strains based on the spatial velocity gradient. More...

void	setQpIncrementalStrains (const RankTwoTensor &dd, const RankTwoTensor &dw)
	Update strain / vorticity / mechanical-strain bookkeeping from already-split (`dd`, `dw`) tensors. More...

void	computeQpLargeKinematicIncrement (const RankTwoTensor &f_inv, RankTwoTensor &dd, RankTwoTensor &dw, RankFourTensor &d_dL_d_f_inv, RankFourTensor &d_dw_d_f_inv, bool need_jacobian)
	Dispatcher: compute (Deltad, Deltaw, d(Deltal)/d(f^{-1}), d(Deltaw)/d(f^{-1})) for the active kinematic approximation. More...

void	computeQpPolarDecomposition (bool need_jacobian)
	Compute and publish the polar decomposition of _F_actual at the current qp. More...

virtual void	subtractQpEigenstrainIncrement (RankTwoTensor &strain)
	Subtract the eigenstrain increment to subtract from the total strain. More...

virtual void	computeQpUnstabilizedDeformationGradient ()
	Calculate the unstabilized (alpha-weighted) deformation gradient at the quadrature point. More...

virtual void	computeQpActualDeformationGradient ()
	Calculate the actual deformation gradient at n+1 (no alpha weighting, no F-bar) More...

virtual void	computeDeformationGradient ()
	Calculate the unstabilized and optionally the stabilized deformation gradients. More...

virtual void	checkMaterialProperty (const std::string &name, const unsigned int state) override

virtual const MaterialData &	materialData () const override

virtual MaterialData &	materialData () override

virtual Moose::MaterialDataType	materialDataType () override

virtual const QBase &	qRule () const override

virtual void	resetQpProperties ()

virtual const FEProblemBase &	miProblem () const

virtual FEProblemBase &	miProblem ()

bool	isPropertyActive (const unsigned int prop_id) const

void	registerPropName (const std::string &prop_name, bool is_get, const unsigned int state)

void	checkExecutionStage ()

void	checkExecutionStage ()

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

virtual bool	hasBlockMaterialPropertyHelper (const std::string &prop_name)

void	initializeBlockRestrictable (const MooseObject *moose_object)

void	initializeKokkosBlockRestrictable ()

Moose::CoordinateSystemType	getBlockCoordSystem ()

KOKKOS_FUNCTION dof_id_type	numKokkosBlockElements () const

KOKKOS_FUNCTION dof_id_type	numKokkosBlockNodes () const

KOKKOS_FUNCTION dof_id_type	numKokkosBlockSides () const

KOKKOS_FUNCTION ContiguousElementID	kokkosBlockElementID (Moose::Kokkos::ThreadID tid) const

KOKKOS_FUNCTION ContiguousElementID	kokkosBlockNodeID (Moose::Kokkos::ThreadID tid) const

KOKKOS_FUNCTION auto	kokkosBlockElementSideID (Moose::Kokkos::ThreadID tid) const

bool	hasBoundaryMaterialPropertyHelper (const std::string &prop_name) const

KOKKOS_FUNCTION dof_id_type	numKokkosBoundaryNodes () const

KOKKOS_FUNCTION dof_id_type	numKokkosBoundarySides () const

KOKKOS_FUNCTION ContiguousNodeID	kokkosBoundaryNodeID (Moose::Kokkos::ThreadID tid) const

KOKKOS_FUNCTION auto	kokkosBoundaryElementSideID (Moose::Kokkos::ThreadID tid) const

bool	isCoupledScalar (const std::string &var_name, unsigned int i=0) const

unsigned int	coupledScalarComponents (const std::string &var_name) const

unsigned int	coupledScalar (const std::string &var_name, unsigned int comp=0) const

libMesh::Order	coupledScalarOrder (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarValue (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledScalarValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< is_ad > &	coupledGenericScalarValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const

const VariableValue &	coupledVectorTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const

const VariableValue &	coupledMatrixTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const

const VariableValue &	coupledScalarValueOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarValueOlder (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDot (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledScalarDot (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDot (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDotOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDu (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDotDu (const std::string &var_name, unsigned int comp=0) const

const MooseVariableScalar *	getScalarVar (const std::string &var_name, unsigned int comp) const

virtual void	addUserObjectDependencyHelper (const UserObjectBase &) const

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &) const

virtual void	addVectorPostprocessorDependencyHelper (const VectorPostprocessorName &) const

T &	declareRestartableData (const std::string &data_name, Args &&... args)

ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

const T &	getRestartableData (const std::string &data_name) const

T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

T &	declareRecoverableData (const std::string &data_name, Args &&... args)

T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)

T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)

std::string	restartableName (const std::string &data_name) const

std::string	deduceFunctorName (const std::string &name) const

const Moose::Functor< T > &	getFunctor (const std::string &name)

const Moose::Functor< T > &	getFunctor (const std::string &name, THREAD_ID tid)

const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem)

const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem, THREAD_ID tid)

bool	isFunctor (const std::string &name) const

bool	isFunctor (const std::string &name, const SubProblem &subproblem) const

Moose::ElemArg	makeElemArg (const Elem *elem, bool correct_skewnewss=false) const

void	checkFunctorSupportsSideIntegration (const std::string &name, bool qp_integration)

const Moose::Functor< T > &	getFunctorByName (const std::string &name)

virtual void	coupledCallback (const std::string &, bool) const

virtual bool	isCoupled (const std::string &var_name, unsigned int i=0) const

virtual bool	isCoupledConstant (const std::string &var_name) const

unsigned int	coupledComponents (const std::string &var_name) const

VariableName	coupledName (const std::string &var_name, unsigned int comp=0) const

std::vector< VariableName >	coupledNames (const std::string &var_name) const

virtual unsigned int	coupled (const std::string &var_name, unsigned int comp=0) const

std::vector< unsigned int >	coupledIndices (const std::string &var_name) const

virtual const VariableValue &	coupledValue (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledValues (const std::string &var_name) const

std::vector< const VectorVariableValue *>	coupledVectorValues (const std::string &var_name) const

const GenericVariableValue< is_ad > &	coupledGenericValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericValue (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericValue (const std::string &var_name, unsigned int comp) const

const GenericVectorVariableValue< is_ad > &	coupledGenericVectorValue (const std::string &var_name, unsigned int comp=0) const

const GenericVectorVariableValue< false > &	coupledGenericVectorValue (const std::string &var_name, unsigned int comp) const

const GenericVectorVariableValue< true > &	coupledGenericVectorValue (const std::string &var_name, unsigned int comp) const

std::vector< const GenericVariableValue< is_ad > *>	coupledGenericValues (const std::string &var_name) const

std::vector< const GenericVariableValue< false > *>	coupledGenericValues (const std::string &var_name) const

std::vector< const GenericVariableValue< true > *>	coupledGenericValues (const std::string &var_name) const

const GenericVariableValue< is_ad > &	coupledGenericDofValue (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericDofValue (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericDofValue (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< is_ad > &	coupledGenericDot (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericDot (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericDot (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< is_ad > &	coupledGenericDotDot (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericDotDot (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericDotDot (const std::string &var_name, unsigned int comp) const

virtual const VariableValue &	coupledValueLower (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledValue (const std::string &var_name, unsigned int comp=0) const

std::vector< const ADVariableValue *>	adCoupledValues (const std::string &var_name) const

const ADVariableValue &	adCoupledLowerValue (const std::string &var_name, unsigned int comp=0) const

const ADVectorVariableValue &	adCoupledVectorValue (const std::string &var_name, unsigned int comp=0) const

std::vector< const ADVectorVariableValue *>	adCoupledVectorValues (const std::string &var_name) const

virtual const VariableValue &	coupledVectorTagValue (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const VariableValue &	coupledVectorTagValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

std::vector< const VariableValue *>	coupledVectorTagValues (const std::string &var_names, TagID tag) const

std::vector< const VariableValue *>	coupledVectorTagValues (const std::string &var_names, const std::string &tag_name) const

virtual const ArrayVariableValue &	coupledVectorTagArrayValue (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const ArrayVariableValue &	coupledVectorTagArrayValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

std::vector< const ArrayVariableValue *>	coupledVectorTagArrayValues (const std::string &var_names, TagID tag) const

std::vector< const ArrayVariableValue *>	coupledVectorTagArrayValues (const std::string &var_names, const std::string &tag_name) const

virtual const VariableGradient &	coupledVectorTagGradient (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const VariableGradient &	coupledVectorTagGradient (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

std::vector< const VariableGradient *>	coupledVectorTagGradients (const std::string &var_names, TagID tag) const

std::vector< const VariableGradient *>	coupledVectorTagGradients (const std::string &var_names, const std::string &tag_name) const

virtual const ArrayVariableGradient &	coupledVectorTagArrayGradient (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const ArrayVariableGradient &	coupledVectorTagArrayGradient (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

std::vector< const ArrayVariableGradient *>	coupledVectorTagArrayGradients (const std::string &var_names, TagID tag) const

std::vector< const ArrayVariableGradient *>	coupledVectorTagArrayGradients (const std::string &var_names, const std::string &tag_name) const

virtual const VariableValue &	coupledVectorTagDofValue (const std::string &var_name, TagID tag, unsigned int index=0) const

virtual const VariableValue &	coupledVectorTagDofValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

const ArrayVariableValue &	coupledVectorTagArrayDofValue (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledVectorTagDofValues (const std::string &var_names, TagID tag) const

std::vector< const VariableValue *>	coupledVectorTagDofValues (const std::string &var_names, const std::string &tag_name) const

virtual const VariableValue &	coupledMatrixTagValue (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const VariableValue &	coupledMatrixTagValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

std::vector< const VariableValue *>	coupledMatrixTagValues (const std::string &var_names, TagID tag) const

std::vector< const VariableValue *>	coupledMatrixTagValues (const std::string &var_names, const std::string &tag_name) const

virtual const VectorVariableValue &	coupledVectorValue (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayValue (const std::string &var_name, unsigned int comp=0) const

std::vector< const ArrayVariableValue *>	coupledArrayValues (const std::string &var_name) const

MooseWritableVariable &	writableVariable (const std::string &var_name, unsigned int comp=0)

virtual VariableValue &	writableCoupledValue (const std::string &var_name, unsigned int comp=0)

void	checkWritableVar (MooseWritableVariable *var)

virtual const VariableValue &	coupledValueOld (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledValuesOld (const std::string &var_name) const

std::vector< const VectorVariableValue *>	coupledVectorValuesOld (const std::string &var_name) const

virtual const VariableValue &	coupledValueOlder (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledValuesOlder (const std::string &var_name) const

virtual const VariableValue &	coupledValuePreviousNL (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorValueOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorValueOlder (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayValueOld (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayValueOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradient (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableGradient *>	coupledGradients (const std::string &var_name) const

const ADVariableGradient &	adCoupledGradient (const std::string &var_name, unsigned int comp=0) const

const ADVariableGradient &	adCoupledGradientDot (const std::string &var_name, unsigned int comp=0) const

std::vector< const ADVariableGradient *>	adCoupledGradients (const std::string &var_name) const

const GenericVariableGradient< is_ad > &	coupledGenericGradient (const std::string &var_name, unsigned int comp=0) const

const GenericVariableGradient< false > &	coupledGenericGradient (const std::string &var_name, unsigned int comp) const

const GenericVariableGradient< true > &	coupledGenericGradient (const std::string &var_name, unsigned int comp) const

std::vector< const GenericVariableGradient< is_ad > *>	coupledGenericGradients (const std::string &var_name) const

std::vector< const GenericVariableGradient< false > *>	coupledGenericGradients (const std::string &var_name) const

std::vector< const GenericVariableGradient< true > *>	coupledGenericGradients (const std::string &var_name) const

const ADVectorVariableGradient &	adCoupledVectorGradient (const std::string &var_name, unsigned int comp=0) const

const ADVariableSecond &	adCoupledSecond (const std::string &var_name, unsigned int comp=0) const

const ADVectorVariableSecond &	adCoupledVectorSecond (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradientOld (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableGradient *>	coupledGradientsOld (const std::string &var_name) const

virtual const VariableGradient &	coupledGradientOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradientPreviousNL (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradientDot (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradientDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableGradient &	coupledVectorGradient (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableGradient &	coupledVectorGradientOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableGradient &	coupledVectorGradientOlder (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayGradient (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayGradientOld (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayGradientOlder (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayGradientDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableCurl &	coupledCurl (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableCurl &	coupledCurlOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableCurl &	coupledCurlOlder (const std::string &var_name, unsigned int comp=0) const

const ADVectorVariableCurl &	adCoupledCurl (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableDivergence &	coupledDiv (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableDivergence &	coupledDivOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableDivergence &	coupledDivOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableSecond &	coupledSecond (const std::string &var_name, unsigned int comp=0) const

virtual const VariableSecond &	coupledSecondOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableSecond &	coupledSecondOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableSecond &	coupledSecondPreviousNL (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDot (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledDots (const std::string &var_name) const

virtual const VariableValue &	coupledDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDotDotOld (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledDot (const std::string &var_name, unsigned int comp=0) const

std::vector< const ADVariableValue *>	adCoupledDots (const std::string &var_name) const

const ADVariableValue &	adCoupledDotDot (const std::string &var_name, unsigned int comp=0) const

const ADVectorVariableValue &	adCoupledVectorDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorDotDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledVectorDotDu (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledVectorDotDotDu (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayDot (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayDotDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDotDu (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDotDotDu (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledArrayDotDu (const std::string &var_name, unsigned int comp=0) const

const T &	coupledNodalValue (const std::string &var_name, unsigned int comp=0) const

const Moose::ADType< T >::type &	adCoupledNodalValue (const std::string &var_name, unsigned int comp=0) const

const T &	coupledNodalValueOld (const std::string &var_name, unsigned int comp=0) const

const T &	coupledNodalValueOlder (const std::string &var_name, unsigned int comp=0) const

const T &	coupledNodalValuePreviousNL (const std::string &var_name, unsigned int comp=0) const

const T &	coupledNodalDot (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNodalDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNodalDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNodalDotDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDofValues (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledAllDofValues (const std::string &var_name) const

virtual const VariableValue &	coupledDofValuesOld (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledAllDofValuesOld (const std::string &var_name) const

virtual const VariableValue &	coupledDofValuesOlder (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue *>	coupledAllDofValuesOlder (const std::string &var_name) const

virtual const ArrayVariableValue &	coupledArrayDofValues (const std::string &var_name, unsigned int comp=0) const

virtual const ADVariableValue &	adCoupledDofValues (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adZeroValue () const

const ADVariableGradient &	adZeroGradient () const

const ADVariableSecond &	adZeroSecond () const

const GenericVariableValue< is_ad > &	genericZeroValue ()

const GenericVariableValue< false > &	genericZeroValue ()

const GenericVariableValue< true > &	genericZeroValue ()

const GenericVariableGradient< is_ad > &	genericZeroGradient ()

const GenericVariableGradient< false > &	genericZeroGradient ()

const GenericVariableGradient< true > &	genericZeroGradient ()

const GenericVariableSecond< is_ad > &	genericZeroSecond ()

const GenericVariableSecond< false > &	genericZeroSecond ()

const GenericVariableSecond< true > &	genericZeroSecond ()

bool	checkVar (const std::string &var_name, unsigned int comp=0, unsigned int comp_bound=0) const

const MooseVariableFieldBase *	getFEVar (const std::string &var_name, unsigned int comp) const

const MooseVariableFieldBase *	getFieldVar (const std::string &var_name, unsigned int comp) const

MooseVariableFieldBase *	getFieldVar (const std::string &var_name, unsigned int comp)

std::vector< const MooseVariableFieldBase *>	getFieldVars (const std::string &var_name) const

const T *	getVarHelper (const std::string &var_name, unsigned int comp) const

T *	getVarHelper (const std::string &var_name, unsigned int comp)

std::vector< const T *>	getVarsHelper (const std::string &var_name) const

MooseVariable *	getVar (const std::string &var_name, unsigned int comp)

const MooseVariable *	getVar (const std::string &var_name, unsigned int comp) const

VectorMooseVariable *	getVectorVar (const std::string &var_name, unsigned int comp)

const VectorMooseVariable *	getVectorVar (const std::string &var_name, unsigned int comp) const

ArrayMooseVariable *	getArrayVar (const std::string &var_name, unsigned int comp)

const ArrayMooseVariable *	getArrayVar (const std::string &var_name, unsigned int comp) const

void	validateExecutionerType (const std::string &name, const std::string &fn_name) const

std::vector< T >	coupledVectorHelper (const std::string &var_name, const Func &func) const

virtual void	getKokkosMaterialPropertyHook (const std::string &, const unsigned int)

void	markMatPropRequested (const std::string &)

MaterialPropertyName	getMaterialPropertyName (const std::string &name) const

const GenericMaterialProperty< T, is_ad > *	defaultGenericMaterialProperty (const std::string &name)

const GenericMaterialProperty< T, is_ad > *	defaultGenericMaterialProperty (const std::string &name)

const MaterialProperty< T > *	defaultMaterialProperty (const std::string &name)

const MaterialProperty< T > *	defaultMaterialProperty (const std::string &name)

const ADMaterialProperty< T > *	defaultADMaterialProperty (const std::string &name)

const ADMaterialProperty< T > *	defaultADMaterialProperty (const std::string &name)

void	issueGuarantee (const MaterialPropertyName &prop_name, Guarantee guarantee)

void	revokeGuarantee (const MaterialPropertyName &prop_name, Guarantee guarantee)

Protected Attributes
const unsigned int	_ndisp

std::vector< const VariableValue * >	_disp

std::vector< const VariableGradient * >	_grad_disp

std::vector< const VariableValue * >	_disp_old
	Old displacement values for the generalized midpoint rule. More...

std::vector< const VariableGradient * >	_grad_disp_old
	Old displacement gradients for the generalized midpoint rule. More...

const std::string	_base_name
	Material system base name. More...

const bool	_large_kinematics
	If true the equilibrium conditions is calculated with large deformations. More...

const bool	_stabilize_strain
	If true stabilize the strains with F_bar. More...

const FBarMode	_F_bar_mode
	Selected F-bar averaging mode (Total vs. Incremental). See `FBarMode`. More...

const bool	_publish_rotation_increment
	If true, publish `_rotation_increment = exp(_vorticity_increment)` (Rodrigues) instead of the default identity. More...

const Real	_alpha
	Generalized-midpoint weight for the deformation gradient (1.0 = backward Euler, 0.5 = midpoint) More...

const KinematicApproximation	_kinematic_approximation
	Selected approximation for the spatial velocity gradient increment. More...

std::vector< MaterialPropertyName >	_eigenstrain_names

std::vector< const MaterialProperty< RankTwoTensor > * >	_eigenstrains

std::vector< const MaterialProperty< RankTwoTensor > * >	_eigenstrains_old

MaterialProperty< RankTwoTensor > &	_total_strain

const MaterialProperty< RankTwoTensor > &	_total_strain_old

MaterialProperty< RankTwoTensor > &	_mechanical_strain

const MaterialProperty< RankTwoTensor > &	_mechanical_strain_old

MaterialProperty< RankTwoTensor > &	_rotated_mechanical_strain
	Mechanical strain accumulated with the incremental rotation r_hat = exp(Deltaw), matching the convention `ComputeFiniteStrain` uses for its `mechanical_strain` output (`eps_n+1 = r_hat * (eps_n + Deltad) * r_hat^T`). More...

const MaterialProperty< RankTwoTensor > &	_rotated_mechanical_strain_old

MaterialProperty< RankTwoTensor > &	_strain_increment
	Strain increment. More...

MaterialProperty< RankTwoTensor > &	_deformation_gradient_increment
	Deformation gradient increment. More...

MaterialProperty< RankTwoTensor > &	_vorticity_increment
	Vorticity increment. More...

MaterialProperty< RankTwoTensor > &	_F_ust
	The unstabilized (alpha-weighted) deformation gradient. More...

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

MaterialProperty< RankTwoTensor > &	_F_actual
	The literal deformation gradient at n+1 (I + grad u_{n+1}). More...

MaterialProperty< RankTwoTensor > &	_F_avg

MaterialProperty< RankTwoTensor > &	_F

const MaterialProperty< RankTwoTensor > &	_F_old
	Old deformation gradient. More...

MaterialProperty< RankTwoTensor > &	_F_inv
	Inverse deformation gradient. More...

MaterialProperty< RankTwoTensor > &	_f_inv
	Inverse incremental deformation gradient. More...

MaterialProperty< RankTwoTensor > &	_F_ust_inv
	Inverse and determinant of the unstabilized deformation gradient F_ust. More...

MaterialProperty< Real > &	_F_ust_det

MaterialProperty< RankFourTensor > &	_d_deformation_gradient_increment_d_F
	Derivative of the spatial velocity gradient increment with respect to F_{n+1}. More...

MaterialProperty< RankFourTensor > &	_d_vorticity_increment_d_F
	Derivative of the vorticity increment Deltaw with respect to F_{n+1}. More...

MaterialProperty< RankFourTensor > &	_d_F_d_grad_u
	Derivative of F_{n+1} with respect to the displacement gradient. More...

MaterialProperty< RankTwoTensor > &	_rotation
	Polar decomposition R of the (alpha-weighted, F-bar-stabilized) deformation gradient F at this qp. More...

MaterialProperty< RankTwoTensor > &	_stretch
	Stretch U from the same polar decomposition. More...

MaterialProperty< RankFourTensor > &	_d_rotation_d_F
	Derivative of R with respect to F. More...

MaterialProperty< RankFourTensor > &	_d_F_stab_d_F_ust
	Partial derivative of the F-bar-stabilized deformation gradient with respect to the unstabilized (per-qp local) deformation gradient. More...

MaterialProperty< RankFourTensor > &	_d_F_stab_d_F_avg
	Partial derivative of the F-bar-stabilized deformation gradient with respect to the element-averaged deformation gradient F_avg (the non-local coupling). More...

std::vector< MaterialPropertyName >	_homogenization_gradient_names
	Names of any extra homogenization gradients. More...

std::vector< const MaterialProperty< RankTwoTensor > * >	_homogenization_contributions
	Actual homogenization contributions. More...

MaterialProperty< RankTwoTensor > &	_rotation_increment
	Rotation increment for "old" materials inheriting from ComputeStressBase. More...

	CURR

	PREV

bool	_bnd

bool	_neighbor

const MooseArray< Point > &	_q_point

const QBase *const &	_qrule

const MooseArray< Real > &	_JxW

const Elem *const &	_current_elem

const SubdomainID &	_current_subdomain_id

const unsigned int &	_current_side

const ConstantTypeEnum	_constant_option

SubProblem &	_subproblem

FEProblemBase &	_fe_problem

THREAD_ID	_tid

Assembly &	_assembly

unsigned int	_qp

const MooseArray< Real > &	_coord

const MooseArray< Point > &	_normals

MooseMesh &	_mesh

const Moose::CoordinateSystemType &	_coord_sys

std::set< std::string >	_requested_props

std::set< std::string >	_supplied_props

std::set< unsigned int >	_supplied_prop_ids

std::unordered_set< unsigned int >	_active_prop_ids

const bool	_compute

std::unordered_map< unsigned int, unsigned int >	_props_to_min_states

std::vector< unsigned int >	_displacements

bool	_has_stateful_property

bool	_overrides_init_stateful_props

const FaceInfo *	_face_info

const MaterialPropertyName	_declare_suffix

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const MaterialData *	_blk_material_data

const ExecFlagEnum &	_execute_enum

const ExecFlagType &	_current_execute_flag

FEProblemBase &	_sc_fe_problem

const THREAD_ID	_sc_tid

const Real &	_real_zero

const VariableValue &	_scalar_zero

const Point &	_point_zero

const InputParameters &	_ti_params

FEProblemBase &	_ti_feproblem

bool	_is_implicit

Real &	_t

const Real &	_t_old

int &	_t_step

Real &	_dt

Real &	_dt_old

bool	_is_transient

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

FEProblemBase &	_mci_feproblem

GeometricSearchData &	_geometric_search_data

bool	_requires_geometric_search

const InputParameters &	_c_parameters

const std::string &	_c_name

const std::string &	_c_type

FEProblemBase &	_c_fe_problem

const SystemBase *const	_c_sys

std::unordered_map< std::string, std::vector< MooseVariableFieldBase *> >	_coupled_vars

std::vector< MooseVariableFieldBase *>	_coupled_moose_vars

std::vector< MooseVariable *>	_coupled_standard_moose_vars

std::vector< VectorMooseVariable *>	_coupled_vector_moose_vars

std::vector< ArrayMooseVariable *>	_coupled_array_moose_vars

std::vector< MooseVariableField< Real > *>	_coupled_fv_moose_vars

const std::unordered_map< std::string, std::string > &	_new_to_deprecated_coupled_vars

bool	_c_nodal

bool	_c_is_implicit

const bool	_c_allow_element_to_nodal_coupling

THREAD_ID	_c_tid

std::unordered_map< std::string, std::vector< std::unique_ptr< VariableValue > > >	_default_value

std::unordered_map< std::string, std::unique_ptr< MooseArray< ADReal > > >	_ad_default_value

std::unordered_map< std::string, std::unique_ptr< VectorVariableValue > >	_default_vector_value

std::unordered_map< std::string, std::unique_ptr< ArrayVariableValue > >	_default_array_value

std::unordered_map< std::string, std::unique_ptr< MooseArray< ADRealVectorValue > > >	_ad_default_vector_value

VariableValue	_default_value_zero

VariableGradient	_default_gradient

MooseArray< ADRealVectorValue >	_ad_default_gradient

MooseArray< ADRealTensorValue >	_ad_default_vector_gradient

VariableSecond	_default_second

MooseArray< ADRealTensorValue >	_ad_default_second

MooseArray< ADRealVectorValue >	_ad_default_curl

const VariableValue &	_zero

const VariablePhiValue &	_phi_zero

const MooseArray< ADReal > &	_ad_zero

const VariableGradient &	_grad_zero

const MooseArray< ADRealVectorValue > &	_ad_grad_zero

const VariablePhiGradient &	_grad_phi_zero

const VariableSecond &	_second_zero

const MooseArray< ADRealTensorValue > &	_ad_second_zero

const VariablePhiSecond &	_second_phi_zero

const VectorVariableValue &	_vector_zero

const VectorVariableCurl &	_vector_curl_zero

VectorVariableValue	_default_vector_value_zero

VectorVariableGradient	_default_vector_gradient

VectorVariableCurl	_default_vector_curl

VectorVariableDivergence	_default_div

ArrayVariableValue	_default_array_value_zero

ArrayVariableGradient	_default_array_gradient

bool	_coupleable_neighbor

const InputParameters &	_mi_params

const std::string	_mi_name

const MooseObjectName	_mi_moose_object_name

FEProblemBase &	_mi_feproblem

SubProblem &	_mi_subproblem

const THREAD_ID	_mi_tid

const bool	_is_kokkos_object

const Moose::MaterialDataType	_material_data_type

MaterialData &	_material_data

bool	_stateful_allowed

bool	_get_material_property_called

std::vector< std::unique_ptr< PropertyValue > >	_default_properties

std::unordered_set< unsigned int >	_material_property_dependencies

const MaterialPropertyName	_get_suffix

const bool	_use_interpolated_state

const Parallel::Communicator &	_communicator

Static Protected Attributes
static const std::string	_interpolated_old

static const std::string	_interpolated_older

Private Member Functions
void	computeLinearIncrement (const RankTwoTensor &f_inv, RankTwoTensor &dd, RankTwoTensor &dw, RankFourTensor &d_dL_d_f_inv, RankFourTensor &d_dw_d_f_inv, bool need_jacobian) const
	Linear approximation: dL = I - f^{-1}. More...

void	computeQuadraticIncrement (const RankTwoTensor &f_inv, RankTwoTensor &dd, RankTwoTensor &dw, RankFourTensor &d_dL_d_f_inv, RankFourTensor &d_dw_d_f_inv, bool need_jacobian) const
	Quadratic approximation: dL = (I - f^{-1}) + 0.5 (I - f^{-1})^2. More...

void	computeRashidApproximateIncrement (const RankTwoTensor &f_inv, RankTwoTensor &dd, RankTwoTensor &dw, RankFourTensor &d_dL_d_f_inv, RankFourTensor &d_dw_d_f_inv, bool need_jacobian) const
	Rashid's approximate symmetric+skew formulas. More...

void	computeRashidEigenIncrement (const RankTwoTensor &f_inv, RankTwoTensor &dd, RankTwoTensor &dw, RankFourTensor &d_dL_d_f_inv, RankFourTensor &d_dw_d_f_inv, bool need_jacobian) const
	"Exact" via polar decomposition of f^{-1} + matrix logs. More...

RankTwoTensor	computeQpRotationIncrement (const RankTwoTensor &f_inv, const RankTwoTensor &dw) const
	Rotation increment matched to the active `_kinematic_approximation`, suitable for publishing as `_rotation_increment` so downstream `ComputeStressBase`-style materials see the OLD-compatible rotation. More...

Detailed Description

template<class G>
class ComputeLagrangianStrainBase< G >

Calculate strains to use the MOOSE materials with the Lagrangian kernels.

This class calculates strain measures used by ComputeLagrangianStress derived materials and used with UpdatedLagrangianStressDivergence and TotalLagrangianStressDivergence kernels

It has two basic jobs 1) Calculate the deformation gradient at time steps n+1 and n (the MOOSE material system doesn't bother for the SmallStrain case) This includes including F_bar stabilization, if requested 2) Calculate the kinematic quantities needed by the kernels: a) The incremental inverse deformation gradient b) The inverse deformation gradient c) The determinant of the current deformation gradient

If required by the stabilize_strain flag it averages the pressure parts of the deformation gradient.

This object cooperates with the homogenization constraint system by adding in the scalar field representing the macroscale displacement gradient before calculating strains.

Definition at line 43 of file ComputeLagrangianStrainBase.h.

Member Enumeration Documentation

◆ FBarMode

template<class G >

enum ComputeLagrangianStrainBase::FBarMode

strong

What F gets F-bar volumetric correction applied to.

Affects only stabilize_strain = true. Total -> average the full deformation gradient F_ust at each qp, then rescale by gamma = cbrt(det(F_avg) / det(F_ust[qp])). This is the existing behavior. Incremental -> average the incremental F (f_ust = F_ust * F_ust_old^{-1}) at each qp, then rescale by gamma = cbrt(det(f_avg) / det(f_ust[qp])). Matches the OLD ComputeFiniteStrain F-bar (averaged Fhat) so cumulative strain is bit-for-bit compatible with volumetric_locking_correction = true.

Enumerator
Total
Incremental

Definition at line 69 of file ComputeLagrangianStrainBase.h.

   {
     Total,
     Incremental
   };

◆ KinematicApproximation

template<class G >

enum ComputeLagrangianStrainBase::KinematicApproximation

strong

Approximation used to convert the inverse incremental deformation gradient f^{-1} into the increment in the spatial velocity gradient (and its symmetric / skew parts).

See rashid_project/plan_outline.pdf section 2.

Enumerator
Linear	dL = I - f^{-1}
Quadratic	dL = (I - f^{-1}) + 0.5 (I - f^{-1})^2
RashidApproximate	Rashid's symmetric+skew formulas.
RashidEigen	"Exact": polar decomposition + matrix logs

Definition at line 54 of file ComputeLagrangianStrainBase.h.

   {
     Linear,            
     Quadratic,         
     RashidApproximate, 
     RashidEigen        
   };

Constructor & Destructor Documentation

◆ ComputeLagrangianStrainBase()

template<class G >

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

Definition at line 76 of file ComputeLagrangianStrainBase.C.

   : Material(parameters),
     GuaranteeProvider(this),
     _ndisp(coupledComponents("displacements")),
     _disp(coupledValues("displacements")),
     _grad_disp(coupledGradients("displacements")),
     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
     _large_kinematics(getParam<bool>("large_kinematics")),
     _stabilize_strain(getParam<bool>("stabilize_strain")),
     _F_bar_mode(getParam<MooseEnum>("F_bar_mode").template getEnum<FBarMode>()),
     _publish_rotation_increment(getParam<bool>("publish_rotation_increment")),
     _alpha(getParam<Real>("alpha")),
     _kinematic_approximation(
         getParam<MooseEnum>("kinematic_approximation").template getEnum<KinematicApproximation>()),
     _eigenstrain_names(getParam<std::vector<MaterialPropertyName>>("eigenstrain_names")),
     _eigenstrains(_eigenstrain_names.size()),
     _eigenstrains_old(_eigenstrain_names.size()),
     _total_strain(declareProperty<RankTwoTensor>(_base_name + "total_strain")),
     _total_strain_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + "total_strain")),
     _mechanical_strain(declareProperty<RankTwoTensor>(_base_name + "mechanical_strain")),
     _mechanical_strain_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + "mechanical_strain")),
     _rotated_mechanical_strain(
         declareProperty<RankTwoTensor>(_base_name + "rotated_mechanical_strain")),
     _rotated_mechanical_strain_old(
         getMaterialPropertyOld<RankTwoTensor>(_base_name + "rotated_mechanical_strain")),
     _strain_increment(declareProperty<RankTwoTensor>(_base_name + "strain_increment")),
     _deformation_gradient_increment(
         declareProperty<RankTwoTensor>(_base_name + "spatial_deformation_gradient_increment")),
     _vorticity_increment(declareProperty<RankTwoTensor>(_base_name + "vorticity_increment")),
     _F_ust(declareProperty<RankTwoTensor>(_base_name + "unstabilized_deformation_gradient")),
     _F_ust_old(
         getMaterialPropertyOld<RankTwoTensor>(_base_name + "unstabilized_deformation_gradient")),
     _F_actual(declareProperty<RankTwoTensor>(_base_name + "actual_deformation_gradient")),
     _F_avg(declareProperty<RankTwoTensor>(_base_name + "average_deformation_gradient")),
     _F(declareProperty<RankTwoTensor>(_base_name + "deformation_gradient")),
     _F_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + "deformation_gradient")),
     _F_inv(declareProperty<RankTwoTensor>(_base_name + "inverse_deformation_gradient")),
     _f_inv(declareProperty<RankTwoTensor>(_base_name + "inverse_incremental_deformation_gradient")),
     _F_ust_inv(
         declareProperty<RankTwoTensor>(_base_name + "inverse_unstabilized_deformation_gradient")),
     _F_ust_det(declareProperty<Real>(_base_name + "det_unstabilized_deformation_gradient")),
     _d_deformation_gradient_increment_d_F(declareProperty<RankFourTensor>(
         _base_name + "d_spatial_deformation_gradient_increment_d_deformation_gradient")),
     _d_vorticity_increment_d_F(declareProperty<RankFourTensor>(
         _base_name + "d_vorticity_increment_d_deformation_gradient")),
     _d_F_d_grad_u(
         declareProperty<RankFourTensor>(_base_name + "d_deformation_gradient_d_grad_displacement")),
     _rotation(declareProperty<RankTwoTensor>(_base_name + "rotation")),
     _stretch(declareProperty<RankTwoTensor>(_base_name + "stretch")),
     _d_rotation_d_F(
         declareProperty<RankFourTensor>(_base_name + "d_rotation_d_deformation_gradient")),
     _d_F_stab_d_F_ust(declareProperty<RankFourTensor>(_base_name + "d_F_stab_d_F_unstabilized")),
     _d_F_stab_d_F_avg(declareProperty<RankFourTensor>(_base_name + "d_F_stab_d_F_average")),
     _homogenization_gradient_names(
         getParam<std::vector<MaterialPropertyName>>("homogenization_gradient_names")),
     _homogenization_contributions(_homogenization_gradient_names.size()),
     _rotation_increment(declareProperty<RankTwoTensor>(_base_name + "rotation_increment"))
 {
   // Couple old displacements only when the simulation is transient. With a Steady executioner
   // there is no "previous step", and the generalized midpoint rule treats the old state as
   // the undeformed reference (u_n = 0, grad u_n = 0, so F_n = I). The (1 - alpha) contribution
   // is then identically zero and we skip it in computeQpUnstabilizedDeformationGradient.
   if (_fe_problem.isTransient())
   {
     _disp_old = coupledValuesOld("displacements");
     _grad_disp_old = coupledGradientsOld("displacements");
   }
 
   // Setup eigenstrains
   for (auto i : make_range(_eigenstrain_names.size()))
   {
     _eigenstrains[i] = &getMaterialProperty<RankTwoTensor>(_eigenstrain_names[i]);
     _eigenstrains_old[i] = &getMaterialPropertyOld<RankTwoTensor>(_eigenstrain_names[i]);
   }
 
   // In the future maybe there is a reason to have more than one, but for now
   if (_homogenization_gradient_names.size() > 1)
     mooseError("ComputeLagrangianStrainBase cannot accommodate more than one "
                "homogenization gradient");
 
   // Setup homogenization contributions
   for (unsigned int i = 0; i < _homogenization_gradient_names.size(); i++)
     _homogenization_contributions[i] =
         &getMaterialProperty<RankTwoTensor>(_homogenization_gradient_names[i]);
 
   // The strain calculator is the single source of truth for the kinematics regime. Publish a
   // LARGE_KINEMATICS guarantee on the deformation gradient (issued in the constructor so it is in
   // place before any consumer's initialSetup); the Lagrangian stress calculators and
   // stress-divergence kernels derive their own `large_kinematics` from it. Small kinematics leaves
   // the guarantee absent, which the consumers read as `large_kinematics = false`.
   if (_large_kinematics)
     issueGuarantee(_base_name + "deformation_gradient", Guarantee::LARGE_KINEMATICS);
 }

Member Function Documentation

◆ baseParams()

template<class G >

InputParameters ComputeLagrangianStrainBase< G >::baseParams ( )

static

Definition at line 17 of file ComputeLagrangianStrainBase.C.

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

 {
   InputParameters params = Material::validParams();
 
   params.addRequiredCoupledVar("displacements", "Displacement variables");
   params.addParam<bool>(
       "large_kinematics", false, "Use large displacement kinematics in the kernel.");
   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,
       "What deformation gradient F-bar averages over (only used when `stabilize_strain = true`). "
       "'total' (default) averages the full F at each qp and rescales each qp's F by "
       "cbrt(det(F_avg)/det(F_ust)). 'incremental' averages the incremental F "
       "(F_ust * F_ust_old^{-1}) at each qp and rescales by cbrt(det(f_avg)/det(f_ust)); this is "
       "bit-for-bit compatible with the OLD `ComputeFiniteStrain` + `volumetric_locking_correction "
       "= "
       "true` formulation. Set to 'incremental' when cross-checking against the old kernel system.");
   params.addParam<bool>(
       "publish_rotation_increment",
       false,
       "If true, publish `rotation_increment = exp(vorticity_increment)` (Rodrigues) for "
       "downstream consumers that rotate by it (e.g. `ComputeMultiPlasticityStress` with "
       "`perform_finite_strain_rotations = true`). Default false keeps `rotation_increment = I` "
       "(the historical behavior -- the Lagrangian objective-rate machinery applies rotation "
       "externally). Enable when wrapping plasticity that needs its internal stress state to "
       "track the rotated Cauchy stress between steps, in tandem with `rotate_old_stress = true` "
       "on the objective rate.");
   params.addRangeCheckedParam<Real>(
       "alpha",
       1.0,
       "alpha >= 0.5 & alpha <= 1.0",
       "Generalized midpoint weight for the deformation gradient. 1.0 = backward Euler (default), "
       "0.5 = midpoint rule (matches Abaqus/Implicit).");
   MooseEnum kinematic_approximation("linear quadratic rashid_approximate rashid_eigen", "linear");
   params.addParam<MooseEnum>(
       "kinematic_approximation",
       kinematic_approximation,
       "Approximation to the increment in the spatial velocity gradient: 'linear' (default; "
       "dL = I - f^{-1}), 'quadratic' (one more Taylor term), 'rashid_approximate' (Rashid's "
       "symmetric+skew formulas), or 'rashid_eigen' (exact log f via polar decomposition + "
       "matrix logs). Only affects large_kinematics; small kinematics is always linear.");
   params.addParam<std::vector<MaterialPropertyName>>(
       "eigenstrain_names", {}, "List of eigenstrains to account for");
   params.addParam<std::vector<MaterialPropertyName>>(
       "homogenization_gradient_names",
       {},
       "List of homogenization gradients to add to the displacement gradient");
 
   params.addParam<std::string>("base_name", "Material property base name");
 
   // We rely on this *not* having use_displaced mesh on
   params.suppressParameter<bool>("use_displaced_mesh");
 
   return params;
 }

◆ computeDeformationGradient()

template<class G >

void ComputeLagrangianStrainBase< G >::computeDeformationGradient ( )

protectedvirtual

Calculate the unstabilized and optionally the stabilized deformation gradients.

Reimplemented in ComputeLagrangianWPSStrain.

Definition at line 809 of file ComputeLagrangianStrainBase.C.

Referenced by ComputeLagrangianWPSStrain::computeDeformationGradient().

 {
   // First calculate the unstabilized deformation gradient at each qp
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
   {
     computeQpUnstabilizedDeformationGradient();
     computeQpActualDeformationGradient();
     _F[_qp] = _F_ust[_qp];
   }
 
   usingTensorIndices(i_, j_, k_, l_);
   const auto I2 = RankTwoTensor::Identity();
 
   // The F-bar local/non-local derivative material properties feed only the Jacobian path
   // (the stress materials chain them into `_pk1_jacobian`/`_cauchy_jacobian`, and the
   // TL kernel's non-local F-bar term contracts `_d_F_stab_d_F_avg`). The residual sweep
   // never reads them, so skip the R4 algebra when assembling a residual alone.
   const bool need_jacobian = _fe_problem.currentlyComputingJacobian() ||
                              _fe_problem.currentlyComputingResidualAndJacobian();
 
   // If stabilization is on do the volumetric correction
   if (_stabilize_strain)
   {
     // `_F_avg` consistently stores the element average of `F_ust` regardless of mode;
     // it's consumed by the UL kernel for the spatial-frame push-forward, which is a
     // purely-geometric quantity. In `F_bar_mode = incremental` the F-bar chain itself
     // operates on the *incremental* averaged tensor `f_avg = avg(F_ust * F_ust_old^{-1})`,
     // which we compute locally -- the kernel matches by weighting grad_phi by F_ust_old^{-1}
     // in its element average. Incremental mode only makes sense for large kinematics
     // (OLD's Fhat F-bar lives in the finite-strain code path).
     const bool incremental = (_F_bar_mode == FBarMode::Incremental);
     if (incremental && !_large_kinematics)
       mooseError("`F_bar_mode = incremental` requires `large_kinematics = true`. The "
                  "incremental F-bar formulation is the multiplicative correction to the "
                  "incremental F, which is only defined for large kinematics. Use "
                  "`F_bar_mode = total` (the default) with small kinematics.");
     const auto F_avg = StabilizationUtils::elementAverage(
         [this](unsigned int qp) { return _F_ust[qp]; }, _JxW, _coord);
     const auto f_avg =
         incremental
             ? StabilizationUtils::elementAverage([this](unsigned int qp)
                                                  { return _F_ust[qp] * _F_ust_old[qp].inverse(); },
                                                  _JxW,
                                                  _coord)
             : RankTwoTensor();
     // Always publish avg(F_ust) -- UL kernel uses this for the push-forward.
     _F_avg.set().setAllValues(F_avg);
     // What the F-bar gamma and `_d_F_stab_d_F_avg` are built against (also what the
     // kernel-side `_avg_grad_trial` will represent the delta of):
     const auto & avg_for_chain = incremental ? f_avg : F_avg;
     // Make the appropriate modification, depending on small or large deformations
     for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
     {
       if (_large_kinematics)
       {
         // Multiplicative F-bar: F_stab = gamma * F_ust where
         //   gamma_total = cbrt(det(F_avg) / det(F_ust))                       (total mode)
         //   gamma_inc   = cbrt(det(f_avg) / det(f_ust)),  f_ust = F_ust*F_ust_old^{-1}
         //                                                                     (incremental mode)
         // For incremental:  det(f_ust) = det(F_ust)/det(F_ust_old).
         //   d log det(f_ust)/d F_ust = F_ust^{-T}   (same as the total-mode chain)
         // so `_d_F_stab_d_F_ust` shares the total-mode shape. The non-local chain
         // contracts `_d_F_stab_d_F_avg` with delta(averaged-quantity); kernel computes
         // deltaf_avg in incremental mode by weighting grad_phi by F_ust_old^{-1} in its
         // element average.
         const Real det_ust_local =
             incremental ? _F_ust[_qp].det() / _F_ust_old[_qp].det() : _F[_qp].det();
         const Real gamma = std::pow(avg_for_chain.det() / det_ust_local, 1.0 / 3.0);
         if (need_jacobian)
         {
           const auto Fust_invT = _F_ust[_qp].inverse().transpose();
           const auto avg_invT = avg_for_chain.inverse().transpose();
           _d_F_stab_d_F_ust[_qp] =
               gamma * RankFourTensor::IdentityFour() -
               (gamma / 3.0) * _F_ust[_qp].template times<i_, j_, k_, l_>(Fust_invT);
           _d_F_stab_d_F_avg[_qp] =
               (gamma / 3.0) * _F_ust[_qp].template times<i_, j_, k_, l_>(avg_invT);
         }
         _F[_qp] *= gamma;
       }
       else
       {
         if (need_jacobian)
         {
           // Additive (trace) F-bar: F_stab = F_ust + (tr(F_avg - F_ust)/3) * I.
           // dF_stab/dF_ust = I^(4) - (1/3) * I2 (x) I2  (each diagonal component pulled out).
           // dF_stab/dF_avg = (1/3) * I2 (x) I2.
           const auto outer = I2.template times<i_, j_, k_, l_>(I2);
           _d_F_stab_d_F_ust[_qp] = RankFourTensor::IdentityFour() - (1.0 / 3.0) * outer;
           _d_F_stab_d_F_avg[_qp] = (1.0 / 3.0) * outer;
         }
         _F[_qp] += (F_avg.trace() - _F[_qp].trace()) * I2 / 3.0;
       }
     }
   }
   else if (need_jacobian)
   {
     // F-bar off: dF_stab/dF_ust = I^(4), dF_stab/dF_avg = 0.
     for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
     {
       _d_F_stab_d_F_ust[_qp] = RankFourTensor::IdentityFour();
       _d_F_stab_d_F_avg[_qp].zero();
     }
   }
 }

◆ computeLinearIncrement()

template<class G >

void ComputeLagrangianStrainBase< G >::computeLinearIncrement	(	const RankTwoTensor &	f_inv,
		RankTwoTensor &	dd,
		RankTwoTensor &	dw,
		RankFourTensor &	d_dL_d_f_inv,
		RankFourTensor &	d_dw_d_f_inv,
		bool	need_jacobian
	)		const

private

Linear approximation: dL = I - f^{-1}.

The RankFour derivative out-parameters are filled only when need_jacobian is true.

Definition at line 441 of file ComputeLagrangianStrainBase.C.

 {
   // Deltal = I - f^{-1}, so Deltad = sym(Deltal), Deltaw = skew(Deltal).
   const RankTwoTensor dL = RankTwoTensor::Identity() - f_inv;
   dd = 0.5 * (dL + dL.transpose());
   dw = 0.5 * (dL - dL.transpose());
 
   if (!need_jacobian)
     return;
   // d(Deltal)/d(f^{-1}) = -I^{(4)}.
   d_dL_d_f_inv = -RankFourTensor::IdentityFour();
   // d(Deltaw)/d(f^{-1}) = - skew projector on f^{-1} = -(1/2)(I^{ikjl} - I^{iljk}).
   usingTensorIndices(i_, j_, m_, n_);
   const auto I2 = RankTwoTensor::Identity();
   d_dw_d_f_inv = -0.5 * (RankFourTensor::IdentityFour() - I2.template times<j_, m_, i_, n_>(I2));
 }

◆ computeProperties()

template<class G >

void ComputeLagrangianStrainBase< G >::computeProperties ( )

overrideprotectedvirtual

Reimplemented from Material.

Definition at line 184 of file ComputeLagrangianStrainBase.C.

 {
   // Average the volumetric terms, if required
   computeDeformationGradient();
 
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
     computeQpProperties();
 }

◆ computeQpActualDeformationGradient()

template<class G >

void ComputeLagrangianStrainBase< G >::computeQpActualDeformationGradient ( )

protectedvirtual

Calculate the actual deformation gradient at n+1 (no alpha weighting, no F-bar)

Definition at line 794 of file ComputeLagrangianStrainBase.C.

 {
   // The literal deformation gradient at n+1 (no alpha weighting, no F-bar). For alpha = 1
   // this is identical to _F_ust.
   _F_actual[_qp].setToIdentity();
   for (auto component : make_range(_ndisp))
     G::addGradOp(_F_actual[_qp],
                  component,
                  (*_grad_disp[component])[_qp],
                  (*_disp[component])[_qp],
                  _q_point[_qp]);
 }

◆ computeQpIncrementalStrains()

template<class G >

void ComputeLagrangianStrainBase< G >::computeQpIncrementalStrains ( const RankTwoTensor & dL )

protectedvirtual

Calculate the strains based on the spatial velocity gradient.

The sym/skew split is trivial; kept as a public helper for backward compatibility with the linear-only path.

Definition at line 363 of file ComputeLagrangianStrainBase.C.

 {
   // Backward-compatible entry point: split into sym/skew and delegate.
   setQpIncrementalStrains(0.5 * (dL + dL.transpose()), 0.5 * (dL - dL.transpose()));
 }

◆ computeQpLargeKinematicIncrement()

template<class G >

void ComputeLagrangianStrainBase< G >::computeQpLargeKinematicIncrement	(	const RankTwoTensor &	f_inv,
		RankTwoTensor &	dd,
		RankTwoTensor &	dw,
		RankFourTensor &	d_dL_d_f_inv,
		RankFourTensor &	d_dw_d_f_inv,
		bool	need_jacobian
	)

protected

Dispatcher: compute (Deltad, Deltaw, d(Deltal)/d(f^{-1}), d(Deltaw)/d(f^{-1})) for the active kinematic approximation.

The vorticity derivative is returned separately so the Jaumann objective rate can chain its own Jacobian without re-projecting from dL. The two RankFour derivative out-parameters are filled only when need_jacobian is true; on residual-only sweeps their computation (RankFour builds, matrix-log derivatives, and the polar-decomposition chain) is skipped and the out-parameters are left untouched.

Definition at line 337 of file ComputeLagrangianStrainBase.C.

 {
   switch (_kinematic_approximation)
   {
     case KinematicApproximation::Linear:
       computeLinearIncrement(f_inv, dd, dw, d_dL_d_f_inv, d_dw_d_f_inv, need_jacobian);
       break;
     case KinematicApproximation::Quadratic:
       computeQuadraticIncrement(f_inv, dd, dw, d_dL_d_f_inv, d_dw_d_f_inv, need_jacobian);
       break;
     case KinematicApproximation::RashidApproximate:
       computeRashidApproximateIncrement(f_inv, dd, dw, d_dL_d_f_inv, d_dw_d_f_inv, need_jacobian);
       break;
     case KinematicApproximation::RashidEigen:
       computeRashidEigenIncrement(f_inv, dd, dw, d_dL_d_f_inv, d_dw_d_f_inv, need_jacobian);
       break;
   }
 }

◆ computeQpPolarDecomposition()

template<class G >

void ComputeLagrangianStrainBase< G >::computeQpPolarDecomposition ( bool need_jacobian )

protected

Compute and publish the polar decomposition of _F_actual at the current qp.

Always populates _rotation and _stretch (R and U). When need_jacobian is true, additionally populates _d_rotation_d_F. Consumed by the Green-Naghdi objective rate.

Definition at line 308 of file ComputeLagrangianStrainBase.C.

 {
   // Polar decomposition F = R * U of the alpha-weighted, F-bar-stabilized deformation
   // gradient at this qp. We decompose _F rather than _F_actual because the rest of the
   // kernel/rate chain treats _F as the spatial frame; using _F here matches the pre-3.1
   // GN rate exactly (it read _def_grad, which is _F via ComputeLagrangianStressCauchy).
   const RankTwoTensor & F = _F[_qp];
   FactorizedRankTwoTensor C(F.transpose() * F);
   // Reuse the sqrt factorization (a tensor eigensolve) for both U and U^{-1}.
   const auto sqrt_C = MathUtils::sqrt(C);
   _stretch[_qp] = sqrt_C.get();
   const RankTwoTensor U_inv = sqrt_C.inverse().get();
   _rotation[_qp] = F * U_inv;
 
   if (!need_jacobian)
     return;
 
   // dR/dF closed form. See ComputeLagrangianObjectiveStress.C:221-227.
   const auto I = RankTwoTensor::Identity();
   const RankTwoTensor Y = _stretch[_qp].trace() * I - _stretch[_qp];
   const RankTwoTensor Z = _rotation[_qp] * Y;
   const RankTwoTensor O = Z * _rotation[_qp].transpose();
   usingTensorIndices(i_, j_, k_, l_);
   _d_rotation_d_F[_qp] =
       (O.template times<i_, k_, l_, j_>(Y) - Z.template times<i_, l_, k_, j_>(Z)) / Y.det();
 }

◆ computeQpProperties()

template<class G >

void ComputeLagrangianStrainBase< G >::computeQpProperties ( )

overrideprotectedvirtual

Reimplemented from Material.

Definition at line 195 of file ComputeLagrangianStrainBase.C.

 {
   // Add in the macroscale gradient contribution to both the stabilized `_F` (used by the
   // strain chain via `_f_inv`) AND the unstabilized `_F_ust` (used by the new F_ust-wrap
   // architecture in the stress materials). The homogenization gradient is a real
   // deformation imposed via the scalar constraint, not a stabilization -- it must appear
   // in F_ust too or PK1 = det(F_ust) sigma F_ust^{-T} will be missing its contribution.
   for (auto contribution : _homogenization_contributions)
   {
     _F[_qp] += (*contribution)[_qp];
     _F_ust[_qp] += (*contribution)[_qp];
   }
 
   // Publish F_ust^{-1} and det(F_ust) for the large-kinematics consumers' spatial push-forward
   // (grad_x = F_ust^{-T} grad_X, J_ust = det F_ust) and the Cauchy -> PK1 wrap. Computed once per
   // qp here -- shared by all displacement kernels and the stress calculator via the material
   // system -- instead of recomputed per test/trial/qp downstream. Gated on `_large_kinematics`
   // (every consumer reads these only on the large-kinematics path) and on `isPropertyActive` (so
   // consumers that never request them pay nothing).
   if (_large_kinematics && isPropertyActive(_F_ust_inv.id()))
   {
     _F_ust_inv[_qp] = _F_ust[_qp].inverse();
     _F_ust_det[_qp] = _F_ust[_qp].det();
   }
 
   // Skip the Jacobian-only RankFourTensor derivative chain when no downstream consumer
   // will read it (i.e. we're in a residual-only sweep). All of `_d_F_d_grad_u`,
   // `_d_deformation_gradient_increment_d_F`, `_d_vorticity_increment_d_F`, and the
   // `_d_rotation_d_F` slot of the polar decomposition feed only `*_jacobian` material
   // properties, which the kernel consumes only during Jacobian or
   // residual-and-Jacobian-together assembly.
   const bool need_jacobian = _fe_problem.currentlyComputingJacobian() ||
                              _fe_problem.currentlyComputingResidualAndJacobian();
 
   // dF/d(grad u_{n+1}) = alpha * I^{(4)} for the generalized midpoint rule
   // (alpha = 1.0 reduces to backward Euler).
   if (need_jacobian)
     _d_F_d_grad_u[_qp] = _alpha * RankFourTensor::IdentityFour();
 
   if (_large_kinematics)
   {
     _F_inv[_qp] = _F[_qp].inverse();
     // For `F_bar_mode = incremental`: `_f_inv` must invert the *incremental* F that was
     // F-bar'd (= `gamma_inc * F_ust * F_ust_old^{-1}`, matching OLD `ComputeFiniteStrain`'s
     // `_Fhat` after its volumetric-locking correction). Since `_F = gamma_inc * F_ust`,
     // `(gamma_inc * F_ust * F_ust_old^{-1})^{-1} = F_ust_old * _F^{-1}` -- i.e., pair the
     // unstabilized old F with the (cumulative) stabilized current `_F^{-1}`. Using
     // `_F_old` (the *cumulative* F-bar'd previous-step `_F`) here would compound F-bar
     // across steps and break OLD-compat. `total` mode keeps the existing form (where `_F`
     // and `_F_old` are the cumulative full-F F-bar'd values and the ratio gives the
     // F-bar'd incremental F directly).
     if (_stabilize_strain && _F_bar_mode == FBarMode::Incremental)
       _f_inv[_qp] = _F_ust_old[_qp] * _F_inv[_qp];
     else
       _f_inv[_qp] = _F_old[_qp] * _F_inv[_qp];
 
     // Dispatch to the active kinematic-approximation helper. Each helper returns
     // dd (= Deltad), dw (= Deltaw), and -- only when `need_jacobian` -- the
     // f^{-1}-derivatives of dL = dd + dw and of dw alone. The (dd, dw) outputs are needed
     // every iteration; the RankFour derivatives feed only the Jacobian chain below, so on
     // residual-only sweeps the helper skips them entirely.
     RankTwoTensor dd, dw;
     RankFourTensor d_dL_d_f_inv, d_dw_d_f_inv;
     computeQpLargeKinematicIncrement(
         _f_inv[_qp], dd, dw, d_dL_d_f_inv, d_dw_d_f_inv, need_jacobian);
 
     if (need_jacobian)
     {
       // Common chain rule: d(f^{-1})_{pq}/dF_{mn} = -f^{-1}_{pm} * F^{-1}_{nq}.
       usingTensorIndices(p_, q_, m_, n_);
       const RankFourTensor d_f_inv_d_F = -_f_inv[_qp].template times<p_, m_, n_, q_>(_F_inv[_qp]);
       _d_deformation_gradient_increment_d_F[_qp] = d_dL_d_f_inv * d_f_inv_d_F;
       _d_vorticity_increment_d_F[_qp] = d_dw_d_f_inv * d_f_inv_d_F;
     }
 
     setQpIncrementalStrains(dd, dw);
     // The polar decomposition (a tensor eigensolve + sqrt per qp, on every residual and Jacobian
     // eval) feeds only the Green-Naghdi objective rate's `_rotation` / `_d_rotation_d_F` (and its
     // internal `_stretch`). Skip it entirely when no active consumer needs it -- Truesdell uses
     // the deformation-gradient increment, Jaumann the vorticity increment, Rashid the Rodrigues
     // `_rotation_increment`. The active-property set self-corrects for future consumers with no
     // coupling flag.
     if (isPropertyActive(_rotation.id()) || isPropertyActive(_stretch.id()))
       computeQpPolarDecomposition(need_jacobian);
   }
   // For small deformations we just provide the identity (and always linear)
   else
   {
     _F_inv[_qp] = RankTwoTensor::Identity();
     _f_inv[_qp] = RankTwoTensor::Identity();
     const RankTwoTensor dL = _F[_qp] - _F_old[_qp];
 
     if (need_jacobian)
     {
       // d(dL)/dF = I^{(4)} when dL = F - F_old. d(dW)/dF = the skew projector.
       _d_deformation_gradient_increment_d_F[_qp] = RankFourTensor::IdentityFour();
       usingTensorIndices(i_, j_, k_, l_);
       const auto I2 = RankTwoTensor::Identity();
       _d_vorticity_increment_d_F[_qp] =
           0.5 * (RankFourTensor::IdentityFour() - I2.template times<j_, k_, i_, l_>(I2));
 
       // Small kinematics: R = I, U = I, dR/dF = 0. Defensive defaults; GN is not used here.
       _d_rotation_d_F[_qp].zero();
     }
     _rotation[_qp].setToIdentity();
     _stretch[_qp].setToIdentity();
 
     setQpIncrementalStrains(0.5 * (dL + dL.transpose()), 0.5 * (dL - dL.transpose()));
   }
 }

◆ computeQpRotationIncrement()

template<class G >

RankTwoTensor ComputeLagrangianStrainBase< G >::computeQpRotationIncrement	(	const RankTwoTensor &	f_inv,
		const RankTwoTensor &	dw
	)		const

private

Rotation increment matched to the active _kinematic_approximation, suitable for publishing as _rotation_increment so downstream ComputeStressBase-style materials see the OLD-compatible rotation.

For RashidApproximate this ports OLD ComputeFiniteStrain's C1/C2/C3 polynomial Rodrigues approximation (bit-for-bit OLD TaylorExpansion); for RashidEigen and Linear / Quadratic it returns exp(dw) via the Rodrigues block (exact rotation around the dw axis – bit-exact for RashidEigen, which has no OLD counterpart for the linear/quadratic cases).

Definition at line 917 of file ComputeLagrangianStrainBase.C.

 {
   // For `rashid_approximate` port OLD `ComputeFiniteStrain`'s C1/C2/C3 polynomial form
   // exactly (Rashid 1993). Pairing this rotation with the wrapped material's FSR (via
   // `_rotation_increment`) lets the constitutive's `_stress` evolution match OLD's bit-
   // for-bit at the same converged displacement state.
   if (_kinematic_approximation == KinematicApproximation::RashidApproximate)
   {
     const Real a[3] = {
         f_inv(1, 2) - f_inv(2, 1), f_inv(2, 0) - f_inv(0, 2), f_inv(0, 1) - f_inv(1, 0)};
     const Real q = (a[0] * a[0] + a[1] * a[1] + a[2] * a[2]) / 4.0;
     const Real trFhatinv_1 = f_inv.trace() - 1.0;
     const Real p = trFhatinv_1 * trFhatinv_1 / 4.0;
     const Real C1_squared = p +
                             3.0 * Utility::pow<2>(p) * (1.0 - (p + q)) / Utility::pow<2>(p + q) -
                             2.0 * Utility::pow<3>(p) * (1.0 - (p + q)) / Utility::pow<3>(p + q);
     if (C1_squared <= 0.0)
       mooseException(
           "Cannot take square root of a number less than or equal to zero in the calculation of "
           "C1 for the Rashid approximation for the rotation tensor.");
     const Real C1 = std::sqrt(C1_squared);
     Real C2;
     if (q > 0.01)
       C2 = (1.0 - C1) / (4.0 * q);
     else
       C2 = 0.125 + q * 0.03125 * (Utility::pow<2>(p) - 12.0 * (p - 1.0)) / Utility::pow<2>(p) +
            Utility::pow<2>(q) * (p - 2.0) * (Utility::pow<2>(p) - 10.0 * p + 32.0) /
                Utility::pow<3>(p) +
            Utility::pow<3>(q) *
                (1104.0 - 992.0 * p + 376.0 * Utility::pow<2>(p) - 72.0 * Utility::pow<3>(p) +
                 5.0 * Utility::pow<4>(p)) /
                (512.0 * Utility::pow<4>(p));
     const Real C3_test =
         (p * q * (3.0 - q) + Utility::pow<3>(p) + Utility::pow<2>(q)) / Utility::pow<3>(p + q);
     if (C3_test <= 0.0)
       mooseException(
           "Cannot take square root of a number less than or equal to zero in the calculation of "
           "C3_test for the Rashid approximation for the rotation tensor.");
     const Real C3 = 0.5 * std::sqrt(C3_test);
     RankTwoTensor R_incr;
     R_incr.addIa(C1);
     for (unsigned int i = 0; i < 3; ++i)
       for (unsigned int j = 0; j < 3; ++j)
         R_incr(i, j) += C2 * a[i] * a[j];
     R_incr(0, 1) += C3 * a[2];
     R_incr(0, 2) -= C3 * a[1];
     R_incr(1, 0) -= C3 * a[2];
     R_incr(1, 2) += C3 * a[0];
     R_incr(2, 0) += C3 * a[1];
     R_incr(2, 1) -= C3 * a[0];
     return R_incr.transpose();
   }
 
   // For `rashid_eigen`, `linear`, `quadratic`: r_hat = exp(dw) via Rodrigues. For RashidEigen,
   // dw is the matrix log of the polar-decomposition R, so exp(dw) recovers that R bit-for-bit
   // -- equivalent to OLD `ComputeFiniteStrain`'s EigenSolution rotation.
   const Real theta2 = 0.5 * dw.doubleContraction(dw);
   const Real theta = std::sqrt(theta2);
   Real f, g;
   const Real small_theta = 1.0e-7;
   if (theta < small_theta)
   {
     f = 1.0 - theta2 / 6.0;
     g = 0.5 - theta2 / 24.0;
   }
   else
   {
     f = std::sin(theta) / theta;
     g = (1.0 - std::cos(theta)) / theta2;
   }
   return RankTwoTensor::Identity() + f * dw + g * dw * dw;
 }

◆ computeQpUnstabilizedDeformationGradient()

template<class G >

void ComputeLagrangianStrainBase< G >::computeQpUnstabilizedDeformationGradient ( )

protectedvirtual

Calculate the unstabilized (alpha-weighted) deformation gradient at the quadrature point.

Definition at line 767 of file ComputeLagrangianStrainBase.C.

 {
   // Generalized midpoint: F^alpha_{n+1} = I + alpha * (grad u_{n+1}, u_{n+1})
   //                                         + (1 - alpha) * (grad u_n, u_n).
   // alpha = 1.0 reduces to backward Euler (no old contribution). With a Steady executioner
   // the old displacement is treated as identically zero (F_n = I), so we skip the old call
   // entirely - this lets a user run with alpha != 1 in steady mode as well.
   _F_ust[_qp].setToIdentity();
   const bool include_old = _alpha != 1.0 && _fe_problem.isTransient();
   for (auto component : make_range(_ndisp))
   {
     G::addGradOp(_F_ust[_qp],
                  component,
                  _alpha * (*_grad_disp[component])[_qp],
                  _alpha * (*_disp[component])[_qp],
                  _q_point[_qp]);
     if (include_old)
       G::addGradOp(_F_ust[_qp],
                    component,
                    (1.0 - _alpha) * (*_grad_disp_old[component])[_qp],
                    (1.0 - _alpha) * (*_disp_old[component])[_qp],
                    _q_point[_qp]);
   }
 }

◆ computeQuadraticIncrement()

template<class G >

void ComputeLagrangianStrainBase< G >::computeQuadraticIncrement	(	const RankTwoTensor &	f_inv,
		RankTwoTensor &	dd,
		RankTwoTensor &	dw,
		RankFourTensor &	d_dL_d_f_inv,
		RankFourTensor &	d_dw_d_f_inv,
		bool	need_jacobian
	)		const

private

Quadratic approximation: dL = (I - f^{-1}) + 0.5 (I - f^{-1})^2.

The RankFour derivative out-parameters are filled only when need_jacobian is true.

Definition at line 465 of file ComputeLagrangianStrainBase.C.

 {
   // Deltal = X + (1/2) X^2 with X = I - f^{-1} (one more Taylor term of -log f^{-1}).
   const RankTwoTensor X = RankTwoTensor::Identity() - f_inv;
   const RankTwoTensor dL = X + 0.5 * X * X;
   dd = 0.5 * (dL + dL.transpose());
   dw = 0.5 * (dL - dL.transpose());
 
   if (!need_jacobian)
     return;
   // dX/d(f^{-1}) = -I^{(4)}, and d(X^2)_{ij}/dX_{mn} = delta_{im} X_{nj} + X_{im} delta_{jn}.
   // So d(Deltal)/d(f^{-1}) = -I^{(4)} - (1/2) (delta_{im} X_{nj} + X_{im} delta_{jn}).
   usingTensorIndices(i_, j_, m_, n_);
   const auto I2 = RankTwoTensor::Identity();
   const RankFourTensor dXX_dX =
       I2.template times<i_, m_, n_, j_>(X) + X.template times<i_, m_, j_, n_>(I2);
   d_dL_d_f_inv = -RankFourTensor::IdentityFour() - 0.5 * dXX_dX;
   // dw = (1/2)(dL - dL^T), so d(dw)_{ij}/d... = (1/2)(d(dL)_{ij}/d... - d(dL)_{ji}/d...).
   d_dw_d_f_inv = 0.5 * (d_dL_d_f_inv - d_dL_d_f_inv.transposeIj());
 }

◆ computeRashidApproximateIncrement()

template<class G >

void ComputeLagrangianStrainBase< G >::computeRashidApproximateIncrement	(	const RankTwoTensor &	f_inv,
		RankTwoTensor &	dd,
		RankTwoTensor &	dw,
		RankFourTensor &	d_dL_d_f_inv,
		RankFourTensor &	d_dw_d_f_inv,
		bool	need_jacobian
	)		const

private

Rashid's approximate symmetric+skew formulas.

The RankFour derivative out-parameters are filled only when need_jacobian is true.

Definition at line 493 of file ComputeLagrangianStrainBase.C.

 {
   // See plan_outline.pdf Sec.2.3 (eq 10-15, with the corrected vorticity).
   // X = I - f^{-1}.  Symmetric part: A = X X^T - X - X^T,  Deltad = -A/2 + A^2/4.
   // Skew part (from the rotation tensor): alpha_i = eps_ijk (f^{-1})_jk,
   //   cos theta = (tr(f^{-1}) - 1)/2, sin theta = sqrt(1 - cos^2theta),  Q = (1/4) alpha*alpha,
   //   Deltaw_ij = -(theta / (2sqrtQ)) eps_ijk alpha_k.
   usingTensorIndices(i_, j_, m_, n_);
   const auto I2 = RankTwoTensor::Identity();
   const auto I4 = RankFourTensor::IdentityFour();
 
   // ---- symmetric part ----
   const RankTwoTensor X = I2 - f_inv;
   const RankTwoTensor Xt = X.transpose();
   const RankTwoTensor A = X * Xt - X - Xt;
   dd = -0.5 * A + 0.25 * A * A;
 
   // ---- skew part ----
   // alpha_i = eps_ijk (f^{-1})_jk  (axial vector of f^{-1}'s skew part, doubled).
   RealVectorValue alpha;
   for (unsigned int i = 0; i < 3; ++i)
   {
     Real ai = 0.0;
     for (unsigned int j = 0; j < 3; ++j)
       for (unsigned int k = 0; k < 3; ++k)
         ai += PermutationTensor::eps(i, j, k) * f_inv(j, k);
     alpha(i) = ai;
   }
   // Derive theta from the axial vector's magnitude rather than from tr(f^{-1}): the trace
   // formula assumes f^{-1} is exactly a rotation, which is only true in the limit. Here
   // sin theta = sqrtQ (Q = |skew part|^2/4); a true rotation matches both, and an arbitrary f^{-1}
   // is projected onto its nearest "rotation-like" interpretation.
   const Real Q_raw = 0.25 * (alpha * alpha);
   // Clamp Q just below 1 so cos theta stays strictly positive (theta -> pi/2 is unphysical for one
   // step).
   const Real Q = std::min(Q_raw, 1.0 - 1.0e-12);
 
   // Small-angle fallback: when sin theta -> 0, theta/(2sqrtQ) -> 1/2 (L'Hopital) and Deltaw ->
   // -alpha/2, which matches sym/skew of the linear approximation. d(Deltaw)/d(f^{-1}) is the
   // antisymmetrizer (1/2)(delta_im delta_jn - delta_jm delta_in).
   const Real small_Q = 1.0e-12;
   if (Q < small_Q)
   {
     // Deltaw_ij = -(1/2) eps_ijk alpha_k
     for (unsigned int i = 0; i < 3; ++i)
       for (unsigned int j = 0; j < 3; ++j)
       {
         Real v = 0.0;
         for (unsigned int k = 0; k < 3; ++k)
           v += PermutationTensor::eps(i, j, k) * alpha(k);
         dw(i, j) = -0.5 * v;
       }
     // d(Deltaw)/d(f^{-1}) = -(1/2)(delta_{im} delta_{jn} - delta_{jm} delta_{in})
     if (need_jacobian)
       d_dw_d_f_inv = -0.5 * (I4 - I2.template times<j_, m_, i_, n_>(I2));
   }
   else
   {
     const Real sin_theta = std::sqrt(Q);
     const Real cos_theta = std::sqrt(1.0 - Q);
     const Real theta = std::asin(sin_theta);
     const Real coeff = -theta / (2.0 * sin_theta);
 
     for (unsigned int i = 0; i < 3; ++i)
       for (unsigned int j = 0; j < 3; ++j)
       {
         Real v = 0.0;
         for (unsigned int k = 0; k < 3; ++k)
           v += PermutationTensor::eps(i, j, k) * alpha(k);
         dw(i, j) = coeff * v;
       }
 
     // Build d(Deltaw)/d(f^{-1}) analytically.
     //   Deltaw_ij = c(f^{-1}) * E_ij(f^{-1}),  E_ij = eps_ijk alpha_k,  c = -theta/(2 sin theta).
     //
     //   dalpha_k/d(f^{-1})_{mn} = eps_{kmn}  (Levi-Civita is constant).
     //   dQ/d(f^{-1})_{mn} = (1/2) alpha_k eps_{kmn}.
     //   With sin theta = sqrtQ : dsin theta/d(f^{-1})_{mn} = alpha_k eps_{kmn} / (4 sin theta).
     //   dtheta/d(f^{-1})_{mn} = dsin theta/d(f^{-1})_{mn} / cos theta.
     //   dc/dtheta = -(sin theta - theta cos theta)/(2 sin^2 theta); dc/d(f^{-1})_{mn} = dc/dtheta *
     //   dtheta/d(f^{-1})_{mn}
     //     = (theta cos theta - sin theta) alpha_k eps_{kmn} / (8 sin^3 theta cos theta).
     //   dE_ij/d(f^{-1})_{mn} = eps_{ijk} eps_{kmn}.
     //
     // Final:
     //   d(Deltaw)_{ij}/d(f^{-1})_{mn} = (dc/d(f^{-1})_{mn}) * E_ij + c * dE_ij/d(f^{-1})_{mn}.
     if (need_jacobian)
     {
       const Real dc_pref =
           (theta * cos_theta - sin_theta) / (8.0 * sin_theta * sin_theta * sin_theta * cos_theta);
       for (unsigned int i = 0; i < 3; ++i)
         for (unsigned int j = 0; j < 3; ++j)
         {
           Real E_ij = 0.0;
           for (unsigned int k = 0; k < 3; ++k)
             E_ij += PermutationTensor::eps(i, j, k) * alpha(k);
           for (unsigned int m = 0; m < 3; ++m)
             for (unsigned int n = 0; n < 3; ++n)
             {
               Real eps_alpha = 0.0;
               for (unsigned int k = 0; k < 3; ++k)
                 eps_alpha += PermutationTensor::eps(k, m, n) * alpha(k);
               const Real dc_dfinv = dc_pref * eps_alpha;
               Real dE_dfinv = 0.0;
               for (unsigned int k = 0; k < 3; ++k)
                 dE_dfinv += PermutationTensor::eps(i, j, k) * PermutationTensor::eps(k, m, n);
               d_dw_d_f_inv(i, j, m, n) = dc_dfinv * E_ij + coeff * dE_dfinv;
             }
         }
     }
   }
 
   if (!need_jacobian)
     return;
 
   // ---- symmetric-part derivative + assemble d(Deltal)/d(f^{-1}) (Jacobian only) ----
   // dX/d(f^{-1}) = -I^{(4)}.
   // d(X X^T)_{ij}/dX_{mn} = delta_{im} X_{jn} + X_{in} delta_{jm}  (from (X X^T)_{ij} = X_{ik}
   // X_{jk}). d(X^T)_{ij}/dX_{mn} = delta_{jm} delta_{in}.
   // -> d(A)/d(f^{-1}) = -[d(X X^T)/dX] + I^{(4)} + (transposed I^{(4)}).
   const RankFourTensor d_XXt_dX =
       I2.template times<i_, m_, j_, n_>(X) + X.template times<i_, n_, j_, m_>(I2);
   const RankFourTensor d_Xt_dX = I2.template times<j_, m_, i_, n_>(I2);
   const RankFourTensor dA_dfinv = -d_XXt_dX + I4 + d_Xt_dX;
 
   // d(A^2)_{ij}/dA_{mn} = delta_{im} A_{nj} + A_{im} delta_{jn}.
   const RankFourTensor d_AA_dA =
       I2.template times<i_, m_, n_, j_>(A) + A.template times<i_, m_, j_, n_>(I2);
   const RankFourTensor d_AA_dfinv = d_AA_dA * dA_dfinv;
 
   const RankFourTensor d_dd_dfinv = -0.5 * dA_dfinv + 0.25 * d_AA_dfinv;
   d_dL_d_f_inv = d_dd_dfinv + d_dw_d_f_inv;
 }

◆ computeRashidEigenIncrement()

template<class G >

void ComputeLagrangianStrainBase< G >::computeRashidEigenIncrement	(	const RankTwoTensor &	f_inv,
		RankTwoTensor &	dd,
		RankTwoTensor &	dw,
		RankFourTensor &	d_dL_d_f_inv,
		RankFourTensor &	d_dw_d_f_inv,
		bool	need_jacobian
	)		const

private

"Exact" via polar decomposition of f^{-1} + matrix logs.

The RankFour derivative out-parameters are filled only when need_jacobian is true.

Definition at line 634 of file ComputeLagrangianStrainBase.C.

 {
   // See plan_outline.pdf Sec.2.4. Polar-decompose f^{-1} = r' u', with u' symmetric positive
   // definite and r' a proper rotation. The PDF's identity `log f^{-1} = -log d - log w`
   // only holds when log u and log r commute (i.e. for non-rotating deformation); in general
   // the right stretch of f^{-1} is u' = R * U^{-1} * R^T where R, U are the right polar of f.
   // So -log(u') = R * log U * R^T is the *spatial-frame* log strain, not the co-rotated
   // log U. We compute it that way first, then rotate by r' = R^T to land in the n-frame
   // so that _strain_increment = log U exactly. This is the strain measure the Rashid
   // objective stress update consumes (eq. 22, sigma_{n+1} = r_hat (sigma_n + Deltasigma) r_hat^T
   // expects Deltasigma in the n-frame).
   usingTensorIndices(a_, b_, m_, n_);
   const auto I2 = RankTwoTensor::Identity();
 
   // ---- polar decomposition of f^{-1} ----
   FactorizedRankTwoTensor cprime(f_inv.transpose() * f_inv);
   // Reuse the sqrt factorization (a tensor eigensolve) for both u and u^{-1}.
   const auto sqrt_cprime = MathUtils::sqrt(cprime);
   const RankTwoTensor u = sqrt_cprime.get();
   const RankTwoTensor u_inv = sqrt_cprime.inverse().get();
   const RankTwoTensor r = f_inv * u_inv;
 
   // ---- intermediate Deltad_spatial = -log u' = R * log U * R^T (n+1 frame) ----
   // u' = sqrt(c'), so log(u') = (1/2) log(c'). Reuse c''s already-computed factorization
   // (`sqrt_cprime` shares c''s eigenvectors) instead of re-decomposing u -- one fewer 3x3
   // eigensolve per qp, on both residual and Jacobian sweeps.
   const RankTwoTensor dd_spatial = -0.5 * MathUtils::log(cprime).get();
 
   // ---- Deltaw = -log r via Rodrigues. ----
   // log r = phi(theta) (r - r^T) with phi(theta) = theta/(2 sin theta),  cos theta = (tr r - 1)/2.
   const Real cos_theta = MathUtils::clamp(0.5 * (r.trace() - 1.0), -1.0, 1.0);
   const Real sin2 = std::max(1.0 - cos_theta * cos_theta, 0.0);
   const Real sin_theta = std::sqrt(sin2);
   const Real theta = std::acos(cos_theta);
   const RankTwoTensor A = r - r.transpose();
 
   // d(log r)_{ij}/d(r)_{mn} = (dphi/dr_{mn}) A_{ij} + phi (delta_{im} delta_{jn} - delta_{jm}
   // delta_{in}).
   //   dphi/dr_{mn} = (dphi/dtheta)(dtheta/d cos theta)(d cos theta/dr_{mn})
   //              = psi delta_{mn}, where psi = (theta cos theta - sin theta)/(4 sin^3 theta).
   // Small-angle: phi -> 1/2, psi -> -1/12, so d(log r)/dr -> (1/2)(I^(4) - swap_ij).
   // `d_logr_d_r` feeds only the Jacobian, so it is built only when `need_jacobian`.
   const Real small_sin = 1.0e-7;
   RankFourTensor d_logr_d_r;
   RankTwoTensor log_r;
   usingTensorIndices(i_, j_, k_, l_);
   if (std::abs(sin_theta) < small_sin)
   {
     log_r = 0.5 * A;
     if (need_jacobian)
     {
       const RankFourTensor swap_ij = I2.template times<j_, m_, i_, n_>(I2);
       d_logr_d_r = 0.5 * (RankFourTensor::IdentityFour() - swap_ij);
     }
   }
   else
   {
     const Real phi = theta / (2.0 * sin_theta);
     log_r = phi * A;
     if (need_jacobian)
     {
       const Real psi = (theta * cos_theta - sin_theta) / (4.0 * sin_theta * sin2);
       const RankFourTensor swap_ij = I2.template times<j_, m_, i_, n_>(I2);
       // (dphi/dr)_{mn} = psi delta_{mn} -> outer with A_{ij} gives A.times<i_, j_, m_, n_>(I2) *
       // psi.
       const RankFourTensor dphi_outer_A = A.template times<i_, j_, m_, n_>(I2);
       d_logr_d_r = psi * dphi_outer_A + phi * (RankFourTensor::IdentityFour() - swap_ij);
     }
   }
   dw = -log_r;
 
   // ---- Rotate Deltad from spatial back to co-rotated (n) frame: log U = r' * (R log U R^T) *
   // r'^T, using r' = R^T from the polar of f^{-1}. ----
   dd = r * dd_spatial * r.transpose();
 
   // Everything below is the Jacobian chain (RankFour matrix-log derivatives, the
   // polar-decomposition dr/d(f^{-1}) closed form, and the three-piece sandwich chain rule).
   // Skip it wholesale on residual-only sweeps.
   if (!need_jacobian)
     return;
 
   // d(log u)/d(c') = (1/2) dlog(c'), and d(c')_{ab}/d(f^{-1})_{mn} = delta_{an} f_inv_{mb}
   //                                                                + delta_{bn} f_inv_{ma}.
   const RankFourTensor dlog_cprime = MathUtils::dlog(cprime);
   const RankFourTensor d_cprime_d_finv =
       I2.template times<a_, n_, m_, b_>(f_inv) + I2.template times<b_, n_, m_, a_>(f_inv);
   const RankFourTensor d_dd_spatial_d_finv = -0.5 * (dlog_cprime * d_cprime_d_finv);
 
   // ---- d(r)/d(f^{-1}) via the polar-decomposition closed form (same trick as
   //      ComputeLagrangianObjectiveStress::polarDecomposition). ----
   const RankTwoTensor Y = u.trace() * I2 - u;
   const RankTwoTensor Z = r * Y;
   const RankTwoTensor O = Z * r.transpose();
   const RankFourTensor d_r_d_finv =
       (O.template times<i_, k_, l_, j_>(Y) - Z.template times<i_, l_, k_, j_>(Z)) / Y.det();
 
   d_dw_d_f_inv = -(d_logr_d_r * d_r_d_finv);
 
   // The derivative of the sandwich r'*A*r'^T w.r.t. f^{-1} expands to three rank-4 pieces
   // (chain rule on r' AND on A). The 6-argument `times<>(RankFourTensor)` overload uses
   // x[0..4] (one dummy at index 4), so we reuse the same dummy label `p2_` in each
   // sub-contraction.
   {
     usingTensorIndices(i2_, j2_, m2_, n2_, p2_);
     const RankTwoTensor M = dd_spatial * r.transpose(); // dd * r^T   (p, j) shape
     const RankTwoTensor N = r * dd_spatial;             // r * dd     (i, q) shape
     // T1_{ijmn} = (dr/d_finv)_{ip,mn} * M_{pj}
     const RankFourTensor T1 = M.template times<p2_, j2_, i2_, p2_, m2_, n2_>(d_r_d_finv);
     // T2_{ijmn} = r_{ip} * (d_dd_spatial_d_finv)_{pq,mn} * r_{jq}: contract twice over the dummy.
     const RankFourTensor mid = r.template times<i2_, p2_, p2_, j2_, m2_, n2_>(d_dd_spatial_d_finv);
     const RankFourTensor T2 = r.template times<j2_, p2_, i2_, p2_, m2_, n2_>(mid);
     // T3_{ijmn} = N_{iq} * (dr/d_finv)_{jq,mn}
     const RankFourTensor T3 = N.template times<i2_, p2_, j2_, p2_, m2_, n2_>(d_r_d_finv);
     const RankFourTensor d_dd_d_finv = T1 + T2 + T3;
     d_dL_d_f_inv = d_dd_d_finv + d_dw_d_f_inv;
   }
 }

◆ hasGuarantee()

bool GuaranteeProvider::hasGuarantee	(	const MaterialPropertyName &	prop_name,
		Guarantee	guarantee
	)

inherited

Definition at line 16 of file GuaranteeProvider.C.

 {
   auto it = _guarantees.find(prop_name);
   if (it == _guarantees.end())
     return false;
 
   auto it2 = it->second.find(guarantee);
   return it2 != it->second.end();
 }

◆ initialSetup() [1/4]

template<>

void ComputeLagrangianStrainBase< GradientOperatorCartesian >::initialSetup ( )

inlinevirtual

Reimplemented from Material.

Definition at line 25 of file ComputeLagrangianStrain.h.

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

◆ initialSetup() [2/4]

template<>

void ComputeLagrangianStrainBase< GradientOperatorAxisymmetricCylindrical >::initialSetup ( )

virtual

Reimplemented from Material.

Definition at line 25 of file ComputeLagrangianStrainAxisymmetricCylindrical.h.

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

◆ initialSetup() [3/4]

template<>

void ComputeLagrangianStrainBase< GradientOperatorCentrosymmetricSpherical >::initialSetup ( )

virtual

Reimplemented from Material.

Definition at line 25 of file ComputeLagrangianStrainCentrosymmetricSpherical.h.

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

◆ initialSetup() [4/4]

template<class G >

virtual void ComputeLagrangianStrainBase< G >::initialSetup ( )

overridevirtual

Reimplemented from Material.

◆ initQpStatefulProperties()

template<class G >

void ComputeLagrangianStrainBase< G >::initQpStatefulProperties ( )

overrideprotectedvirtual

Reimplemented from Material.

Definition at line 172 of file ComputeLagrangianStrainBase.C.

 {
   _total_strain[_qp].zero();
   _mechanical_strain[_qp].zero();
   _rotated_mechanical_strain[_qp].zero();
   _F[_qp].setToIdentity();
   _F_ust[_qp].setToIdentity();
   _rotation[_qp].setToIdentity();
 }

◆ issueGuarantee()

void GuaranteeProvider::issueGuarantee	(	const MaterialPropertyName &	prop_name,
		Guarantee	guarantee
	)

protectedinherited

Definition at line 27 of file GuaranteeProvider.C.

Referenced by ADComputeVariableIsotropicElasticityTensor::ADComputeVariableIsotropicElasticityTensor(), ComputeCosseratElasticityTensor::ComputeCosseratElasticityTensor(), ComputeElasticityTensorTempl< is_ad >::ComputeElasticityTensorTempl(), ComputeIsotropicElasticityTensorTempl< is_ad, T >::ComputeIsotropicElasticityTensorTempl(), ComputeLagrangianStrainBase< G >::ComputeLagrangianStrainBase(), ComputeLayeredCosseratElasticityTensor::ComputeLayeredCosseratElasticityTensor(), ComputeVariableIsotropicElasticityTensor::ComputeVariableIsotropicElasticityTensor(), GeneralizedKelvinVoigtModel::GeneralizedKelvinVoigtModel(), and GeneralizedMaxwellModel::GeneralizedMaxwellModel().

 {
   // intentional insertion
   _guarantees[prop_name].insert(guarantee);
 }

◆ revokeGuarantee()

void GuaranteeProvider::revokeGuarantee	(	const MaterialPropertyName &	prop_name,
		Guarantee	guarantee
	)

protectedinherited

Definition at line 34 of file GuaranteeProvider.C.

Referenced by ComputeElasticityTensorCP::ComputeElasticityTensorCP().

 {
   auto it = _guarantees.find(prop_name);
   if (it != _guarantees.end())
     it->second.erase(guarantee);
 }

◆ setQpIncrementalStrains()

template<class G >

void ComputeLagrangianStrainBase< G >::setQpIncrementalStrains	(	const RankTwoTensor &	dd,
		const RankTwoTensor &	dw
	)

protected

Update strain / vorticity / mechanical-strain bookkeeping from already-split (dd, dw) tensors.

Used by the Rashid options where dd != sym(dL) and dw != skew(dL).

Definition at line 371 of file ComputeLagrangianStrainBase.C.

 {
   _strain_increment[_qp] = dd;
   _vorticity_increment[_qp] = dw;
   // Full kinematic spatial velocity gradient increment, before any eigenstrain subtraction.
   // The objective-rate advection in ComputeLagrangianObjectiveStress consumes this.
   _deformation_gradient_increment[_qp] = dd + dw;
 
   // Increment the total strain
   _total_strain[_qp] = _total_strain_old[_qp] + _strain_increment[_qp];
 
   // Get rid of the eigenstrains
   // Note we currently do not alter the deformation gradient -- this will be
   // needed in the future for a "complete" system
   subtractQpEigenstrainIncrement(_strain_increment[_qp]);
 
   // Increment the mechanical strain
   _mechanical_strain[_qp] = _mechanical_strain_old[_qp] + _strain_increment[_qp];
 
   // Additionally maintain the rotated mechanical-strain accumulator,
   // eps_n+1 = r_hat (eps_n + Deltad) r_hat^T, where r_hat = exp(Deltaw) via Rodrigues. This matches
   // the mechanical_strain output convention of `ComputeFiniteStrain` and is consumed only by aux
   // variables -- the stress chain still uses the un-rotated `_mechanical_strain` above. In small
   // kinematics dw is small and r_hat ~= I + dw + 1/2 dw^2, which contributes only second-order
   // corrections (equivalent to no rotation for small strain).
   RankTwoTensor r_hat;
   if (_large_kinematics)
   {
     const Real theta2 = 0.5 * dw.doubleContraction(dw);
     const Real theta = std::sqrt(theta2);
     Real f, g;
     const Real small_theta = 1.0e-7;
     if (theta < small_theta)
     {
       f = 1.0 - theta2 / 6.0;
       g = 0.5 - theta2 / 24.0;
     }
     else
     {
       f = std::sin(theta) / theta;
       g = (1.0 - std::cos(theta)) / theta2;
     }
     r_hat = RankTwoTensor::Identity() + f * dw + g * dw * dw;
   }
   else
   {
     r_hat = RankTwoTensor::Identity();
   }
   _rotated_mechanical_strain[_qp] =
       r_hat * (_rotated_mechanical_strain_old[_qp] + _strain_increment[_qp]) * r_hat.transpose();
 
   // Published rotation increment for downstream `ComputeStressBase`-style materials. The
   // default (identity) preserves the historical Lagrangian pipeline where the objective
   // rate is the sole rotation source. With `publish_rotation_increment = true` we dispatch
   // to the `kinematic_approximation`-matched formula so wrapped plasticity with
   // `perform_finite_strain_rotations = true` rotates its `_stress` bit-for-bit like OLD's
   // `ComputeFiniteStrain` would have done (the rate then runs in `rotate_old_stress`
   // passthrough mode so we don't double-rotate). Specifically `rashid_approximate` uses
   // OLD's C1/C2/C3 polynomial form (not `exp(dw)`) so the wrapped material's accumulated
   // stress storage matches OLD's `_stress` byte-for-byte through return mapping; without
   // this, the small (~1e-5) per-step rotation drift between `exp(dw)` and OLD's R_incr
   // amplifies through plastic flow into ~1e-3 cumulative stress error.
   _rotation_increment[_qp] = (_publish_rotation_increment && _large_kinematics)
                                  ? computeQpRotationIncrement(_f_inv[_qp], dw)
                                  : RankTwoTensor::Identity();
 }

◆ subtractQpEigenstrainIncrement()

template<class G >

void ComputeLagrangianStrainBase< G >::subtractQpEigenstrainIncrement ( RankTwoTensor & strain )

protectedvirtual

Subtract the eigenstrain increment to subtract from the total strain.

Definition at line 759 of file ComputeLagrangianStrainBase.C.

 {
   for (auto i : make_range(_eigenstrain_names.size()))
     strain -= (*_eigenstrains[i])[_qp] - (*_eigenstrains_old[i])[_qp];
 }

◆ validParams() [1/4]

template<>

InputParameters ComputeLagrangianStrainBase< GradientOperatorAxisymmetricCylindrical >::validParams ( )

inline

Definition at line 16 of file ComputeLagrangianStrainAxisymmetricCylindrical.h.

 {
   InputParameters params = ComputeLagrangianStrainBase::baseParams();
   params.addClassDescription("Compute strain in 2D axisymmetric RZ coordinates.");
   return params;
 }

◆ validParams() [2/4]

template<>

InputParameters ComputeLagrangianStrainBase< GradientOperatorCentrosymmetricSpherical >::validParams ( )

inline

Definition at line 16 of file ComputeLagrangianStrainCentrosymmetricSpherical.h.

 {
   InputParameters params = ComputeLagrangianStrainBase::baseParams();
   params.addClassDescription("Compute strain in centrosymmetric spherical coordinates.");
   return params;
 }

◆ validParams() [3/4]

template<>

InputParameters ComputeLagrangianStrainBase< GradientOperatorCartesian >::validParams ( )

inline

Definition at line 16 of file ComputeLagrangianStrain.h.

 {
   InputParameters params = ComputeLagrangianStrainBase::baseParams();
   params.addClassDescription("Compute strain in Cartesian coordinates.");
   return params;
 }

◆ validParams() [4/4]

template<class G >

static InputParameters ComputeLagrangianStrainBase< G >::validParams ( )

static

Referenced by ComputeLagrangianWPSStrain::validParams().

Member Data Documentation

◆ _alpha

template<class G >

const Real ComputeLagrangianStrainBase< G >::_alpha

protected

Generalized-midpoint weight for the deformation gradient (1.0 = backward Euler, 0.5 = midpoint)

Definition at line 144 of file ComputeLagrangianStrainBase.h.

◆ _base_name

template<class G >

const std::string ComputeLagrangianStrainBase< G >::_base_name

protected

Material system base name.

Definition at line 121 of file ComputeLagrangianStrainBase.h.

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

◆ _d_deformation_gradient_increment_d_F

template<class G >

MaterialProperty<RankFourTensor>& ComputeLagrangianStrainBase< G >::_d_deformation_gradient_increment_d_F

protected

Derivative of the spatial velocity gradient increment with respect to F_{n+1}.

Stored so downstream consumers do not bake in the linear-approximation assumption.

Definition at line 217 of file ComputeLagrangianStrainBase.h.

◆ _d_F_d_grad_u

template<class G >

MaterialProperty<RankFourTensor>& ComputeLagrangianStrainBase< G >::_d_F_d_grad_u

protected

Derivative of F_{n+1} with respect to the displacement gradient.

Identity for backward Euler; will become alpha * Identity for the generalized midpoint rule.

Definition at line 226 of file ComputeLagrangianStrainBase.h.

◆ _d_F_stab_d_F_avg

template<class G >

MaterialProperty<RankFourTensor>& ComputeLagrangianStrainBase< G >::_d_F_stab_d_F_avg

protected

Partial derivative of the F-bar-stabilized deformation gradient with respect to the element-averaged deformation gradient F_avg (the non-local coupling).

Equals zero when F-bar is off.

Definition at line 245 of file ComputeLagrangianStrainBase.h.

◆ _d_F_stab_d_F_ust

template<class G >

MaterialProperty<RankFourTensor>& ComputeLagrangianStrainBase< G >::_d_F_stab_d_F_ust

protected

Partial derivative of the F-bar-stabilized deformation gradient with respect to the unstabilized (per-qp local) deformation gradient.

Equals IdentityFour when F-bar is off.

Definition at line 240 of file ComputeLagrangianStrainBase.h.

◆ _d_rotation_d_F

template<class G >

MaterialProperty<RankFourTensor>& ComputeLagrangianStrainBase< G >::_d_rotation_d_F

protected

Derivative of R with respect to F.

Definition at line 236 of file ComputeLagrangianStrainBase.h.

◆ _d_vorticity_increment_d_F

template<class G >

MaterialProperty<RankFourTensor>& ComputeLagrangianStrainBase< G >::_d_vorticity_increment_d_F

protected

Derivative of the vorticity increment Deltaw with respect to F_{n+1}.

Consumed by the Jaumann objective rate so it can produce a consistent Jacobian regardless of which kinematic_approximation the strain calculator is using.

Definition at line 222 of file ComputeLagrangianStrainBase.h.

◆ _deformation_gradient_increment

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_deformation_gradient_increment

protected

Deformation gradient increment.

Definition at line 173 of file ComputeLagrangianStrainBase.h.

◆ _disp

template<class G >

std::vector<const VariableValue *> ComputeLagrangianStrainBase< G >::_disp

protected

Definition at line 113 of file ComputeLagrangianStrainBase.h.

◆ _disp_old

template<class G >

std::vector<const VariableValue *> ComputeLagrangianStrainBase< G >::_disp_old

protected

Old displacement values for the generalized midpoint rule.

Definition at line 116 of file ComputeLagrangianStrainBase.h.

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

◆ _eigenstrain_names

template<class G >

std::vector<MaterialPropertyName> ComputeLagrangianStrainBase< G >::_eigenstrain_names

protected

Definition at line 150 of file ComputeLagrangianStrainBase.h.

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

◆ _eigenstrains

template<class G >

std::vector<const MaterialProperty<RankTwoTensor> *> ComputeLagrangianStrainBase< G >::_eigenstrains

protected

Definition at line 151 of file ComputeLagrangianStrainBase.h.

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

◆ _eigenstrains_old

template<class G >

std::vector<const MaterialProperty<RankTwoTensor> *> ComputeLagrangianStrainBase< G >::_eigenstrains_old

protected

Definition at line 152 of file ComputeLagrangianStrainBase.h.

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

◆ _F

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_F

protected

Definition at line 197 of file ComputeLagrangianStrainBase.h.

Referenced by ComputeLagrangianWPSStrain::computeDeformationGradient().

◆ _F_actual

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_F_actual

protected

The literal deformation gradient at n+1 (I + grad u_{n+1}).

Equals _F_ust when alpha = 1. Needed by the UL kernel for the spatial-to-reference pull-back, since the spatial frame is always at n+1 regardless of alpha.

Definition at line 189 of file ComputeLagrangianStrainBase.h.

◆ _F_avg

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_F_avg

protected

Definition at line 193 of file ComputeLagrangianStrainBase.h.

◆ _F_bar_mode

template<class G >

const FBarMode ComputeLagrangianStrainBase< G >::_F_bar_mode

protected

Selected F-bar averaging mode (Total vs. Incremental). See FBarMode.

Definition at line 130 of file ComputeLagrangianStrainBase.h.

◆ _F_inv

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_F_inv

protected

Inverse deformation gradient.

Definition at line 203 of file ComputeLagrangianStrainBase.h.

◆ _f_inv

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_f_inv

protected

Inverse incremental deformation gradient.

Definition at line 205 of file ComputeLagrangianStrainBase.h.

◆ _F_old

template<class G >

const MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_F_old

protected

Old deformation gradient.

Definition at line 200 of file ComputeLagrangianStrainBase.h.

◆ _F_ust

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_F_ust

protected

The unstabilized (alpha-weighted) deformation gradient.

Definition at line 179 of file ComputeLagrangianStrainBase.h.

Referenced by ComputeLagrangianWPSStrain::computeDeformationGradient().

◆ _F_ust_det

template<class G >

MaterialProperty<Real>& ComputeLagrangianStrainBase< G >::_F_ust_det

protected

Definition at line 213 of file ComputeLagrangianStrainBase.h.

◆ _F_ust_inv

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_F_ust_inv

protected

Inverse and determinant of the unstabilized deformation gradient F_ust.

Published for the F-bar Lagrangian kernels' spatial push-forward (grad_x = F_ust^{-T} grad_X, J_ust = det F_ust) so the kernel reads a per-qp material property (computed once, shared by all displacement kernels) instead of recomputing the 3x3 inverse per test/trial. Filled only when a consumer marks them active (see isPropertyActive gate in computeQpProperties).

Definition at line 212 of file ComputeLagrangianStrainBase.h.

◆ _F_ust_old

template<class G >

const MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_F_ust_old

protected

Old unstabilized deformation gradient.

Needed for F_bar_mode = incremental so the incremental F (F_ust * F_ust_old^{-1}) at this step is built from the unstabilized pair (matching OLD ComputeFiniteStrain's _Fhat). Only consulted in incremental mode.

Definition at line 184 of file ComputeLagrangianStrainBase.h.

◆ _grad_disp

template<class G >

std::vector<const VariableGradient *> ComputeLagrangianStrainBase< G >::_grad_disp

protected

Definition at line 114 of file ComputeLagrangianStrainBase.h.

◆ _grad_disp_old

template<class G >

std::vector<const VariableGradient *> ComputeLagrangianStrainBase< G >::_grad_disp_old

protected

Old displacement gradients for the generalized midpoint rule.

Definition at line 118 of file ComputeLagrangianStrainBase.h.

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

◆ _homogenization_contributions

template<class G >

std::vector<const MaterialProperty<RankTwoTensor> *> ComputeLagrangianStrainBase< G >::_homogenization_contributions

protected

Actual homogenization contributions.

Definition at line 251 of file ComputeLagrangianStrainBase.h.

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

◆ _homogenization_gradient_names

template<class G >

std::vector<MaterialPropertyName> ComputeLagrangianStrainBase< G >::_homogenization_gradient_names

protected

Names of any extra homogenization gradients.

Definition at line 248 of file ComputeLagrangianStrainBase.h.

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

◆ _kinematic_approximation

template<class G >

const KinematicApproximation ComputeLagrangianStrainBase< G >::_kinematic_approximation

protected

Selected approximation for the spatial velocity gradient increment.

Definition at line 147 of file ComputeLagrangianStrainBase.h.

◆ _large_kinematics

template<class G >

const bool ComputeLagrangianStrainBase< G >::_large_kinematics

protected

If true the equilibrium conditions is calculated with large deformations.

Definition at line 124 of file ComputeLagrangianStrainBase.h.

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

◆ _mechanical_strain

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_mechanical_strain

protected

Definition at line 157 of file ComputeLagrangianStrainBase.h.

◆ _mechanical_strain_old

template<class G >

const MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_mechanical_strain_old

protected

Definition at line 158 of file ComputeLagrangianStrainBase.h.

◆ _ndisp

template<class G >

const unsigned int ComputeLagrangianStrainBase< G >::_ndisp

protected

Definition at line 112 of file ComputeLagrangianStrainBase.h.

◆ _publish_rotation_increment

template<class G >

const bool ComputeLagrangianStrainBase< G >::_publish_rotation_increment

protected

If true, publish _rotation_increment = exp(_vorticity_increment) (Rodrigues) instead of the default identity.

Enables OLD-compatible plasticity through ComputeLagrangianWrappedStress: wrapped materials with perform_finite_strain_rotations = true (e.g. ComputeMultiPlasticityStress) will rotate their internal _stress each step, so the next step's return mapping reads _stress_old = sigma_cauchy_old (matching OLD's ComputeFiniteStrain pipeline). Pair with rotate_old_stress = true on the objective rate so the rate skips its outer rotation (the wrapped material already applied it) and doesn't double-rotate. Default false preserves the existing pipeline where the rate alone applies rotation.

Definition at line 141 of file ComputeLagrangianStrainBase.h.

◆ _rotated_mechanical_strain

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_rotated_mechanical_strain

protected

Mechanical strain accumulated with the incremental rotation r_hat = exp(Deltaw), matching the convention ComputeFiniteStrain uses for its mechanical_strain output (eps_n+1 = r_hat * (eps_n + Deltad) * r_hat^T).

Provided as a separate property so the standard _mechanical_strain (consumed by constitutive materials) stays un-rotated and the objective-rate-driven stress chain is unaffected. Use this for aux-variable output when matching the old-system convention.

Definition at line 166 of file ComputeLagrangianStrainBase.h.

◆ _rotated_mechanical_strain_old

template<class G >

const MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_rotated_mechanical_strain_old

protected

Definition at line 167 of file ComputeLagrangianStrainBase.h.

◆ _rotation

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_rotation

protected

Polar decomposition R of the (alpha-weighted, F-bar-stabilized) deformation gradient F at this qp.

Stateful so the Green-Naghdi rate can read R_n via getMaterialPropertyOld. Computed only when a consumer (the Green-Naghdi objective rate) marks it active – see the isPropertyActive gate on computeQpPolarDecomposition in computeQpProperties.

Definition at line 232 of file ComputeLagrangianStrainBase.h.

◆ _rotation_increment

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_rotation_increment

protected

Rotation increment for "old" materials inheriting from ComputeStressBase.

Definition at line 254 of file ComputeLagrangianStrainBase.h.

◆ _stabilize_strain

template<class G >

const bool ComputeLagrangianStrainBase< G >::_stabilize_strain

protected

If true stabilize the strains with F_bar.

Definition at line 127 of file ComputeLagrangianStrainBase.h.

◆ _strain_increment

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_strain_increment

protected

Strain increment.

Definition at line 170 of file ComputeLagrangianStrainBase.h.

◆ _stretch

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_stretch

protected

Stretch U from the same polar decomposition.

Definition at line 234 of file ComputeLagrangianStrainBase.h.

◆ _total_strain

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_total_strain

protected

Definition at line 155 of file ComputeLagrangianStrainBase.h.

◆ _total_strain_old

template<class G >

const MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_total_strain_old

protected

Definition at line 156 of file ComputeLagrangianStrainBase.h.

◆ _vorticity_increment

template<class G >

MaterialProperty<RankTwoTensor>& ComputeLagrangianStrainBase< G >::_vorticity_increment

protected

Vorticity increment.

Definition at line 176 of file ComputeLagrangianStrainBase.h.

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

solid_mechanics/include/materials/lagrangian/ComputeLagrangianStrainBase.h
solid_mechanics/src/materials/lagrangian/ComputeLagrangianStrainBase.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

template<class G> class ComputeLagrangianStrainBase< G >

Member Enumeration Documentation

◆ FBarMode

◆ KinematicApproximation

Constructor & Destructor Documentation

◆ ComputeLagrangianStrainBase()

Member Function Documentation

◆ baseParams()

◆ computeDeformationGradient()

◆ computeLinearIncrement()

◆ computeProperties()

◆ computeQpActualDeformationGradient()

◆ computeQpIncrementalStrains()

◆ computeQpLargeKinematicIncrement()

◆ computeQpPolarDecomposition()

◆ computeQpProperties()

◆ computeQpRotationIncrement()

◆ computeQpUnstabilizedDeformationGradient()

◆ computeQuadraticIncrement()

◆ computeRashidApproximateIncrement()

◆ computeRashidEigenIncrement()

◆ hasGuarantee()

◆ initialSetup() [1/4]

◆ initialSetup() [2/4]

◆ initialSetup() [3/4]

◆ initialSetup() [4/4]

◆ initQpStatefulProperties()

◆ issueGuarantee()

◆ revokeGuarantee()

◆ setQpIncrementalStrains()

◆ subtractQpEigenstrainIncrement()

◆ validParams() [1/4]

◆ validParams() [2/4]

◆ validParams() [3/4]

◆ validParams() [4/4]

Member Data Documentation

◆ _alpha

◆ _base_name

◆ _d_deformation_gradient_increment_d_F

◆ _d_F_d_grad_u

◆ _d_F_stab_d_F_avg

◆ _d_F_stab_d_F_ust

◆ _d_rotation_d_F

◆ _d_vorticity_increment_d_F

◆ _deformation_gradient_increment

◆ _disp

◆ _disp_old

◆ _eigenstrain_names

◆ _eigenstrains

◆ _eigenstrains_old

◆ _F

◆ _F_actual

◆ _F_avg

◆ _F_bar_mode

◆ _F_inv

◆ _f_inv

◆ _F_old

◆ _F_ust

◆ _F_ust_det

◆ _F_ust_inv

◆ _F_ust_old

◆ _grad_disp

◆ _grad_disp_old

◆ _homogenization_contributions

◆ _homogenization_gradient_names

◆ _kinematic_approximation

◆ _large_kinematics

◆ _mechanical_strain

◆ _mechanical_strain_old

template<class G>
class ComputeLagrangianStrainBase< G >