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

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_flags
	Vector of values going from 1 to 0 as crack damage accumulates. More...

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

const MaterialProperty< RankTwoTensor > &	_rotation_increment

const MaterialProperty< RankTwoTensor > &	_stress_old

const std::string	_base_name

const std::string	_elasticity_tensor_name

const MaterialProperty< RankTwoTensor > &	_mechanical_strain

MaterialProperty< RankTwoTensor > &	_stress

MaterialProperty< RankTwoTensor > &	_elastic_strain

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

std::vector< 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...


MaterialProperty< RealVectorValue > &	_crack_damage

const MaterialProperty< RealVectorValue > &	_crack_damage_old


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


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< RankFourTensor > &	_elasticity_tensor
	Rank-4 and Rank-2 elasticity and elastic strain tensors. More...

const MaterialProperty< RankTwoTensor > &	_elastic_strain_old

const MaterialProperty< RankTwoTensor > &	_strain_increment

Detailed Description

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

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

101 { abrupt, exponential, power } _cracking_release;

ComputeSmearedCrackingStress::_cracking_release

enum ComputeSmearedCrackingStress::CrackingRelease _cracking_release

◆ TangentOperatorEnum

enum ComputeMultipleInelasticStress::TangentOperatorEnum

strongprotectedinherited

what sort of Tangent operator to calculate

Enumerator
elastic
nonlinear

Definition at line 141 of file ComputeMultipleInelasticStress.h.

141 { elastic, nonlinear } _tangent_operator_type;

ComputeMultipleInelasticStress::_tangent_operator_type

enum ComputeMultipleInelasticStress::TangentOperatorEnum _tangent_operator_type

Constructor & Destructor Documentation

◆ ComputeSmearedCrackingStress()

ComputeSmearedCrackingStress::ComputeSmearedCrackingStress ( const InputParameters & parameters )

Definition at line 83 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 419 of file ComputeMultipleInelasticStress.C.

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

 {
   const bool jac = _fe_problem.currentlyComputingJacobian();
   _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];
   }
 }

◆ 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 585 of file ComputeSmearedCrackingStress.C.

Referenced by updateCrackingStateAndStress().

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

◆ 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 494 of file ComputeSmearedCrackingStress.C.

Referenced by updateCrackingStateAndStress().

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

◆ 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 351 of file ComputeMultipleInelasticStress.C.

Referenced by ComputeMultipleInelasticStress::updateQpState().

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

◆ computeQpProperties()

void ComputeStressBase::computeQpProperties ( )

overrideprotectedvirtualinherited

Definition at line 51 of file ComputeStressBase.C.

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

◆ computeQpStress()

void ComputeSmearedCrackingStress::computeQpStress ( )

overridevirtual

Reimplemented from ComputeMultipleInelasticStress.

Definition at line 245 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 182 of file ComputeMultipleInelasticStress.C.

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

 {
   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
       _stress[_qp] = _stress_old[_qp] + _elasticity_tensor[_qp] * _strain_increment[_qp];
 
     if (_fe_problem.currentlyComputingJacobian())
       _Jacobian_mult[_qp] = _elasticity_tensor[_qp];
   }
   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;
   }
 }

◆ 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 216 of file ComputeMultipleInelasticStress.C.

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

 {
   _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 &&
         (_tangent_calculation_method == TangentCalculationMethod::ELASTIC || _num_models == 0)))
     _Jacobian_mult[_qp].rotate(_rotation_increment[_qp]);
 }

◆ 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 573 of file ComputeSmearedCrackingStress.C.

Referenced by computeCrackStrainAndOrientation().

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

◆ hasGuaranteedMaterialProperty()

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

protectedinherited

Definition at line 28 of file GuaranteeConsumer.C.

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

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

◆ initialSetup()

void ComputeSmearedCrackingStress::initialSetup ( )

overridevirtual

Reimplemented from ComputeMultipleInelasticStress.

Definition at line 211 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 148 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 675 of file ComputeSmearedCrackingStress.C.

Referenced by computeQpStress().

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

◆ updateCrackingStateAndStress()

void ComputeSmearedCrackingStress::updateCrackingStateAndStress ( )

protectedvirtual

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

Definition at line 374 of file ComputeSmearedCrackingStress.C.

Referenced by computeQpStress().

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

◆ updateLocalElasticityTensor()

void ComputeSmearedCrackingStress::updateLocalElasticityTensor ( )

protected

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

Definition at line 287 of file ComputeSmearedCrackingStress.C.

Referenced by computeQpStress().

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

◆ 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 230 of file ComputeMultipleInelasticStress.C.

Referenced by ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration().

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

◆ 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 373 of file ComputeMultipleInelasticStress.C.

Referenced by ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration().

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

◆ 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 649 of file ComputeSmearedCrackingStress.C.

Referenced by updateCrackingStateAndStress().

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

Member Data Documentation

◆ _absolute_tolerance

const Real ComputeMultipleInelasticStress::_absolute_tolerance

protectedinherited

Definition at line 121 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticStress::updateQpState().

◆ _base_name

const std::string ComputeStressBase::_base_name

protectedinherited

Definition at line 37 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 156 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 133 of file ComputeSmearedCrackingStress.h.

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

◆ _crack_damage_old

const MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_damage_old

protected

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

Referenced by updateCrackingStateAndStress().

◆ _crack_initiation_strain

MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_initiation_strain

protected

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

Referenced by updateCrackingStateAndStress(), and updateLocalElasticityTensor().

◆ _crack_max_strain

MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_max_strain

protected

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

Referenced by updateCrackingStateAndStress().

◆ _crack_rotation

MaterialProperty<RankTwoTensor>& ComputeSmearedCrackingStress::_crack_rotation

protected

Definition at line 142 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 143 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 122 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 119 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 107 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 110 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 159 of file ComputeMultipleInelasticStress.h.

Referenced by ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration().

◆ _elastic_strain

MaterialProperty<RankTwoTensor>& ComputeStressBase::_elastic_strain

protectedinherited

Definition at line 42 of file ComputeStressBase.h.

Referenced by computeCrackStrainAndOrientation(), ComputeLinearElasticStress::computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::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

Definition at line 130 of file ComputeMultipleInelasticStress.h.

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

◆ _elasticity_tensor

const MaterialProperty<RankFourTensor>& ComputeMultipleInelasticStress::_elasticity_tensor

protectedinherited

Rank-4 and Rank-2 elasticity and elastic strain tensors.

Definition at line 129 of file ComputeMultipleInelasticStress.h.

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

◆ _elasticity_tensor_name

const std::string ComputeStressBase::_elasticity_tensor_name

protectedinherited

Definition at line 38 of file ComputeStressBase.h.

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

◆ _extra_stress

const MaterialProperty<RankTwoTensor>& ComputeStressBase::_extra_stress

protectedinherited

Extra stress tensor.

Definition at line 47 of file ComputeStressBase.h.

Referenced by ComputeStressBase::computeQpProperties().

◆ _identity_symmetric_four

const RankFourTensor ComputeMultipleInelasticStress::_identity_symmetric_four

protectedinherited

Rank four symmetric identity tensor.

Definition at line 166 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 135 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 138 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 153 of file ComputeMultipleInelasticStress.h.

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

◆ _initial_stress_fcn

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

protectedinherited

initial stress components

Definition at line 50 of file ComputeStressBase.h.

◆ _internal_solve_full_iteration_history

const bool ComputeMultipleInelasticStress::_internal_solve_full_iteration_history

protectedinherited

Definition at line 122 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 178 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 53 of file ComputeStressBase.h.

◆ _local_elasticity_tensor

RankFourTensor ComputeSmearedCrackingStress::_local_elasticity_tensor

protected

Definition at line 157 of file ComputeSmearedCrackingStress.h.

Referenced by computeQpStress(), and updateLocalElasticityTensor().

◆ _matl_timestep_limit

MaterialProperty<Real>& ComputeMultipleInelasticStress::_matl_timestep_limit

protectedinherited

Definition at line 161 of file ComputeMultipleInelasticStress.h.

Referenced by computeQpStress(), 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 116 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 119 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 129 of file ComputeSmearedCrackingStress.h.

Referenced by updateStressTensorForCracking().

◆ _mechanical_strain

const MaterialProperty<RankTwoTensor>& ComputeStressBase::_mechanical_strain

protectedinherited

Definition at line 40 of file ComputeStressBase.h.

Referenced by ComputeLinearElasticPFFractureStress::computeQpStress(), ComputeCosseratLinearElasticStress::computeQpStress(), ComputeFiniteStrainElasticStress::computeQpStress(), ComputeIsotropicLinearElasticPFFractureStress::computeQpStress(), and FiniteStrainPlasticMaterial::computeQpStress().

◆ _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 175 of file ComputeMultipleInelasticStress.h.

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