www.mooseframework.org
Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | List of all members
ComputeSmearedCrackingStress Class Reference

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

#include <ComputeSmearedCrackingStress.h>

Inheritance diagram for ComputeSmearedCrackingStress:
[legend]

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 defining the crack release model.

Enumerator
abrupt 
exponential 
power 

Definition at line 101 of file ComputeSmearedCrackingStress.h.

101 { abrupt, exponential, power } _cracking_release;
enum ComputeSmearedCrackingStress::CrackingRelease _cracking_release

◆ TangentOperatorEnum

what sort of Tangent operator to calculate

Enumerator
elastic 
nonlinear 

Definition at line 141 of file ComputeMultipleInelasticStress.h.

141 { elastic, nonlinear } _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.

84  : ComputeMultipleInelasticStress(parameters),
85  _cracking_release(getParam<MooseEnum>("cracking_release").getEnum<CrackingRelease>()),
86  _cracking_residual_stress(getParam<Real>("cracking_residual_stress")),
87  _cracking_stress(coupledValue("cracking_stress")),
88  _max_cracks(getParam<unsigned int>("max_cracks")),
89  _cracking_neg_fraction(getParam<Real>("cracking_neg_fraction")),
90  _cracking_beta(getParam<Real>("cracking_beta")),
91  _shear_retention_factor(getParam<Real>("shear_retention_factor")),
92  _max_stress_correction(getParam<Real>("max_stress_correction")),
93  _crack_damage(declareProperty<RealVectorValue>(_base_name + "crack_damage")),
94  _crack_damage_old(getMaterialPropertyOld<RealVectorValue>(_base_name + "crack_damage")),
95  _crack_flags(declareProperty<RealVectorValue>(_base_name + "crack_flags")),
96  _crack_rotation(declareProperty<RankTwoTensor>(_base_name + "crack_rotation")),
97  _crack_rotation_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + "crack_rotation")),
99  declareProperty<RealVectorValue>(_base_name + "crack_initiation_strain")),
101  getMaterialPropertyOld<RealVectorValue>(_base_name + "crack_initiation_strain")),
102  _crack_max_strain(declareProperty<RealVectorValue>(_base_name + "crack_max_strain")),
103  _crack_max_strain_old(getMaterialPropertyOld<RealVectorValue>(_base_name + "crack_max_strain"))
104 {
105  MultiMooseEnum prescribed_crack_directions =
106  getParam<MultiMooseEnum>("prescribed_crack_directions");
107  if (prescribed_crack_directions.size() > 0)
108  {
109  if (prescribed_crack_directions.size() > 3)
110  mooseError("A maximum of three crack directions may be specified");
111  for (unsigned int i = 0; i < prescribed_crack_directions.size(); ++i)
112  {
113  for (unsigned int j = 0; j < i; ++j)
114  if (prescribed_crack_directions[i] == prescribed_crack_directions[j])
115  mooseError("Entries in 'prescribed_crack_directions' cannot be repeated");
117  static_cast<unsigned int>(prescribed_crack_directions.get(i)));
118  }
119 
120  // Fill in the last remaining direction if 2 are specified
121  if (_prescribed_crack_directions.size() == 2)
122  {
123  std::set<unsigned int> available_dirs = {0, 1, 2};
124  for (auto dir : _prescribed_crack_directions)
125  if (available_dirs.erase(dir) != 1)
126  mooseError("Invalid prescribed crack direction:" + Moose::stringify(dir));
127  if (available_dirs.size() != 1)
128  mooseError("Error in finding remaining available crack direction");
129  _prescribed_crack_directions.push_back(*available_dirs.begin());
130  }
131  }
132 
133  if (parameters.isParamSetByUser("softening_models"))
134  {
135  if (parameters.isParamSetByUser("cracking_release"))
136  mooseError("In ComputeSmearedCrackingStress cannot specify both 'cracking_release' and "
137  "'softening_models'");
138  if (parameters.isParamSetByUser("cracking_residual_stress"))
139  mooseError("In ComputeSmearedCrackingStress cannot specify both 'cracking_residual_stress' "
140  "and 'softening_models'");
141  if (parameters.isParamSetByUser("cracking_beta"))
142  mooseError("In ComputeSmearedCrackingStress cannot specify both 'cracking_beta' and "
143  "'softening_models'");
144  }
145 }
MaterialProperty< RealVectorValue > & _crack_max_strain
MaterialProperty< RealVectorValue > & _crack_initiation_strain
const unsigned int _max_cracks
Maximum number of cracks permitted at a material point.
const MaterialProperty< RankTwoTensor > & _crack_rotation_old
const MaterialProperty< RealVectorValue > & _crack_max_strain_old
MaterialProperty< RankTwoTensor > & _crack_rotation
const Real _cracking_beta
Controls slope of exponential softening curve.
enum ComputeSmearedCrackingStress::CrackingRelease _cracking_release
const VariableValue & _cracking_stress
Threshold at which cracking initiates if tensile stress exceeds it.
const Real _max_stress_correction
Controls the maximum amount that the damaged elastic stress is corrected to folow the release model d...
MaterialProperty< RealVectorValue > & _crack_flags
Vector of values going from 1 to 0 as crack damage accumulates.
const std::string _base_name
const Real _cracking_neg_fraction
Defines transition to changed stiffness during unloading.
MaterialProperty< RealVectorValue > & _crack_damage
const Real _shear_retention_factor
Controls the amount of shear retained.
const MaterialProperty< RealVectorValue > & _crack_damage_old
std::vector< unsigned int > _prescribed_crack_directions
User-prescribed cracking directions.
const MaterialProperty< RealVectorValue > & _crack_initiation_strain_old
ComputeMultipleInelasticStress(const InputParameters &parameters)
const Real _cracking_residual_stress
Input parameters for smeared crack 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_numberThe inelastic model to use
elastic_strain_incrementUpon input, this is the strain increment. Upon output, it is the elastic part of the strain increment
inelastic_strain_incrementThe inelastic strain increment corresponding to the supplied strain increment
consistent_tangent_operatorThe consistent tangent operator

Reimplemented in ComputeMultipleInelasticCosseratStress.

Definition at line 419 of file ComputeMultipleInelasticStress.C.

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

423 {
424  const bool jac = _fe_problem.currentlyComputingJacobian();
425  _models[model_number]->updateState(elastic_strain_increment,
426  inelastic_strain_increment,
427  _rotation_increment[_qp],
428  _stress[_qp],
429  _stress_old[_qp],
430  _elasticity_tensor[_qp],
431  _elastic_strain_old[_qp],
432  (jac && _tangent_computation_flag[model_number]),
433  consistent_tangent_operator);
434 
435  if (jac && !_tangent_computation_flag[model_number])
436  {
438  consistent_tangent_operator.zero();
439  else
440  consistent_tangent_operator = _elasticity_tensor[_qp];
441  }
442 }
const MaterialProperty< RankTwoTensor > & _rotation_increment
const MaterialProperty< RankTwoTensor > & _elastic_strain_old
MaterialProperty< RankTwoTensor > & _stress
std::vector< bool > _tangent_computation_flag
Flags to compute tangent during updateState call.
TangentCalculationMethod _tangent_calculation_method
Calculation method for the tangent modulus.
const MaterialProperty< RankFourTensor > & _elasticity_tensor
Rank-4 and Rank-2 elasticity and elastic strain tensors.
const MaterialProperty< RankTwoTensor > & _stress_old
std::vector< StressUpdateBase * > _models
The user supplied list of inelastic models to use in the simulation.

◆ 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
iIndex of current crack direction
sigmaStress in direction of crack
stiffness_ratioRatio of damaged to original stiffness in cracking direction
strain_in_crack_dirStrain in the current crack direction
cracking_stressThreshold tensile stress for crack initiation
cracking_alphaInitial slope of exponential softening model
youngs_modulusYoung's modulus

Definition at line 585 of file ComputeSmearedCrackingStress.C.

Referenced by updateCrackingStateAndStress().

592 {
593  switch (_cracking_release)
594  {
596  {
597  if (sigma > cracking_stress)
598  {
599  stiffness_ratio /= 3.0;
600  sigma = stiffness_ratio * youngs_modulus * strain_in_crack_dir;
601  }
602  break;
603  }
605  {
606  const Real crack_max_strain = _crack_max_strain[_qp](i);
607  mooseAssert(crack_max_strain >= _crack_initiation_strain[_qp](i),
608  "crack_max_strain must be >= crack_initiation_strain");
609 
610  // Compute stress that follows exponental curve
611  sigma =
612  cracking_stress * (_cracking_residual_stress +
613  (1.0 - _cracking_residual_stress) *
614  std::exp(cracking_alpha * _cracking_beta / cracking_stress *
615  (crack_max_strain - _crack_initiation_strain[_qp](i))));
616  // Compute ratio of current stiffness to original stiffness
617  stiffness_ratio =
618  sigma * _crack_initiation_strain[_qp](i) / (crack_max_strain * cracking_stress);
619  break;
620  }
622  {
623  if (_cracking_residual_stress == 0)
624  {
625  const Real tiny = 1e-16;
626  stiffness_ratio = tiny;
627  sigma = tiny * _crack_initiation_strain[_qp](i) * youngs_modulus;
628  }
629  else
630  {
631  sigma = _cracking_residual_stress * cracking_stress;
632  stiffness_ratio = sigma / (_crack_max_strain[_qp](i) * youngs_modulus);
633  }
634  break;
635  }
636  }
637 
638  if (stiffness_ratio < 0)
639  {
640  std::stringstream err;
641  err << "Negative stiffness ratio: " << i << " " << stiffness_ratio << ", "
642  << _crack_max_strain[_qp](i) << ", " << _crack_initiation_strain[_qp](i) << ", "
643  << std::endl;
644  mooseError(err.str());
645  }
646 }
MaterialProperty< RealVectorValue > & _crack_max_strain
MaterialProperty< RealVectorValue > & _crack_initiation_strain
const Real _cracking_beta
Controls slope of exponential softening curve.
enum ComputeSmearedCrackingStress::CrackingRelease _cracking_release
const Real _cracking_residual_stress
Input parameters for smeared crack models.

◆ 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_dirComputed strains in crack directions

Definition at line 494 of file ComputeSmearedCrackingStress.C.

Referenced by updateCrackingStateAndStress().

496 {
497  // The rotation tensor is ordered such that directions for pre-existing cracks appear first
498  // in the list of columns. For example, if there is one existing crack, its direction is in the
499  // first column in the rotation tensor.
500  const unsigned int num_known_dirs = getNumKnownCrackDirs();
501 
502  if (num_known_dirs == 0)
503  {
504  std::vector<Real> eigval(3, 0.0);
505  RankTwoTensor eigvec;
506 
507  _elastic_strain[_qp].symmetricEigenvaluesEigenvectors(eigval, eigvec);
508 
509  // If the elastic strain is beyond the cracking strain, save the eigen vectors as
510  // the rotation tensor. Reverse their order so that the third principal strain
511  // (most tensile) will correspond to the first crack.
512  _crack_rotation[_qp].fillColumn(0, eigvec.column(2));
513  _crack_rotation[_qp].fillColumn(1, eigvec.column(1));
514  _crack_rotation[_qp].fillColumn(2, eigvec.column(0));
515 
516  strain_in_crack_dir(0) = eigval[2];
517  strain_in_crack_dir(1) = eigval[1];
518  strain_in_crack_dir(2) = eigval[0];
519  }
520  else if (num_known_dirs == 1)
521  {
522  // This is easily the most complicated case.
523  // 1. Rotate the elastic strain to the orientation associated with the known
524  // crack.
525  // 2. Extract the lower 2x2 block into a separate tensor.
526  // 3. Run the eigen solver on the result.
527  // 4. Update the rotation tensor to reflect the effect of the 2 eigenvectors.
528 
529  // 1.
530  const RankTwoTensor & R = _crack_rotation[_qp];
531  RankTwoTensor ePrime(_elastic_strain[_qp]);
532  ePrime.rotate(R.transpose()); // elastic strain in crack coordinates
533 
534  // 2.
535  ColumnMajorMatrix e2x2(2, 2);
536  e2x2(0, 0) = ePrime(1, 1);
537  e2x2(1, 0) = ePrime(2, 1);
538  e2x2(0, 1) = ePrime(1, 2);
539  e2x2(1, 1) = ePrime(2, 2);
540 
541  // 3.
542  ColumnMajorMatrix e_val2x1(2, 1);
543  ColumnMajorMatrix e_vec2x2(2, 2);
544  e2x2.eigen(e_val2x1, e_vec2x2);
545 
546  // 4.
547  RankTwoTensor eigvec(
548  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));
549 
550  _crack_rotation[_qp] = _crack_rotation_old[_qp] * eigvec; // Roe implementation
551 
552  strain_in_crack_dir(0) = ePrime(0, 0);
553  strain_in_crack_dir(1) = e_val2x1(1, 0);
554  strain_in_crack_dir(2) = e_val2x1(0, 0);
555  }
556  else if (num_known_dirs == 2 || num_known_dirs == 3)
557  {
558  // Rotate to cracked orientation and pick off the strains in the rotated
559  // coordinate directions.
560  const RankTwoTensor & R = _crack_rotation[_qp];
561  RankTwoTensor ePrime(_elastic_strain[_qp]);
562  ePrime.rotate(R.transpose()); // elastic strain in crack coordinates
563 
564  strain_in_crack_dir(0) = ePrime(0, 0);
565  strain_in_crack_dir(1) = ePrime(1, 1);
566  strain_in_crack_dir(2) = ePrime(2, 2);
567  }
568  else
569  mooseError("Invalid number of known crack directions");
570 }
const MaterialProperty< RankTwoTensor > & _crack_rotation_old
MaterialProperty< RankTwoTensor > & _crack_rotation
virtual unsigned int getNumKnownCrackDirs() const
Get the number of known crack directions.
MaterialProperty< RankTwoTensor > & _elastic_strain

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

352 {
356  {
357  RankFourTensor A = _identity_symmetric_four;
358  for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
359  A += _consistent_tangent_operator[i_rmm];
360  mooseAssert(A.isSymmetric(), "Tangent operator isn't symmetric");
361  _Jacobian_mult[_qp] = A.invSymm() * _elasticity_tensor[_qp];
362  }
363  else
364  {
365  const RankFourTensor E_inv = _elasticity_tensor[_qp].invSymm();
367  for (unsigned i_rmm = 1; i_rmm < _num_models; ++i_rmm)
368  _Jacobian_mult[_qp] = _consistent_tangent_operator[i_rmm] * E_inv * _Jacobian_mult[_qp];
369  }
370 }
MaterialProperty< RankFourTensor > & _Jacobian_mult
derivative of stress w.r.t. strain (_dstress_dstrain)
std::vector< RankFourTensor > _consistent_tangent_operator
the consistent tangent operators computed by each plastic model
const RankFourTensor _identity_symmetric_four
Rank four symmetric identity tensor.
TangentCalculationMethod _tangent_calculation_method
Calculation method for the tangent modulus.
const unsigned _num_models
number of plastic models
const MaterialProperty< RankFourTensor > & _elasticity_tensor
Rank-4 and Rank-2 elasticity and elastic strain tensors.

◆ computeQpProperties()

void ComputeStressBase::computeQpProperties ( )
overrideprotectedvirtualinherited

Definition at line 51 of file ComputeStressBase.C.

52 {
54 
55  // Add in extra stress
56  _stress[_qp] += _extra_stress[_qp];
57 }
virtual void computeQpStress()=0
MaterialProperty< RankTwoTensor > & _stress
const MaterialProperty< RankTwoTensor > & _extra_stress
Extra stress tensor.

◆ computeQpStress()

void ComputeSmearedCrackingStress::computeQpStress ( )
overridevirtual

Reimplemented from ComputeMultipleInelasticStress.

Definition at line 245 of file ComputeSmearedCrackingStress.C.

246 {
247  bool force_elasticity_rotation = false;
248 
249  if (!previouslyCracked())
251  else
252  {
254 
255  // Propagate behavior from the (now inactive) inelastic models
257  for (auto model : _models)
258  {
259  model->setQp(_qp);
260  model->propagateQpStatefulProperties();
261  }
262 
263  // Since the other inelastic models are inactive, they will not limit the time step
264  _matl_timestep_limit[_qp] = std::numeric_limits<Real>::max();
265 
266  // update _local_elasticity_tensor based on cracking state in previous time step
268 
269  // Calculate stress in intermediate configuration
271 
273  force_elasticity_rotation = true;
274  }
275 
276  // compute crack status and adjust stress
278 
280  {
281  finiteStrainRotation(force_elasticity_rotation);
283  }
284 }
MaterialProperty< RankFourTensor > & _Jacobian_mult
derivative of stress w.r.t. strain (_dstress_dstrain)
const MaterialProperty< RankTwoTensor > & _rotation_increment
const MaterialProperty< RankTwoTensor > & _elastic_strain_old
MaterialProperty< Real > & _matl_timestep_limit
const MaterialProperty< RankTwoTensor > & _strain_increment
void updateLocalElasticityTensor()
Update the local elasticity tensor (_local_elasticity_tensor) due to the effects of cracking...
MaterialProperty< RankTwoTensor > & _crack_rotation
bool previouslyCracked()
Check to see whether there was cracking in any diretion in the previous time step.
MaterialProperty< RankTwoTensor > & _stress
const MaterialProperty< RankTwoTensor > & _inelastic_strain_old
old value of inelastic strain
virtual void computeQpStressIntermediateConfiguration()
Compute the stress for the current QP, but do not rotate tensors from the intermediate configuration ...
virtual void finiteStrainRotation(const bool force_elasticity_rotation=false)
Rotate _elastic_strain, _stress, _inelastic_strain, and _Jacobian_mult to the new configuration...
std::vector< StressUpdateBase * > _models
The user supplied list of inelastic models to use in the simulation.
const bool _perform_finite_strain_rotations
after updateQpState, rotate the stress, elastic_strain, inelastic_strain and Jacobian_mult using _rot...
MaterialProperty< RankTwoTensor > & _elastic_strain
virtual void updateCrackingStateAndStress()
Update all cracking-related state variables and the stress tensor due to cracking in all directions...
MaterialProperty< RankTwoTensor > & _inelastic_strain
The sum of the inelastic strains that come from the plastic models.

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

183 {
184  RankTwoTensor elastic_strain_increment;
185  RankTwoTensor combined_inelastic_strain_increment;
186 
187  if (_num_models == 0)
188  {
190 
191  // If the elasticity tensor values have changed and the tensor is isotropic,
192  // use the old strain to calculate the old stress
195  else
196  _stress[_qp] = _stress_old[_qp] + _elasticity_tensor[_qp] * _strain_increment[_qp];
197 
198  if (_fe_problem.currentlyComputingJacobian())
200  }
201  else
202  {
203  if (_num_models == 1 || _cycle_models)
204  updateQpStateSingleModel((_t_step - 1) % _num_models,
205  elastic_strain_increment,
206  combined_inelastic_strain_increment);
207  else
208  updateQpState(elastic_strain_increment, combined_inelastic_strain_increment);
209 
210  _elastic_strain[_qp] = _elastic_strain_old[_qp] + elastic_strain_increment;
211  _inelastic_strain[_qp] = _inelastic_strain_old[_qp] + combined_inelastic_strain_increment;
212  }
213 }
bool _is_elasticity_tensor_guaranteed_isotropic
is the elasticity tensor guaranteed to be isotropic?
MaterialProperty< RankFourTensor > & _Jacobian_mult
derivative of stress w.r.t. strain (_dstress_dstrain)
const MaterialProperty< RankTwoTensor > & _elastic_strain_old
const MaterialProperty< RankTwoTensor > & _strain_increment
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...
MaterialProperty< RankTwoTensor > & _stress
const MaterialProperty< RankTwoTensor > & _inelastic_strain_old
old value of inelastic strain
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...
const bool _cycle_models
whether to cycle through the models, using only one model per timestep
const unsigned _num_models
number of plastic models
const MaterialProperty< RankFourTensor > & _elasticity_tensor
Rank-4 and Rank-2 elasticity and elastic strain tensors.
const MaterialProperty< RankTwoTensor > & _stress_old
const bool _perform_finite_strain_rotations
after updateQpState, rotate the stress, elastic_strain, inelastic_strain and Jacobian_mult using _rot...
MaterialProperty< RankTwoTensor > & _elastic_strain
MaterialProperty< RankTwoTensor > & _inelastic_strain
The sum of the inelastic strains that come from the plastic models.

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

217 {
218  _elastic_strain[_qp] =
219  _rotation_increment[_qp] * _elastic_strain[_qp] * _rotation_increment[_qp].transpose();
220  _stress[_qp] = _rotation_increment[_qp] * _stress[_qp] * _rotation_increment[_qp].transpose();
221  _inelastic_strain[_qp] =
222  _rotation_increment[_qp] * _inelastic_strain[_qp] * _rotation_increment[_qp].transpose();
223  if (force_elasticity_rotation ||
226  _Jacobian_mult[_qp].rotate(_rotation_increment[_qp]);
227 }
bool _is_elasticity_tensor_guaranteed_isotropic
is the elasticity tensor guaranteed to be isotropic?
MaterialProperty< RankFourTensor > & _Jacobian_mult
derivative of stress w.r.t. strain (_dstress_dstrain)
const MaterialProperty< RankTwoTensor > & _rotation_increment
MaterialProperty< RankTwoTensor > & _stress
TangentCalculationMethod _tangent_calculation_method
Calculation method for the tangent modulus.
const unsigned _num_models
number of plastic models
MaterialProperty< RankTwoTensor > & _elastic_strain
MaterialProperty< RankTwoTensor > & _inelastic_strain
The sum of the inelastic strains that come from the plastic 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 573 of file ComputeSmearedCrackingStress.C.

Referenced by computeCrackStrainAndOrientation().

574 {
575  unsigned int num_known_dirs = 0;
576  for (unsigned int i = 0; i < 3; ++i)
577  {
578  if (_crack_damage_old[_qp](i) > 0.0 || _prescribed_crack_directions.size() >= i + 1)
579  ++num_known_dirs;
580  }
581  return num_known_dirs;
582 }
const MaterialProperty< RealVectorValue > & _crack_damage_old
std::vector< unsigned int > _prescribed_crack_directions
User-prescribed cracking directions.

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

30 {
31  if (!_gc_feproblem->startedInitialSetup())
32  mooseError("hasGuaranteedMaterialProperty() needs to be called in initialSetup()");
33 
34  // Reference to MaterialWarehouse for testing and retrieving block ids
35  const auto & warehouse = _gc_feproblem->getMaterialWarehouse();
36 
37  // Complete set of ids that this object is active
38  const auto & ids = (_gc_block_restrict && _gc_block_restrict->blockRestricted())
39  ? _gc_block_restrict->blockIDs()
40  : _gc_feproblem->mesh().meshSubdomains();
41 
42  // Loop over each id for this object
43  for (const auto & id : ids)
44  {
45  // If block materials exist, look if any issue the required guarantee
46  if (warehouse.hasActiveBlockObjects(id))
47  {
48  const std::vector<std::shared_ptr<Material>> & mats = warehouse.getActiveBlockObjects(id);
49  for (const auto & mat : mats)
50  {
51  const auto & mat_props = mat->getSuppliedItems();
52  if (mat_props.count(prop_name))
53  {
54  auto guarantee_mat = dynamic_cast<GuaranteeProvider *>(mat.get());
55  if (guarantee_mat && !guarantee_mat->hasGuarantee(prop_name, guarantee))
56  {
57  // we found at least one material on the set of block we operate on
58  // that does _not_ provide the requested guarantee
59  return false;
60  }
61  }
62  }
63  }
64  }
65 
66  return true;
67 }
Add-on class that provides the functionality to issue guarantees for declared material properties...
BlockRestrictable *const _gc_block_restrict
Access block restrictions of the object with this interface.
FEProblemBase *const _gc_feproblem
Reference to the FEProblemBase class.

◆ initialSetup()

void ComputeSmearedCrackingStress::initialSetup ( )
overridevirtual

Reimplemented from ComputeMultipleInelasticStress.

Definition at line 211 of file ComputeSmearedCrackingStress.C.

212 {
214 
216  mooseError("ComputeSmearedCrackingStress requires that the elasticity tensor be "
217  "guaranteed isotropic");
218 
219  std::vector<MaterialName> soft_matls = getParam<std::vector<MaterialName>>("softening_models");
220  if (soft_matls.size() != 0)
221  {
222  for (auto soft_matl : soft_matls)
223  {
225  dynamic_cast<SmearedCrackSofteningBase *>(&getMaterialByName(soft_matl));
226  if (scsb)
227  _softening_models.push_back(scsb);
228  else
229  mooseError("Model " + soft_matl +
230  " is not a softening model that can be used with ComputeSmearedCrackingStress");
231  }
232  if (_softening_models.size() == 1)
233  {
234  // Reuse the same model in all 3 directions
235  _softening_models.push_back(_softening_models[0]);
236  _softening_models.push_back(_softening_models[0]);
237  }
238  else if (_softening_models.size() != 3)
239  mooseError("If 'softening_models' is specified in ComputeSmearedCrackingStress, either 1 or "
240  "3 models must be provided");
241  }
242 }
const std::string _elasticity_tensor_name
std::vector< SmearedCrackSofteningBase * > _softening_models
The user-supplied list of softening models to be used in the 3 crack directions.
SmearedCrackSofteningBase is the base class for a set of models that define the softening behavior of...
bool hasGuaranteedMaterialProperty(const MaterialPropertyName &prop, Guarantee guarantee)

◆ initQpStatefulProperties()

void ComputeSmearedCrackingStress::initQpStatefulProperties ( )
overridevirtual

Reimplemented from ComputeMultipleInelasticStress.

Definition at line 148 of file ComputeSmearedCrackingStress.C.

149 {
151 
152  _crack_damage[_qp] = 0.0;
153 
154  _crack_initiation_strain[_qp] = 0.0;
155  _crack_max_strain[_qp](0) = 0.0;
156 
157  switch (_prescribed_crack_directions.size())
158  {
159  case 0:
160  {
161  _crack_rotation[_qp] = RankTwoTensor::Identity();
162  break;
163  }
164  case 1:
165  {
166  _crack_rotation[_qp].zero();
167  switch (_prescribed_crack_directions[0])
168  {
169  case 0:
170  {
171  _crack_rotation[_qp](0, 0) = 1.0;
172  _crack_rotation[_qp](1, 1) = 1.0;
173  _crack_rotation[_qp](2, 2) = 1.0;
174  break;
175  }
176  case 1:
177  {
178  _crack_rotation[_qp](1, 0) = 1.0;
179  _crack_rotation[_qp](0, 1) = 1.0;
180  _crack_rotation[_qp](2, 2) = 1.0;
181  break;
182  }
183  case 2:
184  {
185  _crack_rotation[_qp](2, 0) = 1.0;
186  _crack_rotation[_qp](0, 1) = 1.0;
187  _crack_rotation[_qp](1, 2) = 1.0;
188  break;
189  }
190  }
191  break;
192  }
193  case 2:
194  {
195  mooseError("Number of prescribed crack directions cannot be 2");
196  break;
197  }
198  case 3:
199  {
200  for (unsigned int i = 0; i < _prescribed_crack_directions.size(); ++i)
201  {
202  RealVectorValue crack_dir_vec;
203  crack_dir_vec(_prescribed_crack_directions[i]) = 1.0;
204  _crack_rotation[_qp].fillColumn(i, crack_dir_vec);
205  }
206  }
207  }
208 }
MaterialProperty< RealVectorValue > & _crack_max_strain
MaterialProperty< RealVectorValue > & _crack_initiation_strain
MaterialProperty< RankTwoTensor > & _crack_rotation
MaterialProperty< RealVectorValue > & _crack_damage
std::vector< unsigned int > _prescribed_crack_directions
User-prescribed cracking directions.

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

676 {
677  for (unsigned int i = 0; i < 3; ++i)
678  if (_crack_damage_old[_qp](i) > 0.0)
679  return true;
680  return false;
681 }
const MaterialProperty< RealVectorValue > & _crack_damage_old

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

375 {
376  const Real youngs_modulus =
378  const Real cracking_alpha = -youngs_modulus;
379 
380  Real cracking_stress = _cracking_stress[_qp];
381 
382  if (cracking_stress > 0)
383  {
384  // Initializing crack states
386 
387  for (unsigned i = 0; i < 3; ++i)
388  {
389  _crack_max_strain[_qp](i) = _crack_max_strain_old[_qp](i);
391  _crack_damage[_qp](i) = _crack_damage_old[_qp](i);
392  }
393 
394  // Compute crack orientations: updated _crack_rotation[_qp] based on current strain
395  RealVectorValue strain_in_crack_dir;
396  computeCrackStrainAndOrientation(strain_in_crack_dir);
397 
398  for (unsigned i = 0; i < 3; ++i)
399  {
400  if (strain_in_crack_dir(i) > _crack_max_strain[_qp](i))
401  _crack_max_strain[_qp](i) = strain_in_crack_dir(i);
402  }
403 
404  // Check for new cracks.
405  // Rotate stress to cracked orientation.
406  const RankTwoTensor & R = _crack_rotation[_qp];
407  RankTwoTensor sigmaPrime(_stress[_qp]);
408  sigmaPrime.rotate(R.transpose()); // stress in crack coordinates
409 
410  unsigned int num_cracks = 0;
411  for (unsigned int i = 0; i < 3; ++i)
412  {
413  if (_crack_damage_old[_qp](i) > 0.0)
414  ++num_cracks;
415  }
416 
417  bool cracked(false);
418  RealVectorValue sigma;
419  for (unsigned int i = 0; i < 3; ++i)
420  {
421  sigma(i) = sigmaPrime(i, i);
422 
423  Real stiffness_ratio = 1.0 - _crack_damage[_qp](i);
424 
425  const bool pre_existing_crack = (_crack_damage_old[_qp](i) > 0.0);
426  const bool met_stress_criterion = (sigma(i) > cracking_stress);
427  const bool loading_existing_crack = (strain_in_crack_dir(i) >= _crack_max_strain[_qp](i));
428  const bool allowed_to_crack = (pre_existing_crack || num_cracks < _max_cracks);
429  bool new_crack = false;
430 
431  cracked |= pre_existing_crack;
432 
433  // Adjustments for newly created cracks
434  if (met_stress_criterion && !pre_existing_crack && allowed_to_crack)
435  {
436  new_crack = true;
437  ++num_cracks;
438 
439  // Assume Poisson's ratio drops to zero for this direction. Stiffness is then Young's
440  // modulus.
441  _crack_initiation_strain[_qp](i) = cracking_stress / youngs_modulus;
442 
443  if (_crack_max_strain[_qp](i) < _crack_initiation_strain[_qp](i))
445  }
446 
447  // Update stress and stiffness ratio according to specified crack release model
448  if (new_crack || (pre_existing_crack && loading_existing_crack))
449  {
450  cracked = true;
451  if (_softening_models.size() != 0)
453  stiffness_ratio,
454  strain_in_crack_dir(i),
455  _crack_initiation_strain[_qp](i),
456  _crack_max_strain[_qp](i),
457  cracking_stress,
458  youngs_modulus);
459  else
461  sigma(i),
462  stiffness_ratio,
463  strain_in_crack_dir(i),
464  cracking_stress,
465  cracking_alpha,
466  youngs_modulus);
467  _crack_damage[_qp](i) = 1.0 - stiffness_ratio;
468  }
469 
470  else if (cracked && _cracking_neg_fraction > 0 &&
471  _crack_initiation_strain[_qp](i) * _cracking_neg_fraction > strain_in_crack_dir(i) &&
472  -_crack_initiation_strain[_qp](i) * _cracking_neg_fraction < strain_in_crack_dir(i))
473  {
474  const Real etr = _cracking_neg_fraction * _crack_initiation_strain[_qp](i);
475  const Real Eo = cracking_stress / _crack_initiation_strain[_qp](i);
476  const Real Ec = Eo * (1.0 - _crack_damage_old[_qp](i));
477  const Real a = (Ec - Eo) / (4.0 * etr);
478  const Real b = 0.5 * (Ec + Eo);
479  const Real c = 0.25 * (Ec - Eo) * etr;
480  sigma(i) = (a * strain_in_crack_dir(i) + b) * strain_in_crack_dir(i) + c;
481  }
482  }
483 
484  if (cracked)
486  }
487 
488  _crack_flags[_qp](0) = 1.0 - _crack_damage[_qp](2);
489  _crack_flags[_qp](1) = 1.0 - _crack_damage[_qp](1);
490  _crack_flags[_qp](2) = 1.0 - _crack_damage[_qp](0);
491 }
void updateStressTensorForCracking(RankTwoTensor &tensor, const RealVectorValue &sigma)
Updates the full stress tensor to account for the effect of cracking using the provided stresses in t...
MaterialProperty< RealVectorValue > & _crack_max_strain
MaterialProperty< RealVectorValue > & _crack_initiation_strain
const unsigned int _max_cracks
Maximum number of cracks permitted at a material point.
const MaterialProperty< RankTwoTensor > & _crack_rotation_old
const MaterialProperty< RealVectorValue > & _crack_max_strain_old
MaterialProperty< RankTwoTensor > & _crack_rotation
std::vector< SmearedCrackSofteningBase * > _softening_models
The user-supplied list of softening models to be used in the 3 crack directions.
MaterialProperty< RankTwoTensor > & _stress
void computeCrackStrainAndOrientation(RealVectorValue &strain_in_crack_dir)
Compute the crack strain in the crack coordinate system.
const VariableValue & _cracking_stress
Threshold at which cracking initiates if tensile stress exceeds it.
MaterialProperty< RealVectorValue > & _crack_flags
Vector of values going from 1 to 0 as crack damage accumulates.
const MaterialProperty< RankFourTensor > & _elasticity_tensor
Rank-4 and Rank-2 elasticity and elastic strain tensors.
Real getIsotropicYoungsModulus(const RankFourTensor &elasticity_tensor)
Get the Young&#39;s modulus for an isotropic elasticity tensor param elasticity_tensor the tensor (must b...
const Real _cracking_neg_fraction
Defines transition to changed stiffness during unloading.
MaterialProperty< RealVectorValue > & _crack_damage
const MaterialProperty< RealVectorValue > & _crack_damage_old
const MaterialProperty< RealVectorValue > & _crack_initiation_strain_old
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 si...

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

288 {
289  const Real youngs_modulus =
291 
292  bool cracking_locally_active = false;
293 
294  const Real cracking_stress = _cracking_stress[_qp];
295 
296  if (cracking_stress > 0)
297  {
298  RealVectorValue stiffness_ratio_local(1.0, 1.0, 1.0);
299  const RankTwoTensor & R = _crack_rotation_old[_qp];
300  RankTwoTensor ePrime(_elastic_strain_old[_qp]);
301  ePrime.rotate(R.transpose());
302 
303  for (unsigned int i = 0; i < 3; ++i)
304  {
305  // Update elasticity tensor based on crack status of the end of last time step
306  if (_crack_damage_old[_qp](i) > 0.0)
307  {
308  if (_cracking_neg_fraction == 0.0 && MooseUtils::absoluteFuzzyLessThan(ePrime(i, i), 0.0))
309  stiffness_ratio_local(i) = 1.0;
310  else if (_cracking_neg_fraction > 0.0 &&
311  ePrime(i, i) < _crack_initiation_strain_old[_qp](i) * _cracking_neg_fraction &&
312  ePrime(i, i) > -_crack_initiation_strain_old[_qp](i) * _cracking_neg_fraction)
313  {
314  const Real etr = _cracking_neg_fraction * _crack_initiation_strain_old[_qp](i);
315  const Real Eo = cracking_stress / _crack_initiation_strain_old[_qp](i);
316  const Real Ec = Eo * (1.0 - _crack_damage_old[_qp](i));
317  const Real a = (Ec - Eo) / (4 * etr);
318  const Real b = (Ec + Eo) / 2;
319  // Compute the ratio of the current transition stiffness to the original stiffness
320  stiffness_ratio_local(i) = (2.0 * a * etr + b) / Eo;
321  cracking_locally_active = true;
322  }
323  else
324  {
325  stiffness_ratio_local(i) = (1.0 - _crack_damage_old[_qp](i));
326  cracking_locally_active = true;
327  }
328  }
329  }
330 
331  if (cracking_locally_active)
332  {
333  // Update the elasticity tensor in the crack coordinate system
334  const bool c0_coupled = MooseUtils::absoluteFuzzyEqual(stiffness_ratio_local(0), 1.0);
335  const bool c1_coupled = MooseUtils::absoluteFuzzyEqual(stiffness_ratio_local(1), 1.0);
336  const bool c2_coupled = MooseUtils::absoluteFuzzyEqual(stiffness_ratio_local(2), 1.0);
337 
338  const Real c01 = (c0_coupled && c1_coupled ? 1.0 : 0.0);
339  const Real c02 = (c0_coupled && c2_coupled ? 1.0 : 0.0);
340  const Real c12 = (c1_coupled && c2_coupled ? 1.0 : 0.0);
341 
342  const Real c01_shear_retention = (c0_coupled && c1_coupled ? 1.0 : _shear_retention_factor);
343  const Real c02_shear_retention = (c0_coupled && c2_coupled ? 1.0 : _shear_retention_factor);
344  const Real c12_shear_retention = (c1_coupled && c2_coupled ? 1.0 : _shear_retention_factor);
345 
346  // Filling with 9 components is sufficient because these are the only nonzero entries
347  // for isotropic or orthotropic materials.
348  std::vector<Real> local_elastic(9);
349 
350  local_elastic[0] = (c0_coupled ? _elasticity_tensor[_qp](0, 0, 0, 0)
351  : stiffness_ratio_local(0) * youngs_modulus);
352  local_elastic[1] = _elasticity_tensor[_qp](0, 0, 1, 1) * c01;
353  local_elastic[2] = _elasticity_tensor[_qp](0, 0, 2, 2) * c02;
354  local_elastic[3] = (c1_coupled ? _elasticity_tensor[_qp](1, 1, 1, 1)
355  : stiffness_ratio_local(1) * youngs_modulus);
356  local_elastic[4] = _elasticity_tensor[_qp](1, 1, 2, 2) * c12;
357  local_elastic[5] = (c2_coupled ? _elasticity_tensor[_qp](2, 2, 2, 2)
358  : stiffness_ratio_local(2) * youngs_modulus);
359  local_elastic[6] = _elasticity_tensor[_qp](1, 2, 1, 2) * c12_shear_retention;
360  local_elastic[7] = _elasticity_tensor[_qp](0, 2, 0, 2) * c02_shear_retention;
361  local_elastic[8] = _elasticity_tensor[_qp](0, 1, 0, 1) * c01_shear_retention;
362 
363  _local_elasticity_tensor.fillFromInputVector(local_elastic, RankFourTensor::symmetric9);
364 
365  // Rotate the modified elasticity tensor back into global coordinates
366  _local_elasticity_tensor.rotate(R);
367  }
368  }
369  if (!cracking_locally_active)
371 }
const MaterialProperty< RankTwoTensor > & _elastic_strain_old
const MaterialProperty< RankTwoTensor > & _crack_rotation_old
const VariableValue & _cracking_stress
Threshold at which cracking initiates if tensile stress exceeds it.
const MaterialProperty< RankFourTensor > & _elasticity_tensor
Rank-4 and Rank-2 elasticity and elastic strain tensors.
Real getIsotropicYoungsModulus(const RankFourTensor &elasticity_tensor)
Get the Young&#39;s modulus for an isotropic elasticity tensor param elasticity_tensor the tensor (must b...
const Real _cracking_neg_fraction
Defines transition to changed stiffness during unloading.
const Real _shear_retention_factor
Controls the amount of shear retained.
const MaterialProperty< RealVectorValue > & _crack_damage_old
const MaterialProperty< RealVectorValue > & _crack_initiation_strain_old

◆ 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_incrementThe elastic part of _strain_increment[_qp] after the iterative process has converged
combined_inelastic_strain_incrementThe 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().

232 {
234  {
235  _console << std::endl
236  << "iteration output for ComputeMultipleInelasticStress solve:"
237  << " time=" << _t << " int_pt=" << _qp << std::endl;
238  }
239  Real l2norm_delta_stress;
240  Real first_l2norm_delta_stress = 1.0;
241  unsigned int counter = 0;
242 
243  std::vector<RankTwoTensor> inelastic_strain_increment;
244  inelastic_strain_increment.resize(_num_models);
245 
246  for (unsigned i_rmm = 0; i_rmm < _models.size(); ++i_rmm)
247  inelastic_strain_increment[i_rmm].zero();
248 
249  RankTwoTensor stress_max, stress_min;
250 
251  do
252  {
253  for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
254  {
255  _models[i_rmm]->setQp(_qp);
256 
257  // initially assume the strain is completely elastic
258  elastic_strain_increment = _strain_increment[_qp];
259  // and subtract off all inelastic strain increments calculated so far
260  // except the one that we're about to calculate
261  for (unsigned j_rmm = 0; j_rmm < _num_models; ++j_rmm)
262  if (i_rmm != j_rmm)
263  elastic_strain_increment -= inelastic_strain_increment[j_rmm];
264 
265  // form the trial stress, with the check for changed elasticity constants
267  _stress[_qp] =
268  _elasticity_tensor[_qp] * (_elastic_strain_old[_qp] + elastic_strain_increment);
269  else
270  _stress[_qp] = _stress_old[_qp] + _elasticity_tensor[_qp] * elastic_strain_increment;
271 
272  // given a trial stress (_stress[_qp]) and a strain increment (elastic_strain_increment)
273  // let the i^th model produce an admissible stress (as _stress[_qp]), and decompose
274  // the strain increment into an elastic part (elastic_strain_increment) and an
275  // inelastic part (inelastic_strain_increment[i_rmm])
277  elastic_strain_increment,
278  inelastic_strain_increment[i_rmm],
280 
281  if (i_rmm == 0)
282  {
283  stress_max = _stress[_qp];
284  stress_min = _stress[_qp];
285  }
286  else
287  {
288  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
289  {
290  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
291  {
292  if (_stress[_qp](i, j) > stress_max(i, j))
293  stress_max(i, j) = _stress[_qp](i, j);
294  else if (stress_min(i, j) > _stress[_qp](i, j))
295  stress_min(i, j) = _stress[_qp](i, j);
296  }
297  }
298  }
299  }
300 
301  // now check convergence in the stress:
302  // once the change in stress is within tolerance after each recompute material
303  // consider the stress to be converged
304  l2norm_delta_stress = (stress_max - stress_min).L2norm();
305  if (counter == 0 && l2norm_delta_stress > 0.0)
306  first_l2norm_delta_stress = l2norm_delta_stress;
307 
309  {
310  _console << "stress iteration number = " << counter << "\n"
311  << " relative l2 norm delta stress = "
312  << (0 == first_l2norm_delta_stress ? 0
313  : l2norm_delta_stress / first_l2norm_delta_stress)
314  << "\n"
315  << " stress convergence relative tolerance = " << _relative_tolerance << "\n"
316  << " absolute l2 norm delta stress = " << l2norm_delta_stress << "\n"
317  << " stress convergence absolute tolerance = " << _absolute_tolerance << std::endl;
318  }
319  ++counter;
320  } while (counter < _max_iterations && l2norm_delta_stress > _absolute_tolerance &&
321  (l2norm_delta_stress / first_l2norm_delta_stress) > _relative_tolerance &&
322  _num_models != 1);
323 
324  if (counter == _max_iterations && l2norm_delta_stress > _absolute_tolerance &&
325  (l2norm_delta_stress / first_l2norm_delta_stress) > _relative_tolerance)
326  throw MooseException("Max stress iteration hit during ComputeMultipleInelasticStress solve!");
327 
328  combined_inelastic_strain_increment.zero();
329  for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
330  combined_inelastic_strain_increment +=
331  _inelastic_weights[i_rmm] * inelastic_strain_increment[i_rmm];
332 
333  if (_fe_problem.currentlyComputingJacobian())
335 
336  _matl_timestep_limit[_qp] = 0.0;
337  for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
338  _matl_timestep_limit[_qp] += 1.0 / _models[i_rmm]->computeTimeStepLimit();
339 
340  if (MooseUtils::absoluteFuzzyEqual(_matl_timestep_limit[_qp], 0.0))
341  {
342  _matl_timestep_limit[_qp] = std::numeric_limits<Real>::max();
343  }
344  else
345  {
346  _matl_timestep_limit[_qp] = 1.0 / _matl_timestep_limit[_qp];
347  }
348 }
bool _is_elasticity_tensor_guaranteed_isotropic
is the elasticity tensor guaranteed to be isotropic?
std::vector< RankFourTensor > _consistent_tangent_operator
the consistent tangent operators computed by each plastic model
const MaterialProperty< RankTwoTensor > & _elastic_strain_old
MaterialProperty< Real > & _matl_timestep_limit
const MaterialProperty< RankTwoTensor > & _strain_increment
const std::vector< Real > _inelastic_weights
_inelastic_strain = sum_i (_inelastic_weights_i * inelastic_strain_from_model_i)
MaterialProperty< RankTwoTensor > & _stress
const unsigned _num_models
number of plastic models
const MaterialProperty< RankFourTensor > & _elasticity_tensor
Rank-4 and Rank-2 elasticity and elastic strain tensors.
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_n...
const MaterialProperty< RankTwoTensor > & _stress_old
std::vector< StressUpdateBase * > _models
The user supplied list of inelastic models to use in the simulation.
Real L2norm(const RankTwoTensor &r2tensor)
const bool _perform_finite_strain_rotations
after updateQpState, rotate the stress, elastic_strain, inelastic_strain and Jacobian_mult using _rot...
virtual void computeQpJacobianMult()
Using _elasticity_tensor[_qp] and the consistent tangent operators, _consistent_tangent_operator[...] computed by the inelastic models, compute _Jacobian_mult[_qp].
static unsigned int counter
const unsigned int _max_iterations
Input parameters associated with the recompute iteration to return the stress state to the yield surf...

◆ 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_numberUse this model number
elastic_strain_incrementThe elastic part of _strain_increment[_qp]
combined_inelastic_strain_incrementThe inelastic part of _strain_increment[_qp]

Definition at line 373 of file ComputeMultipleInelasticStress.C.

Referenced by ComputeMultipleInelasticStress::computeQpStressIntermediateConfiguration().

377 {
378  for (auto model : _models)
379  model->setQp(_qp);
380 
381  elastic_strain_increment = _strain_increment[_qp];
382 
383  // If the elasticity tensor values have changed and the tensor is isotropic,
384  // use the old strain to calculate the old stress
386  _stress[_qp] = _elasticity_tensor[_qp] * (_elastic_strain_old[_qp] + elastic_strain_increment);
387  else
388  _stress[_qp] = _stress_old[_qp] + _elasticity_tensor[_qp] * elastic_strain_increment;
389 
390  computeAdmissibleState(model_number,
391  elastic_strain_increment,
392  combined_inelastic_strain_increment,
394 
395  if (_fe_problem.currentlyComputingJacobian())
396  {
400  {
402  mooseAssert(A.isSymmetric(), "Tangent operator isn't symmetric");
403  _Jacobian_mult[_qp] = A.invSymm() * _elasticity_tensor[_qp];
404  }
405  else
407  }
408 
409  _matl_timestep_limit[_qp] = _models[0]->computeTimeStepLimit();
410 
411  /* propagate internal variables, etc, to this timestep for those inelastic models where
412  * "updateState" is not called */
413  for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
414  if (i_rmm != model_number)
415  _models[i_rmm]->propagateQpStatefulProperties();
416 }
bool _is_elasticity_tensor_guaranteed_isotropic
is the elasticity tensor guaranteed to be isotropic?
MaterialProperty< RankFourTensor > & _Jacobian_mult
derivative of stress w.r.t. strain (_dstress_dstrain)
std::vector< RankFourTensor > _consistent_tangent_operator
the consistent tangent operators computed by each plastic model
const MaterialProperty< RankTwoTensor > & _elastic_strain_old
MaterialProperty< Real > & _matl_timestep_limit
const MaterialProperty< RankTwoTensor > & _strain_increment
MaterialProperty< RankTwoTensor > & _stress
const RankFourTensor _identity_symmetric_four
Rank four symmetric identity tensor.
TangentCalculationMethod _tangent_calculation_method
Calculation method for the tangent modulus.
const unsigned _num_models
number of plastic models
const MaterialProperty< RankFourTensor > & _elasticity_tensor
Rank-4 and Rank-2 elasticity and elastic strain tensors.
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_n...
const MaterialProperty< RankTwoTensor > & _stress_old
std::vector< StressUpdateBase * > _models
The user supplied list of inelastic models to use in the simulation.
const bool _perform_finite_strain_rotations
after updateQpState, rotate the stress, elastic_strain, inelastic_strain and Jacobian_mult using _rot...

◆ 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
tensorStress tensor to be updated
sigmaVector of stresses in crack directions

Definition at line 649 of file ComputeSmearedCrackingStress.C.

Referenced by updateCrackingStateAndStress().

651 {
652  // Get transformation matrix
653  const RankTwoTensor & R = _crack_rotation[_qp];
654  // Rotate to crack frame
655  tensor.rotate(R.transpose());
656 
657  // Reset stress if cracked
658  for (unsigned int i = 0; i < 3; ++i)
659  if (_crack_damage[_qp](i) > 0.0)
660  {
661  const Real stress_correction_ratio = (tensor(i, i) - sigma(i)) / tensor(i, i);
662  if (stress_correction_ratio > _max_stress_correction)
663  tensor(i, i) *= (1.0 - _max_stress_correction);
664  else if (stress_correction_ratio < -_max_stress_correction)
665  tensor(i, i) *= (1.0 + _max_stress_correction);
666  else
667  tensor(i, i) = sigma(i);
668  }
669 
670  // Rotate back to global frame
671  tensor.rotate(R);
672 }
MaterialProperty< RankTwoTensor > & _crack_rotation
const Real _max_stress_correction
Controls the maximum amount that the damaged elastic stress is corrected to folow the release model d...
MaterialProperty< RealVectorValue > & _crack_damage

Member Data Documentation

◆ _absolute_tolerance

const Real ComputeMultipleInelasticStress::_absolute_tolerance
protectedinherited

◆ _base_name

const std::string ComputeStressBase::_base_name
protectedinherited

◆ _consistent_tangent_operator

std::vector<RankFourTensor> ComputeMultipleInelasticStress::_consistent_tangent_operator
protectedinherited

◆ _crack_damage

MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_damage
protected

◆ _crack_damage_old

const MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_damage_old
protected

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

◆ _crack_initiation_strain_old

const MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_initiation_strain_old
protected

◆ _crack_max_strain

MaterialProperty<RealVectorValue>& ComputeSmearedCrackingStress::_crack_max_strain
protected

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

◆ _crack_rotation_old

const MaterialProperty<RankTwoTensor>& ComputeSmearedCrackingStress::_crack_rotation_old
protected

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

◆ _elastic_strain_old

const MaterialProperty<RankTwoTensor>& ComputeMultipleInelasticStress::_elastic_strain_old
protectedinherited

◆ _elasticity_tensor

const MaterialProperty<RankFourTensor>& ComputeMultipleInelasticStress::_elasticity_tensor
protectedinherited

◆ _elasticity_tensor_name

const std::string ComputeStressBase::_elasticity_tensor_name
protectedinherited

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

◆ _inelastic_strain

MaterialProperty<RankTwoTensor>& ComputeMultipleInelasticStress::_inelastic_strain
protectedinherited

◆ _inelastic_strain_old

const MaterialProperty<RankTwoTensor>& ComputeMultipleInelasticStress::_inelastic_strain_old
protectedinherited

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

◆ _is_elasticity_tensor_guaranteed_isotropic

bool ComputeMultipleInelasticStress::_is_elasticity_tensor_guaranteed_isotropic
protectedinherited

◆ _Jacobian_mult

MaterialProperty<RankFourTensor>& ComputeStressBase::_Jacobian_mult
protectedinherited

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

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

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

◆ _num_models

const unsigned ComputeMultipleInelasticStress::_num_models
protectedinherited

◆ _perform_finite_strain_rotations

const bool ComputeMultipleInelasticStress::_perform_finite_strain_rotations
protectedinherited

◆ _prescribed_crack_directions

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

User-prescribed cracking directions.

Definition at line 113 of file ComputeSmearedCrackingStress.h.

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

◆ _relative_tolerance

const Real ComputeMultipleInelasticStress::_relative_tolerance
protectedinherited

◆ _rotation_increment

const MaterialProperty<RankTwoTensor>& ComputeFiniteStrainElasticStress::_rotation_increment
protectedinherited

◆ _shear_retention_factor

const Real ComputeSmearedCrackingStress::_shear_retention_factor
protected

Controls the amount of shear retained.

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

Referenced by initialSetup(), and updateCrackingStateAndStress().

◆ _strain_increment

const MaterialProperty<RankTwoTensor>& ComputeMultipleInelasticStress::_strain_increment
protectedinherited

◆ _stress

MaterialProperty<RankTwoTensor>& ComputeStressBase::_stress
protectedinherited

◆ _stress_old

const MaterialProperty<RankTwoTensor>& ComputeFiniteStrainElasticStress::_stress_old
protectedinherited

◆ _tangent_calculation_method

TangentCalculationMethod ComputeMultipleInelasticStress::_tangent_calculation_method
protectedinherited

◆ _tangent_computation_flag

std::vector<bool> ComputeMultipleInelasticStress::_tangent_computation_flag
protectedinherited

Flags to compute tangent during updateState call.

Definition at line 147 of file ComputeMultipleInelasticStress.h.

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

◆ _tangent_operator_type

enum ComputeMultipleInelasticStress::TangentOperatorEnum ComputeMultipleInelasticStress::_tangent_operator_type
protectedinherited

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