ADComputeMultiplePorousInelasticStress< compute_stage > Class Template Reference

Compute state (stress and internal parameters such as plastic strains and internal parameters) using an iterative process. More...

#include <ADComputeMultiplePorousInelasticStress.h>

Inheritance diagram for ADComputeMultiplePorousInelasticStress< compute_stage >:

Public Member Functions
	ADComputeMultiplePorousInelasticStress (const InputParameters &parameters)
virtual void	initialSetup () override

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	initQpStatefulProperties () override
virtual void	computeQpProperties () 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...
bool	hasGuaranteedMaterialProperty (const MaterialPropertyName &prop, Guarantee guarantee)

Protected Attributes
const Real	_initial_porosity
	Initial porosity value. Must be greater than zero. More...
	usingComputeMultipleInelasticStressMembers
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< const MaterialProperty< RankTwoTensor > * >	_extra_stresses
	Extra stress tensors. More...
std::vector< const 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

Private Attributes
const InputParameters &	_gc_params
	Parameters of the object with this interface. More...
FEProblemBase *const	_gc_feproblem
	Reference to the FEProblemBase class. More...
BlockRestrictable *const	_gc_block_restrict
	Access block restrictions of the object with this interface. More...
const MaterialProperty< Real > &	_porosity_old
	ADMaterialProperty (Real) &_porosity
	Material property for porosity. More...

Detailed Description

template<ComputeStage compute_stage>
class ADComputeMultiplePorousInelasticStress< compute_stage >

Compute state (stress and internal parameters such as plastic strains and internal parameters) using an iterative process.

A porosity material property is defined and is calcuated from the trace of inelastic strain increment.

Definition at line 15 of file ADComputeMultiplePorousInelasticStress.h.

Constructor & Destructor Documentation

ADComputeMultiplePorousInelasticStress()

template<ComputeStage compute_stage>

ADComputeMultiplePorousInelasticStress< compute_stage >::ADComputeMultiplePorousInelasticStress

(

const InputParameters &

parameters

)

Definition at line 36 of file ADComputeMultiplePorousInelasticStress.C.

  : ADComputeMultipleInelasticStress<compute_stage>(parameters),
    _porosity(declareADProperty<Real>(getParam<MaterialPropertyName>("porosity_name"))),
    _porosity_old(getMaterialPropertyOld<Real>(getParam<MaterialPropertyName>("porosity_name"))),
    _initial_porosity(getParam<Real>("initial_porosity"))
{
}

Member Function Documentation

ADMaterialProperty() [1/3]

template<ComputeStage compute_stage>

const ADComputeFiniteStrainElasticStress< compute_stage >::ADMaterialProperty ( RankFourTensor  ) &

protectedinherited

Elasticity tensor material property.

ADMaterialProperty() [2/3]

template<ComputeStage compute_stage>

ADComputeMultipleInelasticStress< compute_stage >::ADMaterialProperty ( RankTwoTensor  ) &

protectedinherited

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

ADMaterialProperty() [3/3]

template<ComputeStage compute_stage>

ADComputeMultiplePorousInelasticStress< compute_stage >::ADMaterialProperty ( Real  ) &

protected

Material property for porosity.

computeAdmissibleState()

template<ComputeStage compute_stage>

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

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

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 328 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 ADComputeMultiplePorousInelasticStress< compute_stage >::computeQpProperties ( )

overrideprotectedvirtual

Reimplemented from ADComputeStressBase< compute_stage >.

Definition at line 56 of file ADComputeMultiplePorousInelasticStress.C.

{
  ADComputeStressBase<compute_stage>::computeQpProperties();
 
  _porosity[_qp] =
      (1.0 - _porosity_old[_qp]) * (_inelastic_strain[_qp] - _inelastic_strain_old[_qp]).trace() +
      _porosity_old[_qp];
}

computeQpStress()

template<ComputeStage compute_stage>

void ADComputeMultipleInelasticStress< compute_stage >::computeQpStress ( )

overrideprotectedvirtualinherited

Reimplemented from ADComputeFiniteStrainElasticStress< compute_stage >.

Definition at line 131 of file ADComputeMultipleInelasticStress.C.

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

computeQpStressIntermediateConfiguration()

template<ComputeStage compute_stage>

void ADComputeMultipleInelasticStress< compute_stage >::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 140 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 ( )

protectedvirtualinherited

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

Definition at line 172 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.

{
  if (!_gc_feproblem->startedInitialSetup())
    mooseError("hasGuaranteedMaterialProperty() needs to be called in initialSetup()");
 
  // Reference to MaterialWarehouse for testing and retrieving block ids
  const auto & warehouse = _gc_feproblem->getMaterialWarehouse();
 
  // Complete set of ids that this object is active
  const auto & ids = (_gc_block_restrict && _gc_block_restrict->blockRestricted())
                         ? _gc_block_restrict->blockIDs()
                         : _gc_feproblem->mesh().meshSubdomains();
 
  // Loop over each id for this object
  for (const auto & id : ids)
  {
    // If block materials exist, look if any issue the required guarantee
    if (warehouse.hasActiveBlockObjects(id))
    {
      const std::vector<std::shared_ptr<MaterialBase>> & mats = warehouse.getActiveBlockObjects(id);
      for (const auto & mat : mats)
      {
        const auto & mat_props = mat->getSuppliedItems();
        if (mat_props.count(prop_name))
        {
          auto guarantee_mat = dynamic_cast<GuaranteeProvider *>(mat.get());
          if (guarantee_mat && !guarantee_mat->hasGuarantee(prop_name, guarantee))
          {
            // we found at least one material on the set of block we operate on
            // that does _not_ provide the requested guarantee
            return false;
          }
        }
      }
    }
  }
 
  return true;
}

Referenced by ComputeFiniteStrainElasticStress::initialSetup(), ComputeSmearedCrackingStress::initialSetup(), ComputeLinearElasticPFFractureStress::initialSetup(), CriticalTimeStep::initialSetup(), and ComputeMultipleInelasticStress::initialSetup().

initialSetup()

template<ComputeStage compute_stage>

void ADComputeMultipleInelasticStress< compute_stage >::initialSetup ( )

overridevirtualinherited

Definition at line 104 of file ADComputeMultipleInelasticStress.C.

{
  _is_elasticity_tensor_guaranteed_isotropic =
      this->hasGuaranteedMaterialProperty(_elasticity_tensor_name, Guarantee::ISOTROPIC);
 
  std::vector<MaterialName> models = getParam<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 ADComputeMultiplePorousInelasticStress< compute_stage >::initQpStatefulProperties ( )

overrideprotectedvirtual

Reimplemented from ADComputeMultipleInelasticStress< compute_stage >.

Definition at line 47 of file ADComputeMultiplePorousInelasticStress.C.

{
  ADComputeStressBase<compute_stage>::initQpStatefulProperties();
 
  _porosity[_qp] = _initial_porosity;
}

updateQpState()

template<ComputeStage compute_stage>

void ADComputeMultipleInelasticStress< compute_stage >::updateQpState ( ADRankTwoTensor &  elastic_strain_increment, ADRankTwoTensor &  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.

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 183 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)
    mooseException(
        "In ", _name, ": 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  )

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.

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

validParams()

template<ComputeStage compute_stage>

InputParameters ADComputeMultiplePorousInelasticStress< compute_stage >::validParams ( )

static

Definition at line 20 of file ADComputeMultiplePorousInelasticStress.C.

{
  InputParameters params = ADComputeMultipleInelasticStress<compute_stage>::validParams();
  params.addClassDescription(
      "Compute state (stress and internal parameters such as plastic "
      "strains and internal parameters) using an iterative process. A porosity material property "
      "is defined and is calculated from the trace of inelastic strain increment.");
 
  params.addParam<MaterialPropertyName>(
      "porosity_name", "porosity", "Name of porosity material property");
  params.addRequiredRangeCheckedParam<Real>(
      "initial_porosity", "initial_porosity>0.0 & initial_porosity<1.0", "Initial porosity");
  return params;
}

Member Data Documentation

_absolute_tolerance

template<ComputeStage compute_stage>

const Real ADComputeMultipleInelasticStress< compute_stage >::_absolute_tolerance

protectedinherited

Definition at line 128 of file ADComputeMultipleInelasticStress.h.

_base_name

template<ComputeStage compute_stage>

const std::string ADComputeStressBase< compute_stage >::_base_name

protectedinherited

Definition at line 53 of file ADComputeStressBase.h.

_cycle_models

template<ComputeStage compute_stage>

const bool ADComputeMultipleInelasticStress< compute_stage >::_cycle_models

protectedinherited

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

Definition at line 148 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 59 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 48 of file ADComputeFiniteStrainElasticStress.h.

_extra_stresses

template<ComputeStage compute_stage>

std::vector<const MaterialProperty<RankTwoTensor> *> ADComputeStressBase< compute_stage >::_extra_stresses

protectedinherited

Extra stress tensors.

Definition at line 60 of file ADComputeStressBase.h.

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

_gc_block_restrict

BlockRestrictable* const GuaranteeConsumer::_gc_block_restrict

privateinherited

Access block restrictions of the object with this interface.

Definition at line 41 of file GuaranteeConsumer.h.

Referenced by GuaranteeConsumer::hasGuaranteedMaterialProperty().

_gc_feproblem

FEProblemBase* const GuaranteeConsumer::_gc_feproblem

privateinherited

Reference to the FEProblemBase class.

Definition at line 38 of file GuaranteeConsumer.h.

Referenced by GuaranteeConsumer::hasGuaranteedMaterialProperty().

_gc_params

const InputParameters& GuaranteeConsumer::_gc_params

privateinherited

Parameters of the object with this interface.

Definition at line 35 of file GuaranteeConsumer.h.

_inelastic_strain_old

template<ComputeStage compute_stage>

const MaterialProperty<RankTwoTensor>& ADComputeMultipleInelasticStress< compute_stage >::_inelastic_strain_old

protectedinherited

old value of inelastic strain

Definition at line 139 of file ADComputeMultipleInelasticStress.h.

_inelastic_weights

template<ComputeStage compute_stage>

const std::vector<Real> ADComputeMultipleInelasticStress< compute_stage >::_inelastic_weights

protectedinherited

_inelastic_strain = sum_i (_inelastic_weights_i * inelastic_strain_from_model_i)

Definition at line 145 of file ADComputeMultipleInelasticStress.h.

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

_initial_porosity

template<ComputeStage compute_stage>

const Real ADComputeMultiplePorousInelasticStress< compute_stage >::_initial_porosity

protected

Initial porosity value. Must be greater than zero.

Definition at line 44 of file ADComputeMultiplePorousInelasticStress.h.

_initial_stress_fcn

template<ComputeStage compute_stage>

std::vector<const Function *> ADComputeStressBase< compute_stage >::_initial_stress_fcn

protectedinherited

initial stress components

Definition at line 63 of file ADComputeStressBase.h.

_internal_solve_full_iteration_history

template<ComputeStage compute_stage>

const bool ADComputeMultipleInelasticStress< compute_stage >::_internal_solve_full_iteration_history

protectedinherited

Definition at line 129 of file ADComputeMultipleInelasticStress.h.

_is_elasticity_tensor_guaranteed_isotropic

template<ComputeStage compute_stage>

bool ADComputeMultipleInelasticStress< compute_stage >::_is_elasticity_tensor_guaranteed_isotropic

protectedinherited

is the elasticity tensor guaranteed to be isotropic?

Definition at line 162 of file ADComputeMultipleInelasticStress.h.

_matl_timestep_limit

template<ComputeStage compute_stage>

MaterialProperty<Real>& ADComputeMultipleInelasticStress< compute_stage >::_matl_timestep_limit

protectedinherited

Definition at line 150 of file ADComputeMultipleInelasticStress.h.

_max_iterations

template<ComputeStage compute_stage>

const unsigned int ADComputeMultipleInelasticStress< compute_stage >::_max_iterations

protectedinherited

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

Definition at line 126 of file ADComputeMultipleInelasticStress.h.

_models

template<ComputeStage compute_stage>

std::vector<ADStressUpdateBase<compute_stage> *> ADComputeMultipleInelasticStress< compute_stage >::_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 159 of file ADComputeMultipleInelasticStress.h.

_num_models

template<ComputeStage compute_stage>

const unsigned ADComputeMultipleInelasticStress< compute_stage >::_num_models

protectedinherited

number of plastic models

Definition at line 142 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

protectedinherited

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

Definition at line 133 of file ADComputeMultipleInelasticStress.h.

_porosity_old

template<ComputeStage compute_stage>

const MaterialProperty<Real>& ADComputeMultiplePorousInelasticStress< compute_stage >::_porosity_old

protected

Definition at line 40 of file ADComputeMultiplePorousInelasticStress.h.

_relative_tolerance

template<ComputeStage compute_stage>

const Real ADComputeMultipleInelasticStress< compute_stage >::_relative_tolerance

protectedinherited

Definition at line 127 of file ADComputeMultipleInelasticStress.h.

_stress_old

template<ComputeStage compute_stage>

const MaterialProperty<RankTwoTensor>& ADComputeFiniteStrainElasticStress< compute_stage >::_stress_old

protectedinherited

Definition at line 53 of file ADComputeFiniteStrainElasticStress.h.

usingComputeFiniteStrainElasticStressMembers

template<ComputeStage compute_stage>

ADComputeMultipleInelasticStress< compute_stage >::usingComputeFiniteStrainElasticStressMembers

protectedinherited

Definition at line 164 of file ADComputeMultipleInelasticStress.h.

usingComputeMultipleInelasticStressMembers

template<ComputeStage compute_stage>

ADComputeMultiplePorousInelasticStress< compute_stage >::usingComputeMultipleInelasticStressMembers

protected

Definition at line 46 of file ADComputeMultiplePorousInelasticStress.h.

usingComputeStressBaseMembers

template<ComputeStage compute_stage>

ADComputeFiniteStrainElasticStress< compute_stage >::usingComputeStressBaseMembers

protectedinherited

Definition at line 61 of file ADComputeFiniteStrainElasticStress.h.

usingMaterialMembers

template<ComputeStage compute_stage>

ADComputeStressBase< compute_stage >::usingMaterialMembers

protectedinherited

Definition at line 65 of file ADComputeStressBase.h.

---

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

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