www.mooseframework.org
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
ADComputeMultipleInelasticStress< compute_stage > Class Template Reference

ADComputeMultipleInelasticStress computes the stress and a decomposition of the strain into elastic and inelastic parts. More...

#include <ADComputeMultipleInelasticStress.h>

Inheritance diagram for ADComputeMultipleInelasticStress< compute_stage >:
[legend]

Public Member Functions

 ADComputeMultipleInelasticStress (const InputParameters &parameters)
 
virtual void initialSetup () override
 

Protected Member Functions

virtual void initQpStatefulProperties () override
 
virtual void computeQpStress () override
 
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 ()
 Rotate _elastic_strain, _stress, and _inelastic_strain to the new configuration. More...
 
virtual void updateQpState (ADRankTwoTensor &elastic_strain_increment, ADRankTwoTensor &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. More...
 
virtual void updateQpStateSingleModel (unsigned model_number, ADRankTwoTensor &elastic_strain_increment, ADRankTwoTensor &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. More...
 
virtual void computeAdmissibleState (unsigned model_number, ADRankTwoTensor &elastic_strain_increment, ADRankTwoTensor &inelastic_strain_increment)
 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). More...
 
 ADMaterialProperty (RankTwoTensor) &_inelastic_strain
 The sum of the inelastic strains that come from the plastic models. More...
 
const ADMaterialProperty (RankFourTensor) &_elasticity_tensor
 Elasticity tensor material property. More...
 
virtual void computeQpProperties () override
 
bool hasGuaranteedMaterialProperty (const MaterialPropertyName &prop, Guarantee guarantee)
 

Protected Attributes

const bool _perform_finite_strain_rotations
 after updateQpState, rotate the stress, elastic_strain, and inelastic_strain using _rotation_increment More...
 
const MaterialProperty< RankTwoTensor > & _inelastic_strain_old
 old value of inelastic strain More...
 
const unsigned _num_models
 number of plastic models More...
 
const std::vector< Real > _inelastic_weights
 _inelastic_strain = sum_i (_inelastic_weights_i * inelastic_strain_from_model_i) More...
 
const bool _cycle_models
 whether to cycle through the models, using only one model per timestep More...
 
MaterialProperty< Real > & _matl_timestep_limit
 
std::vector< ADStressUpdateBase< compute_stage > * > _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...
 
 usingComputeFiniteStrainElasticStressMembers
 
const std::string _elasticity_tensor_name
 Name of the elasticity tensor material property. More...
 
const MaterialProperty< RankTwoTensor > & _stress_old
 
const MaterialProperty< RankTwoTensor > & _elastic_strain_old
 The old elastic strain is used to calculate the old stress in the case of variable elasticity tensors. More...
 
 usingComputeStressBaseMembers
 
const std::string _base_name
 
std::vector< Function * > _initial_stress_fcn
 initial stress components More...
 
 usingMaterialMembers
 
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
 

Detailed Description

template<ComputeStage compute_stage>
class ADComputeMultipleInelasticStress< compute_stage >

ADComputeMultipleInelasticStress computes the stress and a decomposition of the strain into elastic and inelastic parts.

By default finite strains are assumed.

The elastic strain is calculated by subtracting the computed inelastic strain increment tensor from the mechanical strain tensor. Mechanical strain is considered as the sum of the elastic and inelastic (plastic, creep, ect) strains.

This material is used to call the recompute iterative materials of a number of specified inelastic models that inherit from ADStressUpdateBase. It iterates over the specified inelastic models until the change in stress is within a user-specified tolerance, in order to produce the stress and the elastic and inelastic strains for the time increment.

Definition at line 24 of file ADComputeMultipleInelasticStress.h.

Constructor & Destructor Documentation

◆ ADComputeMultipleInelasticStress()

template<ComputeStage compute_stage>
ADComputeMultipleInelasticStress< compute_stage >::ADComputeMultipleInelasticStress ( const InputParameters &  parameters)

Definition at line 64 of file ADComputeMultipleInelasticStress.C.

67  _max_iterations(parameters.get<unsigned int>("max_iterations")),
68  _relative_tolerance(parameters.get<Real>("relative_tolerance")),
69  _absolute_tolerance(parameters.get<Real>("absolute_tolerance")),
71  adGetParam<bool>("internal_solve_full_iteration_history")),
72  _perform_finite_strain_rotations(adGetParam<bool>("perform_finite_strain_rotations")),
73  _inelastic_strain(adDeclareADProperty<RankTwoTensor>(_base_name + "combined_inelastic_strain")),
75  adGetMaterialPropertyOld<RankTwoTensor>(_base_name + "combined_inelastic_strain")),
76  _num_models(adGetParam<std::vector<MaterialName>>("inelastic_models").size()),
77  _inelastic_weights(isParamValid("combined_inelastic_strain_weights")
78  ? adGetParam<std::vector<Real>>("combined_inelastic_strain_weights")
79  : std::vector<Real>(_num_models, true)),
80  _cycle_models(adGetParam<bool>("cycle_models")),
81  _matl_timestep_limit(adDeclareProperty<Real>("matl_timestep_limit"))
82 {
83  if (_inelastic_weights.size() != _num_models)
84  paramError("combined_inelastic_strain_weights",
85  "must contain the same number of entries as inelastic_models ",
86  _inelastic_weights.size(),
87  " vs. ",
88  _num_models);
89 }
const unsigned _num_models
number of plastic models
const unsigned int _max_iterations
Input parameters associated with the recompute iteration to return the stress state to the yield surf...
const std::string _base_name
const std::vector< Real > _inelastic_weights
_inelastic_strain = sum_i (_inelastic_weights_i * inelastic_strain_from_model_i)
const bool _perform_finite_strain_rotations
after updateQpState, rotate the stress, elastic_strain, and inelastic_strain using _rotation_incremen...
const MaterialProperty< RankTwoTensor > & _inelastic_strain_old
old value of inelastic strain
const bool _cycle_models
whether to cycle through the models, using only one model per timestep
ADComputeFiniteStrainElasticStress computes the stress following elasticity theory for finite strains...

Member Function Documentation

◆ ADMaterialProperty() [1/2]

template<ComputeStage compute_stage>
const ADComputeFiniteStrainElasticStress< compute_stage >::ADMaterialProperty ( RankFourTensor  ) &
protectedinherited

Elasticity tensor material property.

◆ ADMaterialProperty() [2/2]

template<ComputeStage compute_stage>
ADComputeMultipleInelasticStress< compute_stage >::ADMaterialProperty ( RankTwoTensor  ) &
protected

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

◆ computeAdmissibleState()

template<ComputeStage compute_stage>
void ADComputeMultipleInelasticStress< compute_stage >::computeAdmissibleState ( unsigned  model_number,
ADRankTwoTensor &  elastic_strain_increment,
ADRankTwoTensor &  inelastic_strain_increment 
)
protectedvirtual

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

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

Definition at line 324 of file ADComputeMultipleInelasticStress.C.

328 {
329  _models[model_number]->updateState(elastic_strain_increment,
330  inelastic_strain_increment,
331  _rotation_increment[_qp],
332  _stress[_qp],
333  _stress_old[_qp],
334  _elasticity_tensor[_qp],
335  _elastic_strain_old[_qp]);
336 }
const MaterialProperty< RankTwoTensor > & _elastic_strain_old
The old elastic strain is used to calculate the old stress in the case of variable elasticity tensors...
std::vector< ADStressUpdateBase< compute_stage > * > _models
The user supplied list of inelastic models to use in the simulation.
const MaterialProperty< RankTwoTensor > & _stress_old

◆ computeQpProperties()

template<ComputeStage compute_stage>
void ADComputeStressBase< compute_stage >::computeQpProperties ( )
overrideprotectedvirtualinherited

Definition at line 46 of file ADComputeStressBase.C.

47 {
49 
50  // TODO: Add in extra stress (using a list of extra_stress_names analogous to eigenstrain_names)
51 }
virtual void computeQpStress()=0

◆ computeQpStress()

template<ComputeStage compute_stage>
void ADComputeMultipleInelasticStress< compute_stage >::computeQpStress ( )
overrideprotectedvirtual

Reimplemented from ADComputeFiniteStrainElasticStress< compute_stage >.

Definition at line 128 of file ADComputeMultipleInelasticStress.C.

129 {
133 }
virtual void finiteStrainRotation()
Rotate _elastic_strain, _stress, and _inelastic_strain to the new configuration.
virtual void computeQpStressIntermediateConfiguration()
Compute the stress for the current QP, but do not rotate tensors from the intermediate configuration ...
const bool _perform_finite_strain_rotations
after updateQpState, rotate the stress, elastic_strain, and inelastic_strain using _rotation_incremen...

◆ computeQpStressIntermediateConfiguration()

template<ComputeStage compute_stage>
void ADComputeMultipleInelasticStress< compute_stage >::computeQpStressIntermediateConfiguration ( )
protectedvirtual

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

Definition at line 137 of file ADComputeMultipleInelasticStress.C.

138 {
139  ADRankTwoTensor elastic_strain_increment;
140  ADRankTwoTensor combined_inelastic_strain_increment;
141 
142  if (_num_models == 0)
143  {
144  _elastic_strain[_qp] = _elastic_strain_old[_qp] + _strain_increment[_qp];
145 
146  // If the elasticity tensor values have changed and the tensor is isotropic,
147  // use the old strain to calculate the old stress
149  _stress[_qp] = _elasticity_tensor[_qp] * (_elastic_strain_old[_qp] + _strain_increment[_qp]);
150  else
151  _stress[_qp] = _stress_old[_qp] + _elasticity_tensor[_qp] * _strain_increment[_qp];
152  }
153  else
154  {
155  if (_num_models == 1 || _cycle_models)
156  updateQpStateSingleModel((_t_step - 1) % _num_models,
157  elastic_strain_increment,
158  combined_inelastic_strain_increment);
159  else
160  updateQpState(elastic_strain_increment, combined_inelastic_strain_increment);
161 
162  _elastic_strain[_qp] = _elastic_strain_old[_qp] + elastic_strain_increment;
163  _inelastic_strain[_qp] = _inelastic_strain_old[_qp] + combined_inelastic_strain_increment;
164  }
165 }
const MaterialProperty< RankTwoTensor > & _elastic_strain_old
The old elastic strain is used to calculate the old stress in the case of variable elasticity tensors...
const unsigned _num_models
number of plastic models
virtual void updateQpState(ADRankTwoTensor &elastic_strain_increment, ADRankTwoTensor &combined_inelastic_strain_increment)
Given the _strain_increment[_qp], iterate over all of the user-specified recompute materials in order...
bool _is_elasticity_tensor_guaranteed_isotropic
is the elasticity tensor guaranteed to be isotropic?
const MaterialProperty< RankTwoTensor > & _stress_old
const bool _perform_finite_strain_rotations
after updateQpState, rotate the stress, elastic_strain, and inelastic_strain using _rotation_incremen...
const MaterialProperty< RankTwoTensor > & _inelastic_strain_old
old value of inelastic strain
const bool _cycle_models
whether to cycle through the models, using only one model per timestep
virtual void updateQpStateSingleModel(unsigned model_number, ADRankTwoTensor &elastic_strain_increment, ADRankTwoTensor &combined_inelastic_strain_increment)
An optimised version of updateQpState that gets used when the number of plastic models is unity...

◆ finiteStrainRotation()

template<ComputeStage compute_stage>
void ADComputeMultipleInelasticStress< compute_stage >::finiteStrainRotation ( )
protectedvirtual

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

Definition at line 169 of file ADComputeMultipleInelasticStress.C.

170 {
171  _elastic_strain[_qp] =
172  _rotation_increment[_qp] * _elastic_strain[_qp] * _rotation_increment[_qp].transpose();
173  _stress[_qp] = _rotation_increment[_qp] * _stress[_qp] * _rotation_increment[_qp].transpose();
174  _inelastic_strain[_qp] =
175  _rotation_increment[_qp] * _inelastic_strain[_qp] * _rotation_increment[_qp].transpose();
176 }

◆ hasGuaranteedMaterialProperty()

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

Definition at line 28 of file GuaranteeConsumer.C.

Referenced by ComputeFiniteStrainElasticStress::initialSetup(), ComputeSmearedCrackingStress::initialSetup(), ComputeLinearElasticPFFractureStress::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()

template<ComputeStage compute_stage>
void ADComputeMultipleInelasticStress< compute_stage >::initialSetup ( )
overridevirtual

Definition at line 101 of file ADComputeMultipleInelasticStress.C.

102 {
105 
106  std::vector<MaterialName> models = adGetParam<std::vector<MaterialName>>("inelastic_models");
107 
108  for (unsigned int i = 0; i < _num_models; ++i)
109  {
111  &this->template getMaterialByName<compute_stage>(models[i]));
112 
113  if (rrr)
114  {
115  _models.push_back(rrr);
116  if (rrr->requiresIsotropicTensor() && !_is_elasticity_tensor_guaranteed_isotropic)
117  mooseError("Model " + models[i] +
118  " requires an isotropic elasticity tensor, but the one supplied is not "
119  "guaranteed isotropic");
120  }
121  else
122  mooseError("Model " + models[i] + " is not compatible with ADComputeMultipleInelasticStress");
123  }
124 }
const unsigned _num_models
number of plastic models
ADStressUpdateBase is a material that is not called by MOOSE because of the compute=false flag set in...
std::vector< ADStressUpdateBase< compute_stage > * > _models
The user supplied list of inelastic models to use in the simulation.
bool _is_elasticity_tensor_guaranteed_isotropic
is the elasticity tensor guaranteed to be isotropic?
bool hasGuaranteedMaterialProperty(const MaterialPropertyName &prop, Guarantee guarantee)
const std::string _elasticity_tensor_name
Name of the elasticity tensor material property.

◆ initQpStatefulProperties()

template<ComputeStage compute_stage>
void ADComputeMultipleInelasticStress< compute_stage >::initQpStatefulProperties ( )
overrideprotectedvirtual

Reimplemented from ADComputeStressBase< compute_stage >.

Definition at line 93 of file ADComputeMultipleInelasticStress.C.

94 {
96  _inelastic_strain[_qp].zero();
97 }
virtual void initQpStatefulProperties() override

◆ updateQpState()

template<ComputeStage compute_stage>
void ADComputeMultipleInelasticStress< compute_stage >::updateQpState ( ADRankTwoTensor &  elastic_strain_increment,
ADRankTwoTensor &  combined_inelastic_strain_increment 
)
protectedvirtual

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.

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 180 of file ADComputeMultipleInelasticStress.C.

183 {
185  {
186  _console << std::endl
187  << "iteration output for ADComputeMultipleInelasticStress solve:"
188  << " time=" << _t << " int_pt=" << _qp << std::endl;
189  }
190  Real l2norm_delta_stress;
191  Real first_l2norm_delta_stress = 1.0;
192  unsigned int counter = 0;
193 
194  std::vector<ADRankTwoTensor> inelastic_strain_increment;
195  inelastic_strain_increment.resize(_num_models);
196 
197  for (unsigned i_rmm = 0; i_rmm < _models.size(); ++i_rmm)
198  inelastic_strain_increment[i_rmm].zero();
199 
200  ADRankTwoTensor stress_max, stress_min;
201 
202  do
203  {
204  for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
205  {
206  _models[i_rmm]->setQp(_qp);
207 
208  // initially assume the strain is completely elastic
209  elastic_strain_increment = _strain_increment[_qp];
210  // and subtract off all inelastic strain increments calculated so far
211  // except the one that we're about to calculate
212  for (unsigned j_rmm = 0; j_rmm < _num_models; ++j_rmm)
213  if (i_rmm != j_rmm)
214  elastic_strain_increment -= inelastic_strain_increment[j_rmm];
215 
216  // form the trial stress, with the check for changed elasticity constants
218  _stress[_qp] =
219  _elasticity_tensor[_qp] * (_elastic_strain_old[_qp] + elastic_strain_increment);
220  else
221  _stress[_qp] = _stress_old[_qp] + _elasticity_tensor[_qp] * elastic_strain_increment;
222 
223  // given a trial stress (_stress[_qp]) and a strain increment (elastic_strain_increment)
224  // let the i^th model produce an admissible stress (as _stress[_qp]), and decompose
225  // the strain increment into an elastic part (elastic_strain_increment) and an
226  // inelastic part (inelastic_strain_increment[i_rmm])
227  computeAdmissibleState(i_rmm, elastic_strain_increment, inelastic_strain_increment[i_rmm]);
228 
229  if (i_rmm == 0)
230  {
231  stress_max = _stress[_qp];
232  stress_min = _stress[_qp];
233  }
234  else
235  {
236  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
237  {
238  for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
239  {
240  if (_stress[_qp](i, j) > stress_max(i, j))
241  stress_max(i, j) = _stress[_qp](i, j);
242  else if (stress_min(i, j) > _stress[_qp](i, j))
243  stress_min(i, j) = _stress[_qp](i, j);
244  }
245  }
246  }
247  }
248 
249  // now check convergence in the stress:
250  // once the change in stress is within tolerance after each recompute material
251  // consider the stress to be converged
252  l2norm_delta_stress = MetaPhysicL::raw_value((stress_max - stress_min).L2norm());
253  if (counter == 0 && l2norm_delta_stress > 0.0)
254  first_l2norm_delta_stress = l2norm_delta_stress;
255 
257  {
258  _console << "stress iteration number = " << counter << "\n"
259  << " relative l2 norm delta stress = "
260  << (0 == first_l2norm_delta_stress ? 0
261  : l2norm_delta_stress / first_l2norm_delta_stress)
262  << "\n"
263  << " stress convergence relative tolerance = " << _relative_tolerance << "\n"
264  << " absolute l2 norm delta stress = " << l2norm_delta_stress << "\n"
265  << " stress convergence absolute tolerance = " << _absolute_tolerance << std::endl;
266  }
267  ++counter;
268  } while (counter < _max_iterations && l2norm_delta_stress > _absolute_tolerance &&
269  (l2norm_delta_stress / first_l2norm_delta_stress) > _relative_tolerance &&
270  _num_models != 1);
271 
272  if (counter == _max_iterations && l2norm_delta_stress > _absolute_tolerance &&
273  (l2norm_delta_stress / first_l2norm_delta_stress) > _relative_tolerance)
274  throw MooseException("Max stress iteration hit during ADComputeMultipleInelasticStress solve!");
275 
276  combined_inelastic_strain_increment.zero();
277  for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
278  combined_inelastic_strain_increment +=
279  _inelastic_weights[i_rmm] * inelastic_strain_increment[i_rmm];
280 
281  _matl_timestep_limit[_qp] = 0.0;
282  for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
283  _matl_timestep_limit[_qp] += 1.0 / _models[i_rmm]->computeTimeStepLimit();
284 
285  if (MooseUtils::absoluteFuzzyEqual(_matl_timestep_limit[_qp], 0.0))
286  _matl_timestep_limit[_qp] = std::numeric_limits<Real>::max();
287  else
288  _matl_timestep_limit[_qp] = 1.0 / _matl_timestep_limit[_qp];
289 }
const MaterialProperty< RankTwoTensor > & _elastic_strain_old
The old elastic strain is used to calculate the old stress in the case of variable elasticity tensors...
virtual void computeAdmissibleState(unsigned model_number, ADRankTwoTensor &elastic_strain_increment, ADRankTwoTensor &inelastic_strain_increment)
Given a trial stress (_stress[_qp]) and a strain increment (elastic_strain_increment) let the model_n...
const unsigned _num_models
number of plastic models
const unsigned int _max_iterations
Input parameters associated with the recompute iteration to return the stress state to the yield surf...
std::vector< ADStressUpdateBase< compute_stage > * > _models
The user supplied list of inelastic models to use in the simulation.
bool _is_elasticity_tensor_guaranteed_isotropic
is the elasticity tensor guaranteed to be isotropic?
const MaterialProperty< RankTwoTensor > & _stress_old
const std::vector< Real > _inelastic_weights
_inelastic_strain = sum_i (_inelastic_weights_i * inelastic_strain_from_model_i)
const bool _perform_finite_strain_rotations
after updateQpState, rotate the stress, elastic_strain, and inelastic_strain using _rotation_incremen...
Real L2norm(const RankTwoTensor &r2tensor)
static unsigned int counter

◆ updateQpStateSingleModel()

template<ComputeStage compute_stage>
void ADComputeMultipleInelasticStress< compute_stage >::updateQpStateSingleModel ( unsigned  model_number,
ADRankTwoTensor &  elastic_strain_increment,
ADRankTwoTensor &  combined_inelastic_strain_increment 
)
protectedvirtual

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.

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 293 of file ADComputeMultipleInelasticStress.C.

297 {
298  for (auto model : _models)
299  model->setQp(_qp);
300 
301  elastic_strain_increment = _strain_increment[_qp];
302 
303  // If the elasticity tensor values have changed and the tensor is isotropic,
304  // use the old strain to calculate the old stress
306  _stress[_qp] = _elasticity_tensor[_qp] * (_elastic_strain_old[_qp] + elastic_strain_increment);
307  else
308  _stress[_qp] = _stress_old[_qp] + _elasticity_tensor[_qp] * elastic_strain_increment;
309 
311  model_number, elastic_strain_increment, combined_inelastic_strain_increment);
312 
313  _matl_timestep_limit[_qp] = _models[0]->computeTimeStepLimit();
314 
315  /* propagate internal variables, etc, to this timestep for those inelastic models where
316  * "updateState" is not called */
317  for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
318  if (i_rmm != model_number)
319  _models[i_rmm]->propagateQpStatefulProperties();
320 }
const MaterialProperty< RankTwoTensor > & _elastic_strain_old
The old elastic strain is used to calculate the old stress in the case of variable elasticity tensors...
virtual void computeAdmissibleState(unsigned model_number, ADRankTwoTensor &elastic_strain_increment, ADRankTwoTensor &inelastic_strain_increment)
Given a trial stress (_stress[_qp]) and a strain increment (elastic_strain_increment) let the model_n...
const unsigned _num_models
number of plastic models
std::vector< ADStressUpdateBase< compute_stage > * > _models
The user supplied list of inelastic models to use in the simulation.
bool _is_elasticity_tensor_guaranteed_isotropic
is the elasticity tensor guaranteed to be isotropic?
const MaterialProperty< RankTwoTensor > & _stress_old
const bool _perform_finite_strain_rotations
after updateQpState, rotate the stress, elastic_strain, and inelastic_strain using _rotation_incremen...

Member Data Documentation

◆ _absolute_tolerance

template<ComputeStage compute_stage>
const Real ADComputeMultipleInelasticStress< compute_stage >::_absolute_tolerance
protected

Definition at line 124 of file ADComputeMultipleInelasticStress.h.

◆ _base_name

template<ComputeStage compute_stage>
const std::string ADComputeStressBase< compute_stage >::_base_name
protectedinherited

Definition at line 51 of file ADComputeStressBase.h.

◆ _cycle_models

template<ComputeStage compute_stage>
const bool ADComputeMultipleInelasticStress< compute_stage >::_cycle_models
protected

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

Definition at line 144 of file ADComputeMultipleInelasticStress.h.

◆ _elastic_strain_old

template<ComputeStage compute_stage>
const MaterialProperty<RankTwoTensor>& ADComputeFiniteStrainElasticStress< compute_stage >::_elastic_strain_old
protectedinherited

The old elastic strain is used to calculate the old stress in the case of variable elasticity tensors.

Definition at line 57 of file ADComputeFiniteStrainElasticStress.h.

◆ _elasticity_tensor_name

template<ComputeStage compute_stage>
const std::string ADComputeFiniteStrainElasticStress< compute_stage >::_elasticity_tensor_name
protectedinherited

Name of the elasticity tensor material property.

Definition at line 46 of file ADComputeFiniteStrainElasticStress.h.

◆ _inelastic_strain_old

template<ComputeStage compute_stage>
const MaterialProperty<RankTwoTensor>& ADComputeMultipleInelasticStress< compute_stage >::_inelastic_strain_old
protected

old value of inelastic strain

Definition at line 135 of file ADComputeMultipleInelasticStress.h.

◆ _inelastic_weights

template<ComputeStage compute_stage>
const std::vector<Real> ADComputeMultipleInelasticStress< compute_stage >::_inelastic_weights
protected

_inelastic_strain = sum_i (_inelastic_weights_i * inelastic_strain_from_model_i)

Definition at line 141 of file ADComputeMultipleInelasticStress.h.

Referenced by ADComputeMultipleInelasticStress< compute_stage >::ADComputeMultipleInelasticStress().

◆ _initial_stress_fcn

template<ComputeStage compute_stage>
std::vector<Function *> ADComputeStressBase< compute_stage >::_initial_stress_fcn
protectedinherited

initial stress components

Definition at line 58 of file ADComputeStressBase.h.

◆ _internal_solve_full_iteration_history

template<ComputeStage compute_stage>
const bool ADComputeMultipleInelasticStress< compute_stage >::_internal_solve_full_iteration_history
protected

Definition at line 125 of file ADComputeMultipleInelasticStress.h.

◆ _is_elasticity_tensor_guaranteed_isotropic

template<ComputeStage compute_stage>
bool ADComputeMultipleInelasticStress< compute_stage >::_is_elasticity_tensor_guaranteed_isotropic
protected

is the elasticity tensor guaranteed to be isotropic?

Definition at line 158 of file ADComputeMultipleInelasticStress.h.

◆ _matl_timestep_limit

template<ComputeStage compute_stage>
MaterialProperty<Real>& ADComputeMultipleInelasticStress< compute_stage >::_matl_timestep_limit
protected

Definition at line 146 of file ADComputeMultipleInelasticStress.h.

◆ _max_iterations

template<ComputeStage compute_stage>
const unsigned int ADComputeMultipleInelasticStress< compute_stage >::_max_iterations
protected

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

Definition at line 122 of file ADComputeMultipleInelasticStress.h.

◆ _models

template<ComputeStage compute_stage>
std::vector<ADStressUpdateBase<compute_stage> *> ADComputeMultipleInelasticStress< compute_stage >::_models
protected

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 155 of file ADComputeMultipleInelasticStress.h.

◆ _num_models

template<ComputeStage compute_stage>
const unsigned ADComputeMultipleInelasticStress< compute_stage >::_num_models
protected

◆ _perform_finite_strain_rotations

template<ComputeStage compute_stage>
const bool ADComputeMultipleInelasticStress< compute_stage >::_perform_finite_strain_rotations
protected

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

Definition at line 129 of file ADComputeMultipleInelasticStress.h.

◆ _relative_tolerance

template<ComputeStage compute_stage>
const Real ADComputeMultipleInelasticStress< compute_stage >::_relative_tolerance
protected

Definition at line 123 of file ADComputeMultipleInelasticStress.h.

◆ _stress_old

template<ComputeStage compute_stage>
const MaterialProperty<RankTwoTensor>& ADComputeFiniteStrainElasticStress< compute_stage >::_stress_old
protectedinherited

Definition at line 51 of file ADComputeFiniteStrainElasticStress.h.

◆ usingComputeFiniteStrainElasticStressMembers

template<ComputeStage compute_stage>
ADComputeMultipleInelasticStress< compute_stage >::usingComputeFiniteStrainElasticStressMembers
protected

Definition at line 160 of file ADComputeMultipleInelasticStress.h.

◆ usingComputeStressBaseMembers

template<ComputeStage compute_stage>
ADComputeFiniteStrainElasticStress< compute_stage >::usingComputeStressBaseMembers
protectedinherited

Definition at line 59 of file ADComputeFiniteStrainElasticStress.h.

◆ usingMaterialMembers

template<ComputeStage compute_stage>
ADComputeStressBase< compute_stage >::usingMaterialMembers
protectedinherited

Definition at line 60 of file ADComputeStressBase.h.


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