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

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.

  : ADComputeFiniteStrainElasticStress<compute_stage>(parameters),
    _max_iterations(parameters.get<unsigned int>("max_iterations")),
    _relative_tolerance(parameters.get<Real>("relative_tolerance")),
    _absolute_tolerance(parameters.get<Real>("absolute_tolerance")),
    _internal_solve_full_iteration_history(
        adGetParam<bool>("internal_solve_full_iteration_history")),
    _perform_finite_strain_rotations(adGetParam<bool>("perform_finite_strain_rotations")),
    _inelastic_strain(adDeclareADProperty<RankTwoTensor>(_base_name + "combined_inelastic_strain")),
    _inelastic_strain_old(
        adGetMaterialPropertyOld<RankTwoTensor>(_base_name + "combined_inelastic_strain")),
    _num_models(adGetParam<std::vector<MaterialName>>("inelastic_models").size()),
    _inelastic_weights(isParamValid("combined_inelastic_strain_weights")
                           ? adGetParam<std::vector<Real>>("combined_inelastic_strain_weights")
                           : std::vector<Real>(_num_models, true)),
    _cycle_models(adGetParam<bool>("cycle_models")),
    _matl_timestep_limit(adDeclareProperty<Real>("matl_timestep_limit"))
{
  if (_inelastic_weights.size() != _num_models)
    paramError("combined_inelastic_strain_weights",
               "must contain the same number of entries as inelastic_models ",
               _inelastic_weights.size(),
               " vs. ",
               _num_models);
}

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_number	The inelastic model to use
elastic_strain_increment	Upon input, this is the strain increment. Upon output, it is the elastic part of the strain increment
inelastic_strain_increment	The inelastic strain increment corresponding to the supplied strain increment

Definition at line 324 of file ADComputeMultipleInelasticStress.C.

{
  _models[model_number]->updateState(elastic_strain_increment,
                                     inelastic_strain_increment,
                                     _rotation_increment[_qp],
                                     _stress[_qp],
                                     _stress_old[_qp],
                                     _elasticity_tensor[_qp],
                                     _elastic_strain_old[_qp]);
}

computeQpProperties()

template<ComputeStage compute_stage>

void ADComputeStressBase< compute_stage >::computeQpProperties ( )

overrideprotectedvirtualinherited

Definition at line 46 of file ADComputeStressBase.C.

{
  computeQpStress();

  // TODO: Add in extra stress (using a list of extra_stress_names analogous to eigenstrain_names)
}

computeQpStress()

template<ComputeStage compute_stage>

void ADComputeMultipleInelasticStress< compute_stage >::computeQpStress ( )

overrideprotectedvirtual

Reimplemented from ADComputeFiniteStrainElasticStress< compute_stage >.

Definition at line 128 of file ADComputeMultipleInelasticStress.C.

{
  computeQpStressIntermediateConfiguration();
  if (_perform_finite_strain_rotations)
    finiteStrainRotation();
}

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.

{
  ADRankTwoTensor elastic_strain_increment;
  ADRankTwoTensor combined_inelastic_strain_increment;

  if (_num_models == 0)
  {
    _elastic_strain[_qp] = _elastic_strain_old[_qp] + _strain_increment[_qp];

    // If the elasticity tensor values have changed and the tensor is isotropic,
    // use the old strain to calculate the old stress
    if (_is_elasticity_tensor_guaranteed_isotropic || !_perform_finite_strain_rotations)
      _stress[_qp] = _elasticity_tensor[_qp] * (_elastic_strain_old[_qp] + _strain_increment[_qp]);
    else
      _stress[_qp] = _stress_old[_qp] + _elasticity_tensor[_qp] * _strain_increment[_qp];
  }
  else
  {
    if (_num_models == 1 || _cycle_models)
      updateQpStateSingleModel((_t_step - 1) % _num_models,
                               elastic_strain_increment,
                               combined_inelastic_strain_increment);
    else
      updateQpState(elastic_strain_increment, combined_inelastic_strain_increment);

    _elastic_strain[_qp] = _elastic_strain_old[_qp] + elastic_strain_increment;
    _inelastic_strain[_qp] = _inelastic_strain_old[_qp] + combined_inelastic_strain_increment;
  }
}

finiteStrainRotation()

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.

{
  _elastic_strain[_qp] =
      _rotation_increment[_qp] * _elastic_strain[_qp] * _rotation_increment[_qp].transpose();
  _stress[_qp] = _rotation_increment[_qp] * _stress[_qp] * _rotation_increment[_qp].transpose();
  _inelastic_strain[_qp] =
      _rotation_increment[_qp] * _inelastic_strain[_qp] * _rotation_increment[_qp].transpose();
}

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

{
  if (!_gc_feproblem->startedInitialSetup())
    mooseError("hasGuaranteedMaterialProperty() needs to be called in initialSetup()");

  // Reference to MaterialWarehouse for testing and retrieving block ids
  const auto & warehouse = _gc_feproblem->getMaterialWarehouse();

  // Complete set of ids that this object is active
  const auto & ids = (_gc_block_restrict && _gc_block_restrict->blockRestricted())
                         ? _gc_block_restrict->blockIDs()
                         : _gc_feproblem->mesh().meshSubdomains();

  // Loop over each id for this object
  for (const auto & id : ids)
  {
    // If block materials exist, look if any issue the required guarantee
    if (warehouse.hasActiveBlockObjects(id))
    {
      const std::vector<std::shared_ptr<Material>> & mats = warehouse.getActiveBlockObjects(id);
      for (const auto & mat : mats)
      {
        const auto & mat_props = mat->getSuppliedItems();
        if (mat_props.count(prop_name))
        {
          auto guarantee_mat = dynamic_cast<GuaranteeProvider *>(mat.get());
          if (guarantee_mat && !guarantee_mat->hasGuarantee(prop_name, guarantee))
          {
            // we found at least one material on the set of block we operate on
            // that does _not_ provide the requested guarantee
            return false;
          }
        }
      }
    }
  }

  return true;
}

initialSetup()

template<ComputeStage compute_stage>

void ADComputeMultipleInelasticStress< compute_stage >::initialSetup ( )

overridevirtual

Definition at line 101 of file ADComputeMultipleInelasticStress.C.

{
  _is_elasticity_tensor_guaranteed_isotropic =
      this->hasGuaranteedMaterialProperty(_elasticity_tensor_name, Guarantee::ISOTROPIC);

  std::vector<MaterialName> models = adGetParam<std::vector<MaterialName>>("inelastic_models");

  for (unsigned int i = 0; i < _num_models; ++i)
  {
    ADStressUpdateBase<compute_stage> * rrr = dynamic_cast<ADStressUpdateBase<compute_stage> *>(
        &this->template getMaterialByName<compute_stage>(models[i]));

    if (rrr)
    {
      _models.push_back(rrr);
      if (rrr->requiresIsotropicTensor() && !_is_elasticity_tensor_guaranteed_isotropic)
        mooseError("Model " + models[i] +
                   " requires an isotropic elasticity tensor, but the one supplied is not "
                   "guaranteed isotropic");
    }
    else
      mooseError("Model " + models[i] + " is not compatible with ADComputeMultipleInelasticStress");
  }
}

initQpStatefulProperties()

template<ComputeStage compute_stage>

void ADComputeMultipleInelasticStress< compute_stage >::initQpStatefulProperties ( )

overrideprotectedvirtual

Reimplemented from ADComputeStressBase< compute_stage >.

Definition at line 93 of file ADComputeMultipleInelasticStress.C.

{
  ADComputeStressBase<compute_stage>::initQpStatefulProperties();
  _inelastic_strain[_qp].zero();
}

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_increment	The elastic part of _strain_increment[_qp] after the iterative process has converged
combined_inelastic_strain_increment	The inelastic part of _strain_increment[_qp] after the iterative process has converged. This is a weighted sum of all the inelastic strains computed by all the plastic models during the Picard iterative scheme. The weights are dictated by the user using _inelastic_weights

Definition at line 180 of file ADComputeMultipleInelasticStress.C.

{
  if (_internal_solve_full_iteration_history == true)
  {
    _console << std::endl
             << "iteration output for ADComputeMultipleInelasticStress solve:"
             << " time=" << _t << " int_pt=" << _qp << std::endl;
  }
  Real l2norm_delta_stress;
  Real first_l2norm_delta_stress = 1.0;
  unsigned int counter = 0;

  std::vector<ADRankTwoTensor> inelastic_strain_increment;
  inelastic_strain_increment.resize(_num_models);

  for (unsigned i_rmm = 0; i_rmm < _models.size(); ++i_rmm)
    inelastic_strain_increment[i_rmm].zero();

  ADRankTwoTensor stress_max, stress_min;

  do
  {
    for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
    {
      _models[i_rmm]->setQp(_qp);

      // initially assume the strain is completely elastic
      elastic_strain_increment = _strain_increment[_qp];
      // and subtract off all inelastic strain increments calculated so far
      // except the one that we're about to calculate
      for (unsigned j_rmm = 0; j_rmm < _num_models; ++j_rmm)
        if (i_rmm != j_rmm)
          elastic_strain_increment -= inelastic_strain_increment[j_rmm];

      // form the trial stress, with the check for changed elasticity constants
      if (_is_elasticity_tensor_guaranteed_isotropic || !_perform_finite_strain_rotations)
        _stress[_qp] =
            _elasticity_tensor[_qp] * (_elastic_strain_old[_qp] + elastic_strain_increment);
      else
        _stress[_qp] = _stress_old[_qp] + _elasticity_tensor[_qp] * elastic_strain_increment;

      // given a trial stress (_stress[_qp]) and a strain increment (elastic_strain_increment)
      // let the i^th model produce an admissible stress (as _stress[_qp]), and decompose
      // the strain increment into an elastic part (elastic_strain_increment) and an
      // inelastic part (inelastic_strain_increment[i_rmm])
      computeAdmissibleState(i_rmm, elastic_strain_increment, inelastic_strain_increment[i_rmm]);

      if (i_rmm == 0)
      {
        stress_max = _stress[_qp];
        stress_min = _stress[_qp];
      }
      else
      {
        for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
        {
          for (unsigned int j = 0; j < LIBMESH_DIM; ++j)
          {
            if (_stress[_qp](i, j) > stress_max(i, j))
              stress_max(i, j) = _stress[_qp](i, j);
            else if (stress_min(i, j) > _stress[_qp](i, j))
              stress_min(i, j) = _stress[_qp](i, j);
          }
        }
      }
    }

    // now check convergence in the stress:
    // once the change in stress is within tolerance after each recompute material
    // consider the stress to be converged
    l2norm_delta_stress = MetaPhysicL::raw_value((stress_max - stress_min).L2norm());
    if (counter == 0 && l2norm_delta_stress > 0.0)
      first_l2norm_delta_stress = l2norm_delta_stress;

    if (_internal_solve_full_iteration_history == true)
    {
      _console << "stress iteration number = " << counter << "\n"
               << " relative l2 norm delta stress = "
               << (0 == first_l2norm_delta_stress ? 0
                                                  : l2norm_delta_stress / first_l2norm_delta_stress)
               << "\n"
               << " stress convergence relative tolerance = " << _relative_tolerance << "\n"
               << " absolute l2 norm delta stress = " << l2norm_delta_stress << "\n"
               << " stress convergence absolute tolerance = " << _absolute_tolerance << std::endl;
    }
    ++counter;
  } while (counter < _max_iterations && l2norm_delta_stress > _absolute_tolerance &&
           (l2norm_delta_stress / first_l2norm_delta_stress) > _relative_tolerance &&
           _num_models != 1);

  if (counter == _max_iterations && l2norm_delta_stress > _absolute_tolerance &&
      (l2norm_delta_stress / first_l2norm_delta_stress) > _relative_tolerance)
    throw MooseException("Max stress iteration hit during ADComputeMultipleInelasticStress solve!");

  combined_inelastic_strain_increment.zero();
  for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
    combined_inelastic_strain_increment +=
        _inelastic_weights[i_rmm] * inelastic_strain_increment[i_rmm];

  _matl_timestep_limit[_qp] = 0.0;
  for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
    _matl_timestep_limit[_qp] += 1.0 / _models[i_rmm]->computeTimeStepLimit();

  if (MooseUtils::absoluteFuzzyEqual(_matl_timestep_limit[_qp], 0.0))
    _matl_timestep_limit[_qp] = std::numeric_limits<Real>::max();
  else
    _matl_timestep_limit[_qp] = 1.0 / _matl_timestep_limit[_qp];
}

updateQpStateSingleModel()

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_number	Use this model number
elastic_strain_increment	The elastic part of _strain_increment[_qp]
combined_inelastic_strain_increment	The inelastic part of _strain_increment[_qp]

Definition at line 293 of file ADComputeMultipleInelasticStress.C.

{
  for (auto model : _models)
    model->setQp(_qp);

  elastic_strain_increment = _strain_increment[_qp];

  // If the elasticity tensor values have changed and the tensor is isotropic,
  // use the old strain to calculate the old stress
  if (_is_elasticity_tensor_guaranteed_isotropic || !_perform_finite_strain_rotations)
    _stress[_qp] = _elasticity_tensor[_qp] * (_elastic_strain_old[_qp] + elastic_strain_increment);
  else
    _stress[_qp] = _stress_old[_qp] + _elasticity_tensor[_qp] * elastic_strain_increment;

  computeAdmissibleState(
      model_number, elastic_strain_increment, combined_inelastic_strain_increment);

  _matl_timestep_limit[_qp] = _models[0]->computeTimeStepLimit();

  /* propagate internal variables, etc, to this timestep for those inelastic models where
   * "updateState" is not called */
  for (unsigned i_rmm = 0; i_rmm < _num_models; ++i_rmm)
    if (i_rmm != model_number)
      _models[i_rmm]->propagateQpStatefulProperties();
}

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

number of plastic models

Definition at line 138 of file ADComputeMultipleInelasticStress.h.

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

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

• tensor_mechanics/include/materials/ADComputeMultipleInelasticStress.h
• tensor_mechanics/src/materials/ADComputeMultipleInelasticStress.C