This class uses the Discrete material in a radial return isotropic plasticity model. More...

#include <IsotropicPowerLawHardeningStressUpdate.h>

Inheritance diagram for IsotropicPowerLawHardeningStressUpdate:

Public Member Functions
	IsotropicPowerLawHardeningStressUpdate (const InputParameters &parameters)

virtual void	updateState (RankTwoTensor &strain_increment, RankTwoTensor &inelastic_strain_increment, const RankTwoTensor &rotation_increment, RankTwoTensor &stress_new, const RankTwoTensor &stress_old, const RankFourTensor &elasticity_tensor, const RankTwoTensor &elastic_strain_old, bool compute_full_tangent_operator, RankFourTensor &tangent_operator) override
	A radial return (J2) mapping method is performed with return mapping iterations. More...

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

virtual Real	minimumPermissibleValue (const Real) const override
	Compute the minimum permissible value of the scalar. More...

virtual Real	maximumPermissibleValue (const Real effective_trial_stress) const override
	Compute the maximum permissible value of the scalar. 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...

bool	isIsotropic () override
	Radial return mapped models should be isotropic by default! More...

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

virtual TangentCalculationMethod	getTangentCalculationMethod ()


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 Member Functions
virtual void	computeStressInitialize (const Real effective_trial_stress, const RankFourTensor &elasticity_tensor) override
	Perform any necessary initialization before return mapping iterations. More...

virtual void	computeYieldStress (const RankFourTensor &elasticity_tensor) override

virtual Real	computeHardeningDerivative (Real scalar) override

Real	getIsotropicLameLambda (const RankFourTensor &elasticity_tensor)

virtual void	initQpStatefulProperties () override

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

virtual Real	computeResidual (const Real effective_trial_stress, const Real scalar) override
	Compute the residual for a predicted value of the scalar. More...

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

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

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

virtual Real	computeHardeningValue (Real scalar)

void	propagateQpStatefulPropertiesRadialReturn ()
	Propagate the properties pertaining to this intermediate class. More...

virtual Real	computeStressDerivative (const Real, const Real)
	Calculate the derivative of the strain increment with respect to the updated stress. More...

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

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

virtual Real	initialGuess (const Real)
	Compute an initial guess for the value of the scalar. More...

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

Protected Attributes
Real	_youngs_modulus
	Elastic constants. More...

Real	_effective_trial_stress

const std::string	_plastic_prepend
	a string to prepend to the plastic strain Material Property name More...

const Function *	_yield_stress_function

Real	_yield_stress

const Real	_hardening_constant

const Function *	_hardening_function

Real	_yield_condition

Real	_hardening_slope

MaterialProperty< RankTwoTensor > &	_plastic_strain
	plastic strain in this model More...

const MaterialProperty< RankTwoTensor > &	_plastic_strain_old
	old value of plastic strain More...

MaterialProperty< Real > &	_hardening_variable

const MaterialProperty< Real > &	_hardening_variable_old

const VariableValue &	_temperature

Real	_three_shear_modulus
	3 * shear modulus More...

MaterialProperty< Real > &	_effective_inelastic_strain

const MaterialProperty< Real > &	_effective_inelastic_strain_old

Real	_max_inelastic_increment

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

const RankFourTensor	_identity_symmetric_four
	Rank four symmetric identity tensor. More...

const RankFourTensor	_deviatoric_projection_four
	Rank four deviatoric projection tensor. More...

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

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


Real	_K
	Power law hardening coefficients. More...

Real	_strain_hardening_exponent

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 Real effective_trial_stress, Real &scalar, std::stringstream *iter_output=nullptr)
	Method called from within this class to perform the actual return mappping iterations. More...

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

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

void	checkPermissibleRange (Real &scalar, Real &scalar_increment, const Real scalar_old, const Real min_permissible_scalar, const Real 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 Real scalar, const Real residual, const Real init_resid_sign, Real &scalar_upper_bound, Real &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 SingleVariableReturnMappingSolution::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...


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

Real	_residual

Detailed Description

This class uses the Discrete material in a radial return isotropic plasticity model.

This class is one of the basic radial return constitutive models; more complex constitutive models combine creep and plasticity.

This class models power law hardening by using the relation \( \sigma = \sigma_y + K \epsilon^n \) where \( \sigma_y \) is the yield stress. This class solves for the yield stress as the intersection of the power law relation curve and Hooke's law: \( \epsilon_y = \frac{\sigma_y}{E} = \left( \frac{\sigma_y}{K} \right)^n \) where \(epsilon_y \) is the total strain at the yield point and the stress \( \sigma_y \) is the von Mises stress. Parameters from the parent class, IsotropicPlasticityStressUpdate, are suppressed to enable this class to solve for yield stress: \( \sigma_y = \left( \frac{E^n}{K} \right)^{1/(n-1)} \)

Definition at line 36 of file IsotropicPowerLawHardeningStressUpdate.h.

Member Enumeration Documentation

◆ InternalSolveOutput

enum SingleVariableReturnMappingSolution::InternalSolveOutput

strongprivateinherited

Enumerator
NEVER
ON_ERROR
ALWAYS

Definition at line 130 of file SingleVariableReturnMappingSolution.h.

   {
     NEVER,
     ON_ERROR,
     ALWAYS
   } _internal_solve_output_on;

◆ SolveState

enum SingleVariableReturnMappingSolution::SolveState

strongprivateinherited

Enumerator
SUCCESS
NAN_INF
EXCEEDED_ITERATIONS

Definition at line 137 of file SingleVariableReturnMappingSolution.h.

   {
     SUCCESS,
     NAN_INF,
     EXCEEDED_ITERATIONS
   };

Constructor & Destructor Documentation

◆ IsotropicPowerLawHardeningStressUpdate()

IsotropicPowerLawHardeningStressUpdate::IsotropicPowerLawHardeningStressUpdate ( const InputParameters & parameters )

Definition at line 44 of file IsotropicPowerLawHardeningStressUpdate.C.

   : IsotropicPlasticityStressUpdate(parameters),
     _K(parameters.get<Real>("strength_coefficient")),
     _strain_hardening_exponent(parameters.get<Real>("strain_hardening_exponent"))
 {
 }

Member Function Documentation

◆ checkPermissibleRange()

void SingleVariableReturnMappingSolution::checkPermissibleRange	(	Real &	scalar,
		Real &	scalar_increment,
		const Real	scalar_old,
		const Real	min_permissible_scalar,
		const Real	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 356 of file SingleVariableReturnMappingSolution.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 (" << max_permissible_scalar
                    << ") adjusted scalar=" << scalar << " scalar_increment=" << 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 (" << min_permissible_scalar
                    << ") adjusted scalar=" << scalar << " scalar_increment=" << scalar_increment
                    << std::endl;
   }
 }

Referenced by SingleVariableReturnMappingSolution::internalSolve().

◆ computeDerivative()

Real IsotropicPlasticityStressUpdate::computeDerivative	(	const Real	effective_trial_stress,
		const Real	scalar
	)

overrideprotectedvirtualinherited

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

Definition at line 127 of file IsotropicPlasticityStressUpdate.C.

 {
   if (_yield_condition > 0.0)
     return -1.0 - _hardening_slope / _three_shear_modulus;
  
   return 1.0;
 }

◆ computeHardeningDerivative()

Real IsotropicPowerLawHardeningStressUpdate::computeHardeningDerivative ( Real scalar )

overrideprotectedvirtual

Reimplemented from IsotropicPlasticityStressUpdate.

Definition at line 66 of file IsotropicPowerLawHardeningStressUpdate.C.

 {
   const Real stress_delta = _effective_trial_stress - _three_shear_modulus * scalar;
   Real slope = std::pow(stress_delta, (1.0 / _strain_hardening_exponent - 1.0)) /
                _strain_hardening_exponent * 1.0 / std::pow(_K, 1.0 / _strain_hardening_exponent);
   slope -= 1.0 / _youngs_modulus;
  
   return 1.0 / slope;
 }

◆ computeHardeningValue()

Real IsotropicPlasticityStressUpdate::computeHardeningValue ( Real scalar )

protectedvirtualinherited

Reimplemented in TemperatureDependentHardeningStressUpdate.

Definition at line 151 of file IsotropicPlasticityStressUpdate.C.

 {
   if (_hardening_function)
   {
     const Real strain_old = _effective_inelastic_strain_old[_qp];
     const Point p;
  
     return _hardening_function->value(strain_old + scalar, p) - _yield_stress;
   }
  
   return _hardening_variable_old[_qp] + _hardening_slope * scalar;
 }

Referenced by IsotropicPlasticityStressUpdate::computeResidual(), and IsotropicPlasticityStressUpdate::iterationFinalize().

◆ computeReferenceResidual()

Real RadialReturnStressUpdate::computeReferenceResidual	(	const Real	effective_trial_stress,
		const Real	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 SingleVariableReturnMappingSolution.

Definition at line 150 of file RadialReturnStressUpdate.C.

 {
   return effective_trial_stress / _three_shear_modulus - scalar_effective_inelastic_strain;
 }

◆ computeResidual()

Real IsotropicPlasticityStressUpdate::computeResidual	(	const Real	effective_trial_stress,
		const Real	scalar
	)

overrideprotectedvirtualinherited

Compute the residual for a predicted value of the scalar.

This 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 SingleVariableReturnMappingSolution.

Definition at line 107 of file IsotropicPlasticityStressUpdate.C.

 {
   mooseAssert(_yield_condition != -1.0,
               "the yield stress was not updated by computeStressInitialize");
  
   if (_yield_condition > 0.0)
   {
     _hardening_slope = computeHardeningDerivative(scalar);
     _hardening_variable[_qp] = computeHardeningValue(scalar);
  
     return (effective_trial_stress - _hardening_variable[_qp] - _yield_stress) /
                _three_shear_modulus -
            scalar;
   }
  
   return 0.0;
 }

◆ computeStressDerivative()

virtual Real RadialReturnStressUpdate::computeStressDerivative	(	const	Real,
		const	Real
	)

inlineprotectedvirtualinherited

Calculate the derivative of the strain increment with respect to the updated stress.

Parameters

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

Reimplemented in RadialReturnCreepStressUpdateBase.

Definition at line 118 of file RadialReturnStressUpdate.h.

   {
     return 0.0;
   }

Referenced by RadialReturnStressUpdate::updateState().

◆ computeStressFinalize()

void IsotropicPlasticityStressUpdate::computeStressFinalize ( const RankTwoTensor & )

overrideprotectedvirtualinherited

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

Parameters

inelasticStrainIncrement Inelastic strain increment

Reimplemented from RadialReturnStressUpdate.

Definition at line 144 of file IsotropicPlasticityStressUpdate.C.

 {
   _plastic_strain[_qp] += plastic_strain_increment;
 }

◆ computeStressInitialize()

void IsotropicPowerLawHardeningStressUpdate::computeStressInitialize	(	const Real	Real,
		const RankFourTensor &
	)

overrideprotectedvirtual

Perform any necessary initialization before return mapping iterations.

Parameters

effective_trial_stress	Effective trial stress
elasticityTensor	Elasticity tensor

Reimplemented from IsotropicPlasticityStressUpdate.

Definition at line 53 of file IsotropicPowerLawHardeningStressUpdate.C.

 {
   computeYieldStress(elasticity_tensor);
  
   _effective_trial_stress = effective_trial_stress;
   _yield_condition = effective_trial_stress - _hardening_variable_old[_qp] - _yield_stress;
  
   _hardening_variable[_qp] = _hardening_variable_old[_qp];
   _plastic_strain[_qp] = _plastic_strain_old[_qp];
 }

◆ computeTimeStepLimit()

Real RadialReturnStressUpdate::computeTimeStepLimit ( )

overridevirtualinherited

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

Returns: Limiting time step

Reimplemented from StressUpdateBase.

Definition at line 163 of file RadialReturnStressUpdate.C.

 {
   Real scalar_inelastic_strain_incr;
  
   scalar_inelastic_strain_incr =
       _effective_inelastic_strain[_qp] - _effective_inelastic_strain_old[_qp];
   if (MooseUtils::absoluteFuzzyEqual(scalar_inelastic_strain_incr, 0.0))
     return std::numeric_limits<Real>::max();
  
   return _dt * _max_inelastic_increment / scalar_inelastic_strain_incr;
 }

◆ computeYieldStress()

void IsotropicPowerLawHardeningStressUpdate::computeYieldStress ( const RankFourTensor & elasticity_tensor )

overrideprotectedvirtual

Reimplemented from IsotropicPlasticityStressUpdate.

Definition at line 77 of file IsotropicPowerLawHardeningStressUpdate.C.

 {
   // Pull in the Lam\`{e} lambda, and caculate E
   const Real lambda = getIsotropicLameLambda(elasticity_tensor);
   const Real shear_modulus = _three_shear_modulus / 3.0;
  
   _youngs_modulus = shear_modulus * (3.0 * lambda + 2 * shear_modulus) / (lambda + shear_modulus);
  
   // Then solve for yield stress using equation from the header file
   _yield_stress = std::pow(_K / std::pow(_youngs_modulus, _strain_hardening_exponent),
                            1.0 / (1.0 - _strain_hardening_exponent));
   if (_yield_stress <= 0.0)
     mooseError("The yield stress must be greater than zero, but during the simulation your yield "
                "stress became less than zero.");
 }

Referenced by computeStressInitialize().

◆ converged()

bool SingleVariableReturnMappingSolution::converged	(	const Real	residual,
		const Real	reference
	)

privateinherited

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 298 of file SingleVariableReturnMappingSolution.C.

 {
   return (std::abs(residual) <= _absolute_tolerance ||
           std::abs(residual / reference) <= _relative_tolerance);
 }

Referenced by SingleVariableReturnMappingSolution::convergedAcceptable(), and SingleVariableReturnMappingSolution::internalSolve().

◆ convergedAcceptable()

bool SingleVariableReturnMappingSolution::convergedAcceptable	(	const unsigned int	it,
		const Real	residual,
		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 305 of file SingleVariableReturnMappingSolution.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);
 }

Referenced by SingleVariableReturnMappingSolution::internalSolve().

◆ getIsotropicLameLambda()

Real IsotropicPowerLawHardeningStressUpdate::getIsotropicLameLambda ( const RankFourTensor & elasticity_tensor )

protected

Definition at line 94 of file IsotropicPowerLawHardeningStressUpdate.C.

 {
   const Real lame_lambda = elasticity_tensor(0, 0, 1, 1);
  
   if (_mesh.dimension() == 3 && lame_lambda != elasticity_tensor(1, 1, 2, 2))
     mooseError(
         "Check to ensure that your Elasticity Tensor is truly Isotropic: different lambda values");
   return lame_lambda;
 }

Referenced by computeYieldStress().

◆ getTangentCalculationMethod()

virtual TangentCalculationMethod StressUpdateBase::getTangentCalculationMethod ( )

inlinevirtualinherited

Reimplemented in MultiParameterPlasticityStressUpdate, and RadialReturnCreepStressUpdateBase.

Definition at line 116 of file StressUpdateBase.h.

   {
     return TangentCalculationMethod::ELASTIC;
   }

Referenced by RadialReturnStressUpdate::updateState().

◆ initialGuess()

virtual Real SingleVariableReturnMappingSolution::initialGuess ( const Real )

inlineprotectedvirtualinherited

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

Definition at line 64 of file SingleVariableReturnMappingSolution.h.

64 { return 0.0; }

Referenced by SingleVariableReturnMappingSolution::internalSolve().

◆ initQpStatefulProperties()

void IsotropicPlasticityStressUpdate::initQpStatefulProperties ( )

overrideprotectedvirtualinherited

Reimplemented from RadialReturnStressUpdate.

Definition at line 80 of file IsotropicPlasticityStressUpdate.C.

 {
   _hardening_variable[_qp] = 0.0;
   _plastic_strain[_qp].zero();
 }

◆ internalSolve()

SingleVariableReturnMappingSolution::SolveState SingleVariableReturnMappingSolution::internalSolve	(	const Real	effective_trial_stress,
		Real &	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 157 of file SingleVariableReturnMappingSolution.C.

 {
   scalar = initialGuess(effective_trial_stress);
   Real scalar_old = scalar;
   Real scalar_increment = 0.0;
   const Real min_permissible_scalar = minimumPermissibleValue(effective_trial_stress);
   const Real max_permissible_scalar = maximumPermissibleValue(effective_trial_stress);
   Real scalar_upper_bound = max_permissible_scalar;
   Real scalar_lower_bound = min_permissible_scalar;
   _iteration = 0;
  
   _initial_residual = _residual = computeResidual(effective_trial_stress, scalar);
  
   Real residual_old = _residual;
   Real init_resid_sign = MathUtils::sign(_residual);
   Real reference_residual = computeReferenceResidual(effective_trial_stress, scalar);
  
   if (converged(_residual, reference_residual))
   {
     iterationFinalize(scalar);
     outputIterationStep(
         iter_output, _iteration, effective_trial_stress, scalar, _residual, reference_residual);
     return SolveState::SUCCESS;
   }
  
   _residual_history.assign(_num_resids, std::numeric_limits<Real>::max());
   _residual_history[0] = _residual;
  
   while (_iteration < _max_its && !converged(_residual, reference_residual) &&
          !convergedAcceptable(_iteration, _residual, 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, _iteration, effective_trial_stress, scalar, _residual, reference_residual);
       break;
     }
     else
     {
       bool modified_increment = false;
  
       // Line Search
       if (_line_search)
       {
         if (residual_old - _residual != 0.0)
         {
           Real 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 = " << alpha
                            << " increment = " << 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, _iteration, effective_trial_stress, scalar, _residual, reference_residual);
  
     ++_iteration;
     residual_old = _residual;
     scalar_old = scalar;
     _residual_history[_iteration % _num_resids] = _residual;
   }
  
   if (std::isnan(_residual) || std::isinf(_residual))
     return SolveState::NAN_INF;
  
   if (_iteration == _max_its)
     return SolveState::EXCEEDED_ITERATIONS;
  
   return SolveState::SUCCESS;
 }

Referenced by SingleVariableReturnMappingSolution::returnMappingSolve().

◆ isIsotropic()

bool RadialReturnStressUpdate::isIsotropic ( )

inlineoverridevirtualinherited

Radial return mapped models should be isotropic by default!

Reimplemented from StressUpdateBase.

Definition at line 88 of file RadialReturnStressUpdate.h.

88 { return true; };

◆ iterationFinalize()

void IsotropicPlasticityStressUpdate::iterationFinalize ( Real )

overrideprotectedvirtualinherited

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

Parameters

scalar Inelastic strain increment magnitude being solved for

Reimplemented from SingleVariableReturnMappingSolution.

Definition at line 137 of file IsotropicPlasticityStressUpdate.C.

 {
   if (_yield_condition > 0.0)
     _hardening_variable[_qp] = computeHardeningValue(scalar);
 }

◆ maximumPermissibleValue()

Real RadialReturnStressUpdate::maximumPermissibleValue ( const Real effective_trial_stress ) const

overridevirtualinherited

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

Definition at line 157 of file RadialReturnStressUpdate.C.

 {
   return effective_trial_stress / _three_shear_modulus;
 }

◆ minimumPermissibleValue()

virtual Real RadialReturnStressUpdate::minimumPermissibleValue ( const effective_trial_stress ) const

inlineoverridevirtualinherited

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

Definition at line 67 of file RadialReturnStressUpdate.h.

   {
     return 0.0;
   }

◆ outputIterationStep()

void SingleVariableReturnMappingSolution::outputIterationStep	(	std::stringstream *	iter_output,
		const unsigned int	it,
		const Real	effective_trial_stress,
		const Real	scalar,
		const Real	residual,
		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 328 of file SingleVariableReturnMappingSolution.C.

 {
   if (iter_output)
   {
     *iter_output << " iteration=" << it << " trial_stress=" << effective_trial_stress
                  << " scalar=" << 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';
   }
 }

Referenced by SingleVariableReturnMappingSolution::internalSolve().

◆ outputIterationSummary()

void RadialReturnStressUpdate::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 SingleVariableReturnMappingSolution.

Definition at line 176 of file RadialReturnStressUpdate.C.

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

◆ propagateQpStatefulProperties()

void IsotropicPlasticityStressUpdate::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 StressUpdateBase.

Definition at line 87 of file IsotropicPlasticityStressUpdate.C.

 {
   _hardening_variable[_qp] = _hardening_variable_old[_qp];
   _plastic_strain[_qp] = _plastic_strain_old[_qp];
  
   propagateQpStatefulPropertiesRadialReturn();
 }

◆ propagateQpStatefulPropertiesRadialReturn()

void RadialReturnStressUpdate::propagateQpStatefulPropertiesRadialReturn ( )

protectedinherited

Propagate the properties pertaining to this intermediate class.

This is intended to be called from propagateQpStatefulProperties() in classes that inherit from this one. This is intentionally named uniquely because almost all models that derive from this class have their own stateful properties, and this forces them to define their own implementations of propagateQpStatefulProperties().

Definition at line 59 of file RadialReturnStressUpdate.C.

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

Referenced by RadialReturnCreepStressUpdateBase::propagateQpStatefulProperties(), and IsotropicPlasticityStressUpdate::propagateQpStatefulProperties().

◆ requiresIsotropicTensor()

bool RadialReturnStressUpdate::requiresIsotropicTensor ( )

inlineoverridevirtualinherited

Does the model require the elasticity tensor to be isotropic?

Implements StressUpdateBase.

Definition at line 83 of file RadialReturnStressUpdate.h.

83 { return true; }

◆ resetProperties()

void StressUpdateBase::resetProperties ( )

inlinefinalinherited

Definition at line 123 of file StressUpdateBase.h.

123 {}

◆ resetQpProperties()

void StressUpdateBase::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 122 of file StressUpdateBase.h.

122 {}

◆ returnMappingSolve()

void SingleVariableReturnMappingSolution::returnMappingSolve	(	const Real	effective_trial_stress,
		Real &	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 96 of file SingleVariableReturnMappingSolution.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();
   }
 }

Referenced by ReturnMappingModel::computeStress(), and RadialReturnStressUpdate::updateState().

◆ setQp()

void StressUpdateBase::setQp ( unsigned int qp )

inherited

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

Definition at line 43 of file StressUpdateBase.C.

 {
   _qp = qp;
 }

◆ updateBounds()

void SingleVariableReturnMappingSolution::updateBounds	(	const Real	scalar,
		const Real	residual,
		const Real	init_resid_sign,
		Real &	scalar_upper_bound,
		Real &	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 384 of file SingleVariableReturnMappingSolution.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;
 }

Referenced by SingleVariableReturnMappingSolution::internalSolve().

◆ updateState()

void RadialReturnStressUpdate::updateState	(	RankTwoTensor &	strain_increment,
		RankTwoTensor &	inelastic_strain_increment,
		const RankTwoTensor &	rotation_increment,
		RankTwoTensor &	stress_new,
		const RankTwoTensor &	stress_old,
		const RankFourTensor &	elasticity_tensor,
		const RankTwoTensor &	elastic_strain_old,
		bool	compute_full_tangent_operator,
		RankFourTensor &	tangent_operator
	)

overridevirtualinherited

A radial return (J2) mapping method is performed with return mapping iterations.

Parameters

strain_increment	Sum of elastic and inelastic strain increments
inelastic_strain_increment	Inelastic strain increment calculated by this class
rotation	increment Not used by this class
stress_new	New trial stress from pure elastic calculation
stress_old	Old state of stress
elasticity_tensor	Rank 4 C_{ijkl}, must be isotropic
elastic_strain_old	Old state of total elastic strain
compute_full_tangent_operator	Flag currently unused by this class
tangent_operator	Currently a copy of the elasticity tensor in this class

Implements StressUpdateBase.

Definition at line 65 of file RadialReturnStressUpdate.C.

 {
   // compute the deviatoric trial stress and trial strain from the current intermediate
   // configuration
   RankTwoTensor deviatoric_trial_stress = stress_new.deviatoric();
  
   // compute the effective trial stress
   Real dev_trial_stress_squared =
       deviatoric_trial_stress.doubleContraction(deviatoric_trial_stress);
   Real effective_trial_stress = std::sqrt(3.0 / 2.0 * dev_trial_stress_squared);
  
   // Set the value of 3 * shear modulus for use as a reference residual value
   _three_shear_modulus = 3.0 * ElasticityTensorTools::getIsotropicShearModulus(elasticity_tensor);
  
   computeStressInitialize(effective_trial_stress, elasticity_tensor);
  
   // Use Newton iteration to determine the scalar effective inelastic strain increment
   Real scalar_effective_inelastic_strain = 0.0;
   if (!MooseUtils::absoluteFuzzyEqual(effective_trial_stress, 0.0))
   {
     returnMappingSolve(effective_trial_stress, scalar_effective_inelastic_strain, _console);
     if (scalar_effective_inelastic_strain != 0.0)
       inelastic_strain_increment =
           deviatoric_trial_stress *
           (1.5 * scalar_effective_inelastic_strain / effective_trial_stress);
     else
       inelastic_strain_increment.zero();
   }
   else
     inelastic_strain_increment.zero();
  
   strain_increment -= inelastic_strain_increment;
   _effective_inelastic_strain[_qp] =
       _effective_inelastic_strain_old[_qp] + scalar_effective_inelastic_strain;
  
   // Use the old elastic strain here because we require tensors used by this class
   // to be isotropic and this method natively allows for changing in time
   // elasticity tensors
   stress_new = elasticity_tensor * (strain_increment + elastic_strain_old);
  
   computeStressFinalize(inelastic_strain_increment);
  
   if (compute_full_tangent_operator &&
       getTangentCalculationMethod() == TangentCalculationMethod::PARTIAL)
   {
     if (MooseUtils::absoluteFuzzyEqual(scalar_effective_inelastic_strain, 0.0))
       tangent_operator.zero();
     else
     {
       // mu = _three_shear_modulus / 3.0;
       // norm_dev_stress = ||s_n+1||
       // effective_trial_stress = von mises trial stress = std::sqrt(3.0 / 2.0) * ||s_n+1^trial||
       // scalar_effective_inelastic_strain = Delta epsilon^cr_n+1
       // deriv = derivative of scalar_effective_inelastic_strain w.r.t. von mises stress
       // deriv = std::sqrt(3.0 / 2.0) partial Delta epsilon^cr_n+1n over partial ||s_n+1^trial||
  
       mooseAssert(_three_shear_modulus != 0.0, "Shear modulus is zero");
  
       const RankTwoTensor deviatoric_stress = stress_new.deviatoric();
       const Real norm_dev_stress =
           std::sqrt(deviatoric_stress.doubleContraction(deviatoric_stress));
       mooseAssert(norm_dev_stress != 0.0, "Norm of the deviatoric is zero");
  
       const RankTwoTensor flow_direction = deviatoric_stress / norm_dev_stress;
       const RankFourTensor flow_direction_dyad = flow_direction.outerProduct(flow_direction);
       const Real deriv =
           computeStressDerivative(effective_trial_stress, scalar_effective_inelastic_strain);
       const Real scalar_one = _three_shear_modulus * scalar_effective_inelastic_strain /
                               std::sqrt(1.5) / norm_dev_stress;
  
       tangent_operator = scalar_one * _deviatoric_projection_four +
                          (_three_shear_modulus * deriv - scalar_one) * flow_direction_dyad;
     }
   }
 }

◆ validParams()

InputParameters IsotropicPowerLawHardeningStressUpdate::validParams ( )

static

Definition at line 18 of file IsotropicPowerLawHardeningStressUpdate.C.

 {
   InputParameters params = IsotropicPlasticityStressUpdate::validParams();
   params.addClassDescription("This class uses the discrete material in a radial return isotropic "
                              "plasticity power law hardening model, solving for the yield stress "
                              "as the intersection of the power law relation curve and Hooke's law. "
                              " This class can be used in conjunction with other creep and "
                              "plasticity materials for more complex simulations.");
  
   // Set and Suppress parameters to enable calculation of the yield stress
   params.set<Real>("yield_stress") = 1.0;
   params.set<Real>("hardening_constant") = 1.0;
   params.suppressParameter<Real>("yield_stress");
   params.suppressParameter<Real>("hardening_constant");
  
   // Power law hardening specific parameters
   params.addRequiredParam<Real>("strength_coefficient",
                                 "The strength coefficient (K) for power law hardening");
   params.addRequiredRangeCheckedParam<Real>(
       "strain_hardening_exponent",
       "strain_hardening_exponent>=0.0 & strain_hardening_exponent <=1.0",
       "The strain hardening exponent (n) for power law hardening");
  
   return params;
 }

Member Data Documentation

◆ _absolute_tolerance

Real SingleVariableReturnMappingSolution::_absolute_tolerance

privateinherited

Absolute convergence tolerance.

Definition at line 155 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::converged(), and SingleVariableReturnMappingSolution::outputIterationStep().

◆ _acceptable_multiplier

Real SingleVariableReturnMappingSolution::_acceptable_multiplier

privateinherited

Multiplier applied to relative and absolute tolerances for acceptable convergence.

Definition at line 158 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::convergedAcceptable().

◆ _base_name

const std::string StressUpdateBase::_base_name

protectedinherited

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

Definition at line 128 of file StressUpdateBase.h.

◆ _bracket_solution

bool SingleVariableReturnMappingSolution::_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 127 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::internalSolve().

◆ _check_range

bool SingleVariableReturnMappingSolution::_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 120 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::internalSolve().

◆ _deviatoric_projection_four

const RankFourTensor RadialReturnStressUpdate::_deviatoric_projection_four

protectedinherited

Rank four deviatoric projection tensor.

Definition at line 152 of file RadialReturnStressUpdate.h.

Referenced by RadialReturnStressUpdate::updateState().

◆ _effective_inelastic_strain

MaterialProperty<Real>& RadialReturnStressUpdate::_effective_inelastic_strain

protectedinherited

Definition at line 135 of file RadialReturnStressUpdate.h.

Referenced by RadialReturnStressUpdate::computeTimeStepLimit(), RadialReturnStressUpdate::initQpStatefulProperties(), RadialReturnStressUpdate::propagateQpStatefulPropertiesRadialReturn(), and RadialReturnStressUpdate::updateState().

◆ _effective_inelastic_strain_old

const MaterialProperty<Real>& RadialReturnStressUpdate::_effective_inelastic_strain_old

protectedinherited

Definition at line 136 of file RadialReturnStressUpdate.h.

Referenced by TemperatureDependentHardeningStressUpdate::computeHardeningDerivative(), IsotropicPlasticityStressUpdate::computeHardeningDerivative(), TemperatureDependentHardeningStressUpdate::computeHardeningValue(), IsotropicPlasticityStressUpdate::computeHardeningValue(), RadialReturnStressUpdate::computeTimeStepLimit(), RadialReturnStressUpdate::propagateQpStatefulPropertiesRadialReturn(), and RadialReturnStressUpdate::updateState().

◆ _effective_trial_stress

Real IsotropicPowerLawHardeningStressUpdate::_effective_trial_stress

protected

Definition at line 58 of file IsotropicPowerLawHardeningStressUpdate.h.

Referenced by computeHardeningDerivative(), and computeStressInitialize().

◆ _hardening_constant

const Real IsotropicPlasticityStressUpdate::_hardening_constant

protectedinherited

Definition at line 64 of file IsotropicPlasticityStressUpdate.h.

Referenced by IsotropicPlasticityStressUpdate::computeHardeningDerivative().

◆ _hardening_function

const Function* IsotropicPlasticityStressUpdate::_hardening_function

protectedinherited

Definition at line 65 of file IsotropicPlasticityStressUpdate.h.

Referenced by IsotropicPlasticityStressUpdate::computeHardeningDerivative(), and IsotropicPlasticityStressUpdate::computeHardeningValue().

◆ _hardening_slope

Real IsotropicPlasticityStressUpdate::_hardening_slope

protectedinherited

Definition at line 68 of file IsotropicPlasticityStressUpdate.h.

Referenced by IsotropicPlasticityStressUpdate::computeDerivative(), IsotropicPlasticityStressUpdate::computeHardeningValue(), and IsotropicPlasticityStressUpdate::computeResidual().

◆ _hardening_variable

MaterialProperty<Real>& IsotropicPlasticityStressUpdate::_hardening_variable

protectedinherited

Definition at line 76 of file IsotropicPlasticityStressUpdate.h.

Referenced by IsotropicPlasticityStressUpdate::computeResidual(), TemperatureDependentHardeningStressUpdate::computeStressInitialize(), computeStressInitialize(), IsotropicPlasticityStressUpdate::computeStressInitialize(), IsotropicPlasticityStressUpdate::initQpStatefulProperties(), IsotropicPlasticityStressUpdate::iterationFinalize(), and IsotropicPlasticityStressUpdate::propagateQpStatefulProperties().

◆ _hardening_variable_old

const MaterialProperty<Real>& IsotropicPlasticityStressUpdate::_hardening_variable_old

protectedinherited

Definition at line 77 of file IsotropicPlasticityStressUpdate.h.

Referenced by IsotropicPlasticityStressUpdate::computeHardeningValue(), TemperatureDependentHardeningStressUpdate::computeStressInitialize(), computeStressInitialize(), IsotropicPlasticityStressUpdate::computeStressInitialize(), and IsotropicPlasticityStressUpdate::propagateQpStatefulProperties().

◆ _identity_symmetric_four

const RankFourTensor RadialReturnStressUpdate::_identity_symmetric_four

protectedinherited

Rank four symmetric identity tensor.

Definition at line 147 of file RadialReturnStressUpdate.h.

◆ _identity_two

const RankTwoTensor RadialReturnStressUpdate::_identity_two

protectedinherited

Rank two identity tensor.

Definition at line 142 of file RadialReturnStressUpdate.h.

◆ _initial_residual

Real SingleVariableReturnMappingSolution::_initial_residual

privateinherited

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

Definition at line 170 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::internalSolve(), and SingleVariableReturnMappingSolution::outputIterationSummary().

◆ _internal_solve_full_iteration_history

const bool SingleVariableReturnMappingSolution::_internal_solve_full_iteration_history

privateinherited

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

Definition at line 149 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::returnMappingSolve().

◆ _internal_solve_output_on

enum SingleVariableReturnMappingSolution::InternalSolveOutput SingleVariableReturnMappingSolution::_internal_solve_output_on

privateinherited

Referenced by SingleVariableReturnMappingSolution::returnMappingSolve().

◆ _iteration

unsigned int SingleVariableReturnMappingSolution::_iteration

privateinherited

iteration number

Definition at line 167 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::internalSolve(), and SingleVariableReturnMappingSolution::returnMappingSolve().

◆ _K

Real IsotropicPowerLawHardeningStressUpdate::_K

protected

Power law hardening coefficients.

Definition at line 50 of file IsotropicPowerLawHardeningStressUpdate.h.

Referenced by computeHardeningDerivative(), and computeYieldStress().

◆ _line_search

bool SingleVariableReturnMappingSolution::_line_search

protectedinherited

Whether to use line searches to improve convergence.

Definition at line 123 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::internalSolve().

◆ _max_inelastic_increment

Real RadialReturnStressUpdate::_max_inelastic_increment

protectedinherited

Definition at line 137 of file RadialReturnStressUpdate.h.

Referenced by RadialReturnStressUpdate::computeTimeStepLimit().

◆ _max_its

const unsigned int SingleVariableReturnMappingSolution::_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 146 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::internalSolve().

◆ _num_resids

const std::size_t SingleVariableReturnMappingSolution::_num_resids

privateinherited

Number of residuals to be stored in history.

Definition at line 161 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::convergedAcceptable(), and SingleVariableReturnMappingSolution::internalSolve().

◆ _plastic_prepend

const std::string IsotropicPlasticityStressUpdate::_plastic_prepend

protectedinherited

a string to prepend to the plastic strain Material Property name

Definition at line 60 of file IsotropicPlasticityStressUpdate.h.

◆ _plastic_strain

MaterialProperty<RankTwoTensor>& IsotropicPlasticityStressUpdate::_plastic_strain

protectedinherited

plastic strain in this model

Definition at line 71 of file IsotropicPlasticityStressUpdate.h.

Referenced by IsotropicPlasticityStressUpdate::computeStressFinalize(), TemperatureDependentHardeningStressUpdate::computeStressInitialize(), computeStressInitialize(), IsotropicPlasticityStressUpdate::computeStressInitialize(), IsotropicPlasticityStressUpdate::initQpStatefulProperties(), and IsotropicPlasticityStressUpdate::propagateQpStatefulProperties().

◆ _plastic_strain_old

const MaterialProperty<RankTwoTensor>& IsotropicPlasticityStressUpdate::_plastic_strain_old

protectedinherited

old value of plastic strain

Definition at line 74 of file IsotropicPlasticityStressUpdate.h.

Referenced by TemperatureDependentHardeningStressUpdate::computeStressInitialize(), computeStressInitialize(), IsotropicPlasticityStressUpdate::computeStressInitialize(), and IsotropicPlasticityStressUpdate::propagateQpStatefulProperties().

◆ _relative_tolerance

Real SingleVariableReturnMappingSolution::_relative_tolerance

privateinherited

Relative convergence tolerance.

Definition at line 152 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::converged(), and SingleVariableReturnMappingSolution::outputIterationStep().

◆ _residual

Real SingleVariableReturnMappingSolution::_residual

privateinherited

Definition at line 171 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::internalSolve(), and SingleVariableReturnMappingSolution::outputIterationSummary().

◆ _residual_history

std::vector<Real> SingleVariableReturnMappingSolution::_residual_history

privateinherited

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

Definition at line 164 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::convergedAcceptable(), and SingleVariableReturnMappingSolution::internalSolve().

◆ _strain_hardening_exponent

Real IsotropicPowerLawHardeningStressUpdate::_strain_hardening_exponent

protected

Definition at line 51 of file IsotropicPowerLawHardeningStressUpdate.h.

Referenced by computeHardeningDerivative(), and computeYieldStress().

◆ _svrms_name

const std::string SingleVariableReturnMappingSolution::_svrms_name

privateinherited

MOOSE input name of the object performing the solve.

Definition at line 175 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::outputIterationSummary().

◆ _temperature

const VariableValue& IsotropicPlasticityStressUpdate::_temperature

protectedinherited

Definition at line 78 of file IsotropicPlasticityStressUpdate.h.

Referenced by TemperatureDependentHardeningStressUpdate::computeYieldStress(), IsotropicPlasticityStressUpdate::computeYieldStress(), and TemperatureDependentHardeningStressUpdate::initializeHardeningFunctions().

◆ _three_shear_modulus

Real RadialReturnStressUpdate::_three_shear_modulus

protectedinherited

3 * shear modulus

Definition at line 133 of file RadialReturnStressUpdate.h.

Referenced by PowerLawCreepStressUpdate::computeDerivative(), IsotropicPlasticityStressUpdate::computeDerivative(), computeHardeningDerivative(), RadialReturnStressUpdate::computeReferenceResidual(), PowerLawCreepStressUpdate::computeResidual(), IsotropicPlasticityStressUpdate::computeResidual(), RadialReturnCreepStressUpdateBase::computeStressDerivative(), computeYieldStress(), RadialReturnStressUpdate::maximumPermissibleValue(), and RadialReturnStressUpdate::updateState().

◆ _yield_condition

Real IsotropicPlasticityStressUpdate::_yield_condition

protectedinherited

Definition at line 67 of file IsotropicPlasticityStressUpdate.h.

Referenced by IsotropicPlasticityStressUpdate::computeDerivative(), IsotropicPlasticityStressUpdate::computeResidual(), TemperatureDependentHardeningStressUpdate::computeStressInitialize(), computeStressInitialize(), IsotropicPlasticityStressUpdate::computeStressInitialize(), and IsotropicPlasticityStressUpdate::iterationFinalize().

◆ _yield_stress

Real IsotropicPlasticityStressUpdate::_yield_stress

protectedinherited

Definition at line 63 of file IsotropicPlasticityStressUpdate.h.

Referenced by TemperatureDependentHardeningStressUpdate::computeHardeningValue(), IsotropicPlasticityStressUpdate::computeHardeningValue(), IsotropicPlasticityStressUpdate::computeResidual(), TemperatureDependentHardeningStressUpdate::computeStressInitialize(), computeStressInitialize(), IsotropicPlasticityStressUpdate::computeStressInitialize(), TemperatureDependentHardeningStressUpdate::computeYieldStress(), computeYieldStress(), IsotropicPlasticityStressUpdate::computeYieldStress(), and IsotropicPlasticityStressUpdate::IsotropicPlasticityStressUpdate().

◆ _yield_stress_function

const Function* IsotropicPlasticityStressUpdate::_yield_stress_function

protectedinherited

Definition at line 62 of file IsotropicPlasticityStressUpdate.h.

Referenced by IsotropicPlasticityStressUpdate::computeYieldStress(), and IsotropicPlasticityStressUpdate::IsotropicPlasticityStressUpdate().

◆ _youngs_modulus

Real IsotropicPowerLawHardeningStressUpdate::_youngs_modulus

protected

Elastic constants.

Definition at line 55 of file IsotropicPowerLawHardeningStressUpdate.h.

Referenced by computeHardeningDerivative(), and computeYieldStress().

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

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ InternalSolveOutput

◆ SolveState

Constructor & Destructor Documentation

◆ IsotropicPowerLawHardeningStressUpdate()

Member Function Documentation

◆ checkPermissibleRange()

◆ computeDerivative()

◆ computeHardeningDerivative()

◆ computeHardeningValue()

◆ computeReferenceResidual()

◆ computeResidual()

◆ computeStressDerivative()

◆ computeStressFinalize()

◆ computeStressInitialize()

◆ computeTimeStepLimit()

◆ computeYieldStress()

◆ converged()

◆ convergedAcceptable()

◆ getIsotropicLameLambda()

◆ getTangentCalculationMethod()

◆ initialGuess()

◆ initQpStatefulProperties()

◆ internalSolve()

◆ isIsotropic()

◆ iterationFinalize()

◆ maximumPermissibleValue()

◆ minimumPermissibleValue()

◆ outputIterationStep()

◆ outputIterationSummary()

◆ propagateQpStatefulProperties()

◆ propagateQpStatefulPropertiesRadialReturn()

◆ requiresIsotropicTensor()

◆ resetProperties()

◆ resetQpProperties()

◆ returnMappingSolve()

◆ setQp()

◆ updateBounds()

◆ updateState()

◆ validParams()

Member Data Documentation

◆ _absolute_tolerance

◆ _acceptable_multiplier

◆ _base_name

◆ _bracket_solution

◆ _check_range

◆ _deviatoric_projection_four

◆ _effective_inelastic_strain

◆ _effective_inelastic_strain_old

◆ _effective_trial_stress

◆ _hardening_constant

◆ _hardening_function

◆ _hardening_slope

◆ _hardening_variable

◆ _hardening_variable_old

◆ _identity_symmetric_four

◆ _identity_two

◆ _initial_residual

◆ _internal_solve_full_iteration_history

◆ _internal_solve_output_on

◆ _iteration

◆ _K

◆ _line_search

◆ _max_inelastic_increment

◆ _max_its

◆ _num_resids

◆ _plastic_prepend

◆ _plastic_strain

◆ _plastic_strain_old

◆ _relative_tolerance

◆ _residual

◆ _residual_history