ComputeSmearedCrackingStress computes the stress for a finite strain material with smeared cracking. More...

#include <ComputeSmearedCrackingStress.h>

Inheritance diagram for ComputeSmearedCrackingStress:

Public Member Functions
	ComputeSmearedCrackingStress (const InputParameters &parameters)

virtual void	initialSetup () override

virtual void	initQpStatefulProperties () override

virtual void	computeQpStress () override
	Compute the stress and store it in the _stress material property for the current quadrature point. More...

Static Public Member Functions
static InputParameters	validParams ()

Protected Types
enum	CrackingRelease { CrackingRelease::abrupt, CrackingRelease::exponential, CrackingRelease::power }
	Enum defining the crack release model. More...

enum	TangentOperatorEnum { TangentOperatorEnum::elastic, TangentOperatorEnum::nonlinear }
	what sort of Tangent operator to calculate More...

Protected Member Functions
void	updateLocalElasticityTensor ()
	Update the local elasticity tensor (_local_elasticity_tensor) due to the effects of cracking. More...

virtual void	updateCrackingStateAndStress ()
	Update all cracking-related state variables and the stress tensor due to cracking in all directions. More...

virtual void	computeCrackingRelease (int i, Real &sigma, Real &stiffness_ratio, const Real strain_in_crack_dir, const Real cracking_stress, const Real cracking_alpha, const Real youngs_modulus)
	Compute the effect of the cracking release model on the stress and stiffness in the direction of a single crack. More...

virtual unsigned int	getNumKnownCrackDirs () const
	Get the number of known crack directions. More...

void	computeCrackStrainAndOrientation (RealVectorValue &strain_in_crack_dir)
	Compute the crack strain in the crack coordinate system. More...

void	updateStressTensorForCracking (RankTwoTensor &tensor, const RealVectorValue &sigma)
	Updates the full stress tensor to account for the effect of cracking using the provided stresses in the crack directions. More...

bool	previouslyCracked ()
	Check to see whether there was cracking in any diretion in the previous time step. More...

virtual void	computeQpStressIntermediateConfiguration ()
	Compute the stress for the current QP, but do not rotate tensors from the intermediate configuration to the new configuration. More...

virtual void	finiteStrainRotation (const bool force_elasticity_rotation=false)
	Rotate _elastic_strain, _stress, _inelastic_strain, and _Jacobian_mult to the new configuration. More...

virtual void	updateQpState (RankTwoTensor &elastic_strain_increment, RankTwoTensor &combined_inelastic_strain_increment)
	Given the _strain_increment[_qp], iterate over all of the user-specified recompute materials in order to find an admissible stress (which is placed into _stress[_qp]) and set of inelastic strains, as well as the tangent operator (which is placed into _Jacobian_mult[_qp]). More...

virtual void	updateQpStateSingleModel (unsigned model_number, RankTwoTensor &elastic_strain_increment, RankTwoTensor &combined_inelastic_strain_increment)
	An optimised version of updateQpState that gets used when the number of plastic models is unity, or when we're cycling through models Given the _strain_increment[_qp], find an admissible stress (which is put into _stress[_qp]) and inelastic strain, as well as the tangent operator (which is placed into _Jacobian_mult[_qp]) More...

virtual void	computeQpJacobianMult ()
	Using _elasticity_tensor[_qp] and the consistent tangent operators, _consistent_tangent_operator[...] computed by the inelastic models, compute _Jacobian_mult[_qp]. More...

virtual void	computeAdmissibleState (unsigned model_number, RankTwoTensor &elastic_strain_increment, RankTwoTensor &inelastic_strain_increment, RankFourTensor &consistent_tangent_operator)
	Given a trial stress (_stress[_qp]) and a strain increment (elastic_strain_increment) let the model_number model produce an admissible stress (gets placed back in _stress[_qp]), and decompose the strain increment into an elastic part (gets placed back into elastic_strain_increment) and an inelastic part (inelastic_strain_increment), as well as computing the consistent_tangent_operator. More...

virtual void	computeQpProperties () override

bool	hasGuaranteedMaterialProperty (const MaterialPropertyName &prop, Guarantee guarantee)

Protected Attributes
enum ComputeSmearedCrackingStress::CrackingRelease	_cracking_release

MaterialProperty< RealVectorValue > &	_crack_damage

const MaterialProperty< RealVectorValue > &	_crack_damage_old

MaterialProperty< RealVectorValue > &	_crack_flags
	Vector of values going from 1 to 0 as crack damage accumulates. More...

MaterialProperty< RankTwoTensor > &	_crack_rotation

const MaterialProperty< RankTwoTensor > &	_crack_rotation_old

MaterialProperty< RealVectorValue > &	_crack_initiation_strain

const MaterialProperty< RealVectorValue > &	_crack_initiation_strain_old

MaterialProperty< RealVectorValue > &	_crack_max_strain

const MaterialProperty< RealVectorValue > &	_crack_max_strain_old

RankFourTensor	_local_elasticity_tensor

std::vector< SmearedCrackSofteningBase * >	_softening_models
	The user-supplied list of softening models to be used in the 3 crack directions. More...

const bool	_perform_finite_strain_rotations
	after updateQpState, rotate the stress, elastic_strain, inelastic_strain and Jacobian_mult using _rotation_increment More...

MaterialProperty< RankTwoTensor > &	_inelastic_strain
	The sum of the inelastic strains that come from the plastic models. More...

const MaterialProperty< RankTwoTensor > &	_inelastic_strain_old
	old value of inelastic strain More...

enum ComputeMultipleInelasticStress::TangentOperatorEnum	_tangent_operator_type

const unsigned	_num_models
	number of plastic models More...

std::vector< bool >	_tangent_computation_flag
	Flags to compute tangent during updateState call. More...

TangentCalculationMethod	_tangent_calculation_method
	Calculation method for the tangent modulus. More...

const std::vector< Real >	_inelastic_weights
	_inelastic_strain = sum_i (_inelastic_weights_i * inelastic_strain_from_model_i) More...

std::vector< RankFourTensor >	_consistent_tangent_operator
	the consistent tangent operators computed by each plastic model More...

const bool	_cycle_models
	whether to cycle through the models, using only one model per timestep More...

MaterialProperty< Real > &	_matl_timestep_limit

const RankFourTensor	_identity_symmetric_four
	Rank four symmetric identity tensor. More...

std::vector< StressUpdateBase * >	_models
	The user supplied list of inelastic models to use in the simulation. More...

bool	_is_elasticity_tensor_guaranteed_isotropic
	is the elasticity tensor guaranteed to be isotropic? More...

bool	_all_models_isotropic
	are all inelastic models inherently isotropic? (not the case for e.g. weak plane plasticity models) More...

DamageBase *	_damage_model
	Pointer to the damage model. More...

RankTwoTensor	_undamaged_stress_old

const std::string	_elasticity_tensor_name
	Name of the elasticity tensor material property. More...

const MaterialProperty< RankFourTensor > &	_elasticity_tensor
	Elasticity tensor material property. More...

const MaterialProperty< RankTwoTensor > &	_rotation_increment
	Rotation increment material property. More...

const MaterialProperty< RankTwoTensor > &	_stress_old
	Old state of the stress tensor material property. More...

const std::string	_base_name
	Base name prepended to all material property names to allow for multi-material systems. More...

const MaterialProperty< RankTwoTensor > &	_mechanical_strain
	Mechanical strain material property. More...

MaterialProperty< RankTwoTensor > &	_stress
	Stress material property. More...

MaterialProperty< RankTwoTensor > &	_elastic_strain
	Elastic strain material property. More...

const MaterialProperty< RankTwoTensor > &	_extra_stress
	Extra stress tensor. More...

std::vector< const Function * >	_initial_stress_fcn
	initial stress components More...

MaterialProperty< RankFourTensor > &	_Jacobian_mult
	derivative of stress w.r.t. strain (_dstress_dstrain) More...


const Real	_cracking_residual_stress
	Input parameters for smeared crack models. More...

const VariableValue &	_cracking_stress
	Threshold at which cracking initiates if tensile stress exceeds it. More...

std::vector< unsigned int >	_prescribed_crack_directions
	User-prescribed cracking directions. More...

const unsigned int	_max_cracks
	Maximum number of cracks permitted at a material point. More...

const Real	_cracking_neg_fraction
	Defines transition to changed stiffness during unloading. More...

const Real	_cracking_beta
	Controls slope of exponential softening curve. More...

const Real	_shear_retention_factor
	Controls the amount of shear retained. More...

const Real	_max_stress_correction
	Controls the maximum amount that the damaged elastic stress is corrected to folow the release model during a time step. More...


const unsigned int	_max_iterations
	Input parameters associated with the recompute iteration to return the stress state to the yield surface. More...

const Real	_relative_tolerance

const Real	_absolute_tolerance

const bool	_internal_solve_full_iteration_history


const MaterialProperty< RankTwoTensor > &	_elastic_strain_old
	Strain tensors. More...

const MaterialProperty< RankTwoTensor > &	_strain_increment

Private Attributes
const InputParameters &	_gc_params
	Parameters of the object with this interface. More...

FEProblemBase *const	_gc_feproblem
	Reference to the FEProblemBase class. More...

BlockRestrictable *const	_gc_block_restrict
	Access block restrictions of the object with this interface. More...

Detailed Description

ComputeSmearedCrackingStress computes the stress for a finite strain material with smeared cracking.

Definition at line 26 of file ComputeSmearedCrackingStress.h.

Member Enumeration Documentation

◆ CrackingRelease

enum ComputeSmearedCrackingStress::CrackingRelease

strongprotected

Enum defining the crack release model.

Enumerator
abrupt
exponential
power

Definition at line 102 of file ComputeSmearedCrackingStress.h.

102 { abrupt, exponential, power } _cracking_release;

◆ TangentOperatorEnum

enum ComputeMultipleInelasticStress::TangentOperatorEnum

strongprotectedinherited

what sort of Tangent operator to calculate

Enumerator
elastic
nonlinear

Definition at line 143 of file ComputeMultipleInelasticStress.h.

143 { elastic, nonlinear } _tangent_operator_type;

Constructor & Destructor Documentation

◆ ComputeSmearedCrackingStress()

ComputeSmearedCrackingStress::ComputeSmearedCrackingStress ( const InputParameters & parameters )

Definition at line 84 of file ComputeSmearedCrackingStress.C.

   : ComputeMultipleInelasticStress(parameters),
     _cracking_release(getParam<MooseEnum>("cracking_release").getEnum<CrackingRelease>()),
     _cracking_residual_stress(getParam<Real>("cracking_residual_stress")),
     _cracking_stress(coupledValue("cracking_stress")),
     _max_cracks(getParam<unsigned int>("max_cracks")),
     _cracking_neg_fraction(getParam<Real>("cracking_neg_fraction")),
     _cracking_beta(getParam<Real>("cracking_beta")),
     _shear_retention_factor(getParam<Real>("shear_retention_factor")),
     _max_stress_correction(getParam<Real>("max_stress_correction")),
     _crack_damage(declareProperty<RealVectorValue>(_base_name + "crack_damage")),
     _crack_damage_old(getMaterialPropertyOld<RealVectorValue>(_base_name + "crack_damage")),
     _crack_flags(declareProperty<RealVectorValue>(_base_name + "crack_flags")),
     _crack_rotation(declareProperty<RankTwoTensor>(_base_name + "crack_rotation")),
     _crack_rotation_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + "crack_rotation")),
     _crack_initiation_strain(
         declareProperty<RealVectorValue>(_base_name + "crack_initiation_strain")),
     _crack_initiation_strain_old(
         getMaterialPropertyOld<RealVectorValue>(_base_name + "crack_initiation_strain")),
     _crack_max_strain(declareProperty<RealVectorValue>(_base_name + "crack_max_strain")),
     _crack_max_strain_old(getMaterialPropertyOld<RealVectorValue>(_base_name + "crack_max_strain"))
 {
   MultiMooseEnum prescribed_crack_directions =
       getParam<MultiMooseEnum>("prescribed_crack_directions");
   if (prescribed_crack_directions.size() > 0)
   {
     if (prescribed_crack_directions.size() > 3)
       mooseError("A maximum of three crack directions may be specified");
     for (unsigned int i = 0; i < prescribed_crack_directions.size(); ++i)
     {
       for (unsigned int j = 0; j < i; ++j)
         if (prescribed_crack_directions[i] == prescribed_crack_directions[j])
           mooseError("Entries in 'prescribed_crack_directions' cannot be repeated");
       _prescribed_crack_directions.push_back(
           static_cast<unsigned int>(prescribed_crack_directions.get(i)));
     }
  
     // Fill in the last remaining direction if 2 are specified
     if (_prescribed_crack_directions.size() == 2)
     {
       std::set<unsigned int> available_dirs = {0, 1, 2};
       for (auto dir : _prescribed_crack_directions)
         if (available_dirs.erase(dir) != 1)
           mooseError("Invalid prescribed crack direction:" + Moose::stringify(dir));
       if (available_dirs.size() != 1)
         mooseError("Error in finding remaining available crack direction");
       _prescribed_crack_directions.push_back(*available_dirs.begin());
     }
   }
  
   if (parameters.isParamSetByUser("softening_models"))
   {
     if (parameters.isParamSetByUser("cracking_release"))
       mooseError("In ComputeSmearedCrackingStress cannot specify both 'cracking_release' and "
                  "'softening_models'");
     if (parameters.isParamSetByUser("cracking_residual_stress"))
       mooseError("In ComputeSmearedCrackingStress cannot specify both 'cracking_residual_stress' "
                  "and 'softening_models'");
     if (parameters.isParamSetByUser("cracking_beta"))
       mooseError("In ComputeSmearedCrackingStress cannot specify both 'cracking_beta' and "
                  "'softening_models'");
   }
 }

Member Function Documentation

◆ computeAdmissibleState()

void ComputeMultipleInelasticStress::computeAdmissibleState	(	unsigned	model_number,
		RankTwoTensor &	elastic_strain_increment,
		RankTwoTensor &	inelastic_strain_increment,
		RankFourTensor &	consistent_tangent_operator
	)

protectedvirtualinherited

Given a trial stress (_stress[_qp]) and a strain increment (elastic_strain_increment) let the model_number model produce an admissible stress (gets placed back in _stress[_qp]), and decompose the strain increment into an elastic part (gets placed back into elastic_strain_increment) and an inelastic part (inelastic_strain_increment), as well as computing the consistent_tangent_operator.

Parameters

model_number	The inelastic model to use
elastic_strain_increment	Upon input, this is the strain increment. Upon output, it is the elastic part of the strain increment
inelastic_strain_increment	The inelastic strain increment corresponding to the supplied strain increment
consistent_tangent_operator	The consistent tangent operator

Reimplemented in ComputeMultipleInelasticCosseratStress.

Definition at line 466 of file ComputeMultipleInelasticStress.C.

 {
   const bool jac = _fe_problem.currentlyComputingJacobian();
   if (_damage_model)
     _models[model_number]->updateState(elastic_strain_increment,
                                        inelastic_strain_increment,
                                        _rotation_increment[_qp],
                                        _stress[_qp],
                                        _undamaged_stress_old,
                                        _elasticity_tensor[_qp],
                                        _elastic_strain_old[_qp],
                                        (jac && _tangent_computation_flag[model_number]),
                                        consistent_tangent_operator);
   else
     _models[model_number]->updateState(elastic_strain_increment,
                                        inelastic_strain_increment,
                                        _rotation_increment[_qp],
                                        _stress[_qp],
                                        _stress_old[_qp],
                                        _elasticity_tensor[_qp],
                                        _elastic_strain_old[_qp],
                                        (jac && _tangent_computation_flag[model_number]),
                                        consistent_tangent_operator);
  
   if (jac && !_tangent_computation_flag[model_number])
   {
     if (_tangent_calculation_method == TangentCalculationMethod::PARTIAL)
       consistent_tangent_operator.zero();
     else
       consistent_tangent_operator = _elasticity_tensor[_qp];
   }
 }

Referenced by ComputeMultipleInelasticCosseratStress::computeAdmissibleState(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStress::updateQpStateSingleModel().

◆ computeCrackingRelease()

void ComputeSmearedCrackingStress::computeCrackingRelease	(	int	i,
		Real &	sigma,
		Real &	stiffness_ratio,
		const Real	strain_in_crack_dir,
		const Real	cracking_stress,
		const Real	cracking_alpha,
		const Real	youngs_modulus
	)

protectedvirtual

Compute the effect of the cracking release model on the stress and stiffness in the direction of a single crack.

Parameters

i	Index of current crack direction
sigma	Stress in direction of crack
stiffness_ratio	Ratio of damaged to original stiffness in cracking direction
strain_in_crack_dir	Strain in the current crack direction
cracking_stress	Threshold tensile stress for crack initiation
cracking_alpha	Initial slope of exponential softening model
youngs_modulus	Young's modulus

Definition at line 586 of file ComputeSmearedCrackingStress.C.

 {
   switch (_cracking_release)
   {
     case CrackingRelease::power:
     {
       if (sigma > cracking_stress)
       {
         stiffness_ratio /= 3.0;
         sigma = stiffness_ratio * youngs_modulus * strain_in_crack_dir;
       }
       break;
     }
     case CrackingRelease::exponential:
     {
       const Real crack_max_strain = _crack_max_strain[_qp](i);
       mooseAssert(crack_max_strain >= _crack_initiation_strain[_qp](i),
                   "crack_max_strain must be >= crack_initiation_strain");
  
       // Compute stress that follows exponental curve
       sigma =
           cracking_stress * (_cracking_residual_stress +
                              (1.0 - _cracking_residual_stress) *
                                  std::exp(cracking_alpha * _cracking_beta / cracking_stress *
                                           (crack_max_strain - _crack_initiation_strain[_qp](i))));
       // Compute ratio of current stiffness to original stiffness
       stiffness_ratio =
           sigma * _crack_initiation_strain[_qp](i) / (crack_max_strain * cracking_stress);
       break;
     }
     case CrackingRelease::abrupt:
     {
       if (_cracking_residual_stress == 0)
       {
         const Real tiny = 1e-16;
         stiffness_ratio = tiny;
         sigma = tiny * _crack_initiation_strain[_qp](i) * youngs_modulus;
       }
       else
       {
         sigma = _cracking_residual_stress * cracking_stress;
         stiffness_ratio = sigma / (_crack_max_strain[_qp](i) * youngs_modulus);
       }
       break;
     }
   }
  
   if (stiffness_ratio < 0)
   {
     std::stringstream err;
     err << "Negative stiffness ratio: " << i << " " << stiffness_ratio << ", "
         << _crack_max_strain[_qp](i) << ", " << _crack_initiation_strain[_qp](i) << ", "
         << std::endl;
     mooseError(err.str());
   }
 }

Referenced by updateCrackingStateAndStress().

◆ computeCrackStrainAndOrientation()

void ComputeSmearedCrackingStress::computeCrackStrainAndOrientation ( RealVectorValue & strain_in_crack_dir )

protected

Compute the crack strain in the crack coordinate system.

Also computes the crack orientations, and stores in _crack_rotation.

Parameters

strain_in_crack_dir Computed strains in crack directions

Definition at line 495 of file ComputeSmearedCrackingStress.C.

 {
   // The rotation tensor is ordered such that directions for pre-existing cracks appear first
   // in the list of columns.  For example, if there is one existing crack, its direction is in the
   // first column in the rotation tensor.
   const unsigned int num_known_dirs = getNumKnownCrackDirs();
  
   if (num_known_dirs == 0)
   {
     std::vector<Real> eigval(3, 0.0);
     RankTwoTensor eigvec;
  
     _elastic_strain[_qp].symmetricEigenvaluesEigenvectors(eigval, eigvec);
  
     // If the elastic strain is beyond the cracking strain, save the eigen vectors as
     // the rotation tensor. Reverse their order so that the third principal strain
     // (most tensile) will correspond to the first crack.
     _crack_rotation[_qp].fillColumn(0, eigvec.column(2));
     _crack_rotation[_qp].fillColumn(1, eigvec.column(1));
     _crack_rotation[_qp].fillColumn(2, eigvec.column(0));
  
     strain_in_crack_dir(0) = eigval[2];
     strain_in_crack_dir(1) = eigval[1];
     strain_in_crack_dir(2) = eigval[0];
   }
   else if (num_known_dirs == 1)
   {
     // This is easily the most complicated case.
     // 1.  Rotate the elastic strain to the orientation associated with the known
     //     crack.
     // 2.  Extract the lower 2x2 block into a separate tensor.
     // 3.  Run the eigen solver on the result.
     // 4.  Update the rotation tensor to reflect the effect of the 2 eigenvectors.
  
     // 1.
     const RankTwoTensor & R = _crack_rotation[_qp];
     RankTwoTensor ePrime(_elastic_strain[_qp]);
     ePrime.rotate(R.transpose()); // elastic strain in crack coordinates
  
     // 2.
     ColumnMajorMatrix e2x2(2, 2);
     e2x2(0, 0) = ePrime(1, 1);
     e2x2(1, 0) = ePrime(2, 1);
     e2x2(0, 1) = ePrime(1, 2);
     e2x2(1, 1) = ePrime(2, 2);
  
     // 3.
     ColumnMajorMatrix e_val2x1(2, 1);
     ColumnMajorMatrix e_vec2x2(2, 2);
     e2x2.eigen(e_val2x1, e_vec2x2);
  
     // 4.
     RankTwoTensor eigvec(
         1.0, 0.0, 0.0, 0.0, e_vec2x2(0, 1), e_vec2x2(1, 1), 0.0, e_vec2x2(0, 0), e_vec2x2(1, 0));
  
     _crack_rotation[_qp] = _crack_rotation_old[_qp] * eigvec; // Roe implementation
  
     strain_in_crack_dir(0) = ePrime(0, 0);
     strain_in_crack_dir(1) = e_val2x1(1, 0);
     strain_in_crack_dir(2) = e_val2x1(0, 0);
   }
   else if (num_known_dirs == 2 || num_known_dirs == 3)
   {
     // Rotate to cracked orientation and pick off the strains in the rotated
     // coordinate directions.
     const RankTwoTensor & R = _crack_rotation[_qp];
     RankTwoTensor ePrime(_elastic_strain[_qp]);
     ePrime.rotate(R.transpose()); // elastic strain in crack coordinates
  
     strain_in_crack_dir(0) = ePrime(0, 0);
     strain_in_crack_dir(1) = ePrime(1, 1);
     strain_in_crack_dir(2) = ePrime(2, 2);
   }
   else
     mooseError("Invalid number of known crack directions");
 }

Referenced by updateCrackingStateAndStress().

◆ computeQpJacobianMult()

void ComputeMultipleInelasticStress::computeQpJacobianMult ( )

protectedvirtualinherited

Using _elasticity_tensor[_qp] and the consistent tangent operators, _consistent_tangent_operator[...] computed by the inelastic models, compute _Jacobian_mult[_qp].

Reimplemented in ComputeMultipleInelasticCosseratStress.

Definition at line 393 of file ComputeMultipleInelasticStress.C.

 {
   if (_tangent_calculation_method == TangentCalculationMethod::ELASTIC)
     _Jacobian_mult[_qp] = _elasticity_tensor[_qp];
   else if (_tangent_calculation_method == TangentCalculationMethod::PARTIAL)
   {
     RankFourTensor A = _identity_symmetric_four;
     for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
       A += _consistent_tangent_operator[i_rmm];
     mooseAssert(A.isSymmetric(), "Tangent operator isn't symmetric");
     _Jacobian_mult[_qp] = A.invSymm() * _elasticity_tensor[_qp];
   }
   else
   {
     const RankFourTensor E_inv = _elasticity_tensor[_qp].invSymm();
     _Jacobian_mult[_qp] = _consistent_tangent_operator[0];
     for (unsigned i_rmm = 1; i_rmm < _num_models; ++i_rmm)
       _Jacobian_mult[_qp] = _consistent_tangent_operator[i_rmm] * E_inv * _Jacobian_mult[_qp];
   }
 }

Referenced by ComputeMultipleInelasticStress::updateQpState().

◆ computeQpProperties()

void ComputeStressBase::computeQpProperties ( )

overrideprotectedvirtualinherited

Definition at line 50 of file ComputeStressBase.C.

 {
   computeQpStress();
  
   // Add in extra stress
   _stress[_qp] += _extra_stress[_qp];
 }

◆ computeQpStress()

void ComputeSmearedCrackingStress::computeQpStress ( )

overridevirtual

Compute the stress and store it in the _stress material property for the current quadrature point.

Reimplemented from ComputeMultipleInelasticStress.

Definition at line 246 of file ComputeSmearedCrackingStress.C.

 {
   bool force_elasticity_rotation = false;
  
   if (!previouslyCracked())
     computeQpStressIntermediateConfiguration();
   else
   {
     _elastic_strain[_qp] = _elastic_strain_old[_qp] + _strain_increment[_qp];
  
     // Propagate behavior from the (now inactive) inelastic models
     _inelastic_strain[_qp] = _inelastic_strain_old[_qp];
     for (auto model : _models)
     {
       model->setQp(_qp);
       model->propagateQpStatefulProperties();
     }
  
     // Since the other inelastic models are inactive, they will not limit the time step
     _matl_timestep_limit[_qp] = std::numeric_limits<Real>::max();
  
     // update _local_elasticity_tensor based on cracking state in previous time step
     updateLocalElasticityTensor();
  
     // Calculate stress in intermediate configuration
     _stress[_qp] = _local_elasticity_tensor * _elastic_strain[_qp];
  
     _Jacobian_mult[_qp] = _local_elasticity_tensor;
     force_elasticity_rotation = true;
   }
  
   // compute crack status and adjust stress
   updateCrackingStateAndStress();
  
   if (_perform_finite_strain_rotations)
   {
     finiteStrainRotation(force_elasticity_rotation);
     _crack_rotation[_qp] = _rotation_increment[_qp] * _crack_rotation[_qp];
   }
 }

◆ computeQpStressIntermediateConfiguration()

void ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration ( )

protectedvirtualinherited

Compute the stress for the current QP, but do not rotate tensors from the intermediate configuration to the new configuration.

Definition at line 215 of file ComputeMultipleInelasticStress.C.

 {
   RankTwoTensor elastic_strain_increment;
   RankTwoTensor combined_inelastic_strain_increment;
  
   if (_num_models == 0)
   {
     _elastic_strain[_qp] = _elastic_strain_old[_qp] + _strain_increment[_qp];
  
     // If the elasticity tensor values have changed and the tensor is isotropic,
     // use the old strain to calculate the old stress
     if (_is_elasticity_tensor_guaranteed_isotropic || !_perform_finite_strain_rotations)
       _stress[_qp] = _elasticity_tensor[_qp] * (_elastic_strain_old[_qp] + _strain_increment[_qp]);
     else
     {
       if (_damage_model)
         _stress[_qp] = _undamaged_stress_old + _elasticity_tensor[_qp] * _strain_increment[_qp];
       else
         _stress[_qp] = _stress_old[_qp] + _elasticity_tensor[_qp] * _strain_increment[_qp];
     }
     if (_fe_problem.currentlyComputingJacobian())
       _Jacobian_mult[_qp] = _elasticity_tensor[_qp];
  
     _matl_timestep_limit[_qp] = std::numeric_limits<Real>::max();
   }
   else
   {
     if (_num_models == 1 || _cycle_models)
       updateQpStateSingleModel((_t_step - 1) % _num_models,
                                elastic_strain_increment,
                                combined_inelastic_strain_increment);
     else
       updateQpState(elastic_strain_increment, combined_inelastic_strain_increment);
  
     _elastic_strain[_qp] = _elastic_strain_old[_qp] + elastic_strain_increment;
     _inelastic_strain[_qp] = _inelastic_strain_old[_qp] + combined_inelastic_strain_increment;
   }
 }

Referenced by computeQpStress(), and ComputeMultipleInelasticStress::computeQpStress().

◆ finiteStrainRotation()

void ComputeMultipleInelasticStress::finiteStrainRotation ( const bool force_elasticity_rotation = false )

protectedvirtualinherited

Rotate _elastic_strain, _stress, _inelastic_strain, and _Jacobian_mult to the new configuration.

Parameters

force_elasticity_rotation Force the elasticity tensor to be rotated, even if it is not deemed necessary.

Definition at line 255 of file ComputeMultipleInelasticStress.C.

 {
   _elastic_strain[_qp] =
       _rotation_increment[_qp] * _elastic_strain[_qp] * _rotation_increment[_qp].transpose();
   _stress[_qp] = _rotation_increment[_qp] * _stress[_qp] * _rotation_increment[_qp].transpose();
   _inelastic_strain[_qp] =
       _rotation_increment[_qp] * _inelastic_strain[_qp] * _rotation_increment[_qp].transpose();
  
   if (force_elasticity_rotation ||
       !(_is_elasticity_tensor_guaranteed_isotropic &&
         (_all_models_isotropic ||
          _tangent_calculation_method == TangentCalculationMethod::ELASTIC || _num_models == 0)))
     _Jacobian_mult[_qp].rotate(_rotation_increment[_qp]);
 }

Referenced by computeQpStress(), and ComputeMultipleInelasticStress::computeQpStress().

◆ getNumKnownCrackDirs()

unsigned int ComputeSmearedCrackingStress::getNumKnownCrackDirs ( ) const

protectedvirtual

Get the number of known crack directions.

This includes cracks in prescribed directions (even if not yet active) and active cracks in other directions.

Returns: number of known crack directions

Definition at line 574 of file ComputeSmearedCrackingStress.C.

 {
   unsigned int num_known_dirs = 0;
   for (unsigned int i = 0; i < 3; ++i)
   {
     if (_crack_damage_old[_qp](i) > 0.0 || _prescribed_crack_directions.size() >= i + 1)
       ++num_known_dirs;
   }
   return num_known_dirs;
 }

Referenced by computeCrackStrainAndOrientation().

◆ hasGuaranteedMaterialProperty()

bool GuaranteeConsumer::hasGuaranteedMaterialProperty	(	const MaterialPropertyName &	prop,
		Guarantee	guarantee
	)

protectedinherited

Definition at line 28 of file GuaranteeConsumer.C.

 {
   if (!_gc_feproblem->startedInitialSetup())
     mooseError("hasGuaranteedMaterialProperty() needs to be called in initialSetup()");
  
   // Reference to MaterialWarehouse for testing and retrieving block ids
   const auto & warehouse = _gc_feproblem->getMaterialWarehouse();
  
   // Complete set of ids that this object is active
   const auto & ids = (_gc_block_restrict && _gc_block_restrict->blockRestricted())
                          ? _gc_block_restrict->blockIDs()
                          : _gc_feproblem->mesh().meshSubdomains();
  
   // Loop over each id for this object
   for (const auto & id : ids)
   {
     // If block materials exist, look if any issue the required guarantee
     if (warehouse.hasActiveBlockObjects(id))
     {
       const std::vector<std::shared_ptr<MaterialBase>> & mats = warehouse.getActiveBlockObjects(id);
       for (const auto & mat : mats)
       {
         const auto & mat_props = mat->getSuppliedItems();
         if (mat_props.count(prop_name))
         {
           auto guarantee_mat = dynamic_cast<GuaranteeProvider *>(mat.get());
           if (guarantee_mat && !guarantee_mat->hasGuarantee(prop_name, guarantee))
           {
             // we found at least one material on the set of block we operate on
             // that does _not_ provide the requested guarantee
             return false;
           }
         }
       }
     }
   }
  
   return true;
 }

Referenced by ComputeFiniteStrainElasticStress::initialSetup(), initialSetup(), ComputeLinearElasticPFFractureStress::initialSetup(), CriticalTimeStep::initialSetup(), and ComputeMultipleInelasticStress::initialSetup().

◆ initialSetup()

void ComputeSmearedCrackingStress::initialSetup ( )

overridevirtual

Reimplemented from ComputeMultipleInelasticStress.

Definition at line 212 of file ComputeSmearedCrackingStress.C.

 {
   ComputeMultipleInelasticStress::initialSetup();
  
   if (!hasGuaranteedMaterialProperty(_elasticity_tensor_name, Guarantee::ISOTROPIC))
     mooseError("ComputeSmearedCrackingStress requires that the elasticity tensor be "
                "guaranteed isotropic");
  
   std::vector<MaterialName> soft_matls = getParam<std::vector<MaterialName>>("softening_models");
   if (soft_matls.size() != 0)
   {
     for (auto soft_matl : soft_matls)
     {
       SmearedCrackSofteningBase * scsb =
           dynamic_cast<SmearedCrackSofteningBase *>(&getMaterialByName(soft_matl));
       if (scsb)
         _softening_models.push_back(scsb);
       else
         mooseError("Model " + soft_matl +
                    " is not a softening model that can be used with ComputeSmearedCrackingStress");
     }
     if (_softening_models.size() == 1)
     {
       // Reuse the same model in all 3 directions
       _softening_models.push_back(_softening_models[0]);
       _softening_models.push_back(_softening_models[0]);
     }
     else if (_softening_models.size() != 3)
       mooseError("If 'softening_models' is specified in ComputeSmearedCrackingStress, either 1 or "
                  "3 models must be provided");
   }
 }

◆ initQpStatefulProperties()

void ComputeSmearedCrackingStress::initQpStatefulProperties ( )

overridevirtual

Reimplemented from ComputeMultipleInelasticStress.

Definition at line 149 of file ComputeSmearedCrackingStress.C.

 {
   ComputeMultipleInelasticStress::initQpStatefulProperties();
  
   _crack_damage[_qp] = 0.0;
  
   _crack_initiation_strain[_qp] = 0.0;
   _crack_max_strain[_qp](0) = 0.0;
  
   switch (_prescribed_crack_directions.size())
   {
     case 0:
     {
       _crack_rotation[_qp] = RankTwoTensor::Identity();
       break;
     }
     case 1:
     {
       _crack_rotation[_qp].zero();
       switch (_prescribed_crack_directions[0])
       {
         case 0:
         {
           _crack_rotation[_qp](0, 0) = 1.0;
           _crack_rotation[_qp](1, 1) = 1.0;
           _crack_rotation[_qp](2, 2) = 1.0;
           break;
         }
         case 1:
         {
           _crack_rotation[_qp](1, 0) = 1.0;
           _crack_rotation[_qp](0, 1) = 1.0;
           _crack_rotation[_qp](2, 2) = 1.0;
           break;
         }
         case 2:
         {
           _crack_rotation[_qp](2, 0) = 1.0;
           _crack_rotation[_qp](0, 1) = 1.0;
           _crack_rotation[_qp](1, 2) = 1.0;
           break;
         }
       }
       break;
     }
     case 2:
     {
       mooseError("Number of prescribed crack directions cannot be 2");
       break;
     }
     case 3:
     {
       for (unsigned int i = 0; i < _prescribed_crack_directions.size(); ++i)
       {
         RealVectorValue crack_dir_vec;
         crack_dir_vec(_prescribed_crack_directions[i]) = 1.0;
         _crack_rotation[_qp].fillColumn(i, crack_dir_vec);
       }
     }
   }
 }

◆ previouslyCracked()

bool ComputeSmearedCrackingStress::previouslyCracked ( )

protected

Check to see whether there was cracking in any diretion in the previous time step.

Returns: true if cracked, false if not cracked

Definition at line 676 of file ComputeSmearedCrackingStress.C.

 {
   for (unsigned int i = 0; i < 3; ++i)
     if (_crack_damage_old[_qp](i) > 0.0)
       return true;
   return false;
 }

Referenced by computeQpStress().

◆ updateCrackingStateAndStress()

void ComputeSmearedCrackingStress::updateCrackingStateAndStress ( )

protectedvirtual

Update all cracking-related state variables and the stress tensor due to cracking in all directions.

Definition at line 375 of file ComputeSmearedCrackingStress.C.

 {
   const Real youngs_modulus =
       ElasticityTensorTools::getIsotropicYoungsModulus(_elasticity_tensor[_qp]);
   const Real cracking_alpha = -youngs_modulus;
  
   Real cracking_stress = _cracking_stress[_qp];
  
   if (cracking_stress > 0)
   {
     // Initializing crack states
     _crack_rotation[_qp] = _crack_rotation_old[_qp];
  
     for (unsigned i = 0; i < 3; ++i)
     {
       _crack_max_strain[_qp](i) = _crack_max_strain_old[_qp](i);
       _crack_initiation_strain[_qp](i) = _crack_initiation_strain_old[_qp](i);
       _crack_damage[_qp](i) = _crack_damage_old[_qp](i);
     }
  
     // Compute crack orientations: updated _crack_rotation[_qp] based on current strain
     RealVectorValue strain_in_crack_dir;
     computeCrackStrainAndOrientation(strain_in_crack_dir);
  
     for (unsigned i = 0; i < 3; ++i)
     {
       if (strain_in_crack_dir(i) > _crack_max_strain[_qp](i))
         _crack_max_strain[_qp](i) = strain_in_crack_dir(i);
     }
  
     // Check for new cracks.
     // Rotate stress to cracked orientation.
     const RankTwoTensor & R = _crack_rotation[_qp];
     RankTwoTensor sigmaPrime(_stress[_qp]);
     sigmaPrime.rotate(R.transpose()); // stress in crack coordinates
  
     unsigned int num_cracks = 0;
     for (unsigned int i = 0; i < 3; ++i)
     {
       if (_crack_damage_old[_qp](i) > 0.0)
         ++num_cracks;
     }
  
     bool cracked(false);
     RealVectorValue sigma;
     for (unsigned int i = 0; i < 3; ++i)
     {
       sigma(i) = sigmaPrime(i, i);
  
       Real stiffness_ratio = 1.0 - _crack_damage[_qp](i);
  
       const bool pre_existing_crack = (_crack_damage_old[_qp](i) > 0.0);
       const bool met_stress_criterion = (sigma(i) > cracking_stress);
       const bool loading_existing_crack = (strain_in_crack_dir(i) >= _crack_max_strain[_qp](i));
       const bool allowed_to_crack = (pre_existing_crack || num_cracks < _max_cracks);
       bool new_crack = false;
  
       cracked |= pre_existing_crack;
  
       // Adjustments for newly created cracks
       if (met_stress_criterion && !pre_existing_crack && allowed_to_crack)
       {
         new_crack = true;
         ++num_cracks;
  
         // Assume Poisson's ratio drops to zero for this direction.  Stiffness is then Young's
         // modulus.
         _crack_initiation_strain[_qp](i) = cracking_stress / youngs_modulus;
  
         if (_crack_max_strain[_qp](i) < _crack_initiation_strain[_qp](i))
           _crack_max_strain[_qp](i) = _crack_initiation_strain[_qp](i);
       }
  
       // Update stress and stiffness ratio according to specified crack release model
       if (new_crack || (pre_existing_crack && loading_existing_crack))
       {
         cracked = true;
         if (_softening_models.size() != 0)
           _softening_models[i]->computeCrackingRelease(sigma(i),
                                                        stiffness_ratio,
                                                        strain_in_crack_dir(i),
                                                        _crack_initiation_strain[_qp](i),
                                                        _crack_max_strain[_qp](i),
                                                        cracking_stress,
                                                        youngs_modulus);
         else
           computeCrackingRelease(i,
                                  sigma(i),
                                  stiffness_ratio,
                                  strain_in_crack_dir(i),
                                  cracking_stress,
                                  cracking_alpha,
                                  youngs_modulus);
         _crack_damage[_qp](i) = 1.0 - stiffness_ratio;
       }
  
       else if (cracked && _cracking_neg_fraction > 0 &&
                _crack_initiation_strain[_qp](i) * _cracking_neg_fraction > strain_in_crack_dir(i) &&
                -_crack_initiation_strain[_qp](i) * _cracking_neg_fraction < strain_in_crack_dir(i))
       {
         const Real etr = _cracking_neg_fraction * _crack_initiation_strain[_qp](i);
         const Real Eo = cracking_stress / _crack_initiation_strain[_qp](i);
         const Real Ec = Eo * (1.0 - _crack_damage_old[_qp](i));
         const Real a = (Ec - Eo) / (4.0 * etr);
         const Real b = 0.5 * (Ec + Eo);
         const Real c = 0.25 * (Ec - Eo) * etr;
         sigma(i) = (a * strain_in_crack_dir(i) + b) * strain_in_crack_dir(i) + c;
       }
     }
  
     if (cracked)
       updateStressTensorForCracking(_stress[_qp], sigma);
   }
  
   _crack_flags[_qp](0) = 1.0 - _crack_damage[_qp](2);
   _crack_flags[_qp](1) = 1.0 - _crack_damage[_qp](1);
   _crack_flags[_qp](2) = 1.0 - _crack_damage[_qp](0);
 }

Referenced by computeQpStress().

◆ updateLocalElasticityTensor()

void ComputeSmearedCrackingStress::updateLocalElasticityTensor ( )

protected

Update the local elasticity tensor (_local_elasticity_tensor) due to the effects of cracking.

Definition at line 288 of file ComputeSmearedCrackingStress.C.

 {
   const Real youngs_modulus =
       ElasticityTensorTools::getIsotropicYoungsModulus(_elasticity_tensor[_qp]);
  
   bool cracking_locally_active = false;
  
   const Real cracking_stress = _cracking_stress[_qp];
  
   if (cracking_stress > 0)
   {
     RealVectorValue stiffness_ratio_local(1.0, 1.0, 1.0);
     const RankTwoTensor & R = _crack_rotation_old[_qp];
     RankTwoTensor ePrime(_elastic_strain_old[_qp]);
     ePrime.rotate(R.transpose());
  
     for (unsigned int i = 0; i < 3; ++i)
     {
       // Update elasticity tensor based on crack status of the end of last time step
       if (_crack_damage_old[_qp](i) > 0.0)
       {
         if (_cracking_neg_fraction == 0.0 && MooseUtils::absoluteFuzzyLessThan(ePrime(i, i), 0.0))
           stiffness_ratio_local(i) = 1.0;
         else if (_cracking_neg_fraction > 0.0 &&
                  ePrime(i, i) < _crack_initiation_strain_old[_qp](i) * _cracking_neg_fraction &&
                  ePrime(i, i) > -_crack_initiation_strain_old[_qp](i) * _cracking_neg_fraction)
         {
           const Real etr = _cracking_neg_fraction * _crack_initiation_strain_old[_qp](i);
           const Real Eo = cracking_stress / _crack_initiation_strain_old[_qp](i);
           const Real Ec = Eo * (1.0 - _crack_damage_old[_qp](i));
           const Real a = (Ec - Eo) / (4 * etr);
           const Real b = (Ec + Eo) / 2;
           // Compute the ratio of the current transition stiffness to the original stiffness
           stiffness_ratio_local(i) = (2.0 * a * etr + b) / Eo;
           cracking_locally_active = true;
         }
         else
         {
           stiffness_ratio_local(i) = (1.0 - _crack_damage_old[_qp](i));
           cracking_locally_active = true;
         }
       }
     }
  
     if (cracking_locally_active)
     {
       // Update the elasticity tensor in the crack coordinate system
       const bool c0_coupled = MooseUtils::absoluteFuzzyEqual(stiffness_ratio_local(0), 1.0);
       const bool c1_coupled = MooseUtils::absoluteFuzzyEqual(stiffness_ratio_local(1), 1.0);
       const bool c2_coupled = MooseUtils::absoluteFuzzyEqual(stiffness_ratio_local(2), 1.0);
  
       const Real c01 = (c0_coupled && c1_coupled ? 1.0 : 0.0);
       const Real c02 = (c0_coupled && c2_coupled ? 1.0 : 0.0);
       const Real c12 = (c1_coupled && c2_coupled ? 1.0 : 0.0);
  
       const Real c01_shear_retention = (c0_coupled && c1_coupled ? 1.0 : _shear_retention_factor);
       const Real c02_shear_retention = (c0_coupled && c2_coupled ? 1.0 : _shear_retention_factor);
       const Real c12_shear_retention = (c1_coupled && c2_coupled ? 1.0 : _shear_retention_factor);
  
       // Filling with 9 components is sufficient because these are the only nonzero entries
       // for isotropic or orthotropic materials.
       std::vector<Real> local_elastic(9);
  
       local_elastic[0] = (c0_coupled ? _elasticity_tensor[_qp](0, 0, 0, 0)
                                      : stiffness_ratio_local(0) * youngs_modulus);
       local_elastic[1] = _elasticity_tensor[_qp](0, 0, 1, 1) * c01;
       local_elastic[2] = _elasticity_tensor[_qp](0, 0, 2, 2) * c02;
       local_elastic[3] = (c1_coupled ? _elasticity_tensor[_qp](1, 1, 1, 1)
                                      : stiffness_ratio_local(1) * youngs_modulus);
       local_elastic[4] = _elasticity_tensor[_qp](1, 1, 2, 2) * c12;
       local_elastic[5] = (c2_coupled ? _elasticity_tensor[_qp](2, 2, 2, 2)
                                      : stiffness_ratio_local(2) * youngs_modulus);
       local_elastic[6] = _elasticity_tensor[_qp](1, 2, 1, 2) * c12_shear_retention;
       local_elastic[7] = _elasticity_tensor[_qp](0, 2, 0, 2) * c02_shear_retention;
       local_elastic[8] = _elasticity_tensor[_qp](0, 1, 0, 1) * c01_shear_retention;
  
       _local_elasticity_tensor.fillFromInputVector(local_elastic, RankFourTensor::symmetric9);
  
       // Rotate the modified elasticity tensor back into global coordinates
       _local_elasticity_tensor.rotate(R);
     }
   }
   if (!cracking_locally_active)
     _local_elasticity_tensor = _elasticity_tensor[_qp];
 }

Referenced by computeQpStress().

◆ updateQpState()

void ComputeMultipleInelasticStress::updateQpState	(	RankTwoTensor &	elastic_strain_increment,
		RankTwoTensor &	combined_inelastic_strain_increment
	)

protectedvirtualinherited

Given the _strain_increment[_qp], iterate over all of the user-specified recompute materials in order to find an admissible stress (which is placed into _stress[_qp]) and set of inelastic strains, as well as the tangent operator (which is placed into _Jacobian_mult[_qp]).

Parameters

elastic_strain_increment	The elastic part of _strain_increment[_qp] after the iterative process has converged
combined_inelastic_strain_increment	The inelastic part of _strain_increment[_qp] after the iterative process has converged. This is a weighted sum of all the inelastic strains computed by all the plastic models during the Picard iterative scheme. The weights are dictated by the user using _inelastic_weights

Definition at line 271 of file ComputeMultipleInelasticStress.C.

 {
   if (_internal_solve_full_iteration_history == true)
   {
     _console << std::endl
              << "iteration output for ComputeMultipleInelasticStress solve:"
              << " time=" << _t << " int_pt=" << _qp << std::endl;
   }
   Real l2norm_delta_stress;
   Real first_l2norm_delta_stress = 1.0;
   unsigned int counter = 0;
  
   std::vector<RankTwoTensor> inelastic_strain_increment;
   inelastic_strain_increment.resize(_num_models);
  
   for (unsigned i_rmm = 0; i_rmm < _models.size(); ++i_rmm)
     inelastic_strain_increment[i_rmm].zero();
  
   RankTwoTensor stress_max, stress_min;
  
   do
   {
     for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
     {
       _models[i_rmm]->setQp(_qp);
  
       // initially assume the strain is completely elastic
       elastic_strain_increment = _strain_increment[_qp];
       // and subtract off all inelastic strain increments calculated so far
       // except the one that we're about to calculate
       for (unsigned j_rmm = 0; j_rmm < _num_models; ++j_rmm)
         if (i_rmm != j_rmm)
           elastic_strain_increment -= inelastic_strain_increment[j_rmm];
  
       // form the trial stress, with the check for changed elasticity constants
       if (_is_elasticity_tensor_guaranteed_isotropic || !_perform_finite_strain_rotations)
         _stress[_qp] =
             _elasticity_tensor[_qp] * (_elastic_strain_old[_qp] + elastic_strain_increment);
       else
       {
         if (_damage_model)
           _stress[_qp] = _undamaged_stress_old + _elasticity_tensor[_qp] * elastic_strain_increment;
         else
           _stress[_qp] = _stress_old[_qp] + _elasticity_tensor[_qp] * elastic_strain_increment;
       }
  
       // given a trial stress (_stress[_qp]) and a strain increment (elastic_strain_increment)
       // let the i^th model produce an admissible stress (as _stress[_qp]), and decompose
       // the strain increment into an elastic part (elastic_strain_increment) and an
       // inelastic part (inelastic_strain_increment[i_rmm])
       computeAdmissibleState(i_rmm,
                              elastic_strain_increment,
                              inelastic_strain_increment[i_rmm],
                              _consistent_tangent_operator[i_rmm]);
  
       if (i_rmm == 0)
       {
         stress_max = _stress[_qp];
         stress_min = _stress[_qp];
       }
       else
       {
         for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
         {
           for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
           {
             if (_stress[_qp](i, j) > stress_max(i, j))
               stress_max(i, j) = _stress[_qp](i, j);
             else if (stress_min(i, j) > _stress[_qp](i, j))
               stress_min(i, j) = _stress[_qp](i, j);
           }
         }
       }
     }
  
     // now check convergence in the stress:
     // once the change in stress is within tolerance after each recompute material
     // consider the stress to be converged
     l2norm_delta_stress = (stress_max - stress_min).L2norm();
     if (counter == 0 && l2norm_delta_stress > 0.0)
       first_l2norm_delta_stress = l2norm_delta_stress;
  
     if (_internal_solve_full_iteration_history == true)
     {
       _console << "stress iteration number = " << counter << "\n"
                << " relative l2 norm delta stress = "
                << (0 == first_l2norm_delta_stress ? 0
                                                   : l2norm_delta_stress / first_l2norm_delta_stress)
                << "\n"
                << " stress convergence relative tolerance = " << _relative_tolerance << "\n"
                << " absolute l2 norm delta stress = " << l2norm_delta_stress << "\n"
                << " stress convergence absolute tolerance = " << _absolute_tolerance << std::endl;
     }
     ++counter;
   } while (counter < _max_iterations && l2norm_delta_stress > _absolute_tolerance &&
            (l2norm_delta_stress / first_l2norm_delta_stress) > _relative_tolerance &&
            _num_models != 1);
  
   if (counter == _max_iterations && l2norm_delta_stress > _absolute_tolerance &&
       (l2norm_delta_stress / first_l2norm_delta_stress) > _relative_tolerance)
     throw MooseException("Max stress iteration hit during ComputeMultipleInelasticStress solve!");
  
   combined_inelastic_strain_increment.zero();
   for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
     combined_inelastic_strain_increment +=
         _inelastic_weights[i_rmm] * inelastic_strain_increment[i_rmm];
  
   if (_fe_problem.currentlyComputingJacobian())
     computeQpJacobianMult();
  
   _matl_timestep_limit[_qp] = 0.0;
   for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
     _matl_timestep_limit[_qp] += 1.0 / _models[i_rmm]->computeTimeStepLimit();
  
   if (MooseUtils::absoluteFuzzyEqual(_matl_timestep_limit[_qp], 0.0))
     _matl_timestep_limit[_qp] = std::numeric_limits<Real>::max();
   else
     _matl_timestep_limit[_qp] = 1.0 / _matl_timestep_limit[_qp];
 }

Referenced by ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration().

◆ updateQpStateSingleModel()

void ComputeMultipleInelasticStress::updateQpStateSingleModel	(	unsigned	model_number,
		RankTwoTensor &	elastic_strain_increment,
		RankTwoTensor &	combined_inelastic_strain_increment
	)

protectedvirtualinherited

An optimised version of updateQpState that gets used when the number of plastic models is unity, or when we're cycling through models Given the _strain_increment[_qp], find an admissible stress (which is put into _stress[_qp]) and inelastic strain, as well as the tangent operator (which is placed into _Jacobian_mult[_qp])

Parameters

model_number	Use this model number
elastic_strain_increment	The elastic part of _strain_increment[_qp]
combined_inelastic_strain_increment	The inelastic part of _strain_increment[_qp]

Definition at line 415 of file ComputeMultipleInelasticStress.C.

 {
   for (auto model : _models)
     model->setQp(_qp);
  
   elastic_strain_increment = _strain_increment[_qp];
  
   // If the elasticity tensor values have changed and the tensor is isotropic,
   // use the old strain to calculate the old stress
   if (_is_elasticity_tensor_guaranteed_isotropic || !_perform_finite_strain_rotations)
     _stress[_qp] = _elasticity_tensor[_qp] * (_elastic_strain_old[_qp] + elastic_strain_increment);
   else
   {
     if (_damage_model)
       _stress[_qp] = _undamaged_stress_old + _elasticity_tensor[_qp] * elastic_strain_increment;
     else
       _stress[_qp] = _stress_old[_qp] + _elasticity_tensor[_qp] * elastic_strain_increment;
   }
  
   computeAdmissibleState(model_number,
                          elastic_strain_increment,
                          combined_inelastic_strain_increment,
                          _consistent_tangent_operator[0]);
  
   if (_fe_problem.currentlyComputingJacobian())
   {
     if (_tangent_calculation_method == TangentCalculationMethod::ELASTIC)
       _Jacobian_mult[_qp] = _elasticity_tensor[_qp];
     else if (_tangent_calculation_method == TangentCalculationMethod::PARTIAL)
     {
       RankFourTensor A = _identity_symmetric_four + _consistent_tangent_operator[0];
       mooseAssert(A.isSymmetric(), "Tangent operator isn't symmetric");
       _Jacobian_mult[_qp] = A.invSymm() * _elasticity_tensor[_qp];
     }
     else
       _Jacobian_mult[_qp] = _consistent_tangent_operator[0];
   }
  
   _matl_timestep_limit[_qp] = _models[0]->computeTimeStepLimit();
  
   /* propagate internal variables, etc, to this timestep for those inelastic models where
    * "updateState" is not called */
   for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
     if (i_rmm != model_number)
       _models[i_rmm]->propagateQpStatefulProperties();
 }

Referenced by ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration().

◆ updateStressTensorForCracking()

void ComputeSmearedCrackingStress::updateStressTensorForCracking	(	RankTwoTensor &	tensor,
		const RealVectorValue &	sigma
	)

protected

Updates the full stress tensor to account for the effect of cracking using the provided stresses in the crack directions.

The tensor is rotated into the crack coordinates, modified, and rotated back.

Parameters

tensor	Stress tensor to be updated
sigma	Vector of stresses in crack directions

Definition at line 650 of file ComputeSmearedCrackingStress.C.

 {
   // Get transformation matrix
   const RankTwoTensor & R = _crack_rotation[_qp];
   // Rotate to crack frame
   tensor.rotate(R.transpose());
  
   // Reset stress if cracked
   for (unsigned int i = 0; i < 3; ++i)
     if (_crack_damage[_qp](i) > 0.0)
     {
       const Real stress_correction_ratio = (tensor(i, i) - sigma(i)) / tensor(i, i);
       if (stress_correction_ratio > _max_stress_correction)
         tensor(i, i) *= (1.0 - _max_stress_correction);
       else if (stress_correction_ratio < -_max_stress_correction)
         tensor(i, i) *= (1.0 + _max_stress_correction);
       else
         tensor(i, i) = sigma(i);
     }
  
   // Rotate back to global frame
   tensor.rotate(R);
 }

Referenced by updateCrackingStateAndStress().

◆ validParams()

InputParameters ComputeSmearedCrackingStress::validParams ( )

static

Definition at line 20 of file ComputeSmearedCrackingStress.C.

 {
   InputParameters params = ComputeMultipleInelasticStress::validParams();
   params.addClassDescription("Compute stress using a fixed smeared cracking model");
   MooseEnum cracking_release("abrupt exponential power", "abrupt");
   params.addDeprecatedParam<MooseEnum>(
       "cracking_release",
       cracking_release,
       "The cracking release type.  'abrupt' (default) gives an abrupt "
       "stress release, 'exponential' uses an exponential softening model, "
       "and 'power' uses a power law",
       "This is replaced by the use of 'softening_models' together with a separate block defining "
       "a softening model");
   params.addParam<std::vector<MaterialName>>(
       "softening_models",
       "The material objects used to compute softening behavior for loading a crack."
       "Either 1 or 3 models must be specified. If a single model is specified, it is"
       "used for all directions. If 3 models are specified, they will be used for the"
       "3 crack directions in sequence");
   params.addDeprecatedParam<Real>(
       "cracking_residual_stress",
       0.0,
       "The fraction of the cracking stress allowed to be maintained following a crack.",
       "This is replaced by the use of 'softening_models' together with a separate block defining "
       "a softening model");
   params.addRequiredCoupledVar(
       "cracking_stress",
       "The stress threshold beyond which cracking occurs. Negative values prevent cracking.");
   MultiMooseEnum direction("x y z");
   params.addParam<MultiMooseEnum>(
       "prescribed_crack_directions", direction, "Prescribed directions of first cracks");
   params.addParam<unsigned int>(
       "max_cracks", 3, "The maximum number of cracks allowed at a material point.");
   params.addRangeCheckedParam<Real>("cracking_neg_fraction",
                                     0,
                                     "cracking_neg_fraction <= 1 & cracking_neg_fraction >= 0",
                                     "The fraction of the cracking strain at which "
                                     "a transition begins during decreasing "
                                     "strain to the original stiffness.");
   params.addDeprecatedParam<Real>(
       "cracking_beta",
       1.0,
       "Coefficient used to control the softening in the exponential model.  "
       "When set to 1, the initial softening slope is equal to the negative "
       "of the Young's modulus.  Smaller numbers scale down that slope.",
       "This is replaced by the use of 'softening_models' together with a separate block defining "
       "a softening model");
   params.addParam<Real>(
       "max_stress_correction",
       1.0,
       "Maximum permitted correction to the predicted stress as a ratio of the "
       "stress change to the predicted stress from the previous step's damage level. "
       "Values less than 1 will improve robustness, but not be as accurate.");
  
   params.addRangeCheckedParam<Real>(
       "shear_retention_factor",
       0.0,
       "shear_retention_factor>=0 & shear_retention_factor<=1.0",
       "Fraction of original shear stiffness to be retained after cracking");
   params.set<std::vector<MaterialName>>("inelastic_models") = {};
  
   return params;
 }

Member Data Documentation

◆ _absolute_tolerance

const Real ComputeMultipleInelasticStress::_absolute_tolerance

protectedinherited

Definition at line 124 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticStress::updateQpState().

◆ _all_models_isotropic

bool ComputeMultipleInelasticStress::_all_models_isotropic

protectedinherited

are all inelastic models inherently isotropic? (not the case for e.g. weak plane plasticity models)

Definition at line 183 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticStress::finiteStrainRotation(), and ComputeMultipleInelasticStress::initialSetup().

◆ _base_name

const std::string ComputeStressBase::_base_name

protectedinherited

Base name prepended to all material property names to allow for multi-material systems.

Definition at line 45 of file ComputeStressBase.h.

Referenced by ComputeLinearElasticStress::initialSetup(), and ComputeCosseratLinearElasticStress::initialSetup().

◆ _consistent_tangent_operator

std::vector<RankFourTensor> ComputeMultipleInelasticStress::_consistent_tangent_operator

protectedinherited

the consistent tangent operators computed by each plastic model

Definition at line 158 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticCosseratStress::computeQpJacobianMult(), ComputeMultipleInelasticStress::computeQpJacobianMult(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStress::updateQpStateSingleModel().

◆ _crack_damage

MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_damage

protected

Definition at line 134 of file ComputeSmearedCrackingStress.h.

Referenced by initQpStatefulProperties(), updateCrackingStateAndStress(), and updateStressTensorForCracking().

◆ _crack_damage_old

const MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_damage_old

protected

Definition at line 135 of file ComputeSmearedCrackingStress.h.

Referenced by getNumKnownCrackDirs(), previouslyCracked(), updateCrackingStateAndStress(), and updateLocalElasticityTensor().

◆ _crack_flags

MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_flags

protected

Vector of values going from 1 to 0 as crack damage accumulates.

Legacy property for backward compatibility – remove in the future.

Definition at line 140 of file ComputeSmearedCrackingStress.h.

Referenced by updateCrackingStateAndStress().

◆ _crack_initiation_strain

MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_initiation_strain

protected

Definition at line 148 of file ComputeSmearedCrackingStress.h.

Referenced by computeCrackingRelease(), initQpStatefulProperties(), and updateCrackingStateAndStress().

◆ _crack_initiation_strain_old

const MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_initiation_strain_old

protected

Definition at line 149 of file ComputeSmearedCrackingStress.h.

Referenced by updateCrackingStateAndStress(), and updateLocalElasticityTensor().

◆ _crack_max_strain

MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_max_strain

protected

Definition at line 153 of file ComputeSmearedCrackingStress.h.

Referenced by computeCrackingRelease(), initQpStatefulProperties(), and updateCrackingStateAndStress().

◆ _crack_max_strain_old

const MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_max_strain_old

protected

Definition at line 154 of file ComputeSmearedCrackingStress.h.

Referenced by updateCrackingStateAndStress().

◆ _crack_rotation

MaterialProperty<RankTwoTensor>& ComputeSmearedCrackingStress::_crack_rotation

protected

Definition at line 143 of file ComputeSmearedCrackingStress.h.

Referenced by computeCrackStrainAndOrientation(), computeQpStress(), initQpStatefulProperties(), updateCrackingStateAndStress(), and updateStressTensorForCracking().

◆ _crack_rotation_old

const MaterialProperty<RankTwoTensor>& ComputeSmearedCrackingStress::_crack_rotation_old

protected

Definition at line 144 of file ComputeSmearedCrackingStress.h.

Referenced by computeCrackStrainAndOrientation(), updateCrackingStateAndStress(), and updateLocalElasticityTensor().

◆ _cracking_beta

const Real ComputeSmearedCrackingStress::_cracking_beta

protected

Controls slope of exponential softening curve.

Definition at line 123 of file ComputeSmearedCrackingStress.h.

Referenced by computeCrackingRelease().

◆ _cracking_neg_fraction

const Real ComputeSmearedCrackingStress::_cracking_neg_fraction

protected

Defines transition to changed stiffness during unloading.

Definition at line 120 of file ComputeSmearedCrackingStress.h.

Referenced by updateCrackingStateAndStress(), and updateLocalElasticityTensor().

◆ _cracking_release

enum ComputeSmearedCrackingStress::CrackingRelease ComputeSmearedCrackingStress::_cracking_release

protected

Referenced by computeCrackingRelease().

◆ _cracking_residual_stress

const Real ComputeSmearedCrackingStress::_cracking_residual_stress

protected

Input parameters for smeared crack models.

Ratio of the residual stress after being fully cracked to the tensile cracking threshold stress

Definition at line 108 of file ComputeSmearedCrackingStress.h.

Referenced by computeCrackingRelease().

◆ _cracking_stress

const VariableValue& ComputeSmearedCrackingStress::_cracking_stress

protected

Threshold at which cracking initiates if tensile stress exceeds it.

Definition at line 111 of file ComputeSmearedCrackingStress.h.

Referenced by updateCrackingStateAndStress(), and updateLocalElasticityTensor().

◆ _cycle_models

const bool ComputeMultipleInelasticStress::_cycle_models

protectedinherited

whether to cycle through the models, using only one model per timestep

Definition at line 161 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration().

◆ _damage_model

DamageBase* ComputeMultipleInelasticStress::_damage_model

protectedinherited

Pointer to the damage model.

Definition at line 186 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticStress::computeAdmissibleState(), ComputeMultipleInelasticStress::computeQpStress(), ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration(), ComputeMultipleInelasticStress::initialSetup(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStress::updateQpStateSingleModel().

◆ _elastic_strain

MaterialProperty<RankTwoTensor>& ComputeStressBase::_elastic_strain

protectedinherited

Elastic strain material property.

Definition at line 52 of file ComputeStressBase.h.

Referenced by computeCrackStrainAndOrientation(), ComputeLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), computeQpStress(), FiniteStrainPlasticMaterial::computeQpStress(), ComputeMultiPlasticityStress::computeQpStress(), ComputeLinearViscoelasticStress::computeQpStress(), ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration(), ComputeMultipleInelasticStress::finiteStrainRotation(), and ComputeStressBase::initQpStatefulProperties().

◆ _elastic_strain_old

const MaterialProperty<RankTwoTensor>& ComputeMultipleInelasticStress::_elastic_strain_old

protectedinherited

Strain tensors.

Definition at line 132 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticStress::computeAdmissibleState(), computeQpStress(), ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration(), updateLocalElasticityTensor(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStress::updateQpStateSingleModel().

◆ _elasticity_tensor

const MaterialProperty<RankFourTensor>& ComputeFiniteStrainElasticStress::_elasticity_tensor

protectedinherited

Elasticity tensor material property.

Definition at line 39 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeMultipleInelasticStress::computeAdmissibleState(), ComputeMultipleInelasticCosseratStress::computeQpJacobianMult(), ComputeMultipleInelasticStress::computeQpJacobianMult(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration(), updateCrackingStateAndStress(), updateLocalElasticityTensor(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStress::updateQpStateSingleModel().

◆ _elasticity_tensor_name

const std::string ComputeFiniteStrainElasticStress::_elasticity_tensor_name

protectedinherited

Name of the elasticity tensor material property.

Definition at line 37 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeFiniteStrainElasticStress::initialSetup(), initialSetup(), and ComputeMultipleInelasticStress::initialSetup().

◆ _extra_stress

const MaterialProperty<RankTwoTensor>& ComputeStressBase::_extra_stress

protectedinherited

Extra stress tensor.

Definition at line 55 of file ComputeStressBase.h.

Referenced by ComputeStressBase::computeQpProperties().

◆ _gc_block_restrict

BlockRestrictable* const GuaranteeConsumer::_gc_block_restrict

privateinherited

Access block restrictions of the object with this interface.

Definition at line 41 of file GuaranteeConsumer.h.

Referenced by GuaranteeConsumer::hasGuaranteedMaterialProperty().

◆ _gc_feproblem

FEProblemBase* const GuaranteeConsumer::_gc_feproblem

privateinherited

Reference to the FEProblemBase class.

Definition at line 38 of file GuaranteeConsumer.h.

Referenced by GuaranteeConsumer::hasGuaranteedMaterialProperty().

◆ _gc_params

const InputParameters& GuaranteeConsumer::_gc_params

privateinherited

Parameters of the object with this interface.

Definition at line 35 of file GuaranteeConsumer.h.

◆ _identity_symmetric_four

const RankFourTensor ComputeMultipleInelasticStress::_identity_symmetric_four

protectedinherited

Rank four symmetric identity tensor.

Definition at line 168 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticStress::computeQpJacobianMult(), and ComputeMultipleInelasticStress::updateQpStateSingleModel().

◆ _inelastic_strain

MaterialProperty<RankTwoTensor>& ComputeMultipleInelasticStress::_inelastic_strain

protectedinherited

The sum of the inelastic strains that come from the plastic models.

Definition at line 137 of file ComputeMultipleInelasticStress.h.

Referenced by computeQpStress(), ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration(), ComputeMultipleInelasticStress::finiteStrainRotation(), and ComputeMultipleInelasticStress::initQpStatefulProperties().

◆ _inelastic_strain_old

const MaterialProperty<RankTwoTensor>& ComputeMultipleInelasticStress::_inelastic_strain_old

protectedinherited

old value of inelastic strain

Definition at line 140 of file ComputeMultipleInelasticStress.h.

Referenced by computeQpStress(), and ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration().

◆ _inelastic_weights

const std::vector<Real> ComputeMultipleInelasticStress::_inelastic_weights

protectedinherited

_inelastic_strain = sum_i (_inelastic_weights_i * inelastic_strain_from_model_i)

Definition at line 155 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticStress::ComputeMultipleInelasticStress(), and ComputeMultipleInelasticStress::updateQpState().

◆ _initial_stress_fcn

std::vector<const Function *> ComputeStressBase::_initial_stress_fcn

protectedinherited

initial stress components

Definition at line 58 of file ComputeStressBase.h.

◆ _internal_solve_full_iteration_history

const bool ComputeMultipleInelasticStress::_internal_solve_full_iteration_history

protectedinherited

Definition at line 125 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticStress::updateQpState().

◆ _is_elasticity_tensor_guaranteed_isotropic

bool ComputeMultipleInelasticStress::_is_elasticity_tensor_guaranteed_isotropic

protectedinherited

is the elasticity tensor guaranteed to be isotropic?

Definition at line 180 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration(), ComputeMultipleInelasticStress::finiteStrainRotation(), ComputeMultipleInelasticStress::initialSetup(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStress::updateQpStateSingleModel().

◆ _Jacobian_mult

MaterialProperty<RankFourTensor>& ComputeStressBase::_Jacobian_mult

protectedinherited

derivative of stress w.r.t. strain (_dstress_dstrain)

Definition at line 61 of file ComputeStressBase.h.

◆ _local_elasticity_tensor

RankFourTensor ComputeSmearedCrackingStress::_local_elasticity_tensor

protected

Definition at line 158 of file ComputeSmearedCrackingStress.h.

Referenced by computeQpStress(), and updateLocalElasticityTensor().

◆ _matl_timestep_limit

MaterialProperty<Real>& ComputeMultipleInelasticStress::_matl_timestep_limit

protectedinherited

Definition at line 163 of file ComputeMultipleInelasticStress.h.

Referenced by computeQpStress(), ComputeMultipleInelasticStress::computeQpStress(), ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStress::updateQpStateSingleModel().

◆ _max_cracks

const unsigned int ComputeSmearedCrackingStress::_max_cracks

protected

Maximum number of cracks permitted at a material point.

Definition at line 117 of file ComputeSmearedCrackingStress.h.

Referenced by updateCrackingStateAndStress().

◆ _max_iterations

const unsigned int ComputeMultipleInelasticStress::_max_iterations

protectedinherited

Input parameters associated with the recompute iteration to return the stress state to the yield surface.

Definition at line 122 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticStress::updateQpState().

◆ _max_stress_correction

const Real ComputeSmearedCrackingStress::_max_stress_correction

protected

Controls the maximum amount that the damaged elastic stress is corrected to folow the release model during a time step.

Definition at line 130 of file ComputeSmearedCrackingStress.h.

Referenced by updateStressTensorForCracking().

◆ _mechanical_strain

const MaterialProperty<RankTwoTensor>& ComputeStressBase::_mechanical_strain

protectedinherited

Mechanical strain material property.

Definition at line 48 of file ComputeStressBase.h.

Referenced by ComputeLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), FiniteStrainPlasticMaterial::computeQpStress(), ComputeLinearElasticPFFractureStress::computeQpStress(), ComputeLinearViscoelasticStress::computeQpStress(), ComputeLinearElasticPFFractureStress::computeStrainSpectral(), ComputeLinearElasticPFFractureStress::computeStrainVolDev(), and ComputeLinearElasticPFFractureStress::computeStressSpectral().

◆ _models

std::vector<StressUpdateBase *> ComputeMultipleInelasticStress::_models

protectedinherited

The user supplied list of inelastic models to use in the simulation.

Users should take care to list creep models first and plasticity models last to allow for the case when a creep model relaxes the stress state inside of the yield surface in an iteration.

Definition at line 177 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticStress::computeAdmissibleState(), computeQpStress(), ComputeMultipleInelasticStress::initialSetup(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStress::updateQpStateSingleModel().