CappedMohrCoulombStressUpdate implements rate-independent nonassociative Mohr-Coulomb plus tensile plus compressive plasticity with hardening/softening. More...

#include <CappedMohrCoulombStressUpdate.h>

Inheritance diagram for CappedMohrCoulombStressUpdate:

[legend]

Public Types
using	GR2 = GenericRankTwoTensor< is_ad >

using	GSR2 = Moose::GenericType< R2, is_ad >

using	GR4 = GenericRankFourTensor< is_ad >

using	GSR4 = Moose::GenericType< R4, is_ad >

enum	TEST_TYPE

typedef DataFileName	DataFileParameterType

Public Member Functions
	CappedMohrCoulombStressUpdate (const InputParameters &parameters)

bool	requiresIsotropicTensor () override
	Does the model require the elasticity tensor to be isotropic?

bool	isIsotropic () override
	Is the implmented model isotropic? The safe default is 'false'.

virtual void	updateStateSubstep (GR2 &, GR2 &, const GR2 &, GR2 &, const RankTwoTensor &, const GR4 &, const RankTwoTensor &, bool compute_full_tangent_operator=false, RankFourTensor &tangent_operator=StressUpdateBaseTempl< is_ad >::_identityTensor)
	Similar to the updateState function, this method updates the strain and stress for one substep.

void	setQp (unsigned int qp)
	Sets the value of the global variable _qp for inheriting classes.

virtual Real	computeTimeStepLimit ()

virtual bool	substeppingCapabilityEnabled ()
	Does the model include the infrastructure for substep decomposition of the elastic strain initially used to calculate the trial stress guess Inheriting classes which wish to use the substepping capability should overwrite this method and set it to return true.

virtual bool	substeppingCapabilityRequested ()
	Has the user requested usage of (possibly) implemented substepping capability for inelastic models.

virtual int	calculateNumberSubsteps (const GR2 &)
	Given the elastic strain increment compute the number of substeps required to bring a substepped trial stress guess distance from the yield surface into the tolerance specified in the individual child class.

virtual void	storeIncrementalMaterialProperties (const unsigned int)
	Properly set up the incremental calculation storage of the stateful material properties in the inheriting classes.

virtual void	resetIncrementalMaterialProperties ()
	Reset material properties.

virtual Real	computeStrainEnergyRateDensity (const GenericMaterialProperty< RankTwoTensor, is_ad > &, const GenericMaterialProperty< RankTwoTensor, is_ad > &)
	Compute the strain energy rate density for this inelastic model for the current step.

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

virtual void	computeProperties () 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 > &	getGenericZeroMaterialPropertyByName (const std::string &prop_name)

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

virtual void	initStatefulProperties (const unsigned int n_points)

virtual bool	isInterfaceMaterial ()

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	hasBoundary (const std::vector< BoundaryID > &ids, TEST_TYPE type=ALL) const

bool	hasBoundary (const std::set< BoundaryID > &ids, TEST_TYPE type=ALL) 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	initialSetup ()

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 Moose::Functor< Real > *	defaultFunctor (const std::string &name)

const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const


void	resetQpProperties () final
	Retained as empty methods to avoid a warning from Material.C in framework. These methods are unused in all inheriting classes and should not be overwritten.

void	resetProperties () final

Static Public Member Functions
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
const Elem *const &	_current_elem

Real &	_dt

const MooseArray< Point > &	_q_point

unsigned int	_qp

	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
void	computeStressParams (const RankTwoTensor &stress, std::vector< Real > &stress_params) const override
	Computes stress_params, given stress.

void	dstressparam_dstress (const RankTwoTensor &stress, std::vector< RankTwoTensor > &dsp) const override
	d(stress_param[i])/d(stress) at given stress.

void	d2stressparam_dstress (const RankTwoTensor &stress, std::vector< RankFourTensor > &d2sp) const override
	d2(stress_param[i])/d(stress)/d(stress) at given stress.

virtual void	setStressAfterReturnV (const RankTwoTensor &stress_trial, const std::vector< Real > &stress_params, Real gaE, const std::vector< Real > &intnl, const yieldAndFlow &smoothed_q, const RankFourTensor &Eijkl, RankTwoTensor &stress) const override
	Sets stress from the admissible parameters.

virtual void	preReturnMapV (const std::vector< Real > &trial_stress_params, const RankTwoTensor &stress_trial, const std::vector< Real > &intnl_old, const std::vector< Real > &yf, const RankFourTensor &Eijkl) override
	Derived classes may employ this function to record stuff or do other computations prior to the return-mapping algorithm.

void	setEffectiveElasticity (const RankFourTensor &Eijkl) override
	Sets _Eij and _En and _Cij.

void	yieldFunctionValuesV (const std::vector< Real > &stress_params, const std::vector< Real > &intnl, std::vector< Real > &yf) const override
	Computes the values of the yield functions, given stress_params and intnl parameters.

void	computeAllQV (const std::vector< Real > &stress_params, const std::vector< Real > &intnl, std::vector< yieldAndFlow > &all_q) const override
	Completely fills all_q with correct values.

void	initializeVarsV (const std::vector< Real > &trial_stress_params, const std::vector< Real > &intnl_old, std::vector< Real > &stress_params, Real &gaE, std::vector< Real > &intnl) const override
	Sets (stress_params, intnl) at "good guesses" of the solution to the Return-Map algorithm.

void	setIntnlValuesV (const std::vector< Real > &trial_stress_params, const std::vector< Real > &current_stress_params, const std::vector< Real > &intnl_old, std::vector< Real > &intnl) const override
	Sets the internal parameters based on the trial values of stress_params, their current values, and the old values of the internal parameters.

void	setIntnlDerivativesV (const std::vector< Real > &trial_stress_params, const std::vector< Real > &current_stress_params, const std::vector< Real > &intnl, std::vector< std::vector< Real > > &dintnl) const override
	Sets the derivatives of internal parameters, based on the trial values of stress_params, their current values, and the current values of the internal parameters.

virtual void	consistentTangentOperatorV (const RankTwoTensor &stress_trial, const std::vector< Real > &trial_stress_params, const RankTwoTensor &stress, const std::vector< Real > &stress_params, Real gaE, const yieldAndFlow &smoothed_q, const RankFourTensor &Eijkl, bool compute_full_tangent_operator, const std::vector< std::vector< Real > > &dvar_dtrial, RankFourTensor &cto) override
	Calculates the consistent tangent operator.

virtual void	initQpStatefulProperties () override

virtual void	updateState (RankTwoTensor &strain_increment, RankTwoTensor &inelastic_strain_increment, const RankTwoTensor &rotation_increment, RankTwoTensor &stress_new, const RankTwoTensor &stress_old, const RankFourTensor &elasticity_tensor, const RankTwoTensor &elastic_strain_old, bool compute_full_tangent_operator, RankFourTensor &tangent_operator) override

virtual void	updateState (GR2 &strain_increment, GR2 &inelastic_strain_increment, const GR2 &rotation_increment, GR2 &stress_new, const RankTwoTensor &stress_old, const GR4 &elasticity_tensor, const RankTwoTensor &elastic_strain_old, bool compute_full_tangent_operator=false, RankFourTensor &tangent_operator=StressUpdateBaseTempl< is_ad >::_identityTensor)
	Given a strain increment that results in a trial stress, perform some procedure (such as an iterative return-mapping process) to produce an admissible stress, an elastic strain increment and an inelastic strain increment.

virtual void	propagateQpStatefulProperties () override
	If updateState is not called during a timestep, this will be.

virtual TangentCalculationMethod	getTangentCalculationMethod () override

Real	yieldF (const std::vector< Real > &stress_params, const std::vector< Real > &intnl) const
	Computes the smoothed yield function.

Real	yieldF (const std::vector< Real > &yfs) const
	Computes the smoothed yield function.

Real	ismoother (Real f_diff) const
	Smooths yield functions.

Real	smoother (Real f_diff) const
	Derivative of ismoother.

Real	dsmoother (Real f_diff) const
	Derivative of smoother.

yieldAndFlow	smoothAllQuantities (const std::vector< Real > &stress_params, const std::vector< Real > &intnl) const
	Calculates all yield functions and derivatives, and then performs the smoothing scheme.

int	lineSearch (Real &res2, std::vector< Real > &stress_params, Real &gaE, const std::vector< Real > &trial_stress_params, yieldAndFlow &smoothed_q, const std::vector< Real > &intnl_ok, std::vector< Real > &intnl, std::vector< Real > &rhs, Real &linesearch_needed) const
	Performs a line-search to find stress_params and gaE Upon entry:

int	nrStep (const yieldAndFlow &smoothed_q, const std::vector< Real > &trial_stress_params, const std::vector< Real > &stress_params, const std::vector< Real > &intnl, Real gaE, std::vector< Real > &rhs) const
	Performs a Newton-Raphson step to attempt to zero rhs Upon return, rhs will contain the solution.

Real	calculateRes2 (const std::vector< Real > &rhs) const
	Calculates the residual-squared for the Newton-Raphson + line-search.

void	calculateRHS (const std::vector< Real > &trial_stress_params, const std::vector< Real > &stress_params, Real gaE, const yieldAndFlow &smoothed_q, std::vector< Real > &rhs) const
	Calculates the RHS in the following 0 = rhs[0] = S[0] - S[0]^trial + ga * E[0, j] * dg/dS[j] 0 = rhs[1] = S[1] - S[1]^trial + ga * E[1, j] * dg/dS[j] ... 0 = rhs[N-1] = S[N-1] - S[N-1]^trial + ga * E[N-1, j] * dg/dS[j] 0 = rhs[N] = f(S, intnl) where N = _num_sp.

void	dnRHSdVar (const yieldAndFlow &smoothed_q, const std::vector< std::vector< Real > > &dintnl, const std::vector< Real > &stress_params, Real gaE, std::vector< double > &jac) const
	Derivative of -RHS with respect to the stress_params and gaE, placed into an array ready for solving the linear system using LAPACK gsev.

virtual void	errorHandler (const std::string &message) const
	Performs any necessary cleaning-up, then throw MooseException(message)

virtual void	initializeReturnProcess ()
	Derived classes may use this to perform calculations before any return-map process is performed, for instance, to initialize variables.

virtual void	finalizeReturnProcess (const RankTwoTensor &rotation_increment)
	Derived classes may use this to perform calculations after the return-map process has completed successfully in stress_param space but before the returned stress tensor has been calculcated.

virtual void	setInelasticStrainIncrementAfterReturn (const RankTwoTensor &stress_trial, Real gaE, const yieldAndFlow &smoothed_q, const RankFourTensor &elasticity_tensor, const RankTwoTensor &returned_stress, RankTwoTensor &inelastic_strain_increment)
	Sets inelastic strain increment from the returned configuration This is called after the return-map process has completed successfully in stress_param space, just after finalizeReturnProcess has been called.

void	dVardTrial (bool elastic_only, const std::vector< Real > &trial_stress_params, const std::vector< Real > &stress_params, Real gaE, const std::vector< Real > &intnl, const yieldAndFlow &smoothed_q, Real step_size, bool compute_full_tangent_operator, std::vector< std::vector< Real > > &dvar_dtrial) const
	Calculates derivatives of the stress_params and gaE with repect to the trial values of the stress_params for the (sub)strain increment.

bool	precisionLoss (const std::vector< Real > &solution, const std::vector< Real > &stress_params, Real gaE) const
	Check whether precision loss has occurred.

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

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)

Protected Attributes
const SolidMechanicsHardeningModel &	_tensile_strength
	Hardening model for tensile strength.

const SolidMechanicsHardeningModel &	_compressive_strength
	Hardening model for compressive strength.

const SolidMechanicsHardeningModel &	_cohesion
	Hardening model for cohesion.

const SolidMechanicsHardeningModel &	_phi
	Hardening model for friction angle.

const SolidMechanicsHardeningModel &	_psi
	Hardening model for dilation angle.

const bool	_perfect_guess
	Whether to provide an estimate of the returned stress, based on perfect plasticity.

Real	_poissons_ratio
	Poisson's ratio.

const Real	_shifter
	When equal-eigenvalues are predicted from the stress initialization routine, shift them by this amount.

RankTwoTensor	_eigvecs
	Eigenvectors of the trial stress as a RankTwoTensor, in order to rotate the returned stress back to stress space.

const unsigned	_num_sp
	Number of stress parameters.

const std::vector< Real >	_definitely_ok_sp
	An admissible value of stress_params at the initial time.

std::vector< std::vector< Real > >	_Eij
	E[i, j] in the system of equations to be solved.

Real	_En
	normalising factor

std::vector< std::vector< Real > >	_Cij
	_Cij[i, j] * _Eij[j, k] = 1 iff j == k

const unsigned	_num_yf
	Number of yield functions.

const unsigned	_num_intnl
	Number of internal parameters.

const unsigned	_max_nr_its
	Maximum number of Newton-Raphson iterations allowed in the return-map process.

const bool	_perform_finite_strain_rotations
	Whether to perform finite-strain rotations.

const Real	_smoothing_tol
	Smoothing tolerance: edges of the yield surface get smoothed by this amount.

const Real	_smoothing_tol2
	Square of the smoothing tolerance.

const Real	_f_tol
	The yield-function tolerance.

const Real	_f_tol2
	Square of the yield-function tolerance.

const Real	_min_step_size
	In order to help the Newton-Raphson procedure, the applied strain increment may be applied in sub-increments of size greater than this value.

bool	_step_one
	handles case of initial_stress that is inadmissible being supplied

const bool	_warn_about_precision_loss
	Output a warning message if precision loss is encountered during the return-map process.

MaterialProperty< RankTwoTensor > &	_plastic_strain
	plastic strain

const MaterialProperty< RankTwoTensor > &	_plastic_strain_old
	Old value of plastic strain.

MaterialProperty< std::vector< Real > > &	_intnl
	internal parameters

const MaterialProperty< std::vector< Real > > &	_intnl_old
	old values of internal parameters

MaterialProperty< std::vector< Real > > &	_yf
	yield functions

MaterialProperty< Real > &	_iter
	Number of Newton-Raphson iterations used in the return-map.

MaterialProperty< Real > &	_max_iter_used
	Maximum number of Newton-Raphson iterations used in the return-map during the course of the entire simulation.

const MaterialProperty< Real > &	_max_iter_used_old
	Old value of maximum number of Newton-Raphson iterations used in the return-map during the course of the entire simulation.

MaterialProperty< Real > &	_linesearch_needed
	Whether a line-search was needed in the latest Newton-Raphson process (1 if true, 0 otherwise)

const std::string	_base_name
	Name used as a prefix for all material properties related to the stress update model.

	CURR

	PREV

bool	_bnd

bool	_neighbor

const QBase *const &	_qrule

const MooseArray< Real > &	_JxW

const SubdomainID &	_current_subdomain_id

const unsigned int &	_current_side

const ConstantTypeEnum	_constant_option

SubProblem &	_subproblem

FEProblemBase &	_fe_problem

THREAD_ID	_tid

Assembly &	_assembly

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_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 constexpr unsigned	_tensor_dimensionality = 3
	Internal dimensionality of tensors (currently this is 3 throughout solid mechanics)

static RankFourTensor	_identityTensor

static const std::string	_interpolated_old

static const std::string	_interpolated_older

Private Types
enum class	SmootherFunctionType { cos , poly1 , poly2 , poly3 }
	The type of smoother function. More...

enum	FuncAge

enum	VarType

Private Member Functions
const ADVariableValue *	getADDefaultValue (const std::string &var_name) const

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

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

const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

void	checkVar (const std::string &var_name) const

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

void	markMatPropRequested (const std::string &name)

ConstantTypeEnum	computeConstantOption ()

void	storeSubdomainZeroMatProp (SubdomainID block_id, const MaterialPropertyName &name)

void	storeBoundaryZeroMatProp (BoundaryID boundary_id, const MaterialPropertyName &name)

unsigned int	getMaxQps () const

void	initializeBoundaryRestrictable ()

void	initializeKokkosBoundaryRestrictable ()

std::set< MooseVariableFieldBase * >	checkVariablesHelper (const DofObjectType &dof_object, const std::set< MooseVariableFieldBase * > &vars_to_check)

const VariableValue *	getDefaultValue (const std::string &var_name) const

const Moose::FunctionBase *	getKokkosFunctionByNameHelper (const FunctionName &name) const

const UserObjectBase &	getUserObjectFromFEProblem (const UserObjectName &object_name, const THREAD_ID tid=0) const

const T &	castUserObject (const UserObjectBase &uo_base, const std::string &param_name="") const

void	mooseObjectError (const std::string &param_name, std::stringstream &oss) const

const std::string &	userObjectType (const UserObjectBase &uo) const

const std::string &	userObjectName (const UserObjectBase &uo) const

const PostprocessorName &	getPostprocessorNameInternal (const std::string &param_name, const unsigned int index, const bool allow_default_value=true) const

bool	isDefaultPostprocessorValueByName (const PostprocessorName &name) const

PostprocessorValue	getDefaultPostprocessorValueByName (const PostprocessorName &name) const

void	checkParam (const std::string &param_name, const unsigned int index=std::numeric_limits< unsigned int >::max()) const

bool	postprocessorsAdded () const

const VectorPostprocessorValue &	getVectorPostprocessorByNameHelper (const VectorPostprocessorName &name, const std::string &vector_name, bool broadcast, std::size_t t_index) const

const VectorPostprocessorContext< VectorPostprocessorValue > &	getVectorPostprocessorContextByNameHelper (const VectorPostprocessorName &name, const std::string &vector_name) const

bool	vectorPostprocessorsAdded () const

RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const

void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)

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

virtual bool	isADObject () const override

const OutputTools< T >::VariableValue &	vectorTagValueHelper (const std::string &var_names, TagID tag, unsigned int index=0) const

const OutputTools< T >::VariableValue &	vectorTagValueHelper (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

const OutputTools< T >::VariableValue &	vectorTagDofValueHelper (const std::string &var_name, TagID tag, unsigned int comp=0) const

const OutputTools< T >::VariableValue &	vectorTagDofValueHelper (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

void	requestStates (const std::string &var_name, const TagName &tag_name, const unsigned int comp)

void	checkFuncType (const std::string var_name, VarType t, FuncAge age) const

const VectorVariableValue *	getDefaultVectorValue (const std::string &var_name) const

const ArrayVariableValue *	getDefaultArrayValue (const std::string &var_name) const

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

const RealVectorValue &	getDefaultNodalValue (const std::string &var_name, unsigned int) const

const RealEigenVector &	getDefaultNodalValue (const std::string &var_name, unsigned int) const

const Moose::Functor< T > &	getDefaultFunctor (const std::string &var_name) const

Moose::Kokkos::Variable	kokkosCoupledVectorTagVariable (const std::string &var_name, const std::string &tag_name, unsigned int comp) const

Moose::Kokkos::Variable	kokkosCoupledVectorTagVariables (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::Variable	kokkosCoupledVectorTagVectorVariable (const std::string &var_name, const std::string &tag_name, unsigned int comp) const

Moose::Kokkos::Variable	kokkosCoupledVectorTagVectorVariables (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::Variable	kokkosZeroVariable () const

Moose::MaterialDataType	getMaterialDataType (const std::set< BoundaryID > &boundary_ids) const

void	addConsumedPropertyName (const MooseObjectName &obj_name, const std::string &prop_name)

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

void	possiblyCheckHasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const

void	possiblyCheckHasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const

void	possiblyCheckHasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

void	possiblyCheckHasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
std::vector< RankTwoTensor >	_dsp_trial_scratch
	this is d(stress_param[:])/d(stress) which is calculated by dstressparam_dstress.

std::vector< Real >	_eigvals_scratch
	eigenvalues of the stress, used in dstressparam_dstress and preReturnMapV.

std::vector< Real >	_dga_shear_scratch
	derivative of ga_shear w.r.t.

std::vector< Real >	_dshear_correction_scratch
	scratch vector used in setIntnlDerivativesV.

std::vector< Real >	_trial_sp
	"Trial" value of stress_params that initializes the return-map process This is derived from stress = stress_old + Eijkl * strain_increment.

RankTwoTensor	_stress_trial
	"Trial" value of stress that is set at the beginning of the return-map process.

std::vector< Real >	_rhs
	0 = rhs[0] = S[0] - S[0]^trial + ga * E[0, i] * dg/dS[i] 0 = rhs[1] = S[1] - S[1]^trial + ga * E[1, i] * dg/dS[i] ... 0 = rhs[N-1] = S[N-1] - S[N-1]^trial + ga * E[N-1, i] * dg/dS[i] 0 = rhs[N] = f(S, intnl) Here N = num_sp

std::vector< std::vector< Real > >	_dvar_dtrial
	d({stress_param[i], gaE})/d(trial_stress_param[j])

std::vector< Real >	_ok_sp
	The state (ok_sp, ok_intnl) is known to be admissible, so ok_sp are stress_params that are "OK".

std::vector< Real >	_ok_intnl
	The state (ok_sp, ok_intnl) is known to be admissible.

std::vector< Real >	_del_stress_params
	_del_stress_params = trial_stress_params - ok_sp This is fixed at the beginning of the return-map process, irrespective of substepping.

std::vector< Real >	_current_sp
	The current values of the stress params during the Newton-Raphson.

std::vector< Real >	_current_intnl
	The current values of the internal params during the Newton-Raphson.

yieldAndFlow	_smoothed_q
	Current values of the yield function, derivatives, etc during updateState.

std::vector< RankTwoTensor >	_dsp_scratch
	d(stress_param[:])/d(stress) used in dstressparam_dstress to avoid repeatedly allocating/deallocating this vector

std::vector< RankFourTensor >	_d2sp_scratch
	d2(stress_param[:])/d(stress)/d(stress) used in d2stressparam_dstress to avoid repeatedly allocating/deallocating this vector

std::vector< Real >	_yfs_scratch
	values of yield functions in yieldF, to avoid repeatedly allocating/deallocating this vector

std::vector< Real >	_sp_params_old_scratch
	container to hold old values of old stress_params in lineSearch to avoid repeatedly allocating/deallocating this vector

std::vector< Real >	_delta_nr_params_scratch
	container to hold initial values of rhs in lineSearch to avoid repeatedly allocating/deallocating this vector

std::vector< std::vector< Real > >	_dintnl_scratch
	derivative of internal parameters with respect to stress parameters, to avoid repeatedly allocating/deallocating this vector

std::vector< double >	_jac_scratch
	jacobian in the NR process, to avoid repeatedly allocating/deallocating this vector

std::vector< PetscBLASInt >	_ipiv_scratch
	container to hold LAPACK ipiv integers, to avoid repeatedly allocating/deallocating this vector

std::vector< yieldAndFlow >	_all_q_scratch
	all the yield function information, for use in smoothAllQuantities, to avoid repeatedly allocating/deallocating this vector

enum MultiParameterPlasticityStressUpdate::SmootherFunctionType	_smoother_function_type

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

bool	_ghostable

std::vector< std::unique_ptr< OptionalMaterialPropertyProxyBase< Material > > >	_optional_property_proxies

const bool	_force_stateful_init

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

std::set< SubdomainID >	_blk_ids

std::vector< SubdomainID >	_vec_ids

std::vector< SubdomainName >	_blocks

const bool	_blk_dual_restrictable

FEProblemBase *	_blk_feproblem

const MooseMesh *	_blk_mesh

const std::set< BoundaryID >	_empty_boundary_ids

const std::set< BoundaryID > &	_boundary_ids

THREAD_ID	_blk_tid

const std::string &	_blk_name

unsigned int	_blk_dim

const MooseObject *	_moose_object

Moose::Kokkos::Array< ContiguousElementID >	_kokkos_element_ids

Moose::Kokkos::Array< ContiguousNodeID >	_kokkos_node_ids

Moose::Kokkos::Array< Moose::Kokkos::Pair< ContiguousElementID, unsigned int > >	_kokkos_element_side_ids

FEProblemBase *	_bnd_feproblem

MooseMesh *	_bnd_mesh

std::set< BoundaryID >	_bnd_ids

std::vector< BoundaryName >	_boundary_names

const bool	_bnd_dual_restrictable

const std::set< SubdomainID >	_empty_block_ids

const std::set< SubdomainID > &	_block_ids

THREAD_ID	_bnd_tid

const MaterialData &	_bnd_material_data

bool	_bnd_nodal

ExecFlagEnum	_empty_execute_enum

std::set< MooseVariableFieldBase * >	_moose_variable_dependencies

std::vector< libMesh::dof_id_type >	_dof_indices

const InputParameters &	_sc_parameters

const std::string &	_sc_name

const bool	_sc_is_implicit

std::unordered_map< std::string, std::vector< MooseVariableScalar * > >	_coupled_scalar_vars

std::unordered_map< std::string, std::unique_ptr< ADVariableValue > >	_dual_default_value

std::vector< MooseVariableScalar * >	_coupled_moose_scalar_vars

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

std::set< TagID >	_sc_coupleable_vector_tags

std::set< TagID >	_sc_coupleable_matrix_tags

const MooseObject &	_fni_object

const InputParameters &	_fni_params

FEProblemBase &	_fni_feproblem

const THREAD_ID	_fni_tid

const InputParameters &	_dni_params

FEProblemBase &	_dni_feproblem

const MooseObject *const	_dni_moose_object_ptr

const MooseObject &	_uoi_moose_object

const FEProblemBase &	_uoi_feproblem

const THREAD_ID	_uoi_tid

const std::string	_ti_name

const MooseObject &	_ppi_moose_object

const InputParameters &	_ppi_params

const FEProblemBase &	_ppi_feproblem

std::map< PostprocessorName, std::unique_ptr< PostprocessorValue > >	_default_values

const bool	_broadcast_by_default

const MooseObject &	_vpi_moose_object

const FEProblemBase &	_vpi_feproblem

const THREAD_ID	_vpi_tid

const RestartableDataMapName	_metaname

std::string	_restartable_name

MooseApp &	_oi_moose_app

OutputWarehouse &	_oi_output_warehouse

std::set< OutputName >	_oi_outputs

RandomData *	_random_data

MooseRandom *	_generator

FEProblemBase &	_ri_problem

const std::string	_ri_name

unsigned int	_master_seed

bool	_is_nodal

ExecFlagType	_reset_on

const Node *const &	_curr_node

const Elem *const &	_curr_element

const InputParameters &	_obj_parameters

std::shared_ptr< MooseMesh > &	_id_mesh

const std::string &	_ei_name

const InputParameters &	_fi_params

const std::string	_fi_name

SubProblem *const	_fi_subproblem

const THREAD_ID	_fi_tid

std::vector< std::unique_ptr< Moose::Functor< Real > > >	_default_real_functors

std::vector< std::unique_ptr< Moose::Functor< ADReal > > >	_default_ad_real_functors

unsigned int	_coupleable_max_qps

std::unordered_map< std::string, std::vector< unsigned int > >	_optional_var_index

std::unordered_map< std::string, std::vector< MooseVariableScalar * > >	_c_coupled_scalar_vars

std::set< TagID >	_fe_coupleable_vector_tags

std::set< TagID >	_fe_coupleable_matrix_tags

const bool	_is_fv

const MooseObject *const	_obj

const std::set< std::string >	_older_state_tags

std::vector< std::set< MooseWritableVariable * > >	_writable_coupled_variables

const Real	_kokkos_default_value_zero

const MooseObject &	_mi_moose_object

const bool	_mi_boundary_restricted

const std::set< SubdomainID > &	_mi_block_ids

const std::set< BoundaryID > &	_mi_boundary_ids

Detailed Description

CappedMohrCoulombStressUpdate implements rate-independent nonassociative Mohr-Coulomb plus tensile plus compressive plasticity with hardening/softening.

Definition at line 19 of file CappedMohrCoulombStressUpdate.h.

Member Typedef Documentation

◆ GR2

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

using StressUpdateBaseTempl< is_ad, R2, R4 >::GR2 = GenericRankTwoTensor<is_ad>

inherited

Definition at line 57 of file StressUpdateBase.h.

◆ GR4

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

using StressUpdateBaseTempl< is_ad, R2, R4 >::GR4 = GenericRankFourTensor<is_ad>

inherited

Definition at line 59 of file StressUpdateBase.h.

◆ GSR2

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

using StressUpdateBaseTempl< is_ad, R2, R4 >::GSR2 = Moose::GenericType<R2, is_ad>

inherited

Definition at line 58 of file StressUpdateBase.h.

◆ GSR4

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

using StressUpdateBaseTempl< is_ad, R2, R4 >::GSR4 = Moose::GenericType<R4, is_ad>

inherited

Definition at line 60 of file StressUpdateBase.h.

Member Enumeration Documentation

◆ SmootherFunctionType

enum class MultiParameterPlasticityStressUpdate::SmootherFunctionType

strongprivateinherited

The type of smoother function.

Enumerator
cos
poly1
poly2
poly3

Definition at line 821 of file MultiParameterPlasticityStressUpdate.h.

  {
    cos,
    poly1,
    poly2,
    poly3
  } _smoother_function_type;

Constructor & Destructor Documentation

◆ CappedMohrCoulombStressUpdate()

CappedMohrCoulombStressUpdate::CappedMohrCoulombStressUpdate ( const InputParameters & parameters )

Definition at line 51 of file CappedMohrCoulombStressUpdate.C.

  : MultiParameterPlasticityStressUpdate(parameters, 3, 12, 2),
    _tensile_strength(getUserObject<SolidMechanicsHardeningModel>("tensile_strength")),
    _compressive_strength(getUserObject<SolidMechanicsHardeningModel>("compressive_strength")),
    _cohesion(getUserObject<SolidMechanicsHardeningModel>("cohesion")),
    _phi(getUserObject<SolidMechanicsHardeningModel>("friction_angle")),
    _psi(getUserObject<SolidMechanicsHardeningModel>("dilation_angle")),
    _perfect_guess(getParam<bool>("perfect_guess")),
    _poissons_ratio(0.0),
    _shifter(_f_tol),
    _eigvecs(RankTwoTensor()),
    _dsp_trial_scratch(3),
    _eigvals_scratch(_tensor_dimensionality),
    _dga_shear_scratch(3),
    _dshear_correction_scratch(3)
{
  if (_psi.value(0.0) <= 0.0 || _psi.value(0.0) > _phi.value(0.0))
    mooseWarning("Usually the Mohr-Coulomb dilation angle is positive and not greater than the "
                 "friction angle");
}

Member Function Documentation

◆ calculateNumberSubsteps()

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

virtual int StressUpdateBaseTempl< is_ad, R2, R4 >::calculateNumberSubsteps ( const GR2 & )

inlinevirtualinherited

Given the elastic strain increment compute the number of substeps required to bring a substepped trial stress guess distance from the yield surface into the tolerance specified in the individual child class.

Definition at line 160 of file StressUpdateBase.h.

160{ return 1; }

◆ calculateRes2()

Real MultiParameterPlasticityStressUpdate::calculateRes2 ( const std::vector< Real > & rhs ) const

protectedinherited

Calculates the residual-squared for the Newton-Raphson + line-search.

Parameters

rhs[in] The RHS vector

Returns: sum_i (rhs[i] * rhs[i])

Definition at line 829 of file MultiParameterPlasticityStressUpdate.C.

{
  Real res2 = 0.0;
  for (const auto & r : rhs)
    res2 += r * r;
  return res2;
}

Referenced by MultiParameterPlasticityStressUpdate::lineSearch(), and MultiParameterPlasticityStressUpdate::updateState().

◆ calculateRHS()

void MultiParameterPlasticityStressUpdate::calculateRHS	(	const std::vector< Real > &	trial_stress_params,
		const std::vector< Real > &	stress_params,
		Real	gaE,
		const yieldAndFlow &	smoothed_q,
		std::vector< Real > &	rhs
	)		const

protectedinherited

Calculates the RHS in the following 0 = rhs[0] = S[0] - S[0]^trial + ga * E[0, j] * dg/dS[j] 0 = rhs[1] = S[1] - S[1]^trial + ga * E[1, j] * dg/dS[j] ... 0 = rhs[N-1] = S[N-1] - S[N-1]^trial + ga * E[N-1, j] * dg/dS[j] 0 = rhs[N] = f(S, intnl) where N = _num_sp.

Parameters

trial_stress_params[in]	The trial stress parameters for this (sub)strain increment, S[:]^trial
stress_params[in]	The current stress parameters, S[:]
gaE[in]	ga*_En (the normalisation with _En is so that gaE is of similar magnitude to S)
smoothed_q[in]	Holds the current value of yield function and derivatives evaluated at the current stress parameters and the current internal parameters
rhs[out]	The result

Definition at line 838 of file MultiParameterPlasticityStressUpdate.C.

{
  const Real ga = gaE / _En;
  for (unsigned i = 0; i < _num_sp; ++i)
  {
    rhs[i] = stress_params[i] - trial_stress_params[i];
    for (unsigned j = 0; j < _num_sp; ++j)
      rhs[i] += ga * _Eij[i][j] * smoothed_q.dg[j];
  }
  rhs[_num_sp] = smoothed_q.f;
}

Referenced by MultiParameterPlasticityStressUpdate::lineSearch(), and MultiParameterPlasticityStressUpdate::updateState().

◆ computeAllQV()

void CappedMohrCoulombStressUpdate::computeAllQV	(	const std::vector< Real > &	stress_params,
		const std::vector< Real > &	intnl,
		std::vector< yieldAndFlow > &	all_q
	)		const

overrideprotectedvirtual

Completely fills all_q with correct values.

These values are: (1) the yield function values, yf[i] (2) d(yf[i])/d(stress_params[j]) (3) d(yf[i])/d(intnl[j]) (4) d(flowPotential[i])/d(stress_params[j]) (5) d2(flowPotential[i])/d(stress_params[j])/d(stress_params[k]) (6) d2(flowPotential[i])/d(stress_params[j])/d(intnl[k])

Parameters

	stress_params[in]	The stress parameters
	intnl[in]	The internal parameters
[out]	all_q	All the desired quantities

Implements MultiParameterPlasticityStressUpdate.

Definition at line 161 of file CappedMohrCoulombStressUpdate.C.

{
  const Real ts = _tensile_strength.value(intnl[1]);
  const Real dts = _tensile_strength.derivative(intnl[1]);
  const Real cs = _compressive_strength.value(intnl[1]);
  const Real dcs = _compressive_strength.derivative(intnl[1]);
  const Real sinphi = std::sin(_phi.value(intnl[0]));
  const Real dsinphi = std::cos(_phi.value(intnl[0])) * _phi.derivative(intnl[0]);
  const Real sinpsi = std::sin(_psi.value(intnl[0]));
  const Real dsinpsi = std::cos(_psi.value(intnl[0])) * _psi.derivative(intnl[0]);
  const Real cohcos = _cohesion.value(intnl[0]) * std::cos(_phi.value(intnl[0]));
  const Real dcohcos =
      _cohesion.derivative(intnl[0]) * std::cos(_phi.value(intnl[0])) -
      _cohesion.value(intnl[0]) * std::sin(_phi.value(intnl[0])) * _phi.derivative(intnl[0]);
  const Real smax = stress_params[2]; // largest eigenvalue
  const Real smid = stress_params[1];
  const Real smin = stress_params[0]; // smallest eigenvalue
 
  // yield functions.  See comment in yieldFunctionValuesV
  all_q[0].f = smax - ts;
  all_q[1].f = smid - ts;
  all_q[2].f = smin - ts;
  all_q[3].f = -smin - cs;
  all_q[4].f = -smid - cs;
  all_q[5].f = -smax - cs;
  all_q[6].f = 0.5 * (smax - smin) + 0.5 * (smax + smin) * sinphi - cohcos;
  all_q[7].f = 0.5 * (smid - smin) + 0.5 * (smid + smin) * sinphi - cohcos;
  all_q[8].f = 0.5 * (smax - smid) + 0.5 * (smax + smid) * sinphi - cohcos;
  all_q[9].f = 0.5 * (smid - smax) + 0.5 * (smid + smax) * sinphi - cohcos;
  all_q[10].f = 0.5 * (smin - smid) + 0.5 * (smin + smid) * sinphi - cohcos;
  all_q[11].f = 0.5 * (smin - smax) + 0.5 * (smin + smax) * sinphi - cohcos;
 
  // d(yield function)/d(stress_params)
  for (unsigned yf = 0; yf < _num_yf; ++yf)
    for (unsigned a = 0; a < _num_sp; ++a)
      all_q[yf].df[a] = 0.0;
  all_q[0].df[2] = 1.0;
  all_q[1].df[1] = 1.0;
  all_q[2].df[0] = 1.0;
  all_q[3].df[0] = -1.0;
  all_q[4].df[1] = -1.0;
  all_q[5].df[2] = -1.0;
  all_q[6].df[2] = 0.5 * (1.0 + sinphi);
  all_q[6].df[0] = 0.5 * (-1.0 + sinphi);
  all_q[7].df[1] = 0.5 * (1.0 + sinphi);
  all_q[7].df[0] = 0.5 * (-1.0 + sinphi);
  all_q[8].df[2] = 0.5 * (1.0 + sinphi);
  all_q[8].df[1] = 0.5 * (-1.0 + sinphi);
  all_q[9].df[1] = 0.5 * (1.0 + sinphi);
  all_q[9].df[2] = 0.5 * (-1.0 + sinphi);
  all_q[10].df[0] = 0.5 * (1.0 + sinphi);
  all_q[10].df[1] = 0.5 * (-1.0 + sinphi);
  all_q[11].df[0] = 0.5 * (1.0 + sinphi);
  all_q[11].df[2] = 0.5 * (-1.0 + sinphi);
 
  // d(yield function)/d(intnl)
  for (unsigned i = 0; i < 6; ++i)
    all_q[i].df_di[0] = 0.0;
  all_q[0].df_di[1] = all_q[1].df_di[1] = all_q[2].df_di[1] = -dts;
  all_q[3].df_di[1] = all_q[4].df_di[1] = all_q[5].df_di[1] = -dcs;
  for (unsigned i = 6; i < 12; ++i)
    all_q[i].df_di[1] = 0.0;
  all_q[6].df_di[0] = 0.5 * (smax + smin) * dsinphi - dcohcos;
  all_q[7].df_di[0] = 0.5 * (smid + smin) * dsinphi - dcohcos;
  all_q[8].df_di[0] = 0.5 * (smax + smid) * dsinphi - dcohcos;
  all_q[9].df_di[0] = 0.5 * (smid + smax) * dsinphi - dcohcos;
  all_q[10].df_di[0] = 0.5 * (smin + smid) * dsinphi - dcohcos;
  all_q[11].df_di[0] = 0.5 * (smin + smax) * dsinphi - dcohcos;
 
  // the flow potential is just the yield function with phi->psi
  // d(flow potential)/d(stress_params)
  for (unsigned yf = 0; yf < 6; ++yf)
    for (unsigned a = 0; a < _num_sp; ++a)
      all_q[yf].dg[a] = all_q[yf].df[a];
  all_q[6].dg[2] = all_q[7].dg[1] = all_q[8].dg[2] = all_q[9].dg[1] = all_q[10].dg[0] =
      all_q[11].dg[0] = 0.5 * (1.0 + sinpsi);
  all_q[6].dg[0] = all_q[7].dg[0] = all_q[8].dg[1] = all_q[9].dg[2] = all_q[10].dg[1] =
      all_q[11].dg[2] = 0.5 * (-1.0 + sinpsi);
 
  // d(flow potential)/d(stress_params)/d(intnl)
  for (unsigned yf = 0; yf < _num_yf; ++yf)
    for (unsigned a = 0; a < _num_sp; ++a)
      for (unsigned i = 0; i < _num_intnl; ++i)
        all_q[yf].d2g_di[a][i] = 0.0;
  all_q[6].d2g_di[2][0] = all_q[7].d2g_di[1][0] = all_q[8].d2g_di[2][0] = all_q[9].d2g_di[1][0] =
      all_q[10].d2g_di[0][0] = all_q[11].d2g_di[0][0] = 0.5 * dsinpsi;
  all_q[6].d2g_di[0][0] = all_q[7].d2g_di[0][0] = all_q[8].d2g_di[1][0] = all_q[9].d2g_di[2][0] =
      all_q[10].d2g_di[1][0] = all_q[11].d2g_di[2][0] = 0.5 * dsinpsi;
 
  // d(flow potential)/d(stress_params)/d(stress_params)
  for (unsigned yf = 0; yf < _num_yf; ++yf)
    for (unsigned a = 0; a < _num_sp; ++a)
      for (unsigned b = 0; b < _num_sp; ++b)
        all_q[yf].d2g[a][b] = 0.0;
}

◆ computeStrainEnergyRateDensity()

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

virtual Real StressUpdateBaseTempl< is_ad, R2, R4 >::computeStrainEnergyRateDensity	(	const GenericMaterialProperty< RankTwoTensor, is_ad > &	,
		const GenericMaterialProperty< RankTwoTensor, is_ad > &
	)

inlinevirtualinherited

Compute the strain energy rate density for this inelastic model for the current step.

Parameters

stress	The stress tensor at the end of the step
strain_rate	The strain rate at the end of the step

Returns: The computed strain energy rate density

Reimplemented in CompositePowerLawCreepStressUpdateTempl< is_ad >, and PowerLawCreepStressUpdateTempl< is_ad >.

Definition at line 180 of file StressUpdateBase.h.

  {
    mooseError(
        "The computation of strain energy rate density needs to be implemented by a child class");
    return 0.0;
  }

◆ computeStressParams()

void CappedMohrCoulombStressUpdate::computeStressParams	(	const RankTwoTensor &	stress,
		std::vector< Real > &	stress_params
	)		const

overrideprotectedvirtual

Computes stress_params, given stress.

Derived classes must override this

Parameters

stress[in]	Stress tensor
stress_params[out]	The compute stress_params

Implements MultiParameterPlasticityStressUpdate.

Definition at line 73 of file CappedMohrCoulombStressUpdate.C.

{
  // stress_params[0] = smallest eigenvalue, stress_params[2] = largest eigenvalue
  stress.symmetricEigenvalues(stress_params);
}

◆ computeTimeStepLimit()

template<bool is_ad, typename R2 , typename R4 >

Real StressUpdateBaseTempl< is_ad, R2, R4 >::computeTimeStepLimit ( )

virtualinherited

Reimplemented in GeneralizedRadialReturnStressUpdateTempl< is_ad >, LAROMANCEStressUpdateBaseTempl< is_ad >, RadialReturnStressUpdateTempl< is_ad >, and ViscoplasticityStressUpdateBaseTempl< is_ad >.

Definition at line 61 of file StressUpdateBase.C.

{
  return std::numeric_limits<Real>::max();
}

◆ consistentTangentOperatorV()

void CappedMohrCoulombStressUpdate::consistentTangentOperatorV	(	const RankTwoTensor &	stress_trial,
		const std::vector< Real > &	trial_stress_params,
		const RankTwoTensor &	stress,
		const std::vector< Real > &	stress_params,
		Real	gaE,
		const yieldAndFlow &	smoothed_q,
		const RankFourTensor &	Eijkl,
		bool	compute_full_tangent_operator,
		const std::vector< std::vector< Real > > &	dvar_dtrial,
		RankFourTensor &	cto
	)

overrideprotectedvirtual

Calculates the consistent tangent operator.

Derived classes may choose to override this for computational efficiency. The implementation in this class is quite expensive, even though it looks compact and clean, because of all the manipulations of RankFourTensors involved.

Parameters

	stress_trial[in]	the trial value of the stress tensor for this strain increment
	trial_stress_params[in]	the trial values of the stress_params for this strain increment
	stress[in]	the returned value of the stress tensor for this strain increment
	stress_params[in]	the returned value of the stress_params for this strain increment
	gaE[in]	the total value of that came from this strain increment
	smoothed_q[in]	contains the yield function and derivatives evaluated at (p, q)
	Eijkl[in]	The elasticity tensor
	compute_full_tangent_operator[in]	true if the full consistent tangent operator is needed, otherwise false
	dvar_dtrial[in]	dvar_dtrial[i][j] = d({stress_param[i],gaE})/d(trial_stress_param[j]) for this strain increment
[out]	cto	The consistent tangent operator

Reimplemented from MultiParameterPlasticityStressUpdate.

Reimplemented in CappedMohrCoulombCosseratStressUpdate.

Definition at line 816 of file CappedMohrCoulombStressUpdate.C.

{
  cto = elasticity_tensor;
  if (!compute_full_tangent_operator)
    return;
 
  // dvar_dtrial has been computed already, so
  // d(stress)/d(trial_stress) = d(eigvecs * stress_params * eigvecs.transpose())/d(trial_stress)
  // eigvecs is a rotation matrix, rot(i, j) = e_j(i) = i^th component of j^th eigenvector
  // d(rot_ij)/d(stress_kl) = d(e_j(i))/d(stress_kl)
  // = sum_a 0.5 * e_a(i) * (e_a(k)e_j(l) + e_a(l)e_j(k)) / (la_j - la_a)
  // = sum_a 0.5 * rot(i,a) * (rot(k,a)rot(l,j) + rot(l,a)*rot(k,j)) / (la_j - la_a)
  RankFourTensor drot_dstress;
  for (unsigned i = 0; i < _tensor_dimensionality; ++i)
    for (unsigned j = 0; j < _tensor_dimensionality; ++j)
      for (unsigned k = 0; k < _tensor_dimensionality; ++k)
        for (unsigned l = 0; l < _tensor_dimensionality; ++l)
          for (unsigned a = 0; a < _num_sp; ++a)
          {
            if (trial_stress_params[a] == trial_stress_params[j])
              continue;
            drot_dstress(i, j, k, l) +=
                0.5 * _eigvecs(i, a) *
                (_eigvecs(k, a) * _eigvecs(l, j) + _eigvecs(l, a) * _eigvecs(k, j)) /
                (trial_stress_params[j] - trial_stress_params[a]);
          }
 
  const RankTwoTensor eT = _eigvecs.transpose();
 
  RankFourTensor dstress_dtrial;
  for (unsigned i = 0; i < _tensor_dimensionality; ++i)
    for (unsigned j = 0; j < _tensor_dimensionality; ++j)
      for (unsigned k = 0; k < _tensor_dimensionality; ++k)
        for (unsigned l = 0; l < _tensor_dimensionality; ++l)
          for (unsigned a = 0; a < _num_sp; ++a)
            dstress_dtrial(i, j, k, l) +=
                drot_dstress(i, a, k, l) * stress_params[a] * eT(a, j) +
                _eigvecs(i, a) * stress_params[a] * drot_dstress(j, a, k, l);
 
  dstressparam_dstress(stress_trial, _dsp_trial_scratch);
  for (unsigned i = 0; i < _tensor_dimensionality; ++i)
    for (unsigned j = 0; j < _tensor_dimensionality; ++j)
      for (unsigned k = 0; k < _tensor_dimensionality; ++k)
        for (unsigned l = 0; l < _tensor_dimensionality; ++l)
          for (unsigned a = 0; a < _num_sp; ++a)
            for (unsigned b = 0; b < _num_sp; ++b)
              dstress_dtrial(i, j, k, l) +=
                  _eigvecs(i, a) * dvar_dtrial[a][b] * _dsp_trial_scratch[b](k, l) * eT(a, j);
 
  cto = dstress_dtrial * elasticity_tensor;
}

Referenced by CappedMohrCoulombCosseratStressUpdate::consistentTangentOperatorV().

◆ d2stressparam_dstress()

void CappedMohrCoulombStressUpdate::d2stressparam_dstress	(	const RankTwoTensor &	stress,
		std::vector< RankFourTensor > &	d2sp
	)		const

overrideprotectedvirtual

d2(stress_param[i])/d(stress)/d(stress) at given stress.

When overriding, ensure to assert that d2sp has size _num_sp

Parameters

stress[in]	stress tensor
d2sp[out]	d2(stress_param[:])/d(stress)/d(stress)

Implements MultiParameterPlasticityStressUpdate.

Definition at line 93 of file CappedMohrCoulombStressUpdate.C.

{
  /*
   * This function is not used but is included here in case a derived class needs it.
   * The reason it is unused is because consistentTangentOperatorV is optimised
   */
  mooseAssert(d2sp.size() == 3,
              "CappedMohrCoulombStressUpdate: d2sp incorrectly sized in d2stressparam_dstress");
  stress.d2symmetricEigenvalues(d2sp);
}

◆ dnRHSdVar()

void MultiParameterPlasticityStressUpdate::dnRHSdVar	(	const yieldAndFlow &	smoothed_q,
		const std::vector< std::vector< Real > > &	dintnl,
		const std::vector< Real > &	stress_params,
		Real	gaE,
		std::vector< double > &	jac
	)		const

protectedinherited

Derivative of -RHS with respect to the stress_params and gaE, placed into an array ready for solving the linear system using LAPACK gsev.

Parameters

smoothed_q[in]	Holds the current value of yield function and derivatives evaluated at the current values of the stress_params and the internal parameters
dintnl[in]	The derivatives of the internal parameters wrt the stress_params
stress_params[in]	The current value of the stress_params during the Newton-Raphson process
gaE[in]	The current value of gaE
jac[out]	The outputted derivatives

Definition at line 855 of file MultiParameterPlasticityStressUpdate.C.

{
  for (auto & jac_entry : jac)
    jac_entry = 0.0;
 
  const Real ga = gaE / _En;
 
  unsigned ind = 0;
  for (unsigned var = 0; var < _num_sp; ++var)
  {
    for (unsigned rhs = 0; rhs < _num_sp; ++rhs)
    {
      if (var == rhs)
        jac[ind] -= 1.0;
      for (unsigned j = 0; j < _num_sp; ++j)
      {
        jac[ind] -= ga * _Eij[rhs][j] * smoothed_q.d2g[j][var];
        for (unsigned k = 0; k < _num_intnl; ++k)
          jac[ind] -= ga * _Eij[rhs][j] * smoothed_q.d2g_di[j][k] * dintnl[k][var];
      }
      ind++;
    }
    // now rhs = _num_sp (that is, the yield function)
    jac[ind] -= smoothed_q.df[var];
    for (unsigned k = 0; k < _num_intnl; ++k)
      jac[ind] -= smoothed_q.df_di[k] * dintnl[k][var];
    ind++;
  }
 
  // now var = _num_sp (that is, gaE)
  for (unsigned rhs = 0; rhs < _num_sp; ++rhs)
  {
    for (unsigned j = 0; j < _num_sp; ++j)
      jac[ind] -= (1.0 / _En) * _Eij[rhs][j] * smoothed_q.dg[j];
    ind++;
  }
  // now rhs = _num_sp (that is, the yield function)
  jac[ind] = 0.0;
}

Referenced by MultiParameterPlasticityStressUpdate::dVardTrial(), and MultiParameterPlasticityStressUpdate::nrStep().

◆ dsmoother()

Real MultiParameterPlasticityStressUpdate::dsmoother ( Real f_diff ) const

protectedinherited

Derivative of smoother.

Definition at line 549 of file MultiParameterPlasticityStressUpdate.C.

{
  if (std::abs(f_diff) >= _smoothing_tol)
    return 0.0;
  switch (_smoother_function_type)
  {
    case SmootherFunctionType::cos:
      return 0.25 * M_PI / _smoothing_tol * std::cos(f_diff * M_PI * 0.5 / _smoothing_tol);
    case SmootherFunctionType::poly1:
      return 0.75 / _smoothing_tol * (1.0 - Utility::pow<2>(f_diff / _smoothing_tol));
    case SmootherFunctionType::poly2:
      return 0.625 / _smoothing_tol * (1.0 - Utility::pow<4>(f_diff / _smoothing_tol));
    case SmootherFunctionType::poly3:
      return (7.0 / 12.0 / _smoothing_tol) * (1.0 - Utility::pow<6>(f_diff / _smoothing_tol));
    default:
      return 0.0;
  }
}

Referenced by MultiParameterPlasticityStressUpdate::smoothAllQuantities().

◆ dstressparam_dstress()

void CappedMohrCoulombStressUpdate::dstressparam_dstress	(	const RankTwoTensor &	stress,
		std::vector< RankTwoTensor > &	dsp
	)		const

overrideprotectedvirtual

d(stress_param[i])/d(stress) at given stress.

When overriding, ensure to assert that dsp has size _num_sp

Parameters

stress[in]	stress tensor
dsp[out]	d(stress_param[:])/d(stress)

Implements MultiParameterPlasticityStressUpdate.

Definition at line 81 of file CappedMohrCoulombStressUpdate.C.

{
  mooseAssert(dsp.size() == 3,
              "CappedMohrCoulombStressUpdate: dsp incorrectly sized in dstressparam_dstress");
  mooseAssert(
      _eigvals_scratch.size() == _tensor_dimensionality,
      "_eigvals_scratch incorrectly sized in CappedMohrCoulombStressUpdate:dstressparam_dstress");
  stress.dsymmetricEigenvalues(_eigvals_scratch, dsp);
}

Referenced by consistentTangentOperatorV().

◆ dVardTrial()

void MultiParameterPlasticityStressUpdate::dVardTrial	(	bool	elastic_only,
		const std::vector< Real > &	trial_stress_params,
		const std::vector< Real > &	stress_params,
		Real	gaE,
		const std::vector< Real > &	intnl,
		const yieldAndFlow &	smoothed_q,
		Real	step_size,
		bool	compute_full_tangent_operator,
		std::vector< std::vector< Real > > &	dvar_dtrial
	)		const

protectedinherited

Calculates derivatives of the stress_params and gaE with repect to the trial values of the stress_params for the (sub)strain increment.

After the strain increment has been fully applied, dvar_dtrial will contain the result appropriate to the full strain increment. Before that time (if applying in sub-strain increments) it will contain the result appropriate to the amount of strain increment applied successfully.

Parameters

elastic_only[in]	whether this was an elastic step: if so then the updates to dvar_dtrial are fairly trivial
trial_stress_params[in]	Trial values of stress_params for this (sub)strain increment
stress_params[in]	Returned values of stress_params for this (sub)strain increment
gaE[in]	the value of gaE that came from this (sub)strain increment
intnl[in]	the value of the internal parameters at the returned position
smoothed_q[in]	contains the yield function and derivatives evaluated at (stress_params, intnl)
step_size[in]	size of this (sub)strain increment
compute_full_tangent_operator[in]	true if the full consistent tangent operator is needed, otherwise false
dvar_dtrial[out]	dvar_dtrial[i][j] = d({stress_param[i],gaE})/d(trial_stress_param[j])

Definition at line 900 of file MultiParameterPlasticityStressUpdate.C.

{
  if (!_fe_problem.currentlyComputingJacobian())
    return;
 
  if (!compute_full_tangent_operator)
    return;
 
  if (elastic_only)
  {
    // no change to gaE, and all off-diag stuff remains unchanged from previous step
    for (unsigned v = 0; v < _num_sp; ++v)
      dvar_dtrial[v][v] += step_size;
    return;
  }
 
  const Real ga = gaE / _En;
 
  // the following uses heap allocations in the belief that the compute time spent on alloc/dealloc
  // will be dwarfed by other aspects of implicit time stepping
 
  std::vector<std::vector<Real>> dintnl(_num_intnl, std::vector<Real>(_num_sp));
  setIntnlDerivativesV(trial_stress_params, stress_params, intnl, dintnl);
 
  // rhs is described elsewhere, the following are changes in rhs wrt the trial_stress_param
  // values
  // In the following we use d(intnl)/d(trial variable) = - d(intnl)/d(variable)
  std::vector<Real> rhs_cto((_num_sp + 1) * _num_sp);
 
  unsigned ind = 0;
  for (unsigned a = 0; a < _num_sp; ++a)
  {
    // change in RHS[b] wrt changes in stress_param_trial[a]
    for (unsigned b = 0; b < _num_sp; ++b)
    {
      if (a == b)
        rhs_cto[ind] -= 1.0;
      for (unsigned j = 0; j < _num_sp; ++j)
        for (unsigned k = 0; k < _num_intnl; ++k)
          rhs_cto[ind] -= ga * _Eij[b][j] * smoothed_q.d2g_di[j][k] * dintnl[k][a];
      ind++;
    }
    // now b = _num_sp (that is, the yield function)
    for (unsigned k = 0; k < _num_intnl; ++k)
      rhs_cto[ind] -= smoothed_q.df_di[k] * dintnl[k][a];
    ind++;
  }
 
  // jac = d(-rhs)/d(var)
  std::vector<double> jac((_num_sp + 1) * (_num_sp + 1));
  dnRHSdVar(smoothed_q, dintnl, stress_params, gaE, jac);
 
  std::vector<PetscBLASInt> ipiv(_num_sp + 1);
  PetscBLASInt info;
  const PetscBLASInt gesv_num_rhs = _num_sp + 1;
  const PetscBLASInt gesv_num_pq = _num_sp;
  LAPACKgesv_(&gesv_num_rhs,
              &gesv_num_pq,
              &jac[0],
              &gesv_num_rhs,
              &ipiv[0],
              &rhs_cto[0],
              &gesv_num_rhs,
              &info);
  if (info != 0)
    errorHandler("MultiParameterPlasticityStressUpdate: PETSC LAPACK gsev routine returned with "
                 "error code " +
                 Moose::stringify(info));
 
  ind = 0;
  std::vector<std::vector<Real>> dvarn_dtrialn(_num_sp + 1, std::vector<Real>(_num_sp, 0.0));
  for (unsigned spt = 0; spt < _num_sp; ++spt) // loop over trial stress-param variables
  {
    for (unsigned v = 0; v < _num_sp; ++v) // loop over variables in NR procedure
    {
      dvarn_dtrialn[v][spt] = rhs_cto[ind];
      ind++;
    }
    // the final NR variable is gaE
    dvarn_dtrialn[_num_sp][spt] = rhs_cto[ind];
    ind++;
  }
 
  const std::vector<std::vector<Real>> dvar_dtrial_old = dvar_dtrial;
 
  for (unsigned v = 0; v < _num_sp; ++v) // loop over variables in NR procedure
  {
    for (unsigned spt = 0; spt < _num_sp; ++spt) // loop over trial stress-param variables
    {
      dvar_dtrial[v][spt] = step_size * dvarn_dtrialn[v][spt];
      for (unsigned a = 0; a < _num_sp; ++a)
        dvar_dtrial[v][spt] += dvarn_dtrialn[v][a] * dvar_dtrial_old[a][spt];
    }
  }
  // for gaE the formulae are a little different
  const unsigned v = _num_sp;
  for (unsigned spt = 0; spt < _num_sp; ++spt)
  {
    dvar_dtrial[v][spt] += step_size * dvarn_dtrialn[v][spt]; // note +=
    for (unsigned a = 0; a < _num_sp; ++a)
      dvar_dtrial[v][spt] += dvarn_dtrialn[v][a] * dvar_dtrial_old[a][spt];
  }
}

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ errorHandler()

void MultiParameterPlasticityStressUpdate::errorHandler ( const std::string & message ) const

protectedvirtualinherited

Performs any necessary cleaning-up, then throw MooseException(message)

Parameters

message The message to using in MooseException

Definition at line 688 of file MultiParameterPlasticityStressUpdate.C.

{
  throw MooseException(message);
}

Referenced by MultiParameterPlasticityStressUpdate::dVardTrial(), and MultiParameterPlasticityStressUpdate::updateState().

◆ finalizeReturnProcess()

void MultiParameterPlasticityStressUpdate::finalizeReturnProcess ( const RankTwoTensor & rotation_increment )

protectedvirtualinherited

Derived classes may use this to perform calculations after the return-map process has completed successfully in stress_param space but before the returned stress tensor has been calculcated.

Parameters

rotation_increment[in] The large-strain rotation increment

Reimplemented in CappedDruckerPragerStressUpdate, CappedWeakInclinedPlaneStressUpdate, and CappedWeakPlaneStressUpdate.

Definition at line 699 of file MultiParameterPlasticityStressUpdate.C.

701{

702}

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ getTangentCalculationMethod()

virtual TangentCalculationMethod MultiParameterPlasticityStressUpdate::getTangentCalculationMethod ( )

inlineoverrideprotectedvirtualinherited

Reimplemented from StressUpdateBaseTempl< is_ad, R2, R4 >.

Definition at line 119 of file MultiParameterPlasticityStressUpdate.h.

  {
    return TangentCalculationMethod::FULL;
  }

◆ initializeReturnProcess()

void MultiParameterPlasticityStressUpdate::initializeReturnProcess ( )

protectedvirtualinherited

Derived classes may use this to perform calculations before any return-map process is performed, for instance, to initialize variables.

This is called at the very start of updateState, even before any checking for admissible stresses, etc, is performed

Reimplemented in CappedDruckerPragerStressUpdate, CappedWeakInclinedPlaneStressUpdate, and CappedWeakPlaneStressUpdate.

Definition at line 694 of file MultiParameterPlasticityStressUpdate.C.

695{

696}

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ initializeVarsV()

void CappedMohrCoulombStressUpdate::initializeVarsV	(	const std::vector< Real > &	trial_stress_params,
		const std::vector< Real > &	intnl_old,
		std::vector< Real > &	stress_params,
		Real &	gaE,
		std::vector< Real > &	intnl
	)		const

overrideprotectedvirtual

Sets (stress_params, intnl) at "good guesses" of the solution to the Return-Map algorithm.

The purpose of these "good guesses" is to speed up the Newton-Raphson process by providing it with a good initial guess. Derived classes may choose to override this if their plastic models are easy enough to solve approximately. The default values, provided by this class, are simply gaE = 0, stress_params = trial_stress_params, that is, the "good guess" is just the trial point for this (sub)strain increment.

Parameters

trial_stress_params[in]	The stress_params at the trial point
intnl_old[in]	The internal parameters before applying the (sub)strain increment
stress_params[out]	The "good guess" value of the stress_params
gaE[out]	The "good guess" value of gaE
intnl[out]	The "good guess" value of the internal parameters

For CappedMohrCoulomb there are a number of possibilities for the returned stress configuration:

return to the Tensile yield surface to its plane
return to the Tensile yield surface to its max=mid edge
return to the Tensile yield surface to its tip
return to the Compressive yield surface to its plane
return to the Compressive yield surface to its max=mid edge
return to the Compressive yield surface to its tip
return to the Mohr-Coulomb yield surface to its plane
return to the Mohr-Coulomb yield surface to its max=mid edge
return to the Mohr-Coulomb yield surface to its mid=min edge
return to the Mohr-Coulomb yield surface to its tip
return to the edge between Tensile and Mohr-Coulomb
return to the edge between Tensile and Mohr-Coulomb, at max=mid point
return to the edge between Tensile and Mohr-Coulomb, at mid=min point
return to the edge between Compressive and Mohr-Coulomb
return to the edge between Compressive and Mohr-Coulomb, at max=mid point
return to the edge between Compressive and Mohr-Coulomb, at mid=min point Which of these is more prelevant depends on the parameters tensile strength, compressive strength, cohesion, etc. I simply check each possibility until i find one that works. _shifter is used to avoid equal eigenvalues

Reimplemented from MultiParameterPlasticityStressUpdate.

Definition at line 278 of file CappedMohrCoulombStressUpdate.C.

{
  if (!_perfect_guess)
  {
    for (unsigned i = 0; i < _num_sp; ++i)
      stress_params[i] = trial_stress_params[i];
    gaE = 0.0;
  }
  else
  {
    const Real ts = _tensile_strength.value(intnl_old[1]);
    const Real cs = _compressive_strength.value(intnl_old[1]);
    const Real sinphi = std::sin(_phi.value(intnl_old[0]));
    const Real cohcos = _cohesion.value(intnl_old[0]) * std::cos(_phi.value(intnl_old[0]));
 
    const Real trial_tensile_yf = trial_stress_params[2] - ts;
    const Real trial_compressive_yf = -trial_stress_params[0] - cs;
    const Real trial_mc_yf = 0.5 * (trial_stress_params[2] - trial_stress_params[0]) +
                             0.5 * (trial_stress_params[2] + trial_stress_params[0]) * sinphi -
                             cohcos;
 
    bool found_solution = false;
 
    if (trial_tensile_yf <= _f_tol && trial_compressive_yf <= _f_tol && trial_mc_yf <= _f_tol)
    {
      // this is needed because although we know the smoothed yield function is
      // positive, the individual yield functions may not be
      for (unsigned i = 0; i < _num_sp; ++i)
        stress_params[i] = trial_stress_params[i];
      gaE = 0.0;
      found_solution = true;
    }
 
    const bool tensile_possible = (ts < cohcos / sinphi); // tensile chops MC tip
    const bool mc_tip_possible = (cohcos / sinphi < ts);  // MC tip pokes through tensile
    const bool mc_impossible = (0.5 * (ts + cs) + 0.5 * (ts - cs) * sinphi - cohcos <
                                _f_tol); // MC outside tensile and compressive
 
    const Real sinpsi = std::sin(_psi.value(intnl_old[0]));
    const Real halfplus = 0.5 + 0.5 * sinpsi;
    const Real neghalfplus = -0.5 + 0.5 * sinpsi;
 
    if (!found_solution && tensile_possible && trial_tensile_yf > _f_tol &&
        (trial_compressive_yf <= _f_tol || (trial_compressive_yf > _f_tol && mc_impossible)))
    {
      // try pure tensile failure, return to the plane
      // This involves solving yf[0] = 0 and the three flow-direction equations
      // Don't try this if there is compressive failure, since returning to
      // the tensile yield surface will only make compressive failure worse
      const Real ga = (trial_stress_params[2] - ts) / _Eij[2][2];
      stress_params[2] = ts; // largest eigenvalue
      stress_params[1] = trial_stress_params[1] - ga * _Eij[1][2];
      stress_params[0] = trial_stress_params[0] - ga * _Eij[0][2];
 
      // if we have to return to the edge, or tip, do that
      Real dist_mod = 1.0;
      const Real to_subtract1 = stress_params[1] - (ts - 0.5 * _shifter);
      if (to_subtract1 > 0.0)
      {
        dist_mod += Utility::pow<2>(to_subtract1 / (trial_stress_params[2] - ts));
        stress_params[1] -= to_subtract1;
      }
      const Real to_subtract0 = stress_params[0] - (ts - _shifter);
      if (to_subtract0 > 0.0)
      {
        dist_mod += Utility::pow<2>(to_subtract0 / (trial_stress_params[2] - ts));
        stress_params[0] -= to_subtract0;
      }
      if (mc_impossible) // might have to shift up to the compressive yield surface
      {
        const Real to_add0 = -stress_params[0] - cs;
        if (to_add0 > 0.0)
        {
          dist_mod += Utility::pow<2>(to_add0 / (trial_stress_params[2] - ts));
          stress_params[0] += to_add0;
        }
        const Real to_add1 = -cs + 0.5 * _shifter - stress_params[1];
        if (to_add1 > 0.0)
        {
          dist_mod += Utility::pow<2>(to_add1 / (trial_stress_params[2] - ts));
          stress_params[1] += to_add1;
        }
      }
 
      const Real new_compressive_yf = -stress_params[0] - cs;
      const Real new_mc_yf = 0.5 * (stress_params[2] - stress_params[0]) +
                             0.5 * (stress_params[2] + stress_params[0]) * sinphi - cohcos;
      if (new_mc_yf <= _f_tol && new_compressive_yf <= _f_tol)
      {
        gaE = std::sqrt(dist_mod) * (trial_stress_params[2] - stress_params[2]);
        found_solution = true;
      }
    }
    if (!found_solution && trial_compressive_yf > _f_tol &&
        (trial_tensile_yf <= _f_tol || (trial_tensile_yf > _f_tol && mc_impossible)))
    {
      // try pure compressive failure
      // Don't try this if there is tensile failure, since returning to
      // the compressive yield surface will only make tensile failure worse
      const Real ga = (trial_stress_params[0] + cs) / _Eij[0][0]; // this is negative
      stress_params[0] = -cs;
      stress_params[1] = trial_stress_params[1] - ga * _Eij[1][0];
      stress_params[2] = trial_stress_params[2] - ga * _Eij[2][0];
 
      // if we have to return to the edge, or tip, do that
      Real dist_mod = 1.0;
      const Real to_add1 = -cs + 0.5 * _shifter - stress_params[1];
      if (to_add1 > 0.0)
      {
        dist_mod += Utility::pow<2>(to_add1 / (trial_stress_params[0] + cs));
        stress_params[1] += to_add1;
      }
      const Real to_add2 = -cs + _shifter - stress_params[2];
      if (to_add2 > 0.0)
      {
        dist_mod += Utility::pow<2>(to_add2 / (trial_stress_params[0] + cs));
        stress_params[2] += to_add2;
      }
      if (mc_impossible) // might have to shift down to the tensile yield surface
      {
        const Real to_subtract2 = stress_params[2] - ts;
        if (to_subtract2 > 0.0)
        {
          dist_mod += Utility::pow<2>(to_subtract2 / (trial_stress_params[0] + cs));
          stress_params[2] -= to_subtract2;
        }
        const Real to_subtract1 = stress_params[1] - (ts - 0.5 * _shifter);
        if (to_subtract1 > 0.0)
        {
          dist_mod += Utility::pow<2>(to_subtract1 / (trial_stress_params[0] + cs));
          stress_params[1] -= to_subtract1;
        }
      }
 
      const Real new_tensile_yf = stress_params[2] - ts;
      const Real new_mc_yf = 0.5 * (stress_params[2] - stress_params[0]) +
                             0.5 * (stress_params[2] + stress_params[0]) * sinphi - cohcos;
      if (new_mc_yf <= _f_tol && new_tensile_yf <= _f_tol)
      {
        gaE = std::sqrt(dist_mod) * (-trial_stress_params[0] + stress_params[0]);
        found_solution = true;
      }
    }
    if (!found_solution && !mc_impossible && trial_mc_yf > _f_tol)
    {
      // try pure shear failure, return to the plane
      // This involves solving yf[6]=0 and the three flow-direction equations
      const Real ga = ((trial_stress_params[2] - trial_stress_params[0]) +
                       (trial_stress_params[2] + trial_stress_params[0]) * sinphi - 2.0 * cohcos) /
                      (_Eij[2][2] - _Eij[0][2] + (_Eij[2][2] + _Eij[0][2]) * sinpsi * sinphi);
      stress_params[2] =
          trial_stress_params[2] - ga * (_Eij[2][2] * halfplus + _Eij[2][0] * neghalfplus);
      stress_params[1] = trial_stress_params[1] - ga * _Eij[1][0] * sinpsi;
      stress_params[0] =
          trial_stress_params[0] - ga * (_Eij[0][0] * neghalfplus + _Eij[0][2] * halfplus);
      const Real f7 = 0.5 * (stress_params[1] - stress_params[0]) +
                      0.5 * (stress_params[1] + stress_params[0]) * sinphi - cohcos;
      const Real f8 = 0.5 * (stress_params[2] - stress_params[1]) +
                      0.5 * (stress_params[2] + stress_params[1]) * sinphi - cohcos;
      const Real new_tensile_yf = stress_params[2] - ts;
      const Real new_compressive_yf = -stress_params[0] - cs;
 
      if (f7 <= _f_tol && f8 <= _f_tol && new_tensile_yf <= _f_tol && new_compressive_yf <= _f_tol)
      {
        gaE = ((trial_stress_params[2] - trial_stress_params[0]) -
               (stress_params[2] - stress_params[0])) /
              (_Eij[2][2] - _Eij[0][2]) * _Eij[2][2];
        found_solution = true;
      }
    }
    if (!found_solution && !mc_impossible && trial_mc_yf > _f_tol)
    {
      // Try return to the max=mid MC line.
      // To return to the max=mid line, we need to solve f6 = 0 = f7 and
      // the three flow-direction equations.  In the flow-direction equations
      // there are two plasticity multipliers, which i call ga6 and ga7,
      // corresponding to the amounts of strain normal to the f6 and f7
      // directions, respectively.
      // So:
      // Smax = Smax^trial - ga6 Emax,a dg6/dSa - ga7 Emax,a dg7/dSa
      //      = Smax^trial - ga6 cmax6 - ga7 cmax7  (with cmax6 and cmax7 evaluated below)
      // Smid = Smid^trial - ga6 Emid,a dg6/dSa - ga7 Emid,a dg7/dSa
      //      = Smid^trial - ga6 cmid6 - ga7 cmid7
      // Smin = Smin^trial - ga6 Emin,a dg6/dSa - ga7 Emin,a dg7/dSa
      //      = Smin^trial - ga6 cmin6 - ga7 cmin7
      const Real cmax6 = _Eij[2][2] * halfplus + _Eij[2][0] * neghalfplus;
      const Real cmax7 = _Eij[2][1] * halfplus + _Eij[2][0] * neghalfplus;
      // const Real cmid6 = _Eij[1][2] * halfplus + _Eij[1][0] * neghalfplus;
      // const Real cmid7 = _Eij[1][1] * halfplus + _Eij[1][0] * neghalfplus;
      const Real cmin6 = _Eij[0][2] * halfplus + _Eij[0][0] * neghalfplus;
      const Real cmin7 = _Eij[0][1] * halfplus + _Eij[0][0] * neghalfplus;
      // Substituting these into f6 = 0 yields
      // 0 = f6_trial - ga6 (0.5(cmax6 - cmin6) + 0.5(cmax6 + cmin6)sinphi) - ga7 (0.5(cmax6 -
      // cmin6) + 0.5(cmax6 + cmin6)sinphi) = f6_trial - ga6 c6 - ga7 c7, where
      const Real c6 = 0.5 * (cmax6 - cmin6) + 0.5 * (cmax6 + cmin6) * sinphi;
      const Real c7 = 0.5 * (cmax7 - cmin7) + 0.5 * (cmax7 + cmin7) * sinphi;
      // It isn't too hard to check that the other equation is
      // 0 = f7_trial - ga6 c7 - ga7 c6
      // These equations may be inverted to yield
      if (c6 != c7)
      {
        const Real f6_trial = trial_mc_yf;
        const Real f7_trial = 0.5 * (trial_stress_params[1] - trial_stress_params[0]) +
                              0.5 * (trial_stress_params[1] + trial_stress_params[0]) * sinphi -
                              cohcos;
        const Real descr = Utility::pow<2>(c6) - Utility::pow<2>(c7);
        Real ga6 = (c6 * f6_trial - c7 * f7_trial) / descr;
        Real ga7 = (-c7 * f6_trial + c6 * f7_trial) / descr;
        // and finally
        stress_params[2] = trial_stress_params[2] - ga6 * cmax6 - ga7 * cmax7;
        stress_params[0] = trial_stress_params[0] - ga6 * cmin6 - ga7 * cmin7;
        stress_params[1] = stress_params[2] - 0.5 * _shifter;
 
        Real f8 = 0.5 * (stress_params[2] - stress_params[1]) +
                  0.5 * (stress_params[2] + stress_params[1]) * sinphi - cohcos;
 
        if (mc_tip_possible && f8 > _f_tol)
        {
          stress_params[2] = cohcos / sinphi;
          stress_params[1] = stress_params[2] - 0.5 * _shifter;
          stress_params[0] = stress_params[2] - _shifter;
          f8 = 0.0;
          ga6 = 1.0;
          ga7 = 1.0;
        }
 
        const Real new_tensile_yf = stress_params[2] - ts;
        const Real new_compressive_yf = -stress_params[0] - cs;
 
        if (f8 <= _f_tol && new_tensile_yf <= _f_tol && new_compressive_yf <= _f_tol &&
            ga6 >= 0.0 && ga7 >= 0.0)
        {
          gaE = ((trial_stress_params[2] - trial_stress_params[0]) -
                 (stress_params[2] - stress_params[0])) /
                (_Eij[2][2] - _Eij[0][2]) * _Eij[2][2];
          found_solution = true;
        }
      }
    }
    if (!found_solution && !mc_impossible && trial_mc_yf > _f_tol)
    {
      // Try return to the mid=min line.
      // To return to the mid=min line, we need to solve f6 = 0 = f8 and
      // the three flow-direction equations.  In the flow-direction equations
      // there are two plasticity multipliers, which i call ga6 and ga8,
      // corresponding to the amounts of strain normal to the f6 and f8
      // directions, respectively.
      // So:
      // Smax = Smax^trial - ga6 Emax,a dg6/dSa - ga8 Emax,a dg8/dSa
      //      = Smax^trial - ga6 cmax6 - ga8 cmax8  (with cmax6 and cmax8 evaluated below)
      // Smid = Smid^trial - ga6 Emid,a dg6/dSa - ga8 Emid,a dg8/dSa
      //      = Smid^trial - ga6 cmid6 - ga8 cmid8
      // Smin = Smin^trial - ga6 Emin,a dg6/dSa - ga8 Emin,a dg8/dSa
      //      = Smin^trial - ga6 cmin6 - ga8 cmin8
      const Real cmax6 = _Eij[2][2] * halfplus + _Eij[2][0] * neghalfplus;
      const Real cmax8 = _Eij[2][2] * halfplus + _Eij[2][1] * neghalfplus;
      // const Real cmid6 = _Eij[1][2] * halfplus + _Eij[1][0] * neghalfplus;
      // const Real cmid8 = _Eij[1][2] * halfplus + _Eij[1][1] * neghalfplus;
      const Real cmin6 = _Eij[0][2] * halfplus + _Eij[0][0] * neghalfplus;
      const Real cmin8 = _Eij[0][2] * halfplus + _Eij[0][1] * neghalfplus;
      // Substituting these into f6 = 0 yields
      // 0 = f6_trial - ga6 (0.5(cmax6 - cmin6) + 0.5(cmax6 + cmin6)sinphi) - ga8 (0.5(cmax6 -
      // cmin6) + 0.5(cmax6 + cmin6)sinphi) = f6_trial - ga6 c6 - ga8 c8, where
      const Real c6 = 0.5 * (cmax6 - cmin6) + 0.5 * (cmax6 + cmin6) * sinphi;
      const Real c8 = 0.5 * (cmax8 - cmin8) + 0.5 * (cmax8 + cmin8) * sinphi;
      // It isn't too hard to check that the other equation is
      // 0 = f8_trial - ga6 c8 - ga8 c6
      // These equations may be inverted to yield
      if (c6 != c8)
      {
        const Real f6_trial = trial_mc_yf;
        const Real f8_trial = 0.5 * (trial_stress_params[2] - trial_stress_params[1]) +
                              0.5 * (trial_stress_params[2] + trial_stress_params[1]) * sinphi -
                              cohcos;
        const Real descr = Utility::pow<2>(c6) - Utility::pow<2>(c8);
        Real ga6 = (c6 * f6_trial - c8 * f8_trial) / descr;
        Real ga8 = (-c8 * f6_trial + c6 * f8_trial) / descr;
        // and finally
        stress_params[2] = trial_stress_params[2] - ga6 * cmax6 - ga8 * cmax8;
        stress_params[0] = trial_stress_params[0] - ga6 * cmin6 - ga8 * cmin8;
        stress_params[1] = stress_params[0] + 0.5 * _shifter;
 
        Real f7 = 0.5 * (stress_params[1] - stress_params[0]) +
                  0.5 * (stress_params[1] + stress_params[0]) * sinphi - cohcos;
 
        if (mc_tip_possible && f7 > _f_tol)
        {
          stress_params[2] = cohcos / sinphi;
          stress_params[1] = stress_params[2] - 0.5 * _shifter;
          stress_params[0] = stress_params[2] - _shifter;
          f7 = 0.0;
          ga6 = 1.0;
          ga8 = 1.0;
        }
 
        const Real new_tensile_yf = stress_params[2] - ts;
        const Real new_compressive_yf = -stress_params[0] - cs;
 
        if (f7 <= _f_tol && new_tensile_yf <= _f_tol && new_compressive_yf <= _f_tol &&
            ga6 >= 0.0 && ga8 >= 0.0)
        {
          gaE = ((trial_stress_params[2] - trial_stress_params[0]) -
                 (stress_params[2] - stress_params[0])) /
                (_Eij[2][2] - _Eij[0][2]) * _Eij[2][2];
          found_solution = true;
        }
      }
    }
    if (!found_solution && !mc_impossible && tensile_possible && trial_tensile_yf > _f_tol)
    {
      // Return to the line where yf[0] = 0 = yf[6].
      // To return to this line, we need to solve f0 = 0 = f6 and
      // the three flow-direction equations.  In the flow-direction equations
      // there are two plasticity multipliers, which i call ga0 and ga6
      // corresponding to the amounts of strain normal to the f0 and f6
      // directions, respectively.
      // So:
      // Smax = Smax^trial - ga6 Emax,a dg6/dSa - ga0 Emax,a dg0/dSa
      //      = Smax^trial - ga6 cmax6 - ga0 cmax0  (with cmax6 and cmax0 evaluated below)
      // Smid = Smid^trial - ga6 Emid,a dg6/dSa - ga0 Emid,a dg0/dSa
      //      = Smid^trial - ga6 cmid6 - ga0 cmid0
      // Smin = Smin^trial - ga6 Emin,a dg6/dSa - ga0 Emin,a dg0/dSa
      //      = Smin^trial - ga6 cmin6 - ga0 cmin0
      const Real cmax6 = _Eij[2][2] * halfplus + _Eij[2][0] * neghalfplus;
      const Real cmax0 = _Eij[2][2];
      const Real cmid6 = _Eij[1][2] * halfplus + _Eij[1][0] * neghalfplus;
      const Real cmid0 = _Eij[1][2];
      const Real cmin6 = _Eij[0][2] * halfplus + _Eij[0][0] * neghalfplus;
      const Real cmin0 = _Eij[0][2];
      // Substituting these into f6 = 0 yields
      // 0 = f6_trial - ga6 (0.5(cmax6 - cmin6) + 0.5(cmax6 + cmin6)sinphi) - ga0 (0.5(cmax0 -
      // cmin0) + 0.5(cmax0 + cmin0)sinphi) = f6_trial - ga6 c6 - ga0 c0, where
      const Real c6 = 0.5 * (cmax6 - cmin6) + 0.5 * (cmax6 + cmin6) * sinphi;
      const Real c0 = 0.5 * (cmax0 - cmin0) + 0.5 * (cmax0 + cmin0) * sinphi;
      // Substituting these into f0 = 0 yields
      // 0 = f0_trial - ga6 cmax6 - ga0 cmax0
      // These equations may be inverted to yield the following
      const Real descr = c0 * cmax6 - c6 * cmax0;
      if (descr != 0.0)
      {
        const Real ga0 = (-c6 * trial_tensile_yf + cmax6 * trial_mc_yf) / descr;
        const Real ga6 = (c0 * trial_tensile_yf - cmax0 * trial_mc_yf) / descr;
        stress_params[2] = trial_stress_params[2] - ga6 * cmax6 - ga0 * cmax0;
        stress_params[1] = trial_stress_params[1] - ga6 * cmid6 - ga0 * cmid0;
        stress_params[0] = trial_stress_params[0] - ga6 * cmin6 - ga0 * cmin0;
 
        // enforce physicality (go to corners if necessary)
        stress_params[0] =
            std::min(stress_params[0],
                     stress_params[2] - _shifter); // account for poor choice from user
        // if goto_corner then the max(min()) in the subsequent line will force the solution to lie
        // at the corner where max = mid = tensile.  This means the signs of ga0 and ga6 become
        // irrelevant in the check below
        const bool goto_corner = (stress_params[1] >= stress_params[2] - 0.5 * _shifter);
        stress_params[1] = std::max(std::min(stress_params[1], stress_params[2] - 0.5 * _shifter),
                                    stress_params[0] + 0.5 * _shifter);
 
        const Real new_compressive_yf = -stress_params[0] - cs;
        if (new_compressive_yf <= _f_tol &&
            (goto_corner || (ga0 >= 0.0 && ga6 >= 0.0))) // enforce ga>=0 unless going to a corner
        {
          gaE = ((trial_stress_params[2] - trial_stress_params[0]) -
                 (stress_params[2] - stress_params[0])) /
                    (_Eij[2][2] - _Eij[0][2]) * _Eij[2][2] +
                (trial_stress_params[2] - stress_params[2]);
          found_solution = true;
        }
      }
    }
    if (!found_solution && !mc_impossible)
    {
      // Return to the line where yf[3] = 0 = yf[6].
      // To return to this line, we need to solve f3 = 0 = f6 and
      // the three flow-direction equations.  In the flow-direction equations
      // there are two plasticity multipliers, which i call ga3 and ga6
      // corresponding to the amounts of strain normal to the f3 and f6
      // directions, respectively.
      // So:
      // Smax = Smax^trial - ga6 Emax,a dg6/dSa - ga3 Emax,a dg3/dSa
      //      = Smax^trial - ga6 cmax6 - ga3 cmax3  (with cmax6 and cmax3 evaluated below)
      // Smid = Smid^trial - ga6 Emid,a dg6/dSa - ga3 Emid,a dg3/dSa
      //      = Smid^trial - ga6 cmid6 - ga3 cmid3
      // Smin = Smin^trial - ga6 Emin,a dg6/dSa - ga3 Emin,a dg3/dSa
      //      = Smin^trial - ga6 cmin6 - ga3 cmin3
      const Real cmax6 = _Eij[2][2] * halfplus + _Eij[2][0] * neghalfplus;
      const Real cmax3 = -_Eij[2][0];
      const Real cmid6 = _Eij[1][2] * halfplus + _Eij[1][0] * neghalfplus;
      const Real cmid3 = -_Eij[1][0];
      const Real cmin6 = _Eij[0][2] * halfplus + _Eij[0][0] * neghalfplus;
      const Real cmin3 = -_Eij[0][0];
      // Substituting these into f6 = 0 yields
      // 0 = f6_trial - ga6 (0.5(cmax6 - cmin6) + 0.5(cmax6 + cmin6)sinphi) - ga3 (0.5(cmax3 -
      // cmin3) + 0.5(cmax3 + cmin3)sinphi) = f6_trial - ga6 c6 - ga3 c3, where
      const Real c6 = 0.5 * (cmax6 - cmin6) + 0.5 * (cmax6 + cmin6) * sinphi;
      const Real c3 = 0.5 * (cmax3 - cmin3) + 0.5 * (cmax3 + cmin3) * sinphi;
      // Substituting these into f3 = 0 yields
      // 0 = - f3_trial - ga6 cmin6 - ga3 cmin3
      // These equations may be inverted to yield the following
      const Real descr = c3 * cmin6 - c6 * cmin3;
      if (descr != 0.0)
      {
        const Real ga3 = (c6 * trial_compressive_yf + cmin6 * trial_mc_yf) / descr;
        const Real ga6 = (-c3 * trial_compressive_yf - cmin3 * trial_mc_yf) / descr;
        stress_params[2] = trial_stress_params[2] - ga6 * cmax6 - ga3 * cmax3;
        stress_params[1] = trial_stress_params[1] - ga6 * cmid6 - ga3 * cmid3;
        stress_params[0] = trial_stress_params[0] - ga6 * cmin6 - ga3 * cmin3;
 
        const Real new_tensile_yf = stress_params[2] - ts;
        stress_params[2] =
            std::max(stress_params[2],
                     stress_params[0] + _shifter); // account for poor choice from user
        stress_params[1] = std::max(std::min(stress_params[1], stress_params[2] - 0.5 * _shifter),
                                    stress_params[0] + 0.5 * _shifter);
 
        if (new_tensile_yf <= _f_tol && ga6 >= 0.0)
        {
          gaE = ((trial_stress_params[2] - trial_stress_params[0]) -
                 (stress_params[2] - stress_params[0])) /
                    (_Eij[2][2] - _Eij[0][2]) * _Eij[2][2] +
                (-trial_stress_params[0] - stress_params[0]);
 
          found_solution = true;
        }
      }
    }
    if (!found_solution)
    {
      // Cannot find an acceptable initialisation
      for (unsigned i = 0; i < _num_sp; ++i)
        stress_params[i] = trial_stress_params[i];
      gaE = 0.0;
      mooseWarning("CappedMohrCoulombStressUpdate cannot initialize from max = ",
                   stress_params[2],
                   " mid = ",
                   stress_params[1],
                   " min = ",
                   stress_params[0]);
    }
  }
  setIntnlValuesV(trial_stress_params, stress_params, intnl_old, intnl);
}

◆ initQpStatefulProperties()

void MultiParameterPlasticityStressUpdate::initQpStatefulProperties ( )

overrideprotectedvirtualinherited

Reimplemented from Material.

Reimplemented in CappedWeakInclinedPlaneStressUpdate.

Definition at line 151 of file MultiParameterPlasticityStressUpdate.C.

{
  _plastic_strain[_qp].zero();
  _intnl[_qp].assign(_num_intnl, 0);
  _yf[_qp].assign(_num_yf, 0);
  _iter[_qp] = 0.0;
  _max_iter_used[_qp] = 0.0;
  _linesearch_needed[_qp] = 0.0;
}

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ isIsotropic()

bool CappedMohrCoulombStressUpdate::isIsotropic ( )

inlineoverridevirtual

Is the implmented model isotropic? The safe default is 'false'.

Reimplemented from StressUpdateBaseTempl< is_ad, R2, R4 >.

Definition at line 31 of file CappedMohrCoulombStressUpdate.h.

31{ return true; };

◆ ismoother()

Real MultiParameterPlasticityStressUpdate::ismoother ( Real f_diff ) const

protectedinherited

Smooths yield functions.

The returned value must be zero if abs(f_diff) >= _smoothing_tol and otherwise must satisfy, over -_smoothing_tol <= f_diff <= _smoothing_tol: (1) C2 (2) zero at f_diff = +/- _smoothing_tol (3) derivative is +/-0.5 at f_diff = +/- _smoothing_tol (4) derivative must be in [-0.5, 0.5] (5) second derivative is zero at f_diff = +/- _smoothing_tol (6) second derivative must be non-negative in order to ensure C2 differentiability and convexity of the smoothed yield surface.

Definition at line 500 of file MultiParameterPlasticityStressUpdate.C.

{
  if (std::abs(f_diff) >= _smoothing_tol)
    return 0.0;
  switch (_smoother_function_type)
  {
    case SmootherFunctionType::cos:
      return -_smoothing_tol / M_PI * std::cos(0.5 * M_PI * f_diff / _smoothing_tol);
    case SmootherFunctionType::poly1:
      return 0.75 / _smoothing_tol *
             (0.5 * (Utility::pow<2>(f_diff) - _smoothing_tol2) -
              (_smoothing_tol2 / 12.0) * (Utility::pow<4>(f_diff / _smoothing_tol) - 1.0));
    case SmootherFunctionType::poly2:
      return 0.625 / _smoothing_tol *
             (0.5 * (Utility::pow<2>(f_diff) - _smoothing_tol2) -
              (_smoothing_tol2 / 30.0) * (Utility::pow<6>(f_diff / _smoothing_tol) - 1.0));
    case SmootherFunctionType::poly3:
      return (7.0 / 12.0 / _smoothing_tol) *
             (0.5 * (Utility::pow<2>(f_diff) - _smoothing_tol2) -
              (_smoothing_tol2 / 56.0) * (Utility::pow<8>(f_diff / _smoothing_tol) - 1.0));
    default:
      return 0.0;
  }
}

Referenced by MultiParameterPlasticityStressUpdate::smoothAllQuantities(), and MultiParameterPlasticityStressUpdate::yieldF().

◆ lineSearch()

int MultiParameterPlasticityStressUpdate::lineSearch	(	Real &	res2,
		std::vector< Real > &	stress_params,
		Real &	gaE,
		const std::vector< Real > &	trial_stress_params,
		yieldAndFlow &	smoothed_q,
		const std::vector< Real > &	intnl_ok,
		std::vector< Real > &	intnl,
		std::vector< Real > &	rhs,
		Real &	linesearch_needed
	)		const

protectedinherited

Performs a line-search to find stress_params and gaE Upon entry:

rhs contains the solution to the Newton-Raphson (ie nrStep should have been called). If a full Newton step is used then stress_params[:] += rhs[0:_num_sp-1] and gaE += rhs[_num_sp]
res2 contains the residual-squared before applying any of solution
stress_params contains the stress_params before applying any of the solution
gaE contains gaE before applying any of the solution (that is contained in rhs) Upon exit:
stress_params will be the stress_params after applying the solution
gaE will be the stress_params after applying the solution
rhs will contain the updated rhs values (after applying the solution) ready for the next Newton-Raphson step,
res2 will be the residual-squared after applying the solution
intnl will contain the internal variables corresponding to the return from trial_stress_params to stress_params (and starting from intnl_ok)
linesearch_needed will be 1.0 if a linesearch was needed

smoothed_q will contain the value of the yield function and its derivatives, etc, at (stress_params, intnl)

Parameters

res2[in,out]	the residual-squared, both as an input and output
stress_params[in,out]	Upon input the value of the stress_params before the current Newton-Raphson process was initiated. Upon exit this will hold the values coming from the line search.
trial_stress_params[in]	Trial value for the stress_params for this (sub)strain increment
gaE[in,out]	Upon input the value of gaE before the current Newton-Raphson iteration was initiated. Upon exit this will hold the value coming from the line-search
smoothed_q[in,out]	Upon input, the value of the smoothed yield function and derivatives at the prior-to-Newton configuration. Upon exit this is evaluated at the new (stress_params, intnl)
intnl_ok[in]	The value of the internal parameters from the start of this (sub)strain increment
intnl[in,out]	The value of the internal parameters after the line-search has converged
rhs[in,out]	Upon entry this contains the solution to the Newton-Raphson. Upon exit this contains the updated rhs values

Returns: 0 if successful, 1 otherwise

Definition at line 569 of file MultiParameterPlasticityStressUpdate.C.

{
  const Real res2_old = res2;
  mooseAssert(_sp_params_old_scratch.size() == _num_sp,
              "_sp_params_old_scratch incorrectly sized in lineSearch");
  _sp_params_old_scratch = stress_params;
  const Real gaE_old = gaE;
  mooseAssert(_delta_nr_params_scratch.size() == rhs.size(),
              "_delta_nr_params_scratch incorrectly sized in lineSearch");
  _delta_nr_params_scratch = rhs;
 
  Real lam = 1.0;                     // line-search parameter
  const Real lam_min = 1E-10;         // minimum value of lam allowed
  const Real slope = -2.0 * res2_old; // "Numerical Recipes" uses -b*A*x, in order to check for
                                      // roundoff, but i hope the nrStep would warn if there were
                                      // problems
  Real tmp_lam;                       // cached value of lam used in quadratic & cubic line search
  Real f2 = res2_old; // cached value of f = residual2 used in the cubic in the line search
  Real lam2 = lam;    // cached value of lam used in the cubic in the line search
 
  while (true)
  {
    // update variables using the current line-search parameter
    for (unsigned i = 0; i < _num_sp; ++i)
      stress_params[i] = _sp_params_old_scratch[i] + lam * _delta_nr_params_scratch[i];
    gaE = gaE_old + lam * _delta_nr_params_scratch[_num_sp];
 
    // and internal parameters
    setIntnlValuesV(trial_stress_params, stress_params, intnl_ok, intnl);
 
    smoothed_q = smoothAllQuantities(stress_params, intnl);
 
    // update rhs for next-time through
    calculateRHS(trial_stress_params, stress_params, gaE, smoothed_q, rhs);
    res2 = calculateRes2(rhs);
 
    // do the line-search
    if (res2 < res2_old + 1E-4 * lam * slope)
      break;
    else if (lam < lam_min)
      return 1;
    else if (lam == 1.0)
    {
      // model as a quadratic
      tmp_lam = -0.5 * slope / (res2 - res2_old - slope);
    }
    else
    {
      // model as a cubic
      const Real rhs1 = res2 - res2_old - lam * slope;
      const Real rhs2 = f2 - res2_old - lam2 * slope;
      const Real a = (rhs1 / Utility::pow<2>(lam) - rhs2 / Utility::pow<2>(lam2)) / (lam - lam2);
      const Real b =
          (-lam2 * rhs1 / Utility::pow<2>(lam) + lam * rhs2 / Utility::pow<2>(lam2)) / (lam - lam2);
      if (a == 0.0)
        tmp_lam = -slope / (2.0 * b);
      else
      {
        const Real disc = Utility::pow<2>(b) - 3.0 * a * slope;
        if (disc < 0)
          tmp_lam = 0.5 * lam;
        else if (b <= 0)
          tmp_lam = (-b + std::sqrt(disc)) / (3.0 * a);
        else
          tmp_lam = -slope / (b + std::sqrt(disc));
      }
      if (tmp_lam > 0.5 * lam)
        tmp_lam = 0.5 * lam;
    }
    lam2 = lam;
    f2 = res2;
    lam = std::max(tmp_lam, 0.1 * lam);
  }
 
  if (lam < 1.0)
    linesearch_needed = 1.0;
  return 0;
}

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ nrStep()

int MultiParameterPlasticityStressUpdate::nrStep	(	const yieldAndFlow &	smoothed_q,
		const std::vector< Real > &	trial_stress_params,
		const std::vector< Real > &	stress_params,
		const std::vector< Real > &	intnl,
		Real	gaE,
		std::vector< Real > &	rhs
	)		const

protectedinherited

Performs a Newton-Raphson step to attempt to zero rhs Upon return, rhs will contain the solution.

Parameters

smoothed_q[in]	The value of the smoothed yield function and derivatives prior to this Newton-Raphson step
trial_stress_params[in]	Trial value for the stress_params for this (sub)strain increment
stress_params[in]	The current value of the stress_params
intnl[in]	The current value of the internal parameters
gaE[in]	The current value of gaE
rhs[in,out]	Upon entry, the rhs to zero using Newton-Raphson. Upon exit, the solution to the Newton-Raphson problem

Returns: 0 if successful, 1 otherwise

Definition at line 657 of file MultiParameterPlasticityStressUpdate.C.

{
  mooseAssert(_dintnl_scratch.size() == _num_intnl, "_dintnl_scratch incorrectly sized in nrStep");
  setIntnlDerivativesV(trial_stress_params, stress_params, intnl, _dintnl_scratch);
 
  mooseAssert(_jac_scratch.size() == (_num_sp + 1) * (_num_sp + 1),
              "_jac_scratch incorrectly sized in nrStep");
  dnRHSdVar(smoothed_q, _dintnl_scratch, stress_params, gaE, _jac_scratch);
 
  // use LAPACK to solve the linear system
  const PetscBLASInt nrhs = 1;
  mooseAssert(_ipiv_scratch.size() == _num_sp + 1, "_ipiv_scratch incorrectly sized in nrStep");
  PetscBLASInt info;
  const PetscBLASInt gesv_num_rhs = _num_sp + 1;
  LAPACKgesv_(&gesv_num_rhs,
              &nrhs,
              &_jac_scratch[0],
              &gesv_num_rhs,
              &_ipiv_scratch[0],
              &rhs[0],
              &gesv_num_rhs,
              &info);
  return info;
}

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ precisionLoss()

bool MultiParameterPlasticityStressUpdate::precisionLoss	(	const std::vector< Real > &	solution,
		const std::vector< Real > &	stress_params,
		Real	gaE
	)		const

protectedinherited

Check whether precision loss has occurred.

Parameters

[in]	solution	The solution to the Newton-Raphson system
[in]	stress_params	The currect values of the stress_params for this (sub)strain increment
[in]	gaE	The currenct value of gaE for this (sub)strain increment

Returns: true if precision loss has occurred

Definition at line 1013 of file MultiParameterPlasticityStressUpdate.C.

{
  if (std::abs(solution[_num_sp]) > 1E-13 * std::abs(gaE))
    return false;
  for (unsigned i = 0; i < _num_sp; ++i)
    if (std::abs(solution[i]) > 1E-13 * std::abs(stress_params[i]))
      return false;
  return true;
}

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ preReturnMapV()

void CappedMohrCoulombStressUpdate::preReturnMapV	(	const std::vector< Real > &	trial_stress_params,
		const RankTwoTensor &	stress_trial,
		const std::vector< Real > &	intnl_old,
		const std::vector< Real > &	yf,
		const RankFourTensor &	Eijkl
	)

overrideprotectedvirtual

Derived classes may employ this function to record stuff or do other computations prior to the return-mapping algorithm.

We know that (trial_stress_params, intnl_old) is inadmissible when this is called

Parameters

trial_stress_params[in]	The trial values of the stress parameters
stress_trial[in]	Trial stress tensor
intnl_old[in]	Old value of the internal parameters.
yf[in]	The yield functions at (p_trial, q_trial, intnl_old)
Eijkl[in]	The elasticity tensor

Reimplemented from MultiParameterPlasticityStressUpdate.

Reimplemented in CappedMohrCoulombCosseratStressUpdate.

Definition at line 106 of file CappedMohrCoulombStressUpdate.C.

{
  mooseAssert(_eigvals_scratch.size() == _tensor_dimensionality,
              "_eigvals_scratch incorrectly sized in CappedMohrCoulombStressUpdate:preReturnMapV");
  stress_trial.symmetricEigenvaluesEigenvectors(_eigvals_scratch, _eigvecs);
  _poissons_ratio = ElasticityTensorTools::getIsotropicPoissonsRatio(Eijkl);
}

◆ propagateQpStatefulProperties()

void MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties ( )

overrideprotectedvirtualinherited

If updateState is not called during a timestep, this will be.

This method allows derived classes to set internal parameters from their Old values, for instance

Reimplemented from StressUpdateBaseTempl< is_ad, R2, R4 >.

Definition at line 162 of file MultiParameterPlasticityStressUpdate.C.

{
  _plastic_strain[_qp] = _plastic_strain_old[_qp];
  std::copy(_intnl_old[_qp].begin(), _intnl_old[_qp].end(), _intnl[_qp].begin());
  _max_iter_used[_qp] = _max_iter_used_old[_qp];
}

◆ requiresIsotropicTensor()

bool CappedMohrCoulombStressUpdate::requiresIsotropicTensor ( )

inlineoverridevirtual

Does the model require the elasticity tensor to be isotropic?

Implements StressUpdateBaseTempl< is_ad, R2, R4 >.

Definition at line 29 of file CappedMohrCoulombStressUpdate.h.

29{ return true; }

◆ resetIncrementalMaterialProperties()

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

virtual void StressUpdateBaseTempl< is_ad, R2, R4 >::resetIncrementalMaterialProperties ( )

inlinevirtualinherited

Reset material properties.

Useful for substepping with inelastic models.

Reimplemented in CompositePowerLawCreepStressUpdateTempl< is_ad >, LAROMANCEStressUpdateBaseTempl< is_ad >, and PowerLawCreepStressUpdateTempl< is_ad >.

Definition at line 172 of file StressUpdateBase.h.

172{}

◆ resetProperties()

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

void StressUpdateBaseTempl< is_ad, R2, R4 >::resetProperties ( )

inlinefinalvirtualinherited

Reimplemented from Material.

Definition at line 138 of file StressUpdateBase.h.

138{}

◆ resetQpProperties()

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

void StressUpdateBaseTempl< is_ad, R2, R4 >::resetQpProperties ( )

inlinefinalvirtualinherited

Retained as empty methods to avoid a warning from Material.C in framework. These methods are unused in all inheriting classes and should not be overwritten.

Reimplemented from Material.

Definition at line 137 of file StressUpdateBase.h.

137{}

◆ setEffectiveElasticity()

void CappedMohrCoulombStressUpdate::setEffectiveElasticity ( const RankFourTensor & Eijkl )

overrideprotectedvirtual

Sets _Eij and _En and _Cij.

Implements MultiParameterPlasticityStressUpdate.

Definition at line 260 of file CappedMohrCoulombStressUpdate.C.

{
  // Eijkl is required to be isotropic, so we can use the
  // frame where stress is diagonal
  for (unsigned a = 0; a < _num_sp; ++a)
    for (unsigned b = 0; b < _num_sp; ++b)
      _Eij[a][b] = Eijkl(a, a, b, b);
  _En = _Eij[2][2];
  const Real denom = _Eij[0][0] * (_Eij[0][0] + _Eij[0][1]) - 2 * Utility::pow<2>(_Eij[0][1]);
  for (unsigned a = 0; a < _num_sp; ++a)
  {
    _Cij[a][a] = (_Eij[0][0] + _Eij[0][1]) / denom;
    for (unsigned b = 0; b < a; ++b)
      _Cij[a][b] = _Cij[b][a] = -_Eij[0][1] / denom;
  }
}

◆ setInelasticStrainIncrementAfterReturn()

void MultiParameterPlasticityStressUpdate::setInelasticStrainIncrementAfterReturn	(	const RankTwoTensor &	stress_trial,
		Real	gaE,
		const yieldAndFlow &	smoothed_q,
		const RankFourTensor &	elasticity_tensor,
		const RankTwoTensor &	returned_stress,
		RankTwoTensor &	inelastic_strain_increment
	)

protectedvirtualinherited

Sets inelastic strain increment from the returned configuration This is called after the return-map process has completed successfully in stress_param space, just after finalizeReturnProcess has been called.

Derived classes may override this function

Parameters

stress_trial[in]	The trial value of stress
gaE[in]	The value of gaE after the return-map process has completed successfully
smoothed_q[in]	Holds the current value of yield function and derivatives evaluated at the returned configuration
elasticity_tensor[in]	The elasticity tensor
returned_stress[in]	The stress after the return-map process
inelastic_strain_increment[out]	The inelastic strain increment resulting from this return-map

Reimplemented in TwoParameterPlasticityStressUpdate.

Definition at line 813 of file MultiParameterPlasticityStressUpdate.C.

{
  dstressparam_dstress(returned_stress, _dsp_scratch);
  inelastic_strain_increment = RankTwoTensor();
  for (unsigned i = 0; i < _num_sp; ++i)
    inelastic_strain_increment += smoothed_q.dg[i] * _dsp_scratch[i];
  inelastic_strain_increment *= gaE / _En;
}

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ setIntnlDerivativesV()

void CappedMohrCoulombStressUpdate::setIntnlDerivativesV	(	const std::vector< Real > &	trial_stress_params,
		const std::vector< Real > &	current_stress_params,
		const std::vector< Real > &	intnl,
		std::vector< std::vector< Real > > &	dintnl
	)		const

overrideprotectedvirtual

Sets the derivatives of internal parameters, based on the trial values of stress_params, their current values, and the current values of the internal parameters.

Derived classes must override this.

Parameters

trial_stress_params[in]	The trial stress parameters
current_stress_params[in]	The current stress parameters
intnl[in]	The current value of the internal parameters
dintnl[out]	The derivatives dintnl[i][j] = d(intnl[i])/d(stress_param j)

Implements MultiParameterPlasticityStressUpdate.

Definition at line 772 of file CappedMohrCoulombStressUpdate.C.

{
  // intnl[0] = shear, intnl[1] = tensile
  const Real smax = current_stress_params[2];     // largest eigenvalue
  const Real smin = current_stress_params[0];     // smallest eigenvalue
  const Real trial_smax = trial_stress_params[2]; // largest eigenvalue
  const Real trial_smin = trial_stress_params[0]; // smallest eigenvalue
  const Real ga_shear = ((trial_smax - trial_smin) - (smax - smin)) / (_Eij[2][2] - _Eij[0][2]);
  mooseAssert(
      _dga_shear_scratch.size() == 3,
      "_dga_shear_scratch incorrectly sized in CappedMohrCoulombStressUpdate:setIntnlDerivativesV");
  _dga_shear_scratch[0] = 1.0 / (_Eij[2][2] - _Eij[0][2]);
  _dga_shear_scratch[1] = 0.0;
  _dga_shear_scratch[2] = -1.0 / (_Eij[2][2] - _Eij[0][2]);
  // intnl[0] = intnl_old[0] + ga_shear;
  for (std::size_t i = 0; i < _num_sp; ++i)
    dintnl[0][i] = _dga_shear_scratch[i];
 
  const Real sinpsi = std::sin(_psi.value(intnl[0]));
  const Real dsinpsi_di0 = _psi.derivative(intnl[0]) * std::cos(_psi.value(intnl[0]));
 
  const Real prefactor = (_Eij[2][2] + _Eij[0][2]) * sinpsi;
  const Real dprefactor_di0 = (_Eij[2][2] + _Eij[0][2]) * dsinpsi_di0;
  // const Real shear_correction = prefactor * ga_shear;
  mooseAssert(_dshear_correction_scratch.size() == 3,
              "_dshear_correction_scratch incorrectly sized in "
              "CappedMohrCoulombStressUpdate:setIntnlDerivativesV");
  for (std::size_t i = 0; i < _num_sp; ++i)
    _dshear_correction_scratch[i] =
        prefactor * _dga_shear_scratch[i] + dprefactor_di0 * dintnl[0][i] * ga_shear;
  // const Real ga_tensile = (1 - _poissons_ratio) * ((trial_smax + trial_smin) - (smax + smin) -
  // shear_correction) /
  // _Eij[2][2];
  // intnl[1] = intnl_old[1] + ga_tensile;
  for (std::size_t i = 0; i < _num_sp; ++i)
    dintnl[1][i] = -(1.0 - _poissons_ratio) * _dshear_correction_scratch[i] / _Eij[2][2];
  dintnl[1][2] += -(1.0 - _poissons_ratio) / _Eij[2][2];
  dintnl[1][0] += -(1.0 - _poissons_ratio) / _Eij[2][2];
}

◆ setIntnlValuesV()

void CappedMohrCoulombStressUpdate::setIntnlValuesV	(	const std::vector< Real > &	trial_stress_params,
		const std::vector< Real > &	current_stress_params,
		const std::vector< Real > &	intnl_old,
		std::vector< Real > &	intnl
	)		const

overrideprotectedvirtual

Sets the internal parameters based on the trial values of stress_params, their current values, and the old values of the internal parameters.

Derived classes must override this.

Parameters

trial_stress_params[in]	The trial stress parameters (eg trial_p and trial_q)
current_stress_params[in]	The current stress parameters (eg p and q)
intnl_old[out]	Old value of internal parameters
intnl[out]	The value of internal parameters to be set

Implements MultiParameterPlasticityStressUpdate.

Definition at line 750 of file CappedMohrCoulombStressUpdate.C.

{
  // intnl[0] = shear, intnl[1] = tensile
  const Real smax = current_stress_params[2];     // largest eigenvalue
  const Real smin = current_stress_params[0];     // smallest eigenvalue
  const Real trial_smax = trial_stress_params[2]; // largest eigenvalue
  const Real trial_smin = trial_stress_params[0]; // smallest eigenvalue
  const Real ga_shear = ((trial_smax - trial_smin) - (smax - smin)) / (_Eij[2][2] - _Eij[0][2]);
  intnl[0] = intnl_old[0] + ga_shear;
  const Real sinpsi = std::sin(_psi.value(intnl[0]));
  const Real prefactor = (_Eij[2][2] + _Eij[0][2]) * sinpsi;
  const Real shear_correction = prefactor * ga_shear;
  const Real ga_tensile = (1.0 - _poissons_ratio) *
                          ((trial_smax + trial_smin) - (smax + smin) - shear_correction) /
                          _Eij[2][2];
  intnl[1] = intnl_old[1] + ga_tensile;
}

Referenced by initializeVarsV().

◆ setQp()

template<bool is_ad, typename R2 , typename R4 >

void StressUpdateBaseTempl< is_ad, R2, R4 >::setQp ( unsigned int qp )

inherited

Sets the value of the global variable _qp for inheriting classes.

Definition at line 46 of file StressUpdateBase.C.

{
  _qp = qp;
}

Referenced by ComputeCreepPlasticityStress::updateQpState().

◆ setStressAfterReturnV()

void CappedMohrCoulombStressUpdate::setStressAfterReturnV	(	const RankTwoTensor &	stress_trial,
		const std::vector< Real > &	stress_params,
		Real	gaE,
		const std::vector< Real > &	intnl,
		const yieldAndFlow &	smoothed_q,
		const RankFourTensor &	Eijkl,
		RankTwoTensor &	stress
	)		const

overrideprotectedvirtual

Sets stress from the admissible parameters.

This is called after the return-map process has completed successfully in stress_param space, just after finalizeReturnProcess has been called. Derived classes must override this function

Parameters

stress_trial[in]	The trial value of stress
stress_params[in]	The value of the stress_params after the return-map process has completed successfully
gaE[in]	The value of gaE after the return-map process has completed successfully
intnl[in]	The value of the internal parameters after the return-map process has completed successfully
smoothed_q[in]	Holds the current value of yield function and derivatives evaluated at the returned state
Eijkl[in]	The elasticity tensor
stress[out]	The returned value of the stress tensor

Implements MultiParameterPlasticityStressUpdate.

Reimplemented in CappedMohrCoulombCosseratStressUpdate.

Definition at line 119 of file CappedMohrCoulombStressUpdate.C.

{
  // form the diagonal stress
  stress = RankTwoTensor(stress_params[0], stress_params[1], stress_params[2], 0.0, 0.0, 0.0);
  // rotate to the original frame
  stress = _eigvecs * stress * (_eigvecs.transpose());
}

◆ smoothAllQuantities()

MultiParameterPlasticityStressUpdate::yieldAndFlow MultiParameterPlasticityStressUpdate::smoothAllQuantities	(	const std::vector< Real > &	stress_params,
		const std::vector< Real > &	intnl
	)		const

protectedinherited

Calculates all yield functions and derivatives, and then performs the smoothing scheme.

Parameters

stress_params[in]	The stress parameters (eg stress_params[0] = stress_zz and stress_params[1] = sqrt(stress_zx^2 + stress_zy^2))
intnl[in]	Internal parameters

Returns: The smoothed yield function and derivatives

Definition at line 407 of file MultiParameterPlasticityStressUpdate.C.

{
  mooseAssert(_all_q_scratch.size() == _num_yf,
              "_all_q_scratch incorrectly sized in smoothAllQuantities");
  for (auto & q : _all_q_scratch)
    q.reset();
  computeAllQV(stress_params, intnl, _all_q_scratch);
 
  /* This routine holds the key to my smoothing strategy.  It
   * may be proved that this smoothing strategy produces a
   * yield surface that is both C2 differentiable and convex,
   * assuming the individual yield functions are C2 and
   * convex too.
   * Of course all the derivatives must also be smoothed.
   * Also, I assume that d(flow potential)/dstress gets smoothed
   * by the Yield Function (which produces a C2 flow potential).
   * See the line identified in the loop below.
   * Only time will tell whether this is a good strategy, but it
   * works well in all tests so far.  Convexity is irrelevant
   * for the non-associated case, but at least the return-map
   * problem should always have a unique solution.
   * For two yield functions+flows, labelled 1 and 2, we
   * should have
   * d(g1 - g2) . d(f1 - f2) >= 0
   * If not then the return-map problem for even the
   * multi-surface plasticity with no smoothing won't have a
   * unique solution.  If the multi-surface plasticity has
   * a unique solution then the smoothed version defined
   * below will too.
   */
 
  // res_f is the index that contains the smoothed yieldAndFlow
  std::size_t res_f = 0;
 
  for (std::size_t a = 1; a < _all_q_scratch.size(); ++a)
  {
    if (_all_q_scratch[res_f].f >= _all_q_scratch[a].f + _smoothing_tol)
      // no smoothing is needed: res_f is already indexes the largest yield function
      continue;
    else if (_all_q_scratch[a].f >= _all_q_scratch[res_f].f + _smoothing_tol)
    {
      // no smoothing is needed, and res_f needs to index to _all_q_scratch[a]
      res_f = a;
      continue;
    }
    else
    {
      // smoothing is required
      const Real f_diff = _all_q_scratch[res_f].f - _all_q_scratch[a].f;
      const Real ism = ismoother(f_diff);
      const Real sm = smoother(f_diff);
      const Real dsm = dsmoother(f_diff);
      // we want: _all_q_scratch[res_f].f = 0.5 * _all_q_scratch[res_f].f + _all_q_scratch[a].f +
      // _smoothing_tol) + ism, but we have to do the derivatives first
      for (unsigned i = 0; i < _num_sp; ++i)
      {
        for (unsigned j = 0; j < _num_sp; ++j)
          _all_q_scratch[res_f].d2g[i][j] =
              0.5 * (_all_q_scratch[res_f].d2g[i][j] + _all_q_scratch[a].d2g[i][j]) +
              dsm * (_all_q_scratch[res_f].df[j] - _all_q_scratch[a].df[j]) *
                  (_all_q_scratch[res_f].dg[i] - _all_q_scratch[a].dg[i]) +
              sm * (_all_q_scratch[res_f].d2g[i][j] - _all_q_scratch[a].d2g[i][j]);
        for (unsigned j = 0; j < _num_intnl; ++j)
          _all_q_scratch[res_f].d2g_di[i][j] =
              0.5 * (_all_q_scratch[res_f].d2g_di[i][j] + _all_q_scratch[a].d2g_di[i][j]) +
              dsm * (_all_q_scratch[res_f].df_di[j] - _all_q_scratch[a].df_di[j]) *
                  (_all_q_scratch[res_f].dg[i] - _all_q_scratch[a].dg[i]) +
              sm * (_all_q_scratch[res_f].d2g_di[i][j] - _all_q_scratch[a].d2g_di[i][j]);
      }
      for (unsigned i = 0; i < _num_sp; ++i)
      {
        _all_q_scratch[res_f].df[i] =
            0.5 * (_all_q_scratch[res_f].df[i] + _all_q_scratch[a].df[i]) +
            sm * (_all_q_scratch[res_f].df[i] - _all_q_scratch[a].df[i]);
        // whether the following (smoothing g with f's smoother) is a good strategy remains to be
        // seen...
        _all_q_scratch[res_f].dg[i] =
            0.5 * (_all_q_scratch[res_f].dg[i] + _all_q_scratch[a].dg[i]) +
            sm * (_all_q_scratch[res_f].dg[i] - _all_q_scratch[a].dg[i]);
      }
      for (unsigned i = 0; i < _num_intnl; ++i)
        _all_q_scratch[res_f].df_di[i] =
            0.5 * (_all_q_scratch[res_f].df_di[i] + _all_q_scratch[a].df_di[i]) +
            sm * (_all_q_scratch[res_f].df_di[i] - _all_q_scratch[a].df_di[i]);
      _all_q_scratch[res_f].f =
          0.5 * (_all_q_scratch[res_f].f + _all_q_scratch[a].f + _smoothing_tol) + ism;
    }
  }
  return _all_q_scratch[res_f];
}

Referenced by MultiParameterPlasticityStressUpdate::lineSearch(), and MultiParameterPlasticityStressUpdate::updateState().

◆ smoother()

Real MultiParameterPlasticityStressUpdate::smoother ( Real f_diff ) const

protectedinherited

Derivative of ismoother.

Definition at line 526 of file MultiParameterPlasticityStressUpdate.C.

{
  if (std::abs(f_diff) >= _smoothing_tol)
    return 0.0;
  switch (_smoother_function_type)
  {
    case SmootherFunctionType::cos:
      return 0.5 * std::sin(f_diff * M_PI * 0.5 / _smoothing_tol);
    case SmootherFunctionType::poly1:
      return 0.75 / _smoothing_tol *
             (f_diff - (_smoothing_tol / 3.0) * Utility::pow<3>(f_diff / _smoothing_tol));
    case SmootherFunctionType::poly2:
      return 0.625 / _smoothing_tol *
             (f_diff - (_smoothing_tol / 5.0) * Utility::pow<5>(f_diff / _smoothing_tol));
    case SmootherFunctionType::poly3:
      return (7.0 / 12.0 / _smoothing_tol) *
             (f_diff - (_smoothing_tol / 7.0) * Utility::pow<7>(f_diff / _smoothing_tol));
    default:
      return 0.0;
  }
}

Referenced by MultiParameterPlasticityStressUpdate::smoothAllQuantities().

◆ storeIncrementalMaterialProperties()

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

virtual void StressUpdateBaseTempl< is_ad, R2, R4 >::storeIncrementalMaterialProperties ( const unsigned int )

inlinevirtualinherited

Properly set up the incremental calculation storage of the stateful material properties in the inheriting classes.

Reimplemented in LAROMANCEStressUpdateBaseTempl< is_ad >.

Definition at line 166 of file StressUpdateBase.h.

166 {

167 };

◆ substeppingCapabilityEnabled()

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

virtual bool StressUpdateBaseTempl< is_ad, R2, R4 >::substeppingCapabilityEnabled ( )

inlinevirtualinherited

Does the model include the infrastructure for substep decomposition of the elastic strain initially used to calculate the trial stress guess Inheriting classes which wish to use the substepping capability should overwrite this method and set it to return true.

Reimplemented in ADMultiplePowerLawCreepStressUpdate, CompositePowerLawCreepStressUpdateTempl< is_ad >, LAROMANCEStressUpdateBaseTempl< is_ad >, and PowerLawCreepStressUpdateTempl< is_ad >.

Definition at line 147 of file StressUpdateBase.h.

147{ return false; }

◆ substeppingCapabilityRequested()

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

virtual bool StressUpdateBaseTempl< is_ad, R2, R4 >::substeppingCapabilityRequested ( )

inlinevirtualinherited

Has the user requested usage of (possibly) implemented substepping capability for inelastic models.

Reimplemented in RadialReturnStressUpdateTempl< is_ad >.

Definition at line 153 of file StressUpdateBase.h.

153{ return false; }

◆ updateState() [1/2]

void StressUpdateBaseTempl< is_ad, R2, R4 >::updateState	(	GR2 &	strain_increment,
		GR2 &	inelastic_strain_increment,
		const GR2 &	rotation_increment,
		GR2 &	stress_new,
		const RankTwoTensor &	stress_old,
		const GR4 &	elasticity_tensor,
		const RankTwoTensor &	elastic_strain_old,
		bool	compute_full_tangent_operator = `false`,
		RankFourTensor &	tangent_operator = `StressUpdateBaseTempl<is_ad>::_identityTensor`
	)

protectedvirtualinherited

Given a strain increment that results in a trial stress, perform some procedure (such as an iterative return-mapping process) to produce an admissible stress, an elastic strain increment and an inelastic strain increment.

If _fe_problem.currentlyComputingJacobian() = true, then updateState also computes d(stress)/d(strain) (or some approximation to it).

This method is called by ComputeMultipleInelasticStress. This method is pure virutal: all inheriting classes must overwrite this method.

Parameters

strain_increment	Upon input: the strain increment. Upon output: the elastic strain increment
inelastic_strain_increment	The inelastic_strain resulting from the interative procedure
rotation_increment	The finite-strain rotation increment
stress_new	Upon input: the trial stress that results from applying strain_increment as an elastic strain. Upon output: the admissible stress
stress_old	The old value of stress
elasticity_tensor	The elasticity tensor
compute_full_tangent_operator	The calling routine would like the full consistent tangent operator to be placed in tangent_operator, if possible. This is irrelevant if _fe_problem.currentlyComputingJacobian() = false
tangent_operator	d(stress)/d(strain), or some approximation to it If compute_full_tangent_operator=false, then tangent_operator=elasticity_tensor is an appropriate choice. tangent_operator is only computed if _fe_problem.currentlyComputingJacobian() = true

Reimplemented from StressUpdateBaseTempl< is_ad, R2, R4 >.

Definition at line 89 of file StressUpdateBase.C.

{
  mooseError("updateState called: it needs to be implemented by your inelastic model");
}

◆ updateState() [2/2]

void MultiParameterPlasticityStressUpdate::updateState	(	RankTwoTensor &	strain_increment,
		RankTwoTensor &	inelastic_strain_increment,
		const RankTwoTensor &	rotation_increment,
		RankTwoTensor &	stress_new,
		const RankTwoTensor &	stress_old,
		const RankFourTensor &	elasticity_tensor,
		const RankTwoTensor &	elastic_strain_old,
		bool	compute_full_tangent_operator,
		RankFourTensor &	tangent_operator
	)

overrideprotectedvirtualinherited

Definition at line 170 of file MultiParameterPlasticityStressUpdate.C.

{
  // Size _yf[_qp] appropriately
  _yf[_qp].assign(_num_yf, 0);
  // _plastic_strain and _intnl are usually sized appropriately because they are stateful, but this
  // Material may be used from a DiracKernel where stateful materials are not allowed.  The best we
  // can do is:
  if (_intnl[_qp].size() != _num_intnl)
    initQpStatefulProperties();
 
  initializeReturnProcess();
 
  if (_t_step >= 2)
    _step_one = false;
 
  // initially assume an elastic deformation
  std::copy(_intnl_old[_qp].begin(), _intnl_old[_qp].end(), _intnl[_qp].begin());
 
  _iter[_qp] = 0.0;
  _max_iter_used[_qp] = std::max(_max_iter_used[_qp], _max_iter_used_old[_qp]);
  _linesearch_needed[_qp] = 0.0;
 
  computeStressParams(stress_new, _trial_sp);
  yieldFunctionValuesV(_trial_sp, _intnl[_qp], _yf[_qp]);
 
  if (yieldF(_yf[_qp]) <= _f_tol)
  {
    _plastic_strain[_qp] = _plastic_strain_old[_qp];
    inelastic_strain_increment.zero();
    if (_fe_problem.currentlyComputingJacobian())
      tangent_operator = elasticity_tensor;
    return;
  }
 
  _stress_trial = stress_new;
  /* The trial stress must be inadmissible
   * so we need to return to the yield surface.  The following
   * equations must be satisfied.
   *
   * 0 = rhs[0] = S[0] - S[0]^trial + ga * E[0, i] * dg/dS[i]
   * 0 = rhs[1] = S[1] - S[1]^trial + ga * E[1, i] * dg/dS[i]
   * ...
   * 0 = rhs[N-1] = S[N-1] - S[N-1]^trial + ga * E[N-1, i] * dg/dS[i]
   * 0 = rhs[N] = f(S, intnl)
   *
   * as well as equations defining intnl parameters as functions of
   * stress_params, trial_stress_params and intnl_old
   *
   * The unknowns are S[0], ..., S[N-1], gaE, and the intnl parameters.
   * Here gaE = ga * _En (the _En serves to make gaE similar magnitude to S)
   * I find it convenient to solve the first N+1 equations for p, q and gaE,
   * while substituting the "intnl parameters" equations into these during the solve process
   */
 
  for (auto & deriv : _dvar_dtrial)
    deriv.assign(_num_sp, 0.0);
 
  preReturnMapV(_trial_sp, stress_new, _intnl_old[_qp], _yf[_qp], elasticity_tensor);
 
  setEffectiveElasticity(elasticity_tensor);
 
  if (_step_one)
    std::copy(_definitely_ok_sp.begin(), _definitely_ok_sp.end(), _ok_sp.begin());
  else
    computeStressParams(stress_old, _ok_sp);
  std::copy(_intnl_old[_qp].begin(), _intnl_old[_qp].end(), _ok_intnl.begin());
 
  // Return-map problem: must apply the following changes in stress_params,
  // and find the returned stress_params and gaE
  for (unsigned i = 0; i < _num_sp; ++i)
    _del_stress_params[i] = _trial_sp[i] - _ok_sp[i];
 
  Real step_taken = 0.0; // amount of del_stress_params that we've applied and the return-map
                         // problem has succeeded
  Real step_size = 1.0;  // potentially can apply del_stress_params in substeps
  Real gaE_total = 0.0;
 
  // In the following sub-stepping procedure it is possible that
  // the last step is an elastic step, and therefore _smoothed_q won't
  // be computed on the last step, so we have to compute it.
  bool smoothed_q_calculated = false;
 
  while (step_taken < 1.0 && step_size >= _min_step_size)
  {
    if (1.0 - step_taken < step_size)
      // prevent over-shoots of substepping
      step_size = 1.0 - step_taken;
 
    // trial variables in terms of admissible variables
    for (unsigned i = 0; i < _num_sp; ++i)
      _trial_sp[i] = _ok_sp[i] + step_size * _del_stress_params[i];
 
    // initialize variables that are to be found via Newton-Raphson
    _current_sp = _trial_sp;
    Real gaE = 0.0;
 
    // flags indicating failure of Newton-Raphson and line-search
    int nr_failure = 0;
    int ls_failure = 0;
 
    // NR iterations taken in this substep
    unsigned step_iter = 0;
 
    // The residual-squared for the line-search
    Real res2 = 0.0;
 
    if (step_size < 1.0 && yieldF(_trial_sp, _ok_intnl) <= _f_tol)
      // This is an elastic step
      // The "step_size < 1.0" in above condition is for efficiency: we definitely
      // know that this is a plastic step if step_size = 1.0
      smoothed_q_calculated = false;
    else
    {
      // this is a plastic step
 
      // initialize current_sp, gaE and current_intnl based on the non-smoothed situation
      initializeVarsV(_trial_sp, _ok_intnl, _current_sp, gaE, _current_intnl);
      // and find the smoothed yield function, flow potential and derivatives
      _smoothed_q = smoothAllQuantities(_current_sp, _current_intnl);
      smoothed_q_calculated = true;
      calculateRHS(_trial_sp, _current_sp, gaE, _smoothed_q, _rhs);
      res2 = calculateRes2(_rhs);
 
      // Perform a Newton-Raphson with linesearch to get current_sp, gaE, and also _smoothed_q
      while (res2 > _f_tol2 && step_iter < _max_nr_its && nr_failure == 0 && ls_failure == 0)
      {
        // solve the linear system and store the answer (the "updates") in rhs
        nr_failure = nrStep(_smoothed_q, _trial_sp, _current_sp, _current_intnl, gaE, _rhs);
        if (nr_failure != 0)
          break;
 
        // handle precision loss
        if (precisionLoss(_rhs, _current_sp, gaE))
        {
          if (_warn_about_precision_loss)
          {
            Moose::err << "MultiParameterPlasticityStressUpdate: precision-loss in element "
                       << _current_elem->id() << " quadpoint=" << _qp << ".  Stress_params =";
            for (unsigned i = 0; i < _num_sp; ++i)
              Moose::err << " " << _current_sp[i];
            Moose::err << " gaE = " << gaE << "\n";
          }
          res2 = 0.0;
          break;
        }
 
        // apply (parts of) the updates, re-calculate _smoothed_q, and res2
        ls_failure = lineSearch(res2,
                                _current_sp,
                                gaE,
                                _trial_sp,
                                _smoothed_q,
                                _ok_intnl,
                                _current_intnl,
                                _rhs,
                                _linesearch_needed[_qp]);
        step_iter++;
      }
    }
    if (res2 <= _f_tol2 && step_iter < _max_nr_its && nr_failure == 0 && ls_failure == 0 &&
        gaE >= 0.0)
    {
      // this Newton-Raphson worked fine, or this was an elastic step
      std::copy(_current_sp.begin(), _current_sp.end(), _ok_sp.begin());
      gaE_total += gaE;
      step_taken += step_size;
      setIntnlValuesV(_trial_sp, _ok_sp, _ok_intnl, _intnl[_qp]);
      std::copy(_intnl[_qp].begin(), _intnl[_qp].end(), _ok_intnl.begin());
      // calculate dp/dp_trial, dp/dq_trial, etc, for Jacobian
      dVardTrial(!smoothed_q_calculated,
                 _trial_sp,
                 _ok_sp,
                 gaE,
                 _ok_intnl,
                 _smoothed_q,
                 step_size,
                 compute_full_tangent_operator,
                 _dvar_dtrial);
      if (static_cast<Real>(step_iter) > _iter[_qp])
        _iter[_qp] = static_cast<Real>(step_iter);
      if (static_cast<Real>(step_iter) > _max_iter_used[_qp])
        _max_iter_used[_qp] = static_cast<Real>(step_iter);
      step_size *= 1.1;
    }
    else
    {
      // Newton-Raphson + line-search process failed
      step_size *= 0.5;
    }
  }
 
  if (step_size < _min_step_size)
    errorHandler("MultiParameterPlasticityStressUpdate: Minimum step-size violated");
 
  // success!
  finalizeReturnProcess(rotation_increment);
  yieldFunctionValuesV(_ok_sp, _intnl[_qp], _yf[_qp]);
 
  if (!smoothed_q_calculated)
    _smoothed_q = smoothAllQuantities(_ok_sp, _intnl[_qp]);
 
  setStressAfterReturnV(
      _stress_trial, _ok_sp, gaE_total, _intnl[_qp], _smoothed_q, elasticity_tensor, stress_new);
 
  setInelasticStrainIncrementAfterReturn(_stress_trial,
                                         gaE_total,
                                         _smoothed_q,
                                         elasticity_tensor,
                                         stress_new,
                                         inelastic_strain_increment);
 
  strain_increment = strain_increment - inelastic_strain_increment;
  _plastic_strain[_qp] = _plastic_strain_old[_qp] + inelastic_strain_increment;
 
  if (_fe_problem.currentlyComputingJacobian())
    // for efficiency, do not compute the tangent operator if not currently computing Jacobian
    consistentTangentOperatorV(_stress_trial,
                               _trial_sp,
                               stress_new,
                               _ok_sp,
                               gaE_total,
                               _smoothed_q,
                               elasticity_tensor,
                               compute_full_tangent_operator,
                               _dvar_dtrial,
                               tangent_operator);
}

◆ updateStateSubstep()

template<bool is_ad, typename R2 , typename R4 >

void StressUpdateBaseTempl< is_ad, R2, R4 >::updateStateSubstep	(	GR2 &	,
		GR2 &	,
		const GR2 &	,
		GR2 &	,
		const RankTwoTensor &	,
		const GR4 &	,
		const RankTwoTensor &	,
		bool	compute_full_tangent_operator = `false`,
		RankFourTensor &	tangent_operator = `StressUpdateBaseTempl<is_ad>::_identityTensor`
	)

virtualinherited

Similar to the updateState function, this method updates the strain and stress for one substep.

Definition at line 84 of file StressUpdateBase.C.

{
  this->paramError("use_substep",
                   "updateStateSubstep called: it needs to be implemented by your inelastic model");
}

◆ validParams()

InputParameters CappedMohrCoulombStressUpdate::validParams ( )

static

Definition at line 17 of file CappedMohrCoulombStressUpdate.C.

{
  InputParameters params = MultiParameterPlasticityStressUpdate::validParams();
  params.addRequiredParam<UserObjectName>(
      "tensile_strength",
      "A SolidMechanicsHardening UserObject that defines hardening of the "
      "tensile strength.  In physical situations this is positive (and always "
      "must be greater than negative compressive-strength.");
  params.addRequiredParam<UserObjectName>(
      "compressive_strength",
      "A SolidMechanicsHardening UserObject that defines hardening of the "
      "compressive strength.  In physical situations this is positive.");
  params.addRequiredParam<UserObjectName>(
      "cohesion", "A SolidMechanicsHardening UserObject that defines hardening of the cohesion");
  params.addRequiredParam<UserObjectName>("friction_angle",
                                          "A SolidMechanicsHardening UserObject "
                                          "that defines hardening of the "
                                          "friction angle (in radians)");
  params.addRequiredParam<UserObjectName>(
      "dilation_angle",
      "A SolidMechanicsHardening UserObject that defines hardening of the "
      "dilation angle (in radians).  Unless you are quite confident, this should "
      "be set positive and not greater than the friction angle.");
  params.addParam<bool>("perfect_guess",
                        true,
                        "Provide a guess to the Newton-Raphson procedure "
                        "that is the result from perfect plasticity.  With "
                        "severe hardening/softening this may be "
                        "suboptimal.");
  params.addClassDescription("Nonassociative, smoothed, Mohr-Coulomb plasticity capped with "
                             "tensile (Rankine) and compressive caps, with hardening/softening");
  return params;
}

Referenced by CappedMohrCoulombCosseratStressUpdate::validParams().

◆ yieldF() [1/2]

Real MultiParameterPlasticityStressUpdate::yieldF	(	const std::vector< Real > &	stress_params,
		const std::vector< Real > &	intnl
	)		const

protectedinherited

Computes the smoothed yield function.

Parameters

stress_params	The stress parameters (eg stress_params[0] = stress_zz and stress_params[1] = sqrt(stress_zx^2 + stress_zy^2))
intnl	The internal parameters (eg intnl[0] is shear, intnl[1] is tensile)

Returns: The smoothed yield function value

Definition at line 715 of file MultiParameterPlasticityStressUpdate.C.

{
  mooseAssert(_yfs_scratch.size() == _num_yf, "_yfs_scratch incorrectly sized in yieldF");
  yieldFunctionValuesV(stress_params, intnl, _yfs_scratch);
  return yieldF(_yfs_scratch);
}

Referenced by MultiParameterPlasticityStressUpdate::updateState(), and MultiParameterPlasticityStressUpdate::yieldF().

◆ yieldF() [2/2]

Real MultiParameterPlasticityStressUpdate::yieldF ( const std::vector< Real > & yfs ) const

protectedinherited

Computes the smoothed yield function.

Parameters

yfs	The values of the individual yield functions

Returns: The smoothed yield function value

Definition at line 724 of file MultiParameterPlasticityStressUpdate.C.

{
  Real yf = yfs[0];
  for (std::size_t i = 1; i < yfs.size(); ++i)
    if (yf >= yfs[i] + _smoothing_tol)
      // no smoothing is needed, and yf is the biggest yield function
      continue;
    else if (yfs[i] >= yf + _smoothing_tol)
      // no smoothing is needed, and yfs[i] is the biggest yield function
      yf = yfs[i];
    else
      yf = 0.5 * (yf + yfs[i] + _smoothing_tol) + ismoother(yf - yfs[i]);
  return yf;
}

◆ yieldFunctionValuesV()

void CappedMohrCoulombStressUpdate::yieldFunctionValuesV	(	const std::vector< Real > &	stress_params,
		const std::vector< Real > &	intnl,
		std::vector< Real > &	yf
	)		const

overrideprotectedvirtual

Computes the values of the yield functions, given stress_params and intnl parameters.

Derived classes must override this, to provide the values of the yield functions in yf.

Parameters

	stress_params[in]	The stress parameters
	intnl[in]	The internal parameters
[out]	yf	The yield function values

Implements MultiParameterPlasticityStressUpdate.

Definition at line 134 of file CappedMohrCoulombStressUpdate.C.

{
  // intnl[0] = shear, intnl[1] = tensile
  const Real ts = _tensile_strength.value(intnl[1]);
  const Real cs = _compressive_strength.value(intnl[1]);
  const Real sinphi = std::sin(_phi.value(intnl[0]));
  const Real cohcos = _cohesion.value(intnl[0]) * std::cos(_phi.value(intnl[0]));
  const Real smax = stress_params[2]; // largest eigenvalue
  const Real smid = stress_params[1];
  const Real smin = stress_params[0]; // smallest eigenvalue
  yf[0] = smax - ts;
  yf[1] = smid - ts;
  yf[2] = smin - ts;
  yf[3] = -smin - cs;
  yf[4] = -smid - cs;
  yf[5] = -smax - cs;
  yf[6] = 0.5 * (smax - smin) + 0.5 * (smax + smin) * sinphi - cohcos;
  yf[7] = 0.5 * (smid - smin) + 0.5 * (smid + smin) * sinphi - cohcos;
  yf[8] = 0.5 * (smax - smid) + 0.5 * (smax + smid) * sinphi - cohcos;
  yf[9] = 0.5 * (smid - smax) + 0.5 * (smid + smax) * sinphi - cohcos;
  yf[10] = 0.5 * (smin - smid) + 0.5 * (smin + smid) * sinphi - cohcos;
  yf[11] = 0.5 * (smin - smax) + 0.5 * (smin + smax) * sinphi - cohcos;
}

Member Data Documentation

◆ _all_q_scratch

std::vector<yieldAndFlow> MultiParameterPlasticityStressUpdate::_all_q_scratch

mutableprivateinherited

all the yield function information, for use in smoothAllQuantities, to avoid repeatedly allocating/deallocating this vector

Definition at line 815 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::smoothAllQuantities().

◆ _base_name

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

const std::string StressUpdateBaseTempl< is_ad, R2, R4 >::_base_name

protectedinherited

Name used as a prefix for all material properties related to the stress update model.

Definition at line 191 of file StressUpdateBase.h.

◆ _Cij

std::vector<std::vector<Real> > MultiParameterPlasticityStressUpdate::_Cij

protectedinherited

_Cij[i, j] * _Eij[j, k] = 1 iff j == k

Definition at line 140 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::consistentTangentOperatorV(), CappedMohrCoulombCosseratStressUpdate::setEffectiveElasticity(), setEffectiveElasticity(), TensileStressUpdate::setEffectiveElasticity(), and TwoParameterPlasticityStressUpdate::setEffectiveElasticity().

◆ _cohesion

const SolidMechanicsHardeningModel& CappedMohrCoulombStressUpdate::_cohesion

protected

Hardening model for cohesion.

Definition at line 41 of file CappedMohrCoulombStressUpdate.h.

Referenced by computeAllQV(), initializeVarsV(), and yieldFunctionValuesV().

◆ _compressive_strength

const SolidMechanicsHardeningModel& CappedMohrCoulombStressUpdate::_compressive_strength

protected

Hardening model for compressive strength.

Definition at line 38 of file CappedMohrCoulombStressUpdate.h.

Referenced by computeAllQV(), initializeVarsV(), and yieldFunctionValuesV().

◆ _current_elem

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

const Elem *const & Material::_current_elem

inherited

Referenced by TwoParameterPlasticityStressUpdate::consistentTangentOperator(), CappedDruckerPragerCosseratStressUpdate::consistentTangentOperator(), CappedDruckerPragerStressUpdate::consistentTangentOperator(), MultiParameterPlasticityStressUpdate::consistentTangentOperatorV(), ADViscoplasticityStressUpdate::outputIterationSummary(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _current_intnl

std::vector<Real> MultiParameterPlasticityStressUpdate::_current_intnl

privateinherited

The current values of the internal params during the Newton-Raphson.

Definition at line 748 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _current_sp

std::vector<Real> MultiParameterPlasticityStressUpdate::_current_sp

privateinherited

The current values of the stress params during the Newton-Raphson.

Definition at line 743 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _d2sp_scratch

std::vector<RankFourTensor> MultiParameterPlasticityStressUpdate::_d2sp_scratch

mutableprivateinherited

d2(stress_param[:])/d(stress)/d(stress) used in d2stressparam_dstress to avoid repeatedly allocating/deallocating this vector

Definition at line 773 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::consistentTangentOperatorV().

◆ _definitely_ok_sp

const std::vector<Real> MultiParameterPlasticityStressUpdate::_definitely_ok_sp

protectedinherited

An admissible value of stress_params at the initial time.

Definition at line 131 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::MultiParameterPlasticityStressUpdate(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _del_stress_params

std::vector<Real> MultiParameterPlasticityStressUpdate::_del_stress_params

privateinherited

_del_stress_params = trial_stress_params - ok_sp This is fixed at the beginning of the return-map process, irrespective of substepping.

The return-map problem is: apply del_stress_params to stress_prams, and then find an admissible (returned) stress_params and gaE

Definition at line 738 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _delta_nr_params_scratch

std::vector<Real> MultiParameterPlasticityStressUpdate::_delta_nr_params_scratch

mutableprivateinherited

container to hold initial values of rhs in lineSearch to avoid repeatedly allocating/deallocating this vector

Definition at line 791 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::lineSearch().

◆ _dga_shear_scratch

std::vector<Real> CappedMohrCoulombStressUpdate::_dga_shear_scratch

mutableprivate

derivative of ga_shear w.r.t.

the stress parameters, used in setIntnlDerivativesV. Using this mutable means repeated allocation/deallocation is unnecessary.

Definition at line 142 of file CappedMohrCoulombStressUpdate.h.

Referenced by setIntnlDerivativesV().

◆ _dintnl_scratch

std::vector<std::vector<Real> > MultiParameterPlasticityStressUpdate::_dintnl_scratch

mutableprivateinherited

derivative of internal parameters with respect to stress parameters, to avoid repeatedly allocating/deallocating this vector

Definition at line 797 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::nrStep().

◆ _dshear_correction_scratch

std::vector<Real> CappedMohrCoulombStressUpdate::_dshear_correction_scratch

mutableprivate

scratch vector used in setIntnlDerivativesV.

Using this mutable means repeated allocation/deallocation is unnecessary.

Definition at line 148 of file CappedMohrCoulombStressUpdate.h.

Referenced by setIntnlDerivativesV().

◆ _dsp_scratch

std::vector<RankTwoTensor> MultiParameterPlasticityStressUpdate::_dsp_scratch

mutableprivateinherited

d(stress_param[:])/d(stress) used in dstressparam_dstress to avoid repeatedly allocating/deallocating this vector

Definition at line 761 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::consistentTangentOperatorV(), and MultiParameterPlasticityStressUpdate::setInelasticStrainIncrementAfterReturn().

◆ _dsp_trial_scratch

std::vector<RankTwoTensor> CappedMohrCoulombStressUpdate::_dsp_trial_scratch

mutableprivate

this is d(stress_param[:])/d(stress) which is calculated by dstressparam_dstress.

Using this mutable means repeated allocation/deallocation is unnecessary.

Definition at line 130 of file CappedMohrCoulombStressUpdate.h.

Referenced by consistentTangentOperatorV().

◆ _dt

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

Real & Material::_dt

inherited

Referenced by ADViscoplasticityStressUpdate::computeInelasticStrainIncrement(), and ADViscoplasticityStressUpdate::updateState().

◆ _dvar_dtrial

std::vector<std::vector<Real> > MultiParameterPlasticityStressUpdate::_dvar_dtrial

privateinherited

d({stress_param[i], gaE})/d(trial_stress_param[j])

Definition at line 714 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _eigvals_scratch

std::vector<Real> CappedMohrCoulombStressUpdate::_eigvals_scratch

mutableprivate

eigenvalues of the stress, used in dstressparam_dstress and preReturnMapV.

Using this mutable means repeated allocation/deallocation is unnecessary.

Definition at line 136 of file CappedMohrCoulombStressUpdate.h.

Referenced by dstressparam_dstress(), and preReturnMapV().

◆ _eigvecs

RankTwoTensor CappedMohrCoulombStressUpdate::_eigvecs

protected

Eigenvectors of the trial stress as a RankTwoTensor, in order to rotate the returned stress back to stress space.

Definition at line 63 of file CappedMohrCoulombStressUpdate.h.

Referenced by consistentTangentOperatorV(), CappedMohrCoulombCosseratStressUpdate::preReturnMapV(), preReturnMapV(), CappedMohrCoulombCosseratStressUpdate::setStressAfterReturnV(), and setStressAfterReturnV().

◆ _Eij

std::vector<std::vector<Real> > MultiParameterPlasticityStressUpdate::_Eij

protectedinherited

E[i, j] in the system of equations to be solved.

Definition at line 134 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::calculateRHS(), MultiParameterPlasticityStressUpdate::dnRHSdVar(), MultiParameterPlasticityStressUpdate::dVardTrial(), initializeVarsV(), CappedMohrCoulombCosseratStressUpdate::setEffectiveElasticity(), setEffectiveElasticity(), TensileStressUpdate::setEffectiveElasticity(), TwoParameterPlasticityStressUpdate::setEffectiveElasticity(), setIntnlDerivativesV(), TensileStressUpdate::setIntnlDerivativesV(), setIntnlValuesV(), and TensileStressUpdate::setIntnlValuesV().

◆ _En

Real MultiParameterPlasticityStressUpdate::_En

protectedinherited

normalising factor

Definition at line 137 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::calculateRHS(), MultiParameterPlasticityStressUpdate::consistentTangentOperatorV(), MultiParameterPlasticityStressUpdate::dnRHSdVar(), MultiParameterPlasticityStressUpdate::dVardTrial(), CappedMohrCoulombCosseratStressUpdate::setEffectiveElasticity(), setEffectiveElasticity(), TensileStressUpdate::setEffectiveElasticity(), TwoParameterPlasticityStressUpdate::setEffectiveElasticity(), and MultiParameterPlasticityStressUpdate::setInelasticStrainIncrementAfterReturn().

◆ _f_tol

const Real MultiParameterPlasticityStressUpdate::_f_tol

protectedinherited

The yield-function tolerance.

Definition at line 161 of file MultiParameterPlasticityStressUpdate.h.

Referenced by initializeVarsV(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _f_tol2

const Real MultiParameterPlasticityStressUpdate::_f_tol2

protectedinherited

Square of the yield-function tolerance.

Definition at line 164 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _identityTensor

template<bool is_ad, typename R2 , typename R4 >

RankFourTensor StressUpdateBaseTempl< is_ad, R2, R4 >::_identityTensor

staticprotectedinherited

Initial value:

=

RankFourTensor(RankFourTensor::initIdentityFour)

RankFourTensorTempl< Real >::initIdentityFour

initIdentityFour

Definition at line 193 of file StressUpdateBase.h.

◆ _intnl

MaterialProperty<std::vector<Real> >& MultiParameterPlasticityStressUpdate::_intnl

protectedinherited

internal parameters

Definition at line 186 of file MultiParameterPlasticityStressUpdate.h.

Referenced by CappedWeakPlaneCosseratStressUpdate::consistentTangentOperator(), CappedWeakPlaneStressUpdate::consistentTangentOperator(), MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _intnl_old

const MaterialProperty<std::vector<Real> >& MultiParameterPlasticityStressUpdate::_intnl_old

protectedinherited

old values of internal parameters

Definition at line 189 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _ipiv_scratch

std::vector<PetscBLASInt> MultiParameterPlasticityStressUpdate::_ipiv_scratch

mutableprivateinherited

container to hold LAPACK ipiv integers, to avoid repeatedly allocating/deallocating this vector

Definition at line 809 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::nrStep().

◆ _iter

MaterialProperty<Real>& MultiParameterPlasticityStressUpdate::_iter

protectedinherited

Number of Newton-Raphson iterations used in the return-map.

Definition at line 195 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _jac_scratch

std::vector<double> MultiParameterPlasticityStressUpdate::_jac_scratch

mutableprivateinherited

jacobian in the NR process, to avoid repeatedly allocating/deallocating this vector

Definition at line 803 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::nrStep().

◆ _linesearch_needed

MaterialProperty<Real>& MultiParameterPlasticityStressUpdate::_linesearch_needed

protectedinherited

Whether a line-search was needed in the latest Newton-Raphson process (1 if true, 0 otherwise)

Definition at line 204 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _max_iter_used

MaterialProperty<Real>& MultiParameterPlasticityStressUpdate::_max_iter_used

protectedinherited

Maximum number of Newton-Raphson iterations used in the return-map during the course of the entire simulation.

Definition at line 198 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _max_iter_used_old

const MaterialProperty<Real>& MultiParameterPlasticityStressUpdate::_max_iter_used_old

protectedinherited

Old value of maximum number of Newton-Raphson iterations used in the return-map during the course of the entire simulation.

Definition at line 201 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _max_nr_its

const unsigned MultiParameterPlasticityStressUpdate::_max_nr_its

protectedinherited

Maximum number of Newton-Raphson iterations allowed in the return-map process.

Definition at line 149 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _min_step_size

const Real MultiParameterPlasticityStressUpdate::_min_step_size

protectedinherited

In order to help the Newton-Raphson procedure, the applied strain increment may be applied in sub-increments of size greater than this value.

Definition at line 171 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _num_intnl

const unsigned MultiParameterPlasticityStressUpdate::_num_intnl

protectedinherited

Number of internal parameters.

Definition at line 146 of file MultiParameterPlasticityStressUpdate.h.

Referenced by computeAllQV(), MultiParameterPlasticityStressUpdate::dnRHSdVar(), MultiParameterPlasticityStressUpdate::dVardTrial(), MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), MultiParameterPlasticityStressUpdate::nrStep(), MultiParameterPlasticityStressUpdate::smoothAllQuantities(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _num_sp

const unsigned MultiParameterPlasticityStressUpdate::_num_sp

protectedinherited

Number of stress parameters.

Definition at line 128 of file MultiParameterPlasticityStressUpdate.h.

◆ _num_yf

const unsigned MultiParameterPlasticityStressUpdate::_num_yf

protectedinherited

Number of yield functions.

Definition at line 143 of file MultiParameterPlasticityStressUpdate.h.

Referenced by computeAllQV(), TensileStressUpdate::computeAllQV(), MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), MultiParameterPlasticityStressUpdate::smoothAllQuantities(), MultiParameterPlasticityStressUpdate::updateState(), and MultiParameterPlasticityStressUpdate::yieldF().

◆ _ok_intnl

std::vector<Real> MultiParameterPlasticityStressUpdate::_ok_intnl

privateinherited

The state (ok_sp, ok_intnl) is known to be admissible.

Definition at line 729 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _ok_sp

std::vector<Real> MultiParameterPlasticityStressUpdate::_ok_sp

privateinherited

The state (ok_sp, ok_intnl) is known to be admissible, so ok_sp are stress_params that are "OK".

If the strain_increment is applied in substeps then ok_sp is updated after each sub strain_increment is applied and the return-map is successful. At the end of the entire return-map process _ok_sp will contain the stress_params where (_ok_sp, _intnl) is admissible.

Definition at line 724 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _perfect_guess

const bool CappedMohrCoulombStressUpdate::_perfect_guess

protected

Whether to provide an estimate of the returned stress, based on perfect plasticity.

Definition at line 50 of file CappedMohrCoulombStressUpdate.h.

Referenced by initializeVarsV().

◆ _perform_finite_strain_rotations

const bool MultiParameterPlasticityStressUpdate::_perform_finite_strain_rotations

protectedinherited

Whether to perform finite-strain rotations.

Definition at line 152 of file MultiParameterPlasticityStressUpdate.h.

Referenced by CappedWeakInclinedPlaneStressUpdate::finalizeReturnProcess(), and CappedWeakInclinedPlaneStressUpdate::initializeReturnProcess().

◆ _phi

const SolidMechanicsHardeningModel& CappedMohrCoulombStressUpdate::_phi

protected

Hardening model for friction angle.

Definition at line 44 of file CappedMohrCoulombStressUpdate.h.

Referenced by CappedMohrCoulombStressUpdate(), computeAllQV(), initializeVarsV(), and yieldFunctionValuesV().

◆ _plastic_strain

MaterialProperty<RankTwoTensor>& MultiParameterPlasticityStressUpdate::_plastic_strain

protectedinherited

plastic strain

Definition at line 180 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _plastic_strain_old

const MaterialProperty<RankTwoTensor>& MultiParameterPlasticityStressUpdate::_plastic_strain_old

protectedinherited

Old value of plastic strain.

Definition at line 183 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::propagateQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _poissons_ratio

Real CappedMohrCoulombStressUpdate::_poissons_ratio

protected

Poisson's ratio.

Definition at line 53 of file CappedMohrCoulombStressUpdate.h.

Referenced by CappedMohrCoulombCosseratStressUpdate::preReturnMapV(), preReturnMapV(), setIntnlDerivativesV(), and setIntnlValuesV().

◆ _psi

const SolidMechanicsHardeningModel& CappedMohrCoulombStressUpdate::_psi

protected

Hardening model for dilation angle.

Definition at line 47 of file CappedMohrCoulombStressUpdate.h.

Referenced by CappedMohrCoulombStressUpdate(), computeAllQV(), initializeVarsV(), setIntnlDerivativesV(), and setIntnlValuesV().

◆ _q_point

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

const MooseArray< Point > & Material::_q_point

inherited

Referenced by ADViscoplasticityStressUpdate::computeResidual(), and ADViscoplasticityStressUpdate::outputIterationSummary().

◆ _qp

template<bool is_ad, typename R2 = RankTwoTensor, typename R4 = RankFourTensor>

unsigned int Material::_qp

inherited

◆ _rhs

std::vector<Real> MultiParameterPlasticityStressUpdate::_rhs

privateinherited

0 = rhs[0] = S[0] - S[0]^trial + ga * E[0, i] * dg/dS[i] 0 = rhs[1] = S[1] - S[1]^trial + ga * E[1, i] * dg/dS[i] ... 0 = rhs[N-1] = S[N-1] - S[N-1]^trial + ga * E[N-1, i] * dg/dS[i] 0 = rhs[N] = f(S, intnl) Here N = num_sp

Definition at line 709 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _shifter

const Real CappedMohrCoulombStressUpdate::_shifter

protected

When equal-eigenvalues are predicted from the stress initialization routine, shift them by this amount.

This avoids equal-eigenvalue problems, but also accounts for the smoothing of the yield surface

Definition at line 60 of file CappedMohrCoulombStressUpdate.h.

Referenced by initializeVarsV().

◆ _smoothed_q

yieldAndFlow MultiParameterPlasticityStressUpdate::_smoothed_q

privateinherited

Current values of the yield function, derivatives, etc during updateState.

During Newton-Raphson convergence, this is potentially re-calculated multiple times within the loops of updateState and by the lineSearch function that is called within those loops.

Definition at line 755 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _smoother_function_type

enum MultiParameterPlasticityStressUpdate::SmootherFunctionType MultiParameterPlasticityStressUpdate::_smoother_function_type

privateinherited

Referenced by MultiParameterPlasticityStressUpdate::dsmoother(), MultiParameterPlasticityStressUpdate::ismoother(), and MultiParameterPlasticityStressUpdate::smoother().

◆ _smoothing_tol

const Real MultiParameterPlasticityStressUpdate::_smoothing_tol

protectedinherited

Smoothing tolerance: edges of the yield surface get smoothed by this amount.

Definition at line 155 of file MultiParameterPlasticityStressUpdate.h.

Referenced by CappedDruckerPragerStressUpdate::CappedDruckerPragerStressUpdate(), CappedWeakPlaneStressUpdate::CappedWeakPlaneStressUpdate(), MultiParameterPlasticityStressUpdate::dsmoother(), MultiParameterPlasticityStressUpdate::ismoother(), MultiParameterPlasticityStressUpdate::smoothAllQuantities(), MultiParameterPlasticityStressUpdate::smoother(), and MultiParameterPlasticityStressUpdate::yieldF().

◆ _smoothing_tol2

const Real MultiParameterPlasticityStressUpdate::_smoothing_tol2

protectedinherited

Square of the smoothing tolerance.

Definition at line 158 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::ismoother().

◆ _sp_params_old_scratch

std::vector<Real> MultiParameterPlasticityStressUpdate::_sp_params_old_scratch

mutableprivateinherited

container to hold old values of old stress_params in lineSearch to avoid repeatedly allocating/deallocating this vector

Definition at line 785 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::lineSearch().

◆ _step_one

bool MultiParameterPlasticityStressUpdate::_step_one

protectedinherited

handles case of initial_stress that is inadmissible being supplied

Definition at line 174 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _stress_trial

RankTwoTensor MultiParameterPlasticityStressUpdate::_stress_trial

privateinherited

"Trial" value of stress that is set at the beginning of the return-map process.

It is fixed at stress_old + Eijkl * strain_increment irrespective of any sub-stepping

Definition at line 699 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _tensile_strength

const SolidMechanicsHardeningModel& CappedMohrCoulombStressUpdate::_tensile_strength

protected

Hardening model for tensile strength.

Definition at line 35 of file CappedMohrCoulombStressUpdate.h.

Referenced by computeAllQV(), initializeVarsV(), and yieldFunctionValuesV().

◆ _tensor_dimensionality

constexpr unsigned MultiParameterPlasticityStressUpdate::_tensor_dimensionality = 3

staticconstexprprotectedinherited

Internal dimensionality of tensors (currently this is 3 throughout solid mechanics)

Definition at line 125 of file MultiParameterPlasticityStressUpdate.h.

Referenced by TwoParameterPlasticityStressUpdate::consistentTangentOperator(), CappedDruckerPragerCosseratStressUpdate::consistentTangentOperator(), CappedDruckerPragerStressUpdate::consistentTangentOperator(), CappedWeakPlaneCosseratStressUpdate::consistentTangentOperator(), CappedWeakPlaneStressUpdate::consistentTangentOperator(), CappedMohrCoulombCosseratStressUpdate::consistentTangentOperatorV(), consistentTangentOperatorV(), TensileStressUpdate::consistentTangentOperatorV(), CappedWeakPlaneStressUpdate::d2qdstress2(), dstressparam_dstress(), TensileStressUpdate::dstressparam_dstress(), CappedMohrCoulombCosseratStressUpdate::preReturnMapV(), preReturnMapV(), and TensileStressUpdate::preReturnMapV().

◆ _trial_sp

std::vector<Real> MultiParameterPlasticityStressUpdate::_trial_sp

privateinherited

"Trial" value of stress_params that initializes the return-map process This is derived from stress = stress_old + Eijkl * strain_increment.

However, since the return-map process can fail and be restarted by applying strain_increment in multiple substeps, _trial_sp can vary from substep to substep.

Definition at line 692 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _warn_about_precision_loss

const bool MultiParameterPlasticityStressUpdate::_warn_about_precision_loss

protectedinherited

Output a warning message if precision loss is encountered during the return-map process.

Definition at line 177 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

◆ _yf

MaterialProperty<std::vector<Real> >& MultiParameterPlasticityStressUpdate::_yf

protectedinherited

yield functions

Definition at line 192 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), and MultiParameterPlasticityStressUpdate::updateState().

◆ _yfs_scratch

std::vector<Real> MultiParameterPlasticityStressUpdate::_yfs_scratch

mutableprivateinherited

values of yield functions in yieldF, to avoid repeatedly allocating/deallocating this vector

Definition at line 779 of file MultiParameterPlasticityStressUpdate.h.

Referenced by MultiParameterPlasticityStressUpdate::yieldF().

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

solid_mechanics/include/materials/CappedMohrCoulombStressUpdate.h
solid_mechanics/src/materials/CappedMohrCoulombStressUpdate.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 Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ GR2

◆ GR4

◆ GSR2

◆ GSR4

Member Enumeration Documentation

◆ SmootherFunctionType

Constructor & Destructor Documentation

◆ CappedMohrCoulombStressUpdate()

Member Function Documentation

◆ calculateNumberSubsteps()

◆ calculateRes2()

◆ calculateRHS()

◆ computeAllQV()

◆ computeStrainEnergyRateDensity()

◆ computeStressParams()

◆ computeTimeStepLimit()

◆ consistentTangentOperatorV()

◆ d2stressparam_dstress()

◆ dnRHSdVar()

◆ dsmoother()

◆ dstressparam_dstress()

◆ dVardTrial()

◆ errorHandler()

◆ finalizeReturnProcess()

◆ getTangentCalculationMethod()

◆ initializeReturnProcess()

◆ initializeVarsV()

◆ initQpStatefulProperties()

◆ isIsotropic()

◆ ismoother()

◆ lineSearch()

◆ nrStep()

◆ precisionLoss()

◆ preReturnMapV()

◆ propagateQpStatefulProperties()

◆ requiresIsotropicTensor()

◆ resetIncrementalMaterialProperties()

◆ resetProperties()

◆ resetQpProperties()

◆ setEffectiveElasticity()

◆ setInelasticStrainIncrementAfterReturn()

◆ setIntnlDerivativesV()

◆ setIntnlValuesV()

◆ setQp()

◆ setStressAfterReturnV()

◆ smoothAllQuantities()

◆ smoother()

◆ storeIncrementalMaterialProperties()

◆ substeppingCapabilityEnabled()

◆ substeppingCapabilityRequested()

◆ updateState() [1/2]

◆ updateState() [2/2]

◆ updateStateSubstep()

◆ validParams()

◆ yieldF() [1/2]

◆ yieldF() [2/2]

◆ yieldFunctionValuesV()

Member Data Documentation

◆ _all_q_scratch

◆ _base_name

◆ _Cij

◆ _cohesion

◆ _compressive_strength

◆ _current_elem

◆ _current_intnl