#include <ADViscoplasticityStressUpdate.h>

Inheritance diagram for ADViscoplasticityStressUpdate< compute_stage >:

Public Member Functions
	ADViscoplasticityStressUpdate (const InputParameters &parameters)

virtual void	updateState (ADRankTwoTensor &strain_increment, ADRankTwoTensor &inelastic_strain_increment, const ADRankTwoTensor &rotation_increment, ADRankTwoTensor &stress_new, const RankTwoTensor &stress_old, const ADRankFourTensor &elasticity_tensor, const RankTwoTensor &elastic_strain_old) override
	Given a strain increment that results in a trial stress, perform some procedure (such as an iterative return-mapping process) to produce an admissible stress, an elastic strain increment and an inelastic strain increment. More...

virtual ADReal	minimumPermissibleValue (const ADReal &effective_trial_stress) const override
	Compute the minimum permissible value of the scalar. More...

virtual ADReal	maximumPermissibleValue (const ADReal &effective_trial_stress) const override
	Compute the maximum permissible value of the scalar. More...

virtual Real	computeReferenceResidual (const ADReal &effective_trial_stress, const ADReal &scalar_effective_inelastic_strain) override
	Compute a reference quantity to be used for checking relative convergence. More...

virtual Real	computeTimeStepLimit () override
	Compute the limiting value of the time step for this material. More...

bool	requiresIsotropicTensor () override
	Does the model require the elasticity tensor to be isotropic? More...

void	setQp (unsigned int qp)
	Sets the value of the global variable _qp for inheriting classes. More...


void	resetQpProperties () final
	Retained as empty methods to avoid a warning from Material.C in framework. These methods are unused in all inheriting classes and should not be overwritten. More...

void	resetProperties () final

Static Public Member Functions
static InputParameters	validParams ()

Protected Types
enum	ViscoplasticityModel { ViscoplasticityModel::LPS, ViscoplasticityModel::GTN }
	Enum to choose which viscoplastic model to use. More...

enum	PoreShapeModel { PoreShapeModel::SPHERICAL, PoreShapeModel::CYLINDRICAL }
	Enum to choose which pore shape model to use. More...

Protected Member Functions
virtual ADReal	initialGuess (const ADReal &effective_trial_stress) override
	Compute an initial guess for the value of the scalar. More...

virtual ADReal	computeResidual (const ADReal &effective_trial_stress, const ADReal &scalar) override
	Perform any necessary steps to finalize state after return mapping iterations. More...

ADReal	computeH (const Real n, const ADReal &gauge_stress, const bool derivative=false)

ADRankTwoTensor	computeDGaugeDSigma (const ADReal &gauge_stress, const ADReal &equiv_stress, const ADRankTwoTensor &dev_stress, const ADRankTwoTensor &stress)

void	computeInelasticStrainIncrement (ADReal &gauge_stress, ADReal &dpsi_dgauge, ADRankTwoTensor &creep_strain_increment, const ADReal &equiv_stress, const ADRankTwoTensor &dev_stress, const ADRankTwoTensor &stress)

const	ADMaterialProperty (Real) &_coefficient
	Leading coefficient. More...

	ADMaterialProperty (Real) &_gauge_stress
	Gauge stress. More...

virtual void	initQpStatefulProperties () override

virtual void	propagateQpStatefulProperties () override
	If updateState is not called during a timestep, this will be. More...

virtual void	computeStressInitialize (const ADReal &, const ADRankFourTensor &)
	Perform any necessary initialization before return mapping iterations. More...

virtual void	computeStressFinalize (const ADRankTwoTensor &)
	Perform any necessary steps to finalize state after return mapping iterations. More...

virtual ADReal	computeDerivative (const ADReal &, const ADReal &) override
	Compute the derivative of the residual as a function of the scalar variable. More...

void	updateIntermediatePorosity (const ADRankTwoTensor &elastic_strain_increment)

void	outputIterationSummary (std::stringstream *iter_output, const unsigned int total_it) override
	Output summary information for the convergence history of the model. More...

const	ADMaterialProperty (RankTwoTensor) &_strain_increment
	Material property for the total strain increment. More...

void	returnMappingSolve (const ADReal &effective_trial_stress, ADReal &scalar, const ConsoleStream &console)
	Perform the return mapping iterations. More...

virtual void	iterationFinalize (ADReal)
	Finalize internal state variables for a model for a given iteration. More...

virtual void	outputIterationStep (std::stringstream *iter_output, const ADReal &effective_trial_stress, const ADReal &scalar, const Real reference_residual)
	Output information for a single iteration step to build the convergence history of the model. More...

bool	converged (const ADReal &residual, const Real reference)
	Check to see whether the residual is within the convergence limits. More...

Protected Attributes
enum ADViscoplasticityStressUpdate::ViscoplasticityModel	_model

enum ADViscoplasticityStressUpdate::PoreShapeModel	_pore_shape

const Real	_pore_shape_factor
	Pore shape factor depending on pore shape model. More...

const Real	_power
	Exponent on the effective stress. More...

const Real	_power_factor
	Power factor used for LPS model. More...

const Real	_maximum_gauge_ratio
	Maximum ratio between the gauge stress and the equilvalent stress. More...

const Real	_minimum_equivalent_stress
	Minimum value of equivalent stress below which viscoplasticiy is not calculated. More...

const Real	_maximum_equivalent_stress
	Maximum value of equivalent stress above which an exception is thrown. More...

ADReal	_hydro_stress
	Container for hydrostatic stress. More...

const RankTwoTensor	_identity_two
	Rank two identity tensor. More...

const RankTwoTensor	_dhydro_stress_dsigma
	Derivative of hydrostatic stress with respect to the stress tensor. More...

	usingViscoplasticityStressUpdateBaseMembers

const std::string	_total_strain_base_name
	String designating the base name of the total strain. More...

Real	_max_inelastic_increment
	Max increment for inelastic strain. More...

ADReal	_intermediate_porosity
	Container for the porosity calculated from all other intelastic models except the current model. More...

const MaterialProperty< Real > &	_porosity_old
	Material property for the old porosity. More...

const bool	_verbose
	Flag to enable verbose output. More...

ADReal	_derivative
	Container for _derivative. More...

	usingStressUpdateBaseMembers

	usingSingleVariableReturnMappingSolutionMembers

const std::string	_base_name
	Name used as a prefix for all material properties related to the stress update model. More...

	usingMaterialMembers

bool	_check_range
	Whether to check to see whether iterative solution is within admissible range, and set within that range if outside. More...

bool	_line_search
	Whether to use line searches to improve convergence. More...

bool	_bracket_solution
	Whether to save upper and lower bounds of root for scalar, and set solution to the midpoint between those bounds if outside them. More...


const MaterialProperty< Real > &	_effective_inelastic_strain_old


const MaterialProperty< RankTwoTensor > &	_inelastic_strain_old

Private Types
enum	InternalSolveOutput { InternalSolveOutput::NEVER, InternalSolveOutput::ON_ERROR, InternalSolveOutput::ALWAYS }

enum	SolveState { SolveState::SUCCESS, SolveState::NAN_INF, SolveState::EXCEEDED_ITERATIONS }

Private Member Functions
SolveState	internalSolve (const ADReal effective_trial_stress, ADReal &scalar, std::stringstream *iter_output=nullptr)
	Method called from within this class to perform the actual return mappping iterations. More...

bool	convergedAcceptable (const unsigned int it, const Real reference)
	Check to see whether the residual is within acceptable convergence limits. More...

void	checkPermissibleRange (ADReal &scalar, ADReal &scalar_increment, const ADReal &scalar_old, const ADReal min_permissible_scalar, const ADReal max_permissible_scalar, std::stringstream *iter_output)
	Check to see whether solution is within admissible range, and set it within that range if it is not. More...

void	updateBounds (const ADReal &scalar, const ADReal &residual, const Real init_resid_sign, ADReal &scalar_upper_bound, ADReal &scalar_lower_bound, std::stringstream *iter_output)
	Update the upper and lower bounds of the root for the effective inelastic strain. More...

Private Attributes
enum ADSingleVariableReturnMappingSolution::InternalSolveOutput	_internal_solve_output_on

const unsigned int	_max_its
	Maximum number of return mapping iterations. More...

const bool	_internal_solve_full_iteration_history
	Whether to output iteration information all the time (regardless of whether iterations converge) More...

Real	_relative_tolerance
	Relative convergence tolerance. More...

Real	_absolute_tolerance
	Absolute convergence tolerance. More...

Real	_acceptable_multiplier
	Multiplier applied to relative and absolute tolerances for acceptable convergence. More...

const std::size_t	_num_resids
	Number of residuals to be stored in history. More...

std::vector< Real >	_residual_history
	History of residuals used to check whether progress is still being made on decreasing the residual. More...

unsigned int	_iteration
	iteration number More...

const std::string	_svrms_name
	MOOSE input name of the object performing the solve. More...


ADReal	_initial_residual
	Residual values, kept as members to retain solver state for summary outputting. More...

ADReal	_residual

Detailed Description

template<ComputeStage compute_stage>
class ADViscoplasticityStressUpdate< compute_stage >

Definition at line 15 of file ADViscoplasticityStressUpdate.h.

Member Enumeration Documentation

◆ InternalSolveOutput

template<ComputeStage compute_stage>

enum ADSingleVariableReturnMappingSolution::InternalSolveOutput

strongprivateinherited

Enumerator
NEVER
ON_ERROR
ALWAYS

Definition at line 156 of file ADSingleVariableReturnMappingSolution.h.

   {
     NEVER,
     ON_ERROR,
     ALWAYS
   } _internal_solve_output_on;

◆ PoreShapeModel

template<ComputeStage compute_stage>

enum ADViscoplasticityStressUpdate::PoreShapeModel

strongprotected

Enum to choose which pore shape model to use.

Enumerator
SPHERICAL
CYLINDRICAL

Definition at line 74 of file ADViscoplasticityStressUpdate.h.

74 { SPHERICAL, CYLINDRICAL } _pore_shape;

◆ SolveState

template<ComputeStage compute_stage>

enum ADSingleVariableReturnMappingSolution::SolveState

strongprivateinherited

Enumerator
SUCCESS
NAN_INF
EXCEEDED_ITERATIONS

Definition at line 163 of file ADSingleVariableReturnMappingSolution.h.

   {
     SUCCESS,
     NAN_INF,
     EXCEEDED_ITERATIONS
   };

◆ ViscoplasticityModel

template<ComputeStage compute_stage>

enum ADViscoplasticityStressUpdate::ViscoplasticityModel

strongprotected

Enum to choose which viscoplastic model to use.

Enumerator
LPS
GTN

Definition at line 71 of file ADViscoplasticityStressUpdate.h.

71 { LPS, GTN } _model;

Constructor & Destructor Documentation

◆ ADViscoplasticityStressUpdate()

template<ComputeStage compute_stage>

ADViscoplasticityStressUpdate< compute_stage >::ADViscoplasticityStressUpdate ( const InputParameters & parameters )

Definition at line 56 of file ADViscoplasticityStressUpdate.C.

   : ADViscoplasticityStressUpdateBase<compute_stage>(parameters),
     _model(parameters.get<MooseEnum>("viscoplasticity_model").getEnum<ViscoplasticityModel>()),
     _pore_shape(parameters.get<MooseEnum>("pore_shape_model").getEnum<PoreShapeModel>()),
     _pore_shape_factor(_pore_shape == PoreShapeModel::SPHERICAL ? 1.5 : std::sqrt(3.0)),
     _power(getParam<Real>("power")),
     _power_factor(_model == ViscoplasticityModel::LPS ? (_power - 1.0) / (_power + 1.0) : 1.0),
     _coefficient(getADMaterialProperty<Real>("coefficient")),
     _gauge_stress(declareADProperty<Real>(_base_name + "gauge_stress")),
     _maximum_gauge_ratio(getParam<Real>("maximum_gauge_ratio")),
     _minimum_equivalent_stress(getParam<Real>("minimum_equivalent_stress")),
     _maximum_equivalent_stress(getParam<Real>("maximum_equivalent_stress")),
     _hydro_stress(0.0),
     _identity_two(RankTwoTensor::initIdentity),
     _dhydro_stress_dsigma(_identity_two / 3.0)
 {
   _check_range = true;
 }

Member Function Documentation

◆ ADMaterialProperty() [1/3]

template<ComputeStage compute_stage>

const ADViscoplasticityStressUpdateBase< compute_stage >::ADMaterialProperty ( RankTwoTensor ) &

protectedinherited

Material property for the total strain increment.

◆ ADMaterialProperty() [2/3]

template<ComputeStage compute_stage>

const ADViscoplasticityStressUpdate< compute_stage >::ADMaterialProperty ( Real ) &

protected

Leading coefficient.

◆ ADMaterialProperty() [3/3]

template<ComputeStage compute_stage>

ADViscoplasticityStressUpdate< compute_stage >::ADMaterialProperty ( Real ) &

protected

Gauge stress.

◆ checkPermissibleRange()

template<ComputeStage compute_stage>

void ADSingleVariableReturnMappingSolution< compute_stage >::checkPermissibleRange	(	ADReal &	scalar,
		ADReal &	scalar_increment,
		const ADReal &	scalar_old,
		const ADReal	min_permissible_scalar,
		const ADReal	max_permissible_scalar,
		std::stringstream *	iter_output
	)

privateinherited

Check to see whether solution is within admissible range, and set it within that range if it is not.

Parameters

scalar	Current value of the inelastic strain increment
scalar_increment	Incremental change in scalar from the previous iteration
scalar_old	Previous value of scalar
min_permissible_scalar	Minimum permissible value of scalar
max_permissible_scalar	Maximum permissible value of scalar
iter_output	Output stream

Definition at line 334 of file ADSingleVariableReturnMappingSolution.C.

 {
   if (scalar > max_permissible_scalar)
   {
     scalar_increment = (max_permissible_scalar - scalar_old) / 2.0;
     scalar = scalar_old + scalar_increment;
     if (iter_output)
       *iter_output << "Scalar greater than maximum ("
                    << MetaPhysicL::raw_value(max_permissible_scalar)
                    << ") adjusted scalar=" << MetaPhysicL::raw_value(scalar)
                    << " scalar_increment=" << MetaPhysicL::raw_value(scalar_increment) << std::endl;
   }
   else if (scalar < min_permissible_scalar)
   {
     scalar_increment = (min_permissible_scalar - scalar_old) / 2.0;
     scalar = scalar_old + scalar_increment;
     if (iter_output)
       *iter_output << "Scalar less than minimum (" << MetaPhysicL::raw_value(min_permissible_scalar)
                    << ") adjusted scalar=" << MetaPhysicL::raw_value(scalar)
                    << " scalar_increment=" << MetaPhysicL::raw_value(scalar_increment) << std::endl;
   }
 }

◆ computeDerivative()

template<ComputeStage compute_stage>

virtual ADReal ADViscoplasticityStressUpdateBase< compute_stage >::computeDerivative	(	const ADReal &	effective_trial_stress,
		const ADReal &	scalar
	)

inlineoverrideprotectedvirtualinherited

Compute the derivative of the residual as a function of the scalar variable.

The residual should be in strain increment units for all models for consistency.

Parameters

effective_trial_stress	Effective trial stress
scalar	Inelastic strain increment magnitude being solved for

Implements ADSingleVariableReturnMappingSolution< compute_stage >.

Definition at line 81 of file ADViscoplasticityStressUpdateBase.h.

   {
     return _derivative;
   }

◆ computeDGaugeDSigma()

template<ComputeStage compute_stage>

ADRankTwoTensor ADViscoplasticityStressUpdate< compute_stage >::computeDGaugeDSigma	(	const ADReal &	gauge_stress,
		const ADReal &	equiv_stress,
		const ADRankTwoTensor &	dev_stress,
		const ADRankTwoTensor &	stress
	)

protected

Definition at line 252 of file ADViscoplasticityStressUpdate.C.

 {
   // Compute the derivative of the gauge stress with respect to the equilvalent and hydrostatic
   // stress components
   const ADReal M = std::abs(_hydro_stress) / gauge_stress;
   const ADReal h = computeH(_power, M);
  
   // Compute the derviative of the residual with respect to the hydrostatic stress
   ADReal dresidual_dhydro_stress = 0.0;
   if (_hydro_stress != 0.0)
   {
     const ADReal dM_dhydro_stress = M / _hydro_stress;
     if (_model == ViscoplasticityModel::GTN)
     {
       dresidual_dhydro_stress = 2.0 * _intermediate_porosity * std::sinh(_pore_shape_factor * M) *
                                 _pore_shape_factor * dM_dhydro_stress;
     }
     else
     {
       const ADReal dresidual_dh =
           _intermediate_porosity * (1.0 - _power_factor / Utility::pow<2>(h));
       const ADReal dh_dM = computeH(_power, M, true);
       dresidual_dhydro_stress = dresidual_dh * dh_dM * dM_dhydro_stress;
     }
   }
  
   // Compute the derivative of the residual with respect to the equilvalent stress
   ADReal dresidual_dequiv_stress = 2.0 * equiv_stress / Utility::pow<2>(gauge_stress);
   if (_pore_shape == PoreShapeModel::SPHERICAL)
     dresidual_dequiv_stress *= 1.0 + _intermediate_porosity / 1.5;
  
   // Compute the derivative of the equilvalent stress to the deviatoric stress
   const ADRankTwoTensor dequiv_stress_dsigma = 1.5 * dev_stress / equiv_stress;
  
   // Compute the derivative of the residual with the stress
   const ADRankTwoTensor dresidual_dsigma = dresidual_dhydro_stress * _dhydro_stress_dsigma +
                                            dresidual_dequiv_stress * dequiv_stress_dsigma;
  
   // Compute the deritative of the gauge stress with respect to the stress
   const ADRankTwoTensor dgauge_dsigma =
       dresidual_dsigma * (gauge_stress / dresidual_dsigma.doubleContraction(stress));
  
   return dgauge_dsigma;
 }

◆ computeH()

template<ComputeStage compute_stage>

ADReal ADViscoplasticityStressUpdate< compute_stage >::computeH	(	const Real	n,
		const ADReal &	gauge_stress,
		const bool	derivative = `false`
	)

protected

Definition at line 234 of file ADViscoplasticityStressUpdate.C.

 {
   const ADReal mod = std::pow(M * _pore_shape_factor, (n + 1.0) / n);
  
   // Calculate derivative with respect to M
   if (derivative)
   {
     const ADReal dmod_dM = (n + 1.0) / n * mod / M;
     return dmod_dM * std::pow(1.0 + mod / n, n - 1.0);
   }
  
   return std::pow(1.0 + mod / n, n);
 }

◆ computeInelasticStrainIncrement()

template<ComputeStage compute_stage>

void ADViscoplasticityStressUpdate< compute_stage >::computeInelasticStrainIncrement	(	ADReal &	gauge_stress,
		ADReal &	dpsi_dgauge,
		ADRankTwoTensor &	creep_strain_increment,
		const ADReal &	equiv_stress,
		const ADRankTwoTensor &	dev_stress,
		const ADRankTwoTensor &	stress
	)

protected

Definition at line 303 of file ADViscoplasticityStressUpdate.C.

 {
   // If hydrostatic stress and porosity present, compute non-linear gauge stress
   if (_intermediate_porosity == 0.0)
     gauge_stress = equiv_stress;
   else if (_hydro_stress == 0.0)
     gauge_stress =
         equiv_stress / std::sqrt(1.0 - (1.0 + _power_factor) * _intermediate_porosity +
                                  _power_factor * Utility::pow<2>(_intermediate_porosity));
   else
     returnMappingSolve(equiv_stress, gauge_stress, _console);
  
   mooseAssert(gauge_stress >= equiv_stress,
               "Gauge stress calculated in inner Newton solve is less than the equivalent stress.");
  
   // Compute stress potential
   dpsi_dgauge = _coefficient[_qp] * std::pow(gauge_stress, _power);
  
   // Compute strain increment from stress potential and the gauge stress derivative with respect
   // to the stress stress. The current form is explicit, and should eventually be changed
   inelastic_strain_increment =
       _dt * dpsi_dgauge * computeDGaugeDSigma(gauge_stress, equiv_stress, dev_stress, stress);
 }

◆ computeReferenceResidual()

template<ComputeStage compute_stage>

Real ADViscoplasticityStressUpdateBase< compute_stage >::computeReferenceResidual	(	const ADReal &	effective_trial_stress,
		const ADReal &	scalar
	)

overridevirtualinherited

Compute a reference quantity to be used for checking relative convergence.

This should be in strain increment units for all models for consistency.

Parameters

effective_trial_stress	Effective trial stress
scalar	Inelastic strain increment magnitude being solved for

Implements ADSingleVariableReturnMappingSolution< compute_stage >.

Definition at line 82 of file ADViscoplasticityStressUpdateBase.C.

 {
   // Use gauge stress for relative tolerance criteria, defined as:
   // std::abs(residual / gauge_stress) <= _relative_tolerance
   return MetaPhysicL::raw_value(gauge_stress);
 }

◆ computeResidual()

template<ComputeStage compute_stage>

ADReal ADViscoplasticityStressUpdate< compute_stage >::computeResidual	(	const ADReal &	effective_trial_stress,
		const ADReal &	scalar
	)

overrideprotectedvirtual

Perform any necessary steps to finalize state after return mapping iterations.

Parameters

inelasticStrainIncrement Inelastic strain increment

Implements ADSingleVariableReturnMappingSolution< compute_stage >.

Definition at line 184 of file ADViscoplasticityStressUpdate.C.

 {
   const ADReal M = std::abs(_hydro_stress) / trial_gauge;
   const ADReal dM_dtrial_gauge = -M / trial_gauge;
  
   const ADReal residual_left = Utility::pow<2>(equiv_stress / trial_gauge);
   const ADReal dresidual_left_dtrial_gauge = -2.0 * residual_left / trial_gauge;
  
   ADReal residual = residual_left;
   _derivative = dresidual_left_dtrial_gauge;
  
   if (_pore_shape == PoreShapeModel::SPHERICAL)
   {
     residual *= 1.0 + _intermediate_porosity / 1.5;
     _derivative *= 1.0 + _intermediate_porosity / 1.5;
   }
  
   if (_model == ViscoplasticityModel::GTN)
   {
     residual += 2.0 * _intermediate_porosity * std::cosh(_pore_shape_factor * M) - 1.0 -
                 Utility::pow<2>(_intermediate_porosity);
     _derivative += 2.0 * _intermediate_porosity * std::sinh(_pore_shape_factor * M) *
                    _pore_shape_factor * dM_dtrial_gauge;
   }
   else
   {
     const ADReal h = computeH(_power, M);
     const ADReal dh_dM = computeH(_power, M, true);
  
     residual += _intermediate_porosity * (h + _power_factor / h) - 1.0 -
                 _power_factor * Utility::pow<2>(_intermediate_porosity);
     const ADReal dresidual_dh = _intermediate_porosity * (1.0 - _power_factor / Utility::pow<2>(h));
     _derivative += dresidual_dh * dh_dM * dM_dtrial_gauge;
   }
  
   if (_verbose)
   {
     Moose::out << "in computeResidual:\n"
                << "  position: " << _q_point[_qp] << " hydro_stress: " << _hydro_stress
                << " equiv_stress: " << equiv_stress << " trial_grage: " << trial_gauge
                << " M: " << M << std::endl;
     Moose::out << "  residual: " << residual << "  derivative: " << _derivative << std::endl;
   }
  
   return residual;
 }

◆ computeStressFinalize()

template<ComputeStage compute_stage>

virtual void ADViscoplasticityStressUpdateBase< compute_stage >::computeStressFinalize ( const ADRankTwoTensor & )

inlineprotectedvirtualinherited

Perform any necessary steps to finalize state after return mapping iterations.

Parameters

inelasticStrainIncrement Inelastic strain increment

Definition at line 79 of file ADViscoplasticityStressUpdateBase.h.

79 {}

◆ computeStressInitialize()

template<ComputeStage compute_stage>

virtual void ADViscoplasticityStressUpdateBase< compute_stage >::computeStressInitialize	(	const ADReal &	,
		const ADRankFourTensor &
	)

inlineprotectedvirtualinherited

Perform any necessary initialization before return mapping iterations.

Parameters

effective_trial_stress	Effective trial stress
elasticityTensor	Elasticity tensor

Definition at line 70 of file ADViscoplasticityStressUpdateBase.h.

72 {

73 }

◆ computeTimeStepLimit()

template<ComputeStage compute_stage>

Real ADViscoplasticityStressUpdateBase< compute_stage >::computeTimeStepLimit ( )

overridevirtualinherited

Compute the limiting value of the time step for this material.

Returns: Limiting time step

Reimplemented from ADStressUpdateBase< compute_stage >.

Definition at line 92 of file ADViscoplasticityStressUpdateBase.C.

 {
   const Real scalar_inelastic_strain_incr =
       MetaPhysicL::raw_value(_effective_inelastic_strain[_qp]) -
       _effective_inelastic_strain_old[_qp];
  
   if (!scalar_inelastic_strain_incr)
     return std::numeric_limits<Real>::max();
  
   return _dt * _max_inelastic_increment / scalar_inelastic_strain_incr;
 }

◆ converged()

template<ComputeStage compute_stage>

bool ADSingleVariableReturnMappingSolution< compute_stage >::converged	(	const ADReal &	residual,
		const Real	reference
	)

protectedinherited

Check to see whether the residual is within the convergence limits.

Parameters

residual	Current value of the residual
reference	Current value of the reference quantity

Returns: Whether the model converged

Definition at line 301 of file ADSingleVariableReturnMappingSolution.C.

 {
   const Real residual = MetaPhysicL::raw_value(ad_residual);
   return (std::abs(residual) <= _absolute_tolerance ||
           std::abs(residual / reference) <= _relative_tolerance);
 }

◆ convergedAcceptable()

template<ComputeStage compute_stage>

bool ADSingleVariableReturnMappingSolution< compute_stage >::convergedAcceptable	(	const unsigned int	it,
		const Real	reference
	)

privateinherited

Check to see whether the residual is within acceptable convergence limits.

This will only return true if it has been determined that progress is no longer being made and that the residual is within the acceptable limits.

Parameters

residual	Current iteration count
residual	Current value of the residual
reference	Current value of the reference quantity

Returns: Whether the model converged

Definition at line 311 of file ADSingleVariableReturnMappingSolution.C.

 {
   // Require that we have at least done _num_resids evaluations before we allow for
   // acceptable convergence
   if (it < _num_resids)
     return false;
  
   // Check to see whether the residual has dropped by convergence_history_factor over
   // the last _num_resids iterations. If it has (which means it's still making progress),
   // don't consider it to be converged within the acceptable limits.
   const Real convergence_history_factor = 10.0;
   if (std::abs(_residual * convergence_history_factor) <
       std::abs(_residual_history[(it + 1) % _num_resids]))
     return false;
  
   // Now that it's determined that progress is not being made, treat it as converged if
   // we're within the acceptable convergence limits
   return converged(_residual / _acceptable_multiplier, reference);
 }

◆ initialGuess()

template<ComputeStage compute_stage>

ADReal ADViscoplasticityStressUpdate< compute_stage >::initialGuess ( const ADReal & effective_trial_stress )

overrideprotectedvirtual

Compute an initial guess for the value of the scalar.

For some cases, an intellegent starting point can provide enhanced robustness in the Newton iterations. This is also an opportunity for classes that derive from this to perform initialization tasks.

Parameters

effective_trial_stress Effective trial stress

Reimplemented from ADSingleVariableReturnMappingSolution< compute_stage >.

Definition at line 161 of file ADViscoplasticityStressUpdate.C.

 {
   return effective_trial_stress;
 }

◆ initQpStatefulProperties()

template<ComputeStage compute_stage>

void ADViscoplasticityStressUpdateBase< compute_stage >::initQpStatefulProperties ( )

overrideprotectedvirtualinherited

Definition at line 66 of file ADViscoplasticityStressUpdateBase.C.

 {
   _effective_inelastic_strain[_qp] = 0.0;
   _inelastic_strain[_qp].zero();
 }

◆ internalSolve()

template<ComputeStage compute_stage>

ADSingleVariableReturnMappingSolution< compute_stage >::SolveState ADSingleVariableReturnMappingSolution< compute_stage >::internalSolve	(	const ADReal	effective_trial_stress,
		ADReal &	scalar,
		std::stringstream *	iter_output = `nullptr`
	)

privateinherited

Method called from within this class to perform the actual return mappping iterations.

Parameters

effective_trial_stress	Effective trial stress
scalar	Inelastic strain increment magnitude being solved for
iter_output	Output stream – if null, no output is produced

Returns: Whether the solution was successful

Definition at line 162 of file ADSingleVariableReturnMappingSolution.C.

 {
   scalar = initialGuess(effective_trial_stress);
   ADReal scalar_old = scalar;
   ADReal scalar_increment = 0.0;
   const ADReal min_permissible_scalar = minimumPermissibleValue(effective_trial_stress);
   const ADReal max_permissible_scalar = maximumPermissibleValue(effective_trial_stress);
   ADReal scalar_upper_bound = max_permissible_scalar;
   ADReal scalar_lower_bound = min_permissible_scalar;
   _iteration = 0;
  
   _initial_residual = _residual = computeResidual(effective_trial_stress, scalar);
  
   ADReal residual_old = _residual;
   Real init_resid_sign = MathUtils::sign(MetaPhysicL::raw_value(_residual));
   Real reference_residual = computeReferenceResidual(effective_trial_stress, scalar);
  
   if (converged(_residual, reference_residual))
   {
     iterationFinalize(scalar);
     outputIterationStep(iter_output, effective_trial_stress, scalar, reference_residual);
     return SolveState::SUCCESS;
   }
  
   _residual_history.assign(_num_resids, std::numeric_limits<Real>::max());
   _residual_history[0] = MetaPhysicL::raw_value(_residual);
  
   while (_iteration < _max_its && !converged(_residual, reference_residual) &&
          !convergedAcceptable(_iteration, reference_residual))
   {
     scalar_increment = -_residual / computeDerivative(effective_trial_stress, scalar);
     scalar = scalar_old + scalar_increment;
  
     if (_check_range)
       checkPermissibleRange(scalar,
                             scalar_increment,
                             scalar_old,
                             min_permissible_scalar,
                             max_permissible_scalar,
                             iter_output);
  
     _residual = computeResidual(effective_trial_stress, scalar);
     reference_residual = computeReferenceResidual(effective_trial_stress, scalar);
     iterationFinalize(scalar);
  
     if (_bracket_solution)
       updateBounds(
           scalar, _residual, init_resid_sign, scalar_upper_bound, scalar_lower_bound, iter_output);
  
     if (converged(_residual, reference_residual))
     {
       outputIterationStep(iter_output, effective_trial_stress, scalar, reference_residual);
       break;
     }
     else
     {
       bool modified_increment = false;
  
       // Line Search
       if (_line_search)
       {
         if (residual_old - _residual != 0.0)
         {
           ADReal alpha = residual_old / (residual_old - _residual);
           alpha = MathUtils::clamp(alpha, 1.0e-2, 1.0);
  
           if (alpha != 1.0)
           {
             modified_increment = true;
             scalar_increment *= alpha;
             if (iter_output)
               *iter_output << "  Line search alpha = " << MetaPhysicL::raw_value(alpha)
                            << " increment = " << MetaPhysicL::raw_value(scalar_increment)
                            << std::endl;
           }
         }
       }
  
       if (_bracket_solution)
       {
         // Check to see whether trial scalar_increment is outside the bounds, and set it to a point
         // within the bounds if it is
         if (scalar_old + scalar_increment >= scalar_upper_bound ||
             scalar_old + scalar_increment <= scalar_lower_bound)
         {
           if (scalar_upper_bound != max_permissible_scalar &&
               scalar_lower_bound != min_permissible_scalar)
           {
             const Real frac = 0.5;
             scalar_increment =
                 (1.0 - frac) * scalar_lower_bound + frac * scalar_upper_bound - scalar_old;
             modified_increment = true;
             if (iter_output)
               *iter_output << "  Trial scalar_increment exceeded bounds.  Setting between "
                               "lower/upper bounds. frac: "
                            << frac << std::endl;
           }
         }
       }
  
       // Update the trial scalar and recompute residual if the line search or bounds checking
       // modified the increment
       if (modified_increment)
       {
         scalar = scalar_old + scalar_increment;
         _residual = computeResidual(effective_trial_stress, scalar);
         reference_residual = computeReferenceResidual(effective_trial_stress, scalar);
         iterationFinalize(scalar);
  
         if (_bracket_solution)
           updateBounds(scalar,
                        _residual,
                        init_resid_sign,
                        scalar_upper_bound,
                        scalar_lower_bound,
                        iter_output);
       }
     }
  
     outputIterationStep(iter_output, effective_trial_stress, scalar, reference_residual);
  
     ++_iteration;
     residual_old = _residual;
     scalar_old = scalar;
     _residual_history[_iteration % _num_resids] = MetaPhysicL::raw_value(_residual);
   }
  
   if (std::isnan(_residual) || std::isinf(MetaPhysicL::raw_value(_residual)))
     return SolveState::NAN_INF;
  
   if (_iteration == _max_its)
     return SolveState::EXCEEDED_ITERATIONS;
  
   return SolveState::SUCCESS;
 }

◆ iterationFinalize()

template<ComputeStage compute_stage>

virtual void ADSingleVariableReturnMappingSolution< compute_stage >::iterationFinalize ( ADReal )

inlineprotectedvirtualinherited

Finalize internal state variables for a model for a given iteration.

Parameters

scalar Inelastic strain increment magnitude being solved for

Reimplemented in ADIsotropicPlasticityStressUpdate< compute_stage >.

Definition at line 114 of file ADSingleVariableReturnMappingSolution.h.

114 {}

◆ maximumPermissibleValue()

template<ComputeStage compute_stage>

ADReal ADViscoplasticityStressUpdate< compute_stage >::maximumPermissibleValue ( const ADReal & effective_trial_stress ) const

overridevirtual

Compute the maximum permissible value of the scalar.

For some models, the magnitude of this may be known.

Parameters

effective_trial_stress Effective trial stress

Reimplemented from ADSingleVariableReturnMappingSolution< compute_stage >.

Definition at line 168 of file ADViscoplasticityStressUpdate.C.

 {
   return effective_trial_stress * _maximum_gauge_ratio;
 }

◆ minimumPermissibleValue()

template<ComputeStage compute_stage>

ADReal ADViscoplasticityStressUpdate< compute_stage >::minimumPermissibleValue ( const ADReal & effective_trial_stress ) const

overridevirtual

Compute the minimum permissible value of the scalar.

For some models, the magnitude of this may be known.

Parameters

effective_trial_stress Effective trial stress

Reimplemented from ADSingleVariableReturnMappingSolution< compute_stage >.

Definition at line 176 of file ADViscoplasticityStressUpdate.C.

 {
   return effective_trial_stress;
 }

◆ outputIterationStep()

template<ComputeStage compute_stage>

void ADSingleVariableReturnMappingSolution< compute_stage >::outputIterationStep	(	std::stringstream *	iter_output,
		const ADReal &	effective_trial_stress,
		const ADReal &	scalar,
		const Real	reference_residual
	)

protectedvirtualinherited

Output information for a single iteration step to build the convergence history of the model.

Parameters

iter_output	Output stream
it	Current iteration count
effective_trial_stress	Effective trial stress
scalar	Inelastic strain increment magnitude being solved for
residual	Current value of the residual
reference	Current value of the reference quantity

Definition at line 393 of file ADSingleVariableReturnMappingSolution.C.

 {
   if (iter_output)
   {
     const unsigned int it = _iteration;
     const Real residual = MetaPhysicL::raw_value(_residual);
  
     *iter_output << " iteration=" << it
                  << " trial_stress=" << MetaPhysicL::raw_value(effective_trial_stress)
                  << " scalar=" << MetaPhysicL::raw_value(scalar) << " residual=" << residual
                  << " ref_res=" << reference_residual
                  << " rel_res=" << std::abs(residual) / reference_residual
                  << " rel_tol=" << _relative_tolerance << " abs_res=" << std::abs(residual)
                  << " abs_tol=" << _absolute_tolerance << '\n';
   }
 }

◆ outputIterationSummary()

template<ComputeStage compute_stage>

void ADViscoplasticityStressUpdateBase< compute_stage >::outputIterationSummary	(	std::stringstream *	iter_output,
		const unsigned int	total_it
	)

overrideprotectedvirtualinherited

Output summary information for the convergence history of the model.

Parameters

iter_output	Output stream
total_it	Total iteration count

Reimplemented from ADSingleVariableReturnMappingSolution< compute_stage >.

Definition at line 106 of file ADViscoplasticityStressUpdateBase.C.

 {
   if (iter_output)
   {
     *iter_output << "At element " << _current_elem->id() << " _qp=" << _qp << " Coordinates "
                  << _q_point[_qp] << " block=" << _current_elem->subdomain_id() << '\n';
   }
   ADSingleVariableReturnMappingSolution<compute_stage>::outputIterationSummary(iter_output,
                                                                                total_it);
 }

◆ propagateQpStatefulProperties()

template<ComputeStage compute_stage>

void ADViscoplasticityStressUpdateBase< compute_stage >::propagateQpStatefulProperties ( )

overrideprotectedvirtualinherited

If updateState is not called during a timestep, this will be.

This method allows derived classes to set internal parameters from their Old values, for instance

Reimplemented from ADStressUpdateBase< compute_stage >.

Definition at line 74 of file ADViscoplasticityStressUpdateBase.C.

 {
   _effective_inelastic_strain[_qp] = _effective_inelastic_strain_old[_qp];
   _inelastic_strain[_qp] = _inelastic_strain_old[_qp];
 }

◆ requiresIsotropicTensor()

template<ComputeStage compute_stage>

bool ADViscoplasticityStressUpdateBase< compute_stage >::requiresIsotropicTensor ( )

inlineoverridevirtualinherited

Does the model require the elasticity tensor to be isotropic?

Implements ADStressUpdateBase< compute_stage >.

Definition at line 58 of file ADViscoplasticityStressUpdateBase.h.

58 { return true; }

◆ resetProperties()

template<ComputeStage compute_stage>

void ADStressUpdateBase< compute_stage >::resetProperties ( )

inlinefinalinherited

Definition at line 104 of file ADStressUpdateBase.h.

104 {}

◆ resetQpProperties()

template<ComputeStage compute_stage>

void ADStressUpdateBase< compute_stage >::resetQpProperties ( )

inlinefinalinherited

Retained as empty methods to avoid a warning from Material.C in framework. These methods are unused in all inheriting classes and should not be overwritten.

Definition at line 103 of file ADStressUpdateBase.h.

103 {}

◆ returnMappingSolve()

template<ComputeStage compute_stage>

void ADSingleVariableReturnMappingSolution< compute_stage >::returnMappingSolve	(	const ADReal &	effective_trial_stress,
		ADReal &	scalar,
		const ConsoleStream &	console
	)

protectedinherited

Perform the return mapping iterations.

Parameters

effective_trial_stress	Effective trial stress
scalar	Inelastic strain increment magnitude being solved for
console	Console output

Definition at line 101 of file ADSingleVariableReturnMappingSolution.C.

 {
   // construct the stringstream here only if the debug level is set to ALL
   std::unique_ptr<std::stringstream> iter_output =
       (_internal_solve_output_on == InternalSolveOutput::ALWAYS)
           ? libmesh_make_unique<std::stringstream>()
           : nullptr;
  
   // do the internal solve and capture iteration info during the first round
   // iff full history output is requested regardless of whether the solve failed or succeeded
   auto solve_state =
       internalSolve(effective_trial_stress,
                     scalar,
                     _internal_solve_full_iteration_history ? iter_output.get() : nullptr);
   if (solve_state != SolveState::SUCCESS &&
       _internal_solve_output_on != InternalSolveOutput::ALWAYS)
   {
     // output suppressed by user, throw immediately
     if (_internal_solve_output_on == InternalSolveOutput::NEVER)
       throw MooseException("");
  
     // user expects some kind of output, if necessary setup output stream now
     if (!iter_output)
       iter_output = libmesh_make_unique<std::stringstream>();
  
     // add the appropriate error message to the output
     switch (solve_state)
     {
       case SolveState::NAN_INF:
         *iter_output << "Encountered inf or nan in material return mapping iterations.\n";
         break;
  
       case SolveState::EXCEEDED_ITERATIONS:
         *iter_output << "Exceeded maximum iterations in material return mapping iterations.\n";
         break;
  
       default:
         mooseError("Unhandled solver state");
     }
  
     // if full history output is only requested for failed solves we have to repeat
     // the solve a second time
     if (_internal_solve_full_iteration_history)
       internalSolve(effective_trial_stress, scalar, iter_output.get());
  
     // Append summary and throw exception
     outputIterationSummary(iter_output.get(), _iteration);
     throw MooseException(iter_output->str());
   }
  
   if (_internal_solve_output_on == InternalSolveOutput::ALWAYS)
   {
     // the solve did not fail but the user requested debug output anyways
     outputIterationSummary(iter_output.get(), _iteration);
     console << iter_output->str();
   }
 }

◆ setQp()

template<ComputeStage compute_stage>

void ADStressUpdateBase< compute_stage >::setQp ( unsigned int qp )

inherited

Sets the value of the global variable _qp for inheriting classes.

Definition at line 47 of file ADStressUpdateBase.C.

 {
   _qp = qp;
 }

◆ updateBounds()

template<ComputeStage compute_stage>

void ADSingleVariableReturnMappingSolution< compute_stage >::updateBounds	(	const ADReal &	scalar,
		const ADReal &	residual,
		const Real	init_resid_sign,
		ADReal &	scalar_upper_bound,
		ADReal &	scalar_lower_bound,
		std::stringstream *	iter_output
	)

privateinherited

Update the upper and lower bounds of the root for the effective inelastic strain.

Parameters

scalar	Current value of the inelastic strain increment
residual	Current value of the residual
init_resid_sign	Sign of the initial value of the residual
scalar_upper_bound	Upper bound value of scalar
scalar_lower_bound	Lower bound value of scalar
iter_output	Output stream

Definition at line 365 of file ADSingleVariableReturnMappingSolution.C.

 {
   // Update upper/lower bounds as applicable
   if (residual * init_resid_sign < 0.0 && scalar < scalar_upper_bound)
   {
     scalar_upper_bound = scalar;
     if (scalar_upper_bound < scalar_lower_bound)
     {
       scalar_upper_bound = scalar_lower_bound;
       scalar_lower_bound = 0.0;
       if (iter_output)
         *iter_output << "  Corrected for scalar_upper_bound < scalar_lower_bound" << std::endl;
     }
   }
   // Don't permit setting scalar_lower_bound > scalar_upper_bound (but do permit the reverse).
   // This ensures that if we encounter multiple roots, we pick the lowest one.
   else if (residual * init_resid_sign > 0.0 && scalar > scalar_lower_bound &&
            scalar < scalar_upper_bound)
     scalar_lower_bound = scalar;
 }

◆ updateIntermediatePorosity()

template<ComputeStage compute_stage>

void ADViscoplasticityStressUpdateBase< compute_stage >::updateIntermediatePorosity ( const ADRankTwoTensor & elastic_strain_increment )

protectedinherited

Definition at line 120 of file ADViscoplasticityStressUpdateBase.C.

 {
   // Subtract elastic strain from strain increment to find all inelastic strain increments
   // calculated so far except the one that we're about to calculate
   const ADRankTwoTensor inelastic_volumetric_increment =
       _strain_increment[_qp] - elastic_strain_increment;
  
   // Calculate intermdiate porosity from all inelastic strain increments calculated so far except
   // the one that we're about to calculate
   _intermediate_porosity =
       (1.0 - _porosity_old[_qp]) * inelastic_volumetric_increment.trace() + _porosity_old[_qp];
 }

◆ updateState()

template<ComputeStage compute_stage>

void ADViscoplasticityStressUpdate< compute_stage >::updateState	(	ADRankTwoTensor &	strain_increment,
		ADRankTwoTensor &	inelastic_strain_increment,
		const ADRankTwoTensor &	rotation_increment,
		ADRankTwoTensor &	stress_new,
		const RankTwoTensor &	stress_old,
		const ADRankFourTensor &	elasticity_tensor,
		const RankTwoTensor &	elastic_strain_old
	)

overridevirtual

Given a strain increment that results in a trial stress, perform some procedure (such as an iterative return-mapping process) to produce an admissible stress, an elastic strain increment and an inelastic strain increment.

If _fe_problem.currentlyComputingJacobian() = true, then updateState also computes d(stress)/d(strain) (or some approximation to it).

This method is called by ComputeMultipleInelasticStress. This method is pure virtual: all inheriting classes must overwrite this method.

Parameters

strain_increment	Upon input: the strain increment. Upon output: the elastic strain increment
inelastic_strain_increment	The inelastic_strain resulting from the iterative procedure
rotation_increment	The finite-strain rotation increment
stress_new	Upon input: the trial stress that results from applying strain_increment as an elastic strain. Upon output: the admissible stress
stress_old	The old value of stress
elasticity_tensor	The elasticity tensor

Implements ADStressUpdateBase< compute_stage >.

Definition at line 78 of file ADViscoplasticityStressUpdate.C.

 {
   // Compute initial hydrostatic stress and porosity
   if (_pore_shape == PoreShapeModel::CYLINDRICAL)
     _hydro_stress = (stress(0, 0) + stress(1, 1)) / 2.0;
   else
     _hydro_stress = stress.trace() / 3.0;
  
   updateIntermediatePorosity(elastic_strain_increment);
  
   // Compute intermediate equivalent stress
   const ADRankTwoTensor dev_stress = stress.deviatoric();
   const ADReal dev_stress_squared = dev_stress.doubleContraction(dev_stress);
   const ADReal equiv_stress = dev_stress_squared == 0.0 ? 0.0 : std::sqrt(1.5 * dev_stress_squared);
  
   computeStressInitialize(equiv_stress, elasticity_tensor);
  
   // Prepare values
   _effective_inelastic_strain[_qp] = _effective_inelastic_strain_old[_qp];
   _inelastic_strain[_qp] = _inelastic_strain_old[_qp];
   inelastic_strain_increment.zero();
  
   // Protect against extremely high values of stresses calculated by other viscoplastic materials
   if (equiv_stress > _maximum_equivalent_stress)
     mooseException("In ",
                    _name,
                    ": equivalent stress (",
                    equiv_stress,
                    ") is higher than maximum_equivalent_stress (",
                    _maximum_equivalent_stress,
                    ").\nCutting time step.");
  
   // If equivalent stress is present, calculate creep strain increment
   if (equiv_stress > _minimum_equivalent_stress)
   {
     // Initalize stress potential
     ADReal dpsi_dgauge(0);
  
     computeInelasticStrainIncrement(_gauge_stress[_qp],
                                     dpsi_dgauge,
                                     inelastic_strain_increment,
                                     equiv_stress,
                                     dev_stress,
                                     stress);
  
     // Update elastic strain increment due to inelastic strain calculated here
     elastic_strain_increment -= inelastic_strain_increment;
     // Update stress due to new strain
     stress = elasticity_tensor * (elastic_strain_old + elastic_strain_increment);
  
     // Compute effective strain from the stress potential. Note that this is approximate and to be
     // used qualitatively
     _effective_inelastic_strain[_qp] += dpsi_dgauge * _dt;
     // Update creep strain due to currently computed inelastic strain
     _inelastic_strain[_qp] += inelastic_strain_increment;
   }
  
   const ADRankTwoTensor new_dev_stress = stress.deviatoric();
   const ADReal new_dev_stress_squared = new_dev_stress.doubleContraction(new_dev_stress);
   const ADReal new_equiv_stress =
       new_dev_stress_squared == 0.0 ? 0.0 : std::sqrt(1.5 * new_dev_stress_squared);
  
   if (MooseUtils::relativeFuzzyGreaterThan(new_equiv_stress, equiv_stress))
     mooseException("In ",
                    _name,
                    ": updated equivalent stress (",
                    MetaPhysicL::raw_value(new_equiv_stress),
                    ") is greater than initial equivalent stress (",
                    MetaPhysicL::raw_value(equiv_stress),
                    "). Try decreasing max_inelastic_increment to avoid this exception.");
  
   computeStressFinalize(inelastic_strain_increment);
 }

◆ validParams()

template<ComputeStage compute_stage>

InputParameters ADViscoplasticityStressUpdate< compute_stage >::validParams ( )

static

Definition at line 20 of file ADViscoplasticityStressUpdate.C.

 {
   InputParameters params = ADViscoplasticityStressUpdateBase<compute_stage>::validParams();
   params.addClassDescription(
       "This material computes the non-linear homogenized gauge stress in order to compute the "
       "viscoplastic responce due to creep in porous materials. This material must be used in "
       "conjunction with ADComputeMultiplePorousInelasticStress");
   MooseEnum viscoplasticity_model("LPS GTN", "LPS");
   params.addParam<MooseEnum>(
       "viscoplasticity_model", viscoplasticity_model, "Which viscoplastic model to use");
   MooseEnum pore_shape_model("spherical cylindrical", "spherical");
   params.addParam<MooseEnum>("pore_shape_model", pore_shape_model, "Which pore shape model to use");
   params.addRequiredParam<MaterialPropertyName>(
       "coefficient", "Material property name for the leading coefficient for Norton power law");
   params.addRequiredRangeCheckedParam<Real>(
       "power", "power>=1.0", "Stress exponent for Norton power law");
   params.addParam<Real>(
       "maximum_gauge_ratio",
       1.0e6,
       "Maximum ratio between the gauge stress and the equivalent stress. This "
       "should be a high number. Note that this does not set an upper bound on the value, but "
       "rather will help with convergence of the inner Newton loop");
   params.addParam<Real>(
       "minimum_equivalent_stress",
       1.0e-3,
       "Minimum value of equivalent stress below which viscoplasticiy is not calculated.");
   params.addParam<Real>("maximum_equivalent_stress",
                         1.0e12,
                         "Maximum value of equivalent stress above which an exception is thrown "
                         "instead of calculating the properties in this material.");
  
   params.addParamNamesToGroup("verbose maximum_gauge_ratio maximum_equivalent_stress", "Advanced");
   return params;
 }

Member Data Documentation

◆ _absolute_tolerance

template<ComputeStage compute_stage>

Real ADSingleVariableReturnMappingSolution< compute_stage >::_absolute_tolerance

privateinherited

Absolute convergence tolerance.

Definition at line 181 of file ADSingleVariableReturnMappingSolution.h.

◆ _acceptable_multiplier

template<ComputeStage compute_stage>

Real ADSingleVariableReturnMappingSolution< compute_stage >::_acceptable_multiplier

privateinherited

Multiplier applied to relative and absolute tolerances for acceptable convergence.

Definition at line 184 of file ADSingleVariableReturnMappingSolution.h.

◆ _base_name

template<ComputeStage compute_stage>

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

protectedinherited

Name used as a prefix for all material properties related to the stress update model.

Definition at line 109 of file ADStressUpdateBase.h.

◆ _bracket_solution

template<ComputeStage compute_stage>

bool ADSingleVariableReturnMappingSolution< compute_stage >::_bracket_solution

protectedinherited

Whether to save upper and lower bounds of root for scalar, and set solution to the midpoint between those bounds if outside them.

Definition at line 131 of file ADSingleVariableReturnMappingSolution.h.

◆ _check_range

template<ComputeStage compute_stage>

bool ADSingleVariableReturnMappingSolution< compute_stage >::_check_range

protectedinherited

Whether to check to see whether iterative solution is within admissible range, and set within that range if outside.

Definition at line 124 of file ADSingleVariableReturnMappingSolution.h.

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

◆ _derivative

template<ComputeStage compute_stage>

ADReal ADViscoplasticityStressUpdateBase< compute_stage >::_derivative

protectedinherited

Container for _derivative.

Definition at line 121 of file ADViscoplasticityStressUpdateBase.h.

Referenced by ADViscoplasticityStressUpdateBase< compute_stage >::computeDerivative().

◆ _dhydro_stress_dsigma

template<ComputeStage compute_stage>

const RankTwoTensor ADViscoplasticityStressUpdate< compute_stage >::_dhydro_stress_dsigma

protected

Derivative of hydrostatic stress with respect to the stress tensor.

Definition at line 107 of file ADViscoplasticityStressUpdate.h.

◆ _effective_inelastic_strain_old

template<ComputeStage compute_stage>

const MaterialProperty<Real>& ADViscoplasticityStressUpdateBase< compute_stage >::_effective_inelastic_strain_old

protectedinherited

Definition at line 100 of file ADViscoplasticityStressUpdateBase.h.

◆ _hydro_stress

template<ComputeStage compute_stage>

ADReal ADViscoplasticityStressUpdate< compute_stage >::_hydro_stress

protected

Container for hydrostatic stress.

Definition at line 101 of file ADViscoplasticityStressUpdate.h.

◆ _identity_two

template<ComputeStage compute_stage>

const RankTwoTensor ADViscoplasticityStressUpdate< compute_stage >::_identity_two

protected

Rank two identity tensor.

Definition at line 104 of file ADViscoplasticityStressUpdate.h.

◆ _inelastic_strain_old

template<ComputeStage compute_stage>

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

protectedinherited

Definition at line 105 of file ADViscoplasticityStressUpdateBase.h.

◆ _initial_residual

template<ComputeStage compute_stage>

ADReal ADSingleVariableReturnMappingSolution< compute_stage >::_initial_residual

privateinherited

Residual values, kept as members to retain solver state for summary outputting.

Definition at line 196 of file ADSingleVariableReturnMappingSolution.h.

◆ _intermediate_porosity

template<ComputeStage compute_stage>

ADReal ADViscoplasticityStressUpdateBase< compute_stage >::_intermediate_porosity

protectedinherited

Container for the porosity calculated from all other intelastic models except the current model.

Definition at line 112 of file ADViscoplasticityStressUpdateBase.h.

◆ _internal_solve_full_iteration_history

template<ComputeStage compute_stage>

const bool ADSingleVariableReturnMappingSolution< compute_stage >::_internal_solve_full_iteration_history

privateinherited

Whether to output iteration information all the time (regardless of whether iterations converge)

Definition at line 175 of file ADSingleVariableReturnMappingSolution.h.

◆ _internal_solve_output_on

template<ComputeStage compute_stage>

enum ADSingleVariableReturnMappingSolution::InternalSolveOutput ADSingleVariableReturnMappingSolution< compute_stage >::_internal_solve_output_on

privateinherited

◆ _iteration

template<ComputeStage compute_stage>

unsigned int ADSingleVariableReturnMappingSolution< compute_stage >::_iteration

privateinherited

iteration number

Definition at line 193 of file ADSingleVariableReturnMappingSolution.h.

◆ _line_search

template<ComputeStage compute_stage>

bool ADSingleVariableReturnMappingSolution< compute_stage >::_line_search

protectedinherited

Whether to use line searches to improve convergence.

Definition at line 127 of file ADSingleVariableReturnMappingSolution.h.

◆ _max_inelastic_increment

template<ComputeStage compute_stage>

Real ADViscoplasticityStressUpdateBase< compute_stage >::_max_inelastic_increment

protectedinherited

Max increment for inelastic strain.

Definition at line 109 of file ADViscoplasticityStressUpdateBase.h.

◆ _max_its

template<ComputeStage compute_stage>

const unsigned int ADSingleVariableReturnMappingSolution< compute_stage >::_max_its

privateinherited

Maximum number of return mapping iterations.

This exists only to avoid an infinite loop, and is is intended to be a large number that is not settable by the user.

Definition at line 172 of file ADSingleVariableReturnMappingSolution.h.

◆ _maximum_equivalent_stress

template<ComputeStage compute_stage>

const Real ADViscoplasticityStressUpdate< compute_stage >::_maximum_equivalent_stress

protected

Maximum value of equivalent stress above which an exception is thrown.

Definition at line 98 of file ADViscoplasticityStressUpdate.h.

◆ _maximum_gauge_ratio

template<ComputeStage compute_stage>

const Real ADViscoplasticityStressUpdate< compute_stage >::_maximum_gauge_ratio

protected

Maximum ratio between the gauge stress and the equilvalent stress.

Definition at line 92 of file ADViscoplasticityStressUpdate.h.

◆ _minimum_equivalent_stress

template<ComputeStage compute_stage>

const Real ADViscoplasticityStressUpdate< compute_stage >::_minimum_equivalent_stress

protected

Minimum value of equivalent stress below which viscoplasticiy is not calculated.

Definition at line 95 of file ADViscoplasticityStressUpdate.h.

◆ _model

template<ComputeStage compute_stage>

enum ADViscoplasticityStressUpdate::ViscoplasticityModel ADViscoplasticityStressUpdate< compute_stage >::_model

protected

◆ _num_resids

template<ComputeStage compute_stage>

const std::size_t ADSingleVariableReturnMappingSolution< compute_stage >::_num_resids

privateinherited

Number of residuals to be stored in history.

Definition at line 187 of file ADSingleVariableReturnMappingSolution.h.

◆ _pore_shape

template<ComputeStage compute_stage>

enum ADViscoplasticityStressUpdate::PoreShapeModel ADViscoplasticityStressUpdate< compute_stage >::_pore_shape

protected

◆ _pore_shape_factor

template<ComputeStage compute_stage>

const Real ADViscoplasticityStressUpdate< compute_stage >::_pore_shape_factor

protected

Pore shape factor depending on pore shape model.

Definition at line 77 of file ADViscoplasticityStressUpdate.h.

◆ _porosity_old

template<ComputeStage compute_stage>

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

protectedinherited

Material property for the old porosity.

Definition at line 115 of file ADViscoplasticityStressUpdateBase.h.

◆ _power

template<ComputeStage compute_stage>

const Real ADViscoplasticityStressUpdate< compute_stage >::_power

protected

Exponent on the effective stress.

Definition at line 80 of file ADViscoplasticityStressUpdate.h.

◆ _power_factor

template<ComputeStage compute_stage>

const Real ADViscoplasticityStressUpdate< compute_stage >::_power_factor

protected

Power factor used for LPS model.

Definition at line 83 of file ADViscoplasticityStressUpdate.h.

◆ _relative_tolerance

template<ComputeStage compute_stage>

Real ADSingleVariableReturnMappingSolution< compute_stage >::_relative_tolerance

privateinherited

Relative convergence tolerance.

Definition at line 178 of file ADSingleVariableReturnMappingSolution.h.

◆ _residual

template<ComputeStage compute_stage>

ADReal ADSingleVariableReturnMappingSolution< compute_stage >::_residual

privateinherited

Definition at line 197 of file ADSingleVariableReturnMappingSolution.h.

◆ _residual_history

template<ComputeStage compute_stage>

std::vector<Real> ADSingleVariableReturnMappingSolution< compute_stage >::_residual_history

privateinherited

History of residuals used to check whether progress is still being made on decreasing the residual.

Definition at line 190 of file ADSingleVariableReturnMappingSolution.h.

◆ _svrms_name

template<ComputeStage compute_stage>

const std::string ADSingleVariableReturnMappingSolution< compute_stage >::_svrms_name

privateinherited

MOOSE input name of the object performing the solve.

Definition at line 201 of file ADSingleVariableReturnMappingSolution.h.

◆ _total_strain_base_name

template<ComputeStage compute_stage>

const std::string ADViscoplasticityStressUpdateBase< compute_stage >::_total_strain_base_name

protectedinherited

String designating the base name of the total strain.

Definition at line 93 of file ADViscoplasticityStressUpdateBase.h.

◆ _verbose

template<ComputeStage compute_stage>

const bool ADViscoplasticityStressUpdateBase< compute_stage >::_verbose

protectedinherited

Flag to enable verbose output.

Definition at line 118 of file ADViscoplasticityStressUpdateBase.h.

◆ usingMaterialMembers

template<ComputeStage compute_stage>

ADStressUpdateBase< compute_stage >::usingMaterialMembers

protectedinherited

Definition at line 111 of file ADStressUpdateBase.h.

◆ usingSingleVariableReturnMappingSolutionMembers

template<ComputeStage compute_stage>

ADViscoplasticityStressUpdateBase< compute_stage >::usingSingleVariableReturnMappingSolutionMembers

protectedinherited

Definition at line 124 of file ADViscoplasticityStressUpdateBase.h.

◆ usingStressUpdateBaseMembers

template<ComputeStage compute_stage>

ADViscoplasticityStressUpdateBase< compute_stage >::usingStressUpdateBaseMembers

protectedinherited

Definition at line 123 of file ADViscoplasticityStressUpdateBase.h.

◆ usingViscoplasticityStressUpdateBaseMembers

template<ComputeStage compute_stage>

ADViscoplasticityStressUpdate< compute_stage >::usingViscoplasticityStressUpdateBaseMembers

protected

Definition at line 109 of file ADViscoplasticityStressUpdate.h.

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

tensor_mechanics/include/materials/ADViscoplasticityStressUpdate.h
tensor_mechanics/src/materials/ADViscoplasticityStressUpdate.C

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

template<ComputeStage compute_stage> class ADViscoplasticityStressUpdate< compute_stage >

Member Enumeration Documentation

◆ InternalSolveOutput

◆ PoreShapeModel

◆ SolveState

◆ ViscoplasticityModel

Constructor & Destructor Documentation

◆ ADViscoplasticityStressUpdate()

Member Function Documentation

◆ ADMaterialProperty() [1/3]

◆ ADMaterialProperty() [2/3]

◆ ADMaterialProperty() [3/3]

◆ checkPermissibleRange()

◆ computeDerivative()

◆ computeDGaugeDSigma()

◆ computeH()

◆ computeInelasticStrainIncrement()

◆ computeReferenceResidual()

◆ computeResidual()

◆ computeStressFinalize()

◆ computeStressInitialize()

◆ computeTimeStepLimit()

◆ converged()

◆ convergedAcceptable()

◆ initialGuess()

◆ initQpStatefulProperties()

◆ internalSolve()

◆ iterationFinalize()

◆ maximumPermissibleValue()

◆ minimumPermissibleValue()

◆ outputIterationStep()

◆ outputIterationSummary()

◆ propagateQpStatefulProperties()

◆ requiresIsotropicTensor()

◆ resetProperties()

◆ resetQpProperties()

◆ returnMappingSolve()

◆ setQp()

◆ updateBounds()

◆ updateIntermediatePorosity()

◆ updateState()

◆ validParams()

Member Data Documentation

◆ _absolute_tolerance

◆ _acceptable_multiplier

◆ _base_name

◆ _bracket_solution

◆ _check_range

◆ _derivative

◆ _dhydro_stress_dsigma

◆ _effective_inelastic_strain_old

◆ _hydro_stress

◆ _identity_two

◆ _inelastic_strain_old

◆ _initial_residual

◆ _intermediate_porosity

◆ _internal_solve_full_iteration_history

◆ _internal_solve_output_on

◆ _iteration

◆ _line_search

◆ _max_inelastic_increment

◆ _max_its

◆ _maximum_equivalent_stress

◆ _maximum_gauge_ratio

◆ _minimum_equivalent_stress

◆ _model

◆ _num_resids

◆ _pore_shape

◆ _pore_shape_factor

◆ _porosity_old

◆ _power

template<ComputeStage compute_stage>
class ADViscoplasticityStressUpdate< compute_stage >