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	ConstantTypeEnum { ConstantTypeEnum::NONE, ConstantTypeEnum::ELEMENT, ConstantTypeEnum::SUBDOMAIN }

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? More...

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

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. More...

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. More...

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

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. More...

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

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. More...

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

virtual void	resetIncrementalMaterialProperties ()
	Reset material properties. More...

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. More...

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

bool	ghostable () const override final

virtual void	resolveOptionalProperties () override

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

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty ()

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

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty ()

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

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty ()

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

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

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

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

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

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

virtual void	initStatefulProperties (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 ()

void	checkStatefulSanity () const

std::set< OutputName >	getOutputs ()

bool	hasStatefulProperties () const

void	setFaceInfo (const FaceInfo &fi)

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

bool	forceStatefulInit () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

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

void	callMooseError (std::string msg, const bool with_prefix) const

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

const InputParameters &	parameters () const

MooseObjectName	uniqueName () 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 &	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 &nm) const

void	paramError (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

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

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

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

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

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

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

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

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

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

std::string	getDataFileNameByName (const std::string &name, const std::string *param=nullptr) 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 (SubdomainID id) const

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

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

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

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

bool	hasBlockMaterialProperty (const std::string &prop_name)

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

virtual bool	blockRestricted () const

virtual void	checkVariable (const MooseVariableFieldBase &variable) const

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

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

unsigned int	numBoundaryIDs () const

bool	hasBoundary (const BoundaryName &name) const

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

bool	hasBoundary (const BoundaryID &id) const

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

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

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

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

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

virtual bool	boundaryRestricted () const

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

virtual bool	checkVariableBoundaryIntegrity () const

virtual void	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={})

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

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

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 UserObject &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

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

bool	isImplicit ()

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

std::pair< const MaterialProperty< T > *, std::set< SubdomainID > >	getBlockMaterialProperty (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)

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	hasGenericMaterialProperty (const std::string &name)

bool	hasGenericMaterialProperty (const std::string &name)

bool	hasGenericMaterialPropertyByName (const std::string &name)

bool	hasGenericMaterialPropertyByName (const std::string &name)

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

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

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

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

bool	requiresGeometricSearch () const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const


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. More...

void	resetProperties () final

Static Public Member Functions
static InputParameters	validParams ()

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)

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

const ConsoleStream	_console

Static Public Attributes
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. More...

std::vector< RankTwoTensor >	dstress_param_dstress (const RankTwoTensor &stress) const override
	d(stress_param[i])/d(stress) at given stress More...

std::vector< RankFourTensor >	d2stress_param_dstress (const RankTwoTensor &stress) const override
	d2(stress_param[i])/d(stress)/d(stress) at given stress More...

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. More...

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. More...

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

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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

virtual TangentCalculationMethod	getTangentCalculationMethod () override

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

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

Real	ismoother (Real f_diff) const
	Smooths yield functions. More...

Real	smoother (Real f_diff) const
	Derivative of ismoother. More...

Real	dsmoother (Real f_diff) const
	Derivative of smoother. More...

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. More...

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: More...

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. More...

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

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] ... More...

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. More...

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

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

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. More...

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) const
	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. More...

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. More...

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

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

virtual const MaterialData &	materialData () const override

virtual MaterialData &	materialData () 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 ()

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

void	initializeBlockRestrictable (const MooseObject *moose_object)

Moose::CoordinateSystemType	getBlockCoordSystem ()

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

void	addMooseVariableDependency (MooseVariableFieldBase *var)

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

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

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 UserObject &) const

Moose::StateArg	determineState () 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)

void	flagInvalidSolutionInternal (InvalidSolutionID _invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message) const

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

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

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

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

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)

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

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

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

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. More...

const SolidMechanicsHardeningModel &	_compressive_strength
	Hardening model for compressive strength. More...

const SolidMechanicsHardeningModel &	_cohesion
	Hardening model for cohesion. More...

const SolidMechanicsHardeningModel &	_phi
	Hardening model for friction angle. More...

const SolidMechanicsHardeningModel &	_psi
	Hardening model for dilation angle. More...

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

Real	_poissons_ratio
	Poisson's ratio. More...

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

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

const unsigned	_num_sp
	Number of stress parameters. More...

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

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

Real	_En
	normalising factor More...

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

const unsigned	_num_yf
	Number of yield functions. More...

const unsigned	_num_intnl
	Number of internal parameters. More...

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

const bool	_perform_finite_strain_rotations
	Whether to perform finite-strain rotations. More...

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

const Real	_smoothing_tol2
	Square of the smoothing tolerance. More...

const Real	_f_tol
	The yield-function tolerance. More...

const Real	_f_tol2
	Square of the yield-function tolerance. More...

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. More...

bool	_step_one
	handles case of initial_stress that is inadmissible being supplied More...

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

MaterialProperty< RankTwoTensor > &	_plastic_strain
	plastic strain More...

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

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

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

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

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

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

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. More...

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

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

	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 bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

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

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< MooseVariableFV< Real > *>	_coupled_standard_fv_moose_vars

std::vector< MooseLinearVariableFV< Real > *>	_coupled_standard_linear_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< DualReal > > >	_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

const VariableValue &	_zero

const VariablePhiValue &	_phi_zero

const MooseArray< DualReal > &	_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 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 tensor_mechanics) More...

static RankFourTensor	_identityTensor

static const std::string	_interpolated_old

static const std::string	_interpolated_older

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.

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())
 {
   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 800 of file MultiParameterPlasticityStressUpdate.C.

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

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

◆ 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 809 of file MultiParameterPlasticityStressUpdate.C.

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

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

◆ 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 148 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 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 69 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 RadialReturnStressUpdateTempl< is_ad >, GeneralizedRadialReturnStressUpdateTempl< is_ad >, LAROMANCEStressUpdateBaseTempl< 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 796 of file CappedMohrCoulombStressUpdate.C.

Referenced by CappedMohrCoulombCosseratStressUpdate::consistentTangentOperatorV().

 {
   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);
 
   const std::vector<RankTwoTensor> dsp_trial = dstress_param_dstress(stress_trial);
   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[b](k, l) * eT(a, j);
 
   cto = dstress_dtrial * elasticity_tensor;
 }

◆ d2stress_param_dstress()

std::vector< RankFourTensor > CappedMohrCoulombStressUpdate::d2stress_param_dstress ( const RankTwoTensor & stress ) const

overrideprotectedvirtual

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

Parameters

stress stress tensor

Returns: d2(stress_param[:])/d(stress)/d(stress)

Implements MultiParameterPlasticityStressUpdate.

Definition at line 86 of file CappedMohrCoulombStressUpdate.C.

 {
   std::vector<RankFourTensor> d2;
   stress.d2symmetricEigenvalues(d2);
   return d2;
 }

◆ 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 826 of file MultiParameterPlasticityStressUpdate.C.

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

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

◆ dsmoother()

Real MultiParameterPlasticityStressUpdate::dsmoother ( Real f_diff ) const

protectedinherited

Derivative of smoother.

Definition at line 531 of file MultiParameterPlasticityStressUpdate.C.

Referenced by MultiParameterPlasticityStressUpdate::smoothAllQuantities().

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

◆ dstress_param_dstress()

std::vector< RankTwoTensor > CappedMohrCoulombStressUpdate::dstress_param_dstress ( const RankTwoTensor & stress ) const

overrideprotectedvirtual

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

Parameters

stress stress tensor

Returns: d(stress_param[:])/d(stress)

Implements MultiParameterPlasticityStressUpdate.

Definition at line 77 of file CappedMohrCoulombStressUpdate.C.

Referenced by consistentTangentOperatorV().

 {
   std::vector<Real> sp;
   std::vector<RankTwoTensor> dsp;
   stress.dsymmetricEigenvalues(sp, dsp);
   return dsp;
 }

◆ 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 871 of file MultiParameterPlasticityStressUpdate.C.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

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

◆ 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 659 of file MultiParameterPlasticityStressUpdate.C.

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

 {
   throw MooseException(message);
 }

◆ 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, CappedWeakPlaneStressUpdate, and CappedWeakInclinedPlaneStressUpdate.

Definition at line 670 of file MultiParameterPlasticityStressUpdate.C.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

672 {

673 }

◆ 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, CappedWeakPlaneStressUpdate, and CappedWeakInclinedPlaneStressUpdate.

Definition at line 665 of file MultiParameterPlasticityStressUpdate.C.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

666 {

667 }

◆ 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 265 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 139 of file MultiParameterPlasticityStressUpdate.C.

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

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

◆ 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 482 of file MultiParameterPlasticityStressUpdate.C.

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

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

◆ 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 551 of file MultiParameterPlasticityStressUpdate.C.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

 {
   const Real res2_old = res2;
   const std::vector<Real> sp_params_old = stress_params;
   const Real gaE_old = gaE;
   const std::vector<Real> delta_nr_params = 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[i] + lam * delta_nr_params[i];
     gaE = gaE_old + lam * delta_nr_params[_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;
 }

◆ 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 635 of file MultiParameterPlasticityStressUpdate.C.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

 {
   std::vector<std::vector<Real>> dintnl(_num_intnl, std::vector<Real>(_num_sp));
   setIntnlDerivativesV(trial_stress_params, stress_params, intnl, dintnl);
 
   std::vector<double> jac((_num_sp + 1) * (_num_sp + 1));
   dnRHSdVar(smoothed_q, dintnl, stress_params, gaE, jac);
 
   // use LAPACK to solve the linear system
   const PetscBLASInt nrhs = 1;
   std::vector<PetscBLASInt> ipiv(_num_sp + 1);
   PetscBLASInt info;
   const PetscBLASInt gesv_num_rhs = _num_sp + 1;
   LAPACKgesv_(
       &gesv_num_rhs, &nrhs, &jac[0], &gesv_num_rhs, &ipiv[0], &rhs[0], &gesv_num_rhs, &info);
   return info;
 }

◆ 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 981 of file MultiParameterPlasticityStressUpdate.C.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

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

◆ 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 94 of file CappedMohrCoulombStressUpdate.C.

 {
   std::vector<Real> eigvals;
   stress_trial.symmetricEigenvaluesEigenvectors(eigvals, _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 150 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 PowerLawCreepStressUpdateTempl< is_ad >, and LAROMANCEStressUpdateBaseTempl< 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 247 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
	)		const

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 784 of file MultiParameterPlasticityStressUpdate.C.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

 {
   const std::vector<RankTwoTensor> dsp_dstress = dstress_param_dstress(returned_stress);
   inelastic_strain_increment = RankTwoTensor();
   for (unsigned i = 0; i < _num_sp; ++i)
     inelastic_strain_increment += smoothed_q.dg[i] * dsp_dstress[i];
   inelastic_strain_increment *= gaE / _En;
 }

◆ 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 759 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]);
   const std::vector<Real> dga_shear = {
       1.0 / (_Eij[2][2] - _Eij[0][2]), 0.0, -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[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;
   std::vector<Real> dshear_correction(_num_sp);
   for (std::size_t i = 0; i < _num_sp; ++i)
     dshear_correction[i] = prefactor * dga_shear[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[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 737 of file CappedMohrCoulombStressUpdate.C.

Referenced by initializeVarsV().

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

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

Referenced by ComputeCreepPlasticityStress::updateQpState().

 {
   _qp = qp;
 }

◆ 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 106 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 398 of file MultiParameterPlasticityStressUpdate.C.

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

 {
   std::vector<yieldAndFlow> all_q(_num_yf, yieldAndFlow(_num_sp, _num_intnl));
   computeAllQV(stress_params, intnl, all_q);
 
   /* 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.size(); ++a)
   {
     if (all_q[res_f].f >= all_q[a].f + _smoothing_tol)
       // no smoothing is needed: res_f is already indexes the largest yield function
       continue;
     else if (all_q[a].f >= all_q[res_f].f + _smoothing_tol)
     {
       // no smoothing is needed, and res_f needs to index to all_q[a]
       res_f = a;
       continue;
     }
     else
     {
       // smoothing is required
       const Real f_diff = all_q[res_f].f - all_q[a].f;
       const Real ism = ismoother(f_diff);
       const Real sm = smoother(f_diff);
       const Real dsm = dsmoother(f_diff);
       // we want: all_q[res_f].f = 0.5 * all_q[res_f].f + all_q[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[res_f].d2g[i][j] =
               0.5 * (all_q[res_f].d2g[i][j] + all_q[a].d2g[i][j]) +
               dsm * (all_q[res_f].df[j] - all_q[a].df[j]) * (all_q[res_f].dg[i] - all_q[a].dg[i]) +
               sm * (all_q[res_f].d2g[i][j] - all_q[a].d2g[i][j]);
         for (unsigned j = 0; j < _num_intnl; ++j)
           all_q[res_f].d2g_di[i][j] = 0.5 * (all_q[res_f].d2g_di[i][j] + all_q[a].d2g_di[i][j]) +
                                       dsm * (all_q[res_f].df_di[j] - all_q[a].df_di[j]) *
                                           (all_q[res_f].dg[i] - all_q[a].dg[i]) +
                                       sm * (all_q[res_f].d2g_di[i][j] - all_q[a].d2g_di[i][j]);
       }
       for (unsigned i = 0; i < _num_sp; ++i)
       {
         all_q[res_f].df[i] = 0.5 * (all_q[res_f].df[i] + all_q[a].df[i]) +
                              sm * (all_q[res_f].df[i] - all_q[a].df[i]);
         // whether the following (smoothing g with f's smoother) is a good strategy remains to be
         // seen...
         all_q[res_f].dg[i] = 0.5 * (all_q[res_f].dg[i] + all_q[a].dg[i]) +
                              sm * (all_q[res_f].dg[i] - all_q[a].dg[i]);
       }
       for (unsigned i = 0; i < _num_intnl; ++i)
         all_q[res_f].df_di[i] = 0.5 * (all_q[res_f].df_di[i] + all_q[a].df_di[i]) +
                                 sm * (all_q[res_f].df_di[i] - all_q[a].df_di[i]);
       all_q[res_f].f = 0.5 * (all_q[res_f].f + all_q[a].f + _smoothing_tol) + ism;
     }
   }
   return all_q[res_f];
 }

◆ smoother()

Real MultiParameterPlasticityStressUpdate::smoother ( Real f_diff ) const

protectedinherited

Derivative of ismoother.

Definition at line 508 of file MultiParameterPlasticityStressUpdate.C.

Referenced by MultiParameterPlasticityStressUpdate::smoothAllQuantities().

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

◆ 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 167 of file StressUpdateBase.h.

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, PowerLawCreepStressUpdateTempl< is_ad >, and LAROMANCEStressUpdateBaseTempl< 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/3]

template<bool is_ad, typename R2 , typename R4 >

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

virtualinherited

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

Definition at line 68 of file StressUpdateBase.C.

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

◆ updateState() [2/3]

void StressUpdateBaseTempl< is_ad, R2, R4 >::updateState

protectedinherited

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

Definition at line 68 of file StressUpdateBase.C.

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

◆ updateState() [3/3]

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 158 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;
 
   // current values of the yield function, derivatives, etc
   yieldAndFlow smoothed_q;
 
   // 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->template 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.

Referenced by CappedMohrCoulombCosseratStressUpdate::validParams().

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

◆ 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 686 of file MultiParameterPlasticityStressUpdate.C.

Referenced by MultiParameterPlasticityStressUpdate::updateState().

 {
   std::vector<Real> yfs(_num_yf);
   yieldFunctionValuesV(stress_params, intnl, yfs);
   return yieldF(yfs);
 }

◆ 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 695 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 121 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

◆ _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(), TensileStressUpdate::setEffectiveElasticity(), 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

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

◆ _dt

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

Real & Material::_dt

inherited

◆ _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(), TensileStressUpdate::setEffectiveElasticity(), setEffectiveElasticity(), TwoParameterPlasticityStressUpdate::setEffectiveElasticity(), TensileStressUpdate::setIntnlDerivativesV(), setIntnlDerivativesV(), TensileStressUpdate::setIntnlValuesV(), and 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(), TensileStressUpdate::setEffectiveElasticity(), 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 = RankTwoTensor, typename R4 = RankFourTensor>

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

staticprotectedinherited

Initial value:

=

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

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

◆ _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 TensileStressUpdate::computeAllQV(), computeAllQV(), MultiParameterPlasticityStressUpdate::initQpStatefulProperties(), MultiParameterPlasticityStressUpdate::smoothAllQuantities(), MultiParameterPlasticityStressUpdate::updateState(), and MultiParameterPlasticityStressUpdate::yieldF().

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

◆ _qp

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

unsigned int Material::_qp

inherited

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

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

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

◆ _tensile_strength

const SolidMechanicsHardeningModel& CappedMohrCoulombStressUpdate::_tensile_strength

protected

Hardening model for tensile strength.

Definition at line 31 of file CappedMohrCoulombStressUpdate.h.

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

◆ _tensor_dimensionality

constexpr unsigned MultiParameterPlasticityStressUpdate::_tensor_dimensionality = 3

staticprotectedinherited

Internal dimensionality of tensors (currently this is 3 throughout tensor_mechanics)

Definition at line 125 of file MultiParameterPlasticityStressUpdate.h.

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

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

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

Detailed Description

Member Typedef Documentation

◆ GR2

◆ GR4

◆ GSR2

◆ GSR4

Constructor & Destructor Documentation

◆ CappedMohrCoulombStressUpdate()

Member Function Documentation

◆ calculateNumberSubsteps()

◆ calculateRes2()

◆ calculateRHS()

◆ computeAllQV()

◆ computeStrainEnergyRateDensity()

◆ computeStressParams()

◆ computeTimeStepLimit()

◆ consistentTangentOperatorV()

◆ d2stress_param_dstress()

◆ dnRHSdVar()

◆ dsmoother()

◆ dstress_param_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/3]

◆ updateState() [2/3]

◆ updateState() [3/3]

◆ updateStateSubstep()

◆ validParams()

◆ yieldF() [1/2]

◆ yieldF() [2/2]

◆ yieldFunctionValuesV()

Member Data Documentation

◆ _base_name

◆ _Cij

◆ _cohesion

◆ _compressive_strength

◆ _current_elem

◆ _definitely_ok_sp

◆ _dt

◆ _eigvecs

◆ _Eij

◆ _En

◆ _f_tol

◆ _f_tol2