ComputeSmearedCrackingStress Class Reference

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

#include <ComputeSmearedCrackingStress.h>

Inheritance diagram for ComputeSmearedCrackingStress:

Public Types
typedef DerivativeMaterialPropertyNameInterface::SymbolName	SymbolName

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.
const GenericMaterialProperty< U, is_ad > &	getDefaultMaterialProperty (const std::string &name)
const GenericMaterialProperty< U, is_ad > &	getDefaultMaterialPropertyByName (const std::string &name)
void	validateDerivativeMaterialPropertyBase (const std::string &base)
const MaterialPropertyName	derivativePropertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const
const MaterialPropertyName	derivativePropertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const
const MaterialPropertyName	derivativePropertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const
const MaterialPropertyName	derivativePropertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< VariableName > &c)
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< VariableName > &c)
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)
GenericMaterialProperty< U, is_ad > &	declarePropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< VariableName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, unsigned int v2, unsigned int v3=libMesh::invalid_uint)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, unsigned int v1, unsigned int v2=libMesh::invalid_uint, unsigned int v3=libMesh::invalid_uint)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< VariableName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const std::vector< SymbolName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, const SymbolName &c1, unsigned int v2, unsigned int v3=libMesh::invalid_uint)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivative (const std::string &base, unsigned int v1, unsigned int v2=libMesh::invalid_uint, unsigned int v3=libMesh::invalid_uint)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< VariableName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< SymbolName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< VariableName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const std::vector< SymbolName > &c)
const GenericMaterialProperty< U, is_ad > &	getMaterialPropertyDerivativeByName (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2="", const SymbolName &c3="")
void	validateCoupling (const MaterialPropertyName &base, const std::vector< VariableName > &c, bool validate_aux=true)
void	validateCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")
void	validateCoupling (const MaterialPropertyName &base, const std::vector< VariableName > &c, bool validate_aux=true)
void	validateCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")
void	validateNonlinearCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")
void	validateNonlinearCoupling (const MaterialPropertyName &base, const VariableName &c1="", const VariableName &c2="", const VariableName &c3="")
const MaterialPropertyName	propertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const
const MaterialPropertyName	propertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const
const MaterialPropertyName	propertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const
const MaterialPropertyName	propertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const
const MaterialPropertyName	propertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const
const MaterialPropertyName	propertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const
const MaterialPropertyName	propertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const
const MaterialPropertyName	propertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const

Static Public Member Functions
static InputParameters	validParams ()

Protected Types
enum class	CrackedElasticityType { DIAGONAL , FULL }
	Enum defining the method used to adjust the elasticity tensor for cracking. More...
enum class	TangentOperatorEnum { elastic , 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.
virtual void	updateCrackingStateAndStress ()
	Update all cracking-related state variables and the stress tensor due to cracking in all directions.
virtual unsigned int	getNumKnownCrackDirs () const
	Get the number of known crack directions.
void	computeCrackStrainAndOrientation (RealVectorValue &strain_in_crack_dir)
	Compute the crack strain in the crack coordinate system.
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.
bool	previouslyCracked ()
	Check to see whether there was cracking in any diretion in the previous time step.
virtual std::vector< MaterialName >	getInelasticModelNames () override
virtual void	updateQpState (RankTwoTensor &elastic_strain_increment, RankTwoTensor &combined_inelastic_strain_increment) override
	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]).
virtual void	computeQpStressIntermediateConfiguration ()
	Compute the stress for the current QP, but do not rotate tensors from the intermediate configuration to the new configuration.
virtual void	finiteStrainRotation (const bool force_elasticity_rotation=false)
	Rotate _elastic_strain, _stress, _inelastic_strain, and _Jacobian_mult to the new configuration.
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])
virtual void	computeQpJacobianMult ()
	Using _elasticity_tensor[_qp] and the consistent tangent operators, _consistent_tangent_operator[...] computed by the inelastic models, compute _Jacobian_mult[_qp].
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.
virtual void	computeQpProperties () override
bool	hasGuaranteedMaterialProperty (const MaterialPropertyName &prop, Guarantee guarantee)

Protected Attributes
enum ComputeSmearedCrackingStress::CrackedElasticityType	_cracked_elasticity_type
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.
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.
std::vector< Real >	_local_elastic_vector
	Vector helper to update local elasticity tensor.
const bool	_perform_finite_strain_rotations
	after updateQpState, rotate the stress, elastic_strain, inelastic_strain and Jacobian_mult using _rotation_increment
MaterialProperty< RankTwoTensor > &	_inelastic_strain
	The sum of the inelastic strains that come from the plastic models.
const MaterialProperty< RankTwoTensor > &	_inelastic_strain_old
	old value of inelastic strain
enum ComputeMultipleInelasticStressBase::TangentOperatorEnum	_tangent_operator_type
unsigned	_num_models
	number of plastic models
std::vector< bool >	_tangent_computation_flag
	Flags to compute tangent during updateState call.
TangentCalculationMethod	_tangent_calculation_method
	Calculation method for the tangent modulus.
std::vector< Real >	_inelastic_weights
	_inelastic_strain = sum_i (_inelastic_weights_i * inelastic_strain_from_model_i)
std::vector< RankFourTensor >	_consistent_tangent_operator
	the consistent tangent operators computed by each plastic model
const bool	_cycle_models
	whether to cycle through the models, using only one model per timestep
MaterialProperty< Real > &	_material_timestep_limit
const RankFourTensor	_identity_symmetric_four
	Rank four symmetric identity tensor.
std::vector< StressUpdateBase * >	_models
	The user supplied list of inelastic models to use in the simulation.
bool	_is_elasticity_tensor_guaranteed_isotropic
	is the elasticity tensor guaranteed to be isotropic?
bool	_all_models_isotropic
	are all inelastic models inherently isotropic? (not the case for e.g. weak plane plasticity models)
DamageBaseTempl< false > *	_damage_model
	Pointer to the damage model.
RankTwoTensor	_undamaged_stress_old
const std::string	_elasticity_tensor_name
	Name of the elasticity tensor material property.
const MaterialProperty< RankFourTensor > &	_elasticity_tensor
	Elasticity tensor material property.
MaterialProperty< RankTwoTensor > &	_rotation_total
	Rotation up to current step "n" to compute anisotropic elasticity tensor.
const MaterialProperty< RankTwoTensor > &	_rotation_total_old
	Rotation up to "n - 1" (previous) step to compute anisotropic elasticity tensor.
const MaterialProperty< RankTwoTensor > &	_rotation_increment
	Rotation increment material property.
const MaterialProperty< RankTwoTensor > &	_stress_old
	Old state of the stress tensor material property.
const std::string	_base_name
	Base name prepended to all material property names to allow for multi-material systems.
const MaterialProperty< RankTwoTensor > &	_mechanical_strain
	Mechanical strain material property.
MaterialProperty< RankTwoTensor > &	_stress
	Stress material property.
MaterialProperty< RankTwoTensor > &	_elastic_strain
	Elastic strain material property.
const MaterialProperty< RankTwoTensor > &	_extra_stress
	Extra stress tensor.
std::vector< const Function * >	_initial_stress_fcn
	initial stress components
MaterialProperty< RankFourTensor > &	_Jacobian_mult
	derivative of stress w.r.t. strain (_dstress_dstrain)
const VariableValue &	_cracking_stress
	Input parameters for smeared crack models.
std::vector< unsigned int >	_prescribed_crack_directions
	User-prescribed cracking directions.
const unsigned int	_max_cracks
	Maximum number of cracks permitted at a material point.
const Real	_cracking_neg_fraction
	Defines transition to changed stiffness during unloading.
const Real	_shear_retention_factor
	Controls the amount of shear retained.
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.
const unsigned int	_max_iterations
	Input parameters associated with the recompute iteration to return the stress state to the yield surface.
const Real	_relative_tolerance
const Real	_absolute_tolerance
const bool	_internal_solve_full_iteration_history
const MaterialProperty< RankTwoTensor > &	_elastic_strain_old
	Strain tensors.
const MaterialProperty< RankTwoTensor > &	_strain_increment

Private Member Functions
bool	haveMaterialProperty (const std::string &prop_name)
std::vector< VariableName >	buildVariableVector (const VariableName &c1, const VariableName &c2, const VariableName &c3)
void	validateCouplingHelper (const MaterialPropertyName &base, const std::vector< VariableName > &c, const System &system, std::vector< VariableName > &missing)
bool	isNotObjectVariable (const VariableName &name)

Private Attributes
FEProblemBase &	_dmi_fe_problem
const InputParameters &	_gc_params
	Parameters of the object with this interface.
FEProblemBase *const	_gc_feproblem
	Reference to the FEProblemBase class.
BlockRestrictable *const	_gc_block_restrict
	Access block restrictions of the object with this interface.

Detailed Description

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

Definition at line 21 of file ComputeSmearedCrackingStress.h.

Member Enumeration Documentation

CrackedElasticityType

enum class ComputeSmearedCrackingStress::CrackedElasticityType

strongprotected

Enum defining the method used to adjust the elasticity tensor for cracking.

Enumerator
DIAGONAL
FULL

Definition at line 99 of file ComputeSmearedCrackingStress.h.

{ DIAGONAL, FULL } _cracked_elasticity_type;

TangentOperatorEnum

enum class ComputeMultipleInelasticStressBase::TangentOperatorEnum

strongprotectedinherited

what sort of Tangent operator to calculate

Enumerator
elastic
nonlinear

Definition at line 139 of file ComputeMultipleInelasticStressBase.h.

{ elastic, nonlinear } _tangent_operator_type;

Constructor & Destructor Documentation

ComputeSmearedCrackingStress()

ComputeSmearedCrackingStress::ComputeSmearedCrackingStress

(

const InputParameters &

parameters

)

Definition at line 69 of file ComputeSmearedCrackingStress.C.

  : ComputeMultipleInelasticStress(parameters),
    _cracking_stress(coupledValue("cracking_stress")),
    _max_cracks(getParam<unsigned int>("max_cracks")),
    _cracking_neg_fraction(getParam<Real>("cracking_neg_fraction")),
    _shear_retention_factor(getParam<Real>("shear_retention_factor")),
    _max_stress_correction(getParam<Real>("max_stress_correction")),
    _cracked_elasticity_type(
        getParam<MooseEnum>("cracked_elasticity_type").getEnum<CrackedElasticityType>()),
    _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 (!isParamSetByUser("cracked_elasticity_type"))
    paramWarning(
        "cracked_elasticity_type",
        "Defaulting to the legacy option of 'DIAGONAL', but the 'FULL' option is preferred");
 
  _local_elastic_vector.resize(9);
}

Member Function Documentation

computeAdmissibleState()

void ComputeMultipleInelasticStressBase::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 356 of file ComputeMultipleInelasticStressBase.C.

{
  // Reset properties to the beginning of the time step (necessary if substepping is employed).
  _models[model_number]->resetIncrementalMaterialProperties();
 
  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 if (_models[model_number]->substeppingCapabilityEnabled() &&
           (_is_elasticity_tensor_guaranteed_isotropic || !_perform_finite_strain_rotations))
    _models[model_number]->updateStateSubstep(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);
  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(), ComputeCreepPlasticityStress::updateQpState(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

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 488 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 ComputeMultipleInelasticStressBase::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 283 of file ComputeMultipleInelasticStressBase.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 (const auto i_rmm : make_range(_num_models))
      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 (const auto i_rmm : make_range(1u, _num_models))
      _Jacobian_mult[_qp] = _consistent_tangent_operator[i_rmm] * E_inv * _Jacobian_mult[_qp];
  }
}

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

computeQpProperties()

void ComputeGeneralStressBase::computeQpProperties ( )

overrideprotectedvirtualinherited

Definition at line 44 of file ComputeGeneralStressBase.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 ComputeMultipleInelasticStressBase.

Definition at line 218 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
    _material_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 ComputeMultipleInelasticStressBase::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 227 of file ComputeMultipleInelasticStressBase.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];
 
    _material_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 ComputeMultipleInelasticStressBase::computeQpStress(), and computeQpStress().

finiteStrainRotation()

void ComputeMultipleInelasticStressBase::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 267 of file ComputeMultipleInelasticStressBase.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 ComputeMultipleInelasticStressBase::computeQpStress(), and computeQpStress().

getInelasticModelNames()

std::vector< MaterialName > ComputeMultipleInelasticStress::getInelasticModelNames ( )

overrideprotectedvirtualinherited

Implements ComputeMultipleInelasticStressBase.

Definition at line 36 of file ComputeMultipleInelasticStress.C.

{
  return getParam<std::vector<MaterialName>>("inelastic_models");
}

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 567 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::computeQpStress(), LagrangianStressDivergenceBase::initialSetup(), ADComputeMultipleInelasticStress::initialSetup(), ADComputeSmearedCrackingStress::initialSetup(), ComputeLinearElasticPFFractureStress::initialSetup(), ComputeMultipleInelasticStressBase::initialSetup(), initialSetup(), ComputeLagrangianStressBase::initialSetup(), ComputeStVenantKirchhoffStress::initialSetup(), and CriticalTimeStep::initialSetup().

initialSetup()

void ComputeSmearedCrackingStress::initialSetup ( )

overridevirtual

Reimplemented from ComputeMultipleInelasticStressBase.

Definition at line 189 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");
  for (auto soft_matl : soft_matls)
  {
    SmearedCrackSofteningBase * scsb =
        dynamic_cast<SmearedCrackSofteningBase *>(&getMaterialByName(soft_matl));
    if (scsb)
      _softening_models.push_back(scsb);
    else
      paramError("softening_models", "Model " + soft_matl + " is not a softening model");
  }
  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)
    paramError("softening_models", "Either 1 or 3 softening models must be specified");
}

initQpStatefulProperties()

void ComputeSmearedCrackingStress::initQpStatefulProperties ( )

overridevirtual

Reimplemented from ComputeMultipleInelasticStressBase.

Definition at line 126 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 605 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 373 of file ComputeSmearedCrackingStress.C.

{
  const Real youngs_modulus =
      ElasticityTensorTools::getIsotropicYoungsModulus(_elasticity_tensor[_qp]);
 
  const Real poissons_ratio =
      ElasticityTensorTools::getIsotropicPoissonsRatio(_elasticity_tensor[_qp]);
 
  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;
    mooseAssert(_softening_models.size() == 3, "Must have 3 softening models");
    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;
        _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,
                                                     poissons_ratio);
        _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 260 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
      if (_cracked_elasticity_type == CrackedElasticityType::DIAGONAL)
      {
        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);
 
        _local_elastic_vector[0] = (c0_coupled ? _elasticity_tensor[_qp](0, 0, 0, 0)
                                               : stiffness_ratio_local(0) * youngs_modulus);
        _local_elastic_vector[1] = _elasticity_tensor[_qp](0, 0, 1, 1) * c01;
        _local_elastic_vector[2] = _elasticity_tensor[_qp](0, 0, 2, 2) * c02;
        _local_elastic_vector[3] = (c1_coupled ? _elasticity_tensor[_qp](1, 1, 1, 1)
                                               : stiffness_ratio_local(1) * youngs_modulus);
        _local_elastic_vector[4] = _elasticity_tensor[_qp](1, 1, 2, 2) * c12;
        _local_elastic_vector[5] = (c2_coupled ? _elasticity_tensor[_qp](2, 2, 2, 2)
                                               : stiffness_ratio_local(2) * youngs_modulus);
        _local_elastic_vector[6] = _elasticity_tensor[_qp](1, 2, 1, 2) * c12_shear_retention;
        _local_elastic_vector[7] = _elasticity_tensor[_qp](0, 2, 0, 2) * c02_shear_retention;
        _local_elastic_vector[8] = _elasticity_tensor[_qp](0, 1, 0, 1) * c01_shear_retention;
      }
      else // _cracked_elasticity_type == CrackedElasticityType::FULL
      {
        const Real & c0 = stiffness_ratio_local(0);
        const Real & c1 = stiffness_ratio_local(1);
        const Real & c2 = stiffness_ratio_local(2);
 
        const Real c01 = c0 * c1;
        const Real c02 = c0 * c2;
        const Real c12 = c1 * c2;
 
        const Real c01_shear_retention = std::max(c01, _shear_retention_factor);
        const Real c02_shear_retention = std::max(c02, _shear_retention_factor);
        const Real c12_shear_retention = std::max(c12, _shear_retention_factor);
 
        _local_elastic_vector[0] = _elasticity_tensor[_qp](0, 0, 0, 0) * c0;
        _local_elastic_vector[1] = _elasticity_tensor[_qp](0, 0, 1, 1) * c01;
        _local_elastic_vector[2] = _elasticity_tensor[_qp](0, 0, 2, 2) * c02;
        _local_elastic_vector[3] = _elasticity_tensor[_qp](1, 1, 1, 1) * c1;
        _local_elastic_vector[4] = _elasticity_tensor[_qp](1, 1, 2, 2) * c12;
        _local_elastic_vector[5] = _elasticity_tensor[_qp](2, 2, 2, 2) * c2;
        _local_elastic_vector[6] = _elasticity_tensor[_qp](1, 2, 1, 2) * c12_shear_retention;
        _local_elastic_vector[7] = _elasticity_tensor[_qp](0, 2, 0, 2) * c02_shear_retention;
        _local_elastic_vector[8] = _elasticity_tensor[_qp](0, 1, 0, 1) * c01_shear_retention;
      }
 
      // Filling with 9 components is sufficient because these are the only nonzero entries
      // for isotropic or orthotropic materials.
      _local_elasticity_tensor.fillFromInputVector(_local_elastic_vector,
                                                   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  )

overrideprotectedvirtualinherited

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

Implements ComputeMultipleInelasticStressBase.

Definition at line 42 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 (const auto i_rmm : index_range(_models))
    inelastic_strain_increment[i_rmm].zero();
 
  RankTwoTensor stress_max, stress_min;
 
  do
  {
    for (const auto i_rmm : index_range(_models))
    {
      _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 (const auto j_rmm : make_range(_num_models))
        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 (const auto i : make_range(Moose::dim))
          for (const auto j : make_range(Moose::dim))
            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 (const auto i_rmm : make_range(_num_models))
    combined_inelastic_strain_increment +=
        _inelastic_weights[i_rmm] * inelastic_strain_increment[i_rmm];
 
  if (_fe_problem.currentlyComputingJacobian())
    computeQpJacobianMult();
 
  _material_timestep_limit[_qp] = 0.0;
  for (const auto i_rmm : make_range(_num_models))
    _material_timestep_limit[_qp] += 1.0 / _models[i_rmm]->computeTimeStepLimit();
 
  if (MooseUtils::absoluteFuzzyEqual(_material_timestep_limit[_qp], 0.0))
    _material_timestep_limit[_qp] = std::numeric_limits<Real>::max();
  else
    _material_timestep_limit[_qp] = 1.0 / _material_timestep_limit[_qp];
}

updateQpStateSingleModel()

void ComputeMultipleInelasticStressBase::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 305 of file ComputeMultipleInelasticStressBase.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];
  }
 
  _material_timestep_limit[_qp] = _models[0]->computeTimeStepLimit();
 
  /* propagate internal variables, etc, to this timestep for those inelastic models where
   * "updateState" is not called */
  for (const auto i_rmm : make_range(_num_models))
    if (i_rmm != model_number)
      _models[i_rmm]->propagateQpStatefulProperties();
}

Referenced by ComputeMultipleInelasticStressBase::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 579 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 18 of file ComputeSmearedCrackingStress.C.

{
  InputParameters params = ComputeMultipleInelasticStress::validParams();
  params.addClassDescription("Compute stress using a fixed smeared cracking model");
  params.addRequiredParam<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.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.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") = {};
 
  MooseEnum crackedElasticityType("DIAGONAL FULL", "DIAGONAL");
  crackedElasticityType.addDocumentation(
      "DIAGONAL", "Zero out terms coupling with directions orthogonal to a crack (legacy)");
  crackedElasticityType.addDocumentation(
      "FULL", "Consistently scale all entries based on damage (recommended)");
  params.addParam<MooseEnum>(
      "cracked_elasticity_type",
      crackedElasticityType,
      "Method to modify the local elasticity tensor to account for cracking");
 
  return params;
}

Member Data Documentation

_absolute_tolerance

const Real ComputeMultipleInelasticStressBase::_absolute_tolerance

protectedinherited

Definition at line 120 of file ComputeMultipleInelasticStressBase.h.

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

_all_models_isotropic

bool ComputeMultipleInelasticStressBase::_all_models_isotropic

protectedinherited

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

Definition at line 179 of file ComputeMultipleInelasticStressBase.h.

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

_base_name

const std::string ComputeGeneralStressBase::_base_name

protectedinherited

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

Definition at line 43 of file ComputeGeneralStressBase.h.

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

_consistent_tangent_operator

std::vector<RankFourTensor> ComputeMultipleInelasticStressBase::_consistent_tangent_operator

protectedinherited

the consistent tangent operators computed by each plastic model

Definition at line 154 of file ComputeMultipleInelasticStressBase.h.

Referenced by ComputeMultipleInelasticStressBase::computeQpJacobianMult(), ComputeMultipleInelasticCosseratStress::computeQpJacobianMult(), ComputeCreepPlasticityStress::computeTangentOperators(), ComputeMultipleInelasticStressBase::initialSetup(), ComputeCreepPlasticityStress::updateQpState(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

_crack_damage

MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_damage

protected

Definition at line 102 of file ComputeSmearedCrackingStress.h.

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

_crack_damage_old

const MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_damage_old

protected

Definition at line 103 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 108 of file ComputeSmearedCrackingStress.h.

Referenced by updateCrackingStateAndStress().

_crack_initiation_strain

MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_initiation_strain

protected

Definition at line 116 of file ComputeSmearedCrackingStress.h.

Referenced by initQpStatefulProperties(), and updateCrackingStateAndStress().

_crack_initiation_strain_old

const MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_initiation_strain_old

protected

Definition at line 117 of file ComputeSmearedCrackingStress.h.

Referenced by updateCrackingStateAndStress(), and updateLocalElasticityTensor().

_crack_max_strain

MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_max_strain

protected

Definition at line 121 of file ComputeSmearedCrackingStress.h.

Referenced by initQpStatefulProperties(), and updateCrackingStateAndStress().

_crack_max_strain_old

const MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_max_strain_old

protected

Definition at line 122 of file ComputeSmearedCrackingStress.h.

Referenced by updateCrackingStateAndStress().

_crack_rotation

MaterialProperty<RankTwoTensor>& ComputeSmearedCrackingStress::_crack_rotation

protected

Definition at line 111 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 112 of file ComputeSmearedCrackingStress.h.

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

_cracked_elasticity_type

enum ComputeSmearedCrackingStress::CrackedElasticityType ComputeSmearedCrackingStress::_cracked_elasticity_type

protected

Referenced by updateLocalElasticityTensor().

_cracking_neg_fraction

const Real ComputeSmearedCrackingStress::_cracking_neg_fraction

protected

Defines transition to changed stiffness during unloading.

Definition at line 88 of file ComputeSmearedCrackingStress.h.

Referenced by updateCrackingStateAndStress(), and updateLocalElasticityTensor().

_cracking_stress

const VariableValue& ComputeSmearedCrackingStress::_cracking_stress

protected

Input parameters for smeared crack models.

Threshold at which cracking initiates if tensile stress exceeds it

Definition at line 79 of file ComputeSmearedCrackingStress.h.

Referenced by updateCrackingStateAndStress(), and updateLocalElasticityTensor().

_cycle_models

const bool ComputeMultipleInelasticStressBase::_cycle_models

protectedinherited

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

Definition at line 157 of file ComputeMultipleInelasticStressBase.h.

Referenced by ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration().

_damage_model

DamageBaseTempl<false>* ComputeMultipleInelasticStressBase::_damage_model

protectedinherited

Pointer to the damage model.

Definition at line 182 of file ComputeMultipleInelasticStressBase.h.

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

_elastic_strain

MaterialProperty<RankTwoTensor>& ComputeGeneralStressBase::_elastic_strain

protectedinherited

Elastic strain material property.

Definition at line 50 of file ComputeGeneralStressBase.h.

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

_elastic_strain_old

const MaterialProperty<RankTwoTensor>& ComputeMultipleInelasticStressBase::_elastic_strain_old

protectedinherited

Strain tensors.

Definition at line 128 of file ComputeMultipleInelasticStressBase.h.

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

_elasticity_tensor

const MaterialProperty<RankFourTensor>& ComputeFiniteStrainElasticStress::_elasticity_tensor

protectedinherited

Elasticity tensor material property.

Definition at line 35 of file ComputeFiniteStrainElasticStress.h.

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

_elasticity_tensor_name

const std::string ComputeFiniteStrainElasticStress::_elasticity_tensor_name

protectedinherited

Name of the elasticity tensor material property.

Definition at line 33 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeFiniteStrainElasticStress::computeQpStress(), ComputeMultipleInelasticStressBase::initialSetup(), and initialSetup().

_extra_stress

const MaterialProperty<RankTwoTensor>& ComputeGeneralStressBase::_extra_stress

protectedinherited

Extra stress tensor.

Definition at line 53 of file ComputeGeneralStressBase.h.

Referenced by ComputeGeneralStressBase::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 ComputeMultipleInelasticStressBase::_identity_symmetric_four

protectedinherited

Rank four symmetric identity tensor.

Definition at line 164 of file ComputeMultipleInelasticStressBase.h.

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

_inelastic_strain

MaterialProperty<RankTwoTensor>& ComputeMultipleInelasticStressBase::_inelastic_strain

protectedinherited

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

Definition at line 133 of file ComputeMultipleInelasticStressBase.h.

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

_inelastic_strain_old

const MaterialProperty<RankTwoTensor>& ComputeMultipleInelasticStressBase::_inelastic_strain_old

protectedinherited

old value of inelastic strain

Definition at line 136 of file ComputeMultipleInelasticStressBase.h.

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

_inelastic_weights

std::vector<Real> ComputeMultipleInelasticStressBase::_inelastic_weights

protectedinherited

_inelastic_strain = sum_i (_inelastic_weights_i * inelastic_strain_from_model_i)

Definition at line 151 of file ComputeMultipleInelasticStressBase.h.

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

_initial_stress_fcn

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

protectedinherited

initial stress components

Definition at line 56 of file ComputeGeneralStressBase.h.

_internal_solve_full_iteration_history

const bool ComputeMultipleInelasticStressBase::_internal_solve_full_iteration_history

protectedinherited

Definition at line 121 of file ComputeMultipleInelasticStressBase.h.

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

_is_elasticity_tensor_guaranteed_isotropic

bool ComputeMultipleInelasticStressBase::_is_elasticity_tensor_guaranteed_isotropic

protectedinherited

is the elasticity tensor guaranteed to be isotropic?

Definition at line 176 of file ComputeMultipleInelasticStressBase.h.

Referenced by ComputeMultipleInelasticStressBase::computeAdmissibleState(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeCreepPlasticityStress::computeStress(), ComputeMultipleInelasticStressBase::finiteStrainRotation(), ComputeMultipleInelasticStressBase::initialSetup(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

_Jacobian_mult

MaterialProperty<RankFourTensor>& ComputeGeneralStressBase::_Jacobian_mult

protectedinherited

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

Definition at line 59 of file ComputeGeneralStressBase.h.

Referenced by ComputeStrainIncrementBasedStress::computeQpJacobian(), FiniteStrainHyperElasticViscoPlastic::computeQpJacobian(), ComputeMultipleInelasticStressBase::computeQpJacobianMult(), ComputeMultipleInelasticCosseratStress::computeQpJacobianMult(), ComputeMultiPlasticityStress::computeQpStress(), FiniteStrainPlasticMaterial::computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeLinearElasticPFFractureStress::computeQpStress(), ComputeLinearElasticStress::computeQpStress(), ComputeLinearViscoelasticStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStress(), computeQpStress(), ComputeMultipleCrystalPlasticityStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeLinearElasticPFFractureStress::computeStrainSpectral(), ComputeLinearElasticPFFractureStress::computeStrainVolDev(), ComputeLinearElasticPFFractureStress::computeStressSpectral(), FiniteStrainUObasedCP::elasticTangentModuli(), FiniteStrainUObasedCP::elastoPlasticTangentModuli(), ComputeMultipleInelasticStressBase::finiteStrainRotation(), ComputeMultiPlasticityStress::postReturnMap(), FiniteStrainCrystalPlasticity::postSolveQp(), FiniteStrainCrystalPlasticity::preSolveQp(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

_local_elastic_vector

std::vector<Real> ComputeSmearedCrackingStress::_local_elastic_vector

protected

Vector helper to update local elasticity tensor.

Definition at line 133 of file ComputeSmearedCrackingStress.h.

Referenced by ComputeSmearedCrackingStress(), and updateLocalElasticityTensor().

_local_elasticity_tensor

RankFourTensor ComputeSmearedCrackingStress::_local_elasticity_tensor

protected

Definition at line 126 of file ComputeSmearedCrackingStress.h.

Referenced by computeQpStress(), and updateLocalElasticityTensor().

_material_timestep_limit

MaterialProperty<Real>& ComputeMultipleInelasticStressBase::_material_timestep_limit

protectedinherited

Definition at line 159 of file ComputeMultipleInelasticStressBase.h.

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

_max_cracks

const unsigned int ComputeSmearedCrackingStress::_max_cracks

protected

Maximum number of cracks permitted at a material point.

Definition at line 85 of file ComputeSmearedCrackingStress.h.

Referenced by updateCrackingStateAndStress().

_max_iterations

const unsigned int ComputeMultipleInelasticStressBase::_max_iterations

protectedinherited

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

Definition at line 118 of file ComputeMultipleInelasticStressBase.h.

Referenced by ComputeCreepPlasticityStress::updateQpState(), and 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 95 of file ComputeSmearedCrackingStress.h.

Referenced by updateStressTensorForCracking().

_mechanical_strain

const MaterialProperty<RankTwoTensor>& ComputeGeneralStressBase::_mechanical_strain

protectedinherited

Mechanical strain material property.

Definition at line 46 of file ComputeGeneralStressBase.h.

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

_models

std::vector<StressUpdateBase *> ComputeMultipleInelasticStressBase::_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 173 of file ComputeMultipleInelasticStressBase.h.

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

_num_models

unsigned ComputeMultipleInelasticStressBase::_num_models

protectedinherited

number of plastic models

Definition at line 142 of file ComputeMultipleInelasticStressBase.h.

Referenced by ComputeMultipleInelasticStressBase::computeQpJacobianMult(), ComputeMultipleInelasticCosseratStress::computeQpJacobianMult(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeMultipleInelasticStressBase::finiteStrainRotation(), ComputeMultipleInelasticStressBase::initialSetup(), ComputeCreepPlasticityStress::updateQpState(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

_perform_finite_strain_rotations

const bool ComputeMultipleInelasticStressBase::_perform_finite_strain_rotations

protectedinherited

after updateQpState, rotate the stress, elastic_strain, inelastic_strain and Jacobian_mult using _rotation_increment

Definition at line 125 of file ComputeMultipleInelasticStressBase.h.

Referenced by ComputeMultipleInelasticStressBase::computeAdmissibleState(), ComputeMultipleInelasticCosseratStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStress(), computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeCreepPlasticityStress::computeStress(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

_prescribed_crack_directions

std::vector<unsigned int> ComputeSmearedCrackingStress::_prescribed_crack_directions

protected

User-prescribed cracking directions.

Definition at line 82 of file ComputeSmearedCrackingStress.h.

Referenced by ComputeSmearedCrackingStress(), getNumKnownCrackDirs(), and initQpStatefulProperties().

_relative_tolerance

const Real ComputeMultipleInelasticStressBase::_relative_tolerance

protectedinherited

Definition at line 119 of file ComputeMultipleInelasticStressBase.h.

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

_rotation_increment

const MaterialProperty<RankTwoTensor>& ComputeFiniteStrainElasticStress::_rotation_increment

protectedinherited

Rotation increment material property.

Definition at line 43 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeMultipleInelasticStressBase::computeAdmissibleState(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeMultipleInelasticCosseratStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStress(), computeQpStress(), and ComputeMultipleInelasticStressBase::finiteStrainRotation().

_rotation_total

MaterialProperty<RankTwoTensor>& ComputeFiniteStrainElasticStress::_rotation_total

protectedinherited

Rotation up to current step "n" to compute anisotropic elasticity tensor.

Definition at line 37 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeFiniteStrainElasticStress::computeQpStress(), and ComputeFiniteStrainElasticStress::initQpStatefulProperties().

_rotation_total_old

const MaterialProperty<RankTwoTensor>& ComputeFiniteStrainElasticStress::_rotation_total_old

protectedinherited

Rotation up to "n - 1" (previous) step to compute anisotropic elasticity tensor.

Definition at line 39 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeFiniteStrainElasticStress::computeQpStress().

_shear_retention_factor

const Real ComputeSmearedCrackingStress::_shear_retention_factor

protected

Controls the amount of shear retained.

Definition at line 91 of file ComputeSmearedCrackingStress.h.

Referenced by updateLocalElasticityTensor().

_softening_models

std::vector<SmearedCrackSofteningBase *> ComputeSmearedCrackingStress::_softening_models

protected

The user-supplied list of softening models to be used in the 3 crack directions.

Definition at line 130 of file ComputeSmearedCrackingStress.h.

Referenced by initialSetup(), and updateCrackingStateAndStress().

_strain_increment

const MaterialProperty<RankTwoTensor>& ComputeMultipleInelasticStressBase::_strain_increment

protectedinherited

Definition at line 129 of file ComputeMultipleInelasticStressBase.h.

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

_stress

MaterialProperty<RankTwoTensor>& ComputeGeneralStressBase::_stress

protectedinherited

Stress material property.

Definition at line 48 of file ComputeGeneralStressBase.h.

Referenced by ComputeMultipleInelasticStressBase::computeAdmissibleState(), ComputeMultipleInelasticCosseratStress::computeAdmissibleState(), ComputeGeneralStressBase::computeQpProperties(), ComputeMultiPlasticityStress::computeQpStress(), ComputeStrainIncrementBasedStress::computeQpStress(), FiniteStrainPlasticMaterial::computeQpStress(), AbaqusUMATStress::computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeLinearElasticPFFractureStress::computeQpStress(), ComputeLinearElasticStress::computeQpStress(), ComputeLinearViscoelasticStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStress(), computeQpStress(), ComputeMultipleCrystalPlasticityStress::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeLinearElasticPFFractureStress::computeStrainSpectral(), ComputeLinearElasticPFFractureStress::computeStrainVolDev(), ComputeLinearElasticPFFractureStress::computeStressSpectral(), ComputeCreepPlasticityStress::computeTangentOperators(), ComputeMultipleInelasticStressBase::finiteStrainRotation(), FiniteStrainCrystalPlasticity::initQpStatefulProperties(), FiniteStrainUObasedCP::initQpStatefulProperties(), FiniteStrainHyperElasticViscoPlastic::initQpStatefulProperties(), ComputeGeneralStressBase::initQpStatefulProperties(), ComputeMultiPlasticityStress::postReturnMap(), FiniteStrainCrystalPlasticity::postSolveQp(), FiniteStrainUObasedCP::postSolveQp(), FiniteStrainHyperElasticViscoPlastic::postSolveQp(), updateCrackingStateAndStress(), ComputeCreepPlasticityStress::updateQpState(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

_stress_old

const MaterialProperty<RankTwoTensor>& ComputeFiniteStrainElasticStress::_stress_old

protectedinherited

Old state of the stress tensor material property.

Definition at line 45 of file ComputeFiniteStrainElasticStress.h.

Referenced by ComputeMultipleInelasticStressBase::computeAdmissibleState(), ComputeMultipleInelasticStressBase::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeCreepPlasticityStress::computeStress(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

_tangent_calculation_method

TangentCalculationMethod ComputeMultipleInelasticStressBase::_tangent_calculation_method

protectedinherited

Calculation method for the tangent modulus.

Definition at line 148 of file ComputeMultipleInelasticStressBase.h.

Referenced by ComputeMultipleInelasticStressBase::computeAdmissibleState(), ComputeMultipleInelasticStressBase::computeQpJacobianMult(), ComputeMultipleInelasticStressBase::finiteStrainRotation(), ComputeMultipleInelasticStressBase::initialSetup(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

_tangent_computation_flag

std::vector<bool> ComputeMultipleInelasticStressBase::_tangent_computation_flag

protectedinherited

Flags to compute tangent during updateState call.

Definition at line 145 of file ComputeMultipleInelasticStressBase.h.

Referenced by ComputeMultipleInelasticStressBase::computeAdmissibleState(), and ComputeMultipleInelasticStressBase::initialSetup().

_tangent_operator_type

enum ComputeMultipleInelasticStressBase::TangentOperatorEnum ComputeMultipleInelasticStressBase::_tangent_operator_type

protectedinherited

Referenced by ComputeMultipleInelasticCosseratStress::computeQpJacobianMult(), and ComputeMultipleInelasticStressBase::initialSetup().

_undamaged_stress_old

RankTwoTensor ComputeMultipleInelasticStressBase::_undamaged_stress_old

protectedinherited

Definition at line 184 of file ComputeMultipleInelasticStressBase.h.

Referenced by ComputeMultipleInelasticStressBase::computeAdmissibleState(), ComputeMultipleInelasticStressBase::computeQpStress(), ComputeMultipleInelasticStressBase::computeQpStressIntermediateConfiguration(), ComputeCreepPlasticityStress::computeStress(), ComputeMultipleInelasticStress::updateQpState(), and ComputeMultipleInelasticStressBase::updateQpStateSingleModel().

---

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

• solid_mechanics/include/materials/ComputeSmearedCrackingStress.h
• solid_mechanics/src/materials/ComputeSmearedCrackingStress.C