Base class that provides capability for Newton return mapping iterations on a single variable. More...

#include <SingleVariableReturnMappingSolution.h>

Inheritance diagram for SingleVariableReturnMappingSolutionTempl< is_ad >:

Public Member Functions
	SingleVariableReturnMappingSolutionTempl (const InputParameters &parameters)

virtual	~SingleVariableReturnMappingSolutionTempl ()

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
void	returnMappingSolve (const GenericReal< is_ad > &effective_trial_stress, GenericReal< is_ad > &scalar, const ConsoleStream &console)
	Perform the return mapping iterations. More...

virtual GenericReal< is_ad >	minimumPermissibleValue (const GenericReal< is_ad > &effective_trial_stress) const
	Compute the minimum permissible value of the scalar. More...

virtual GenericReal< is_ad >	maximumPermissibleValue (const GenericReal< is_ad > &effective_trial_stress) const
	Compute the maximum permissible value of the scalar. More...

virtual GenericReal< is_ad >	initialGuess (const GenericReal< is_ad > &)
	Compute an initial guess for the value of the scalar. More...

virtual GenericReal< is_ad >	computeResidual (const GenericReal< is_ad > &, const GenericReal< is_ad > &)=0
	Compute the residual for a predicted value of the scalar. More...

virtual GenericReal< is_ad >	computeDerivative (const GenericReal< is_ad > &, const GenericReal< is_ad > &)=0
	Compute the derivative of the residual as a function of the scalar variable. More...

virtual GenericChainedReal< is_ad >	computeResidualAndDerivative (const GenericReal< is_ad > &, const GenericChainedReal< is_ad > &)
	Compute the residual and the derivative for a predicted value of the scalar. More...

virtual Real	computeReferenceResidual (const GenericReal< is_ad > &effective_trial_stress, const GenericReal< is_ad > &scalar)=0
	Compute a reference quantity to be used for checking relative convergence. More...

virtual void	preStep (const GenericReal< is_ad > &, const GenericReal< is_ad > &, const GenericReal< is_ad > &)
	This method is called before taking a step in the return mapping algorithm. More...

virtual void	iterationFinalize (const GenericReal< is_ad > &)
	Finalize internal state variables for a model for a given iteration. More...

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

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

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

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

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

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

Private Member Functions
void	computeResidualAndDerivativeHelper (const GenericReal< is_ad > &effective_trial_stress, const GenericReal< is_ad > &scalar)
	Helper function to compute and set the _residual and _derivative. More...

SolveState	internalSolve (const GenericReal< is_ad > effective_trial_stress, GenericReal< is_ad > &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 (GenericReal< is_ad > &scalar, GenericReal< is_ad > &scalar_increment, const GenericReal< is_ad > &scalar_old, const GenericReal< is_ad > min_permissible_scalar, const GenericReal< is_ad > 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 GenericReal< is_ad > &scalar, const GenericReal< is_ad > &residual, const Real init_resid_sign, GenericReal< is_ad > &scalar_upper_bound, GenericReal< is_ad > &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 SingleVariableReturnMappingSolutionTempl::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 bool	_ad_derivative

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

GenericReal< is_ad >	_derivative
	Derivative of the residual. More...

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


GenericReal< is_ad >	_initial_residual
	Residual values, kept as members to retain solver state for summary outputting. More...

GenericReal< is_ad >	_residual

Detailed Description

template<bool is_ad>
class SingleVariableReturnMappingSolutionTempl< is_ad >

Base class that provides capability for Newton return mapping iterations on a single variable.

Definition at line 24 of file SingleVariableReturnMappingSolution.h.

Member Enumeration Documentation

◆ InternalSolveOutput

template<bool is_ad>

enum SingleVariableReturnMappingSolutionTempl::InternalSolveOutput

strongprivate

Enumerator
NEVER
ON_ERROR
ALWAYS

Definition at line 172 of file SingleVariableReturnMappingSolution.h.

   {
     NEVER,
     ON_ERROR,
     ALWAYS
   } _internal_solve_output_on;

◆ SolveState

template<bool is_ad>

enum SingleVariableReturnMappingSolutionTempl::SolveState

strongprivate

Enumerator
SUCCESS
NAN_INF
EXCEEDED_ITERATIONS

Definition at line 179 of file SingleVariableReturnMappingSolution.h.

   {
     SUCCESS,
     NAN_INF,
     EXCEEDED_ITERATIONS
   };

Constructor & Destructor Documentation

◆ SingleVariableReturnMappingSolutionTempl()

template<bool is_ad>

SingleVariableReturnMappingSolutionTempl< is_ad >::SingleVariableReturnMappingSolutionTempl ( const InputParameters & parameters )

Definition at line 59 of file SingleVariableReturnMappingSolution.C.

   : _check_range(false),
     _line_search(true),
     _bracket_solution(true),
     _internal_solve_output_on(
         parameters.get<MooseEnum>("internal_solve_output_on").getEnum<InternalSolveOutput>()),
     _max_its(1000), // Far larger than ever expected to be needed
     _internal_solve_full_iteration_history(
         parameters.get<bool>("internal_solve_full_iteration_history")),
     _relative_tolerance(parameters.get<Real>("relative_tolerance")),
     _absolute_tolerance(parameters.get<Real>("absolute_tolerance")),
     _acceptable_multiplier(parameters.get<Real>("acceptable_multiplier")),
     _ad_derivative(parameters.get<bool>("automatic_differentiation_return_mapping")),
     _num_resids(30),
     _residual_history(_num_resids, std::numeric_limits<Real>::max()),
     _iteration(0),
     _initial_residual(0.0),
     _residual(0.0),
     _svrms_name(parameters.get<std::string>("_object_name"))
 {
 }

◆ ~SingleVariableReturnMappingSolutionTempl()

template<bool is_ad>

virtual SingleVariableReturnMappingSolutionTempl< is_ad >::~SingleVariableReturnMappingSolutionTempl ( )

inlinevirtual

Definition at line 30 of file SingleVariableReturnMappingSolution.h.

30 {}

Member Function Documentation

◆ checkPermissibleRange()

template<bool is_ad>

void SingleVariableReturnMappingSolutionTempl< is_ad >::checkPermissibleRange	(	GenericReal< is_ad > &	scalar,
		GenericReal< is_ad > &	scalar_increment,
		const GenericReal< is_ad > &	scalar_old,
		const GenericReal< is_ad >	min_permissible_scalar,
		const GenericReal< is_ad >	max_permissible_scalar,
		std::stringstream *	iter_output
	)

private

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 359 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 ("
                    << 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<bool is_ad>

virtual GenericReal<is_ad> SingleVariableReturnMappingSolutionTempl< is_ad >::computeDerivative	(	const GenericReal< is_ad > &	,
		const GenericReal< is_ad > &
	)

protectedpure virtual

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

Implemented in LAROMANCEStressUpdateBaseTempl< is_ad >, CompositePowerLawCreepStressUpdateTempl< is_ad >, IsotropicPlasticityStressUpdateTempl< is_ad >, PowerLawCreepStressUpdateTempl< is_ad >, PowerLawCreepTestTempl< is_ad >, and CombinedNonlinearHardeningPlasticityTempl< is_ad >.

◆ computeReferenceResidual()

template<bool is_ad>

virtual Real SingleVariableReturnMappingSolutionTempl< is_ad >::computeReferenceResidual	(	const GenericReal< is_ad > &	effective_trial_stress,
		const GenericReal< is_ad > &	scalar
	)

protectedpure virtual

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

Implemented in RadialReturnStressUpdateTempl< is_ad >.

◆ computeResidual()

template<bool is_ad>

virtual GenericReal<is_ad> SingleVariableReturnMappingSolutionTempl< is_ad >::computeResidual	(	const GenericReal< is_ad > &	,
		const GenericReal< is_ad > &
	)

protectedpure virtual

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

Implemented in LAROMANCEStressUpdateBaseTempl< is_ad >, IsotropicPlasticityStressUpdateTempl< is_ad >, CompositePowerLawCreepStressUpdateTempl< is_ad >, PowerLawCreepStressUpdateTempl< is_ad >, PowerLawCreepTestTempl< is_ad >, and CombinedNonlinearHardeningPlasticityTempl< is_ad >.

◆ computeResidualAndDerivative()

template<bool is_ad>

virtual GenericChainedReal<is_ad> SingleVariableReturnMappingSolutionTempl< is_ad >::computeResidualAndDerivative	(	const GenericReal< is_ad > &	,
		const GenericChainedReal< is_ad > &
	)

inlineprotectedvirtual

Compute the residual and the derivative 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

Reimplemented in CompositePowerLawCreepStressUpdateTempl< is_ad >, and PowerLawCreepStressUpdateTempl< is_ad >.

Definition at line 97 of file SingleVariableReturnMappingSolution.h.

   {
     mooseError("computeResidualAndDerivative has to be implemented if "
                "automatic_differentiation_return_mapping = true.");
     return 0;
   };

◆ computeResidualAndDerivativeHelper()

template<bool is_ad>

void SingleVariableReturnMappingSolutionTempl< is_ad >::computeResidualAndDerivativeHelper	(	const GenericReal< is_ad > &	effective_trial_stress,
		const GenericReal< is_ad > &	scalar
	)

private

Helper function to compute and set the _residual and _derivative.

Definition at line 307 of file SingleVariableReturnMappingSolution.C.

 {
   if (_ad_derivative)
   {
     GenericChainedReal<is_ad> residual_and_derivative =
         computeResidualAndDerivative(effective_trial_stress, GenericChainedReal<is_ad>(scalar, 1));
     _residual = residual_and_derivative.value();
     _derivative = residual_and_derivative.derivatives();
   }
   else
   {
     _residual = computeResidual(effective_trial_stress, scalar);
     _derivative = computeDerivative(effective_trial_stress, scalar);
   }
 }

◆ converged()

template<bool is_ad>

bool SingleVariableReturnMappingSolutionTempl< is_ad >::converged	(	const GenericReal< is_ad > &	residual,
		const Real	reference
	)

protected

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

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

◆ convergedAcceptable()

template<bool is_ad>

bool SingleVariableReturnMappingSolutionTempl< is_ad >::convergedAcceptable	(	const unsigned int	it,
		const Real	reference
	)

private

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 336 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);
 }

◆ initialGuess()

template<bool is_ad>

virtual GenericReal<is_ad> SingleVariableReturnMappingSolutionTempl< is_ad >::initialGuess ( const GenericReal< is_ad > & )

inlineprotectedvirtual

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 in PowerLawCreepTestTempl< is_ad >.

Definition at line 66 of file SingleVariableReturnMappingSolution.h.

   {
     return 0.0;
   }

◆ internalSolve()

template<bool is_ad>

SingleVariableReturnMappingSolutionTempl< is_ad >::SolveState SingleVariableReturnMappingSolutionTempl< is_ad >::internalSolve	(	const GenericReal< is_ad >	effective_trial_stress,
		GenericReal< is_ad > &	scalar,
		std::stringstream *	iter_output = `nullptr`
	)

private

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

 {
   scalar = initialGuess(effective_trial_stress);
   GenericReal<is_ad> scalar_old = scalar;
   GenericReal<is_ad> scalar_increment = 0.0;
   const GenericReal<is_ad> min_permissible_scalar = minimumPermissibleValue(effective_trial_stress);
   const GenericReal<is_ad> max_permissible_scalar = maximumPermissibleValue(effective_trial_stress);
   GenericReal<is_ad> scalar_upper_bound = max_permissible_scalar;
   GenericReal<is_ad> scalar_lower_bound = min_permissible_scalar;
   _iteration = 0;
 
   computeResidualAndDerivativeHelper(effective_trial_stress, scalar);
   _initial_residual = _residual;
 
   GenericReal<is_ad> 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))
   {
     preStep(scalar_old, _residual, _derivative);
 
     scalar_increment = -_residual / _derivative;
     scalar = scalar_old + scalar_increment;
 
     if (_check_range)
       checkPermissibleRange(scalar,
                             scalar_increment,
                             scalar_old,
                             min_permissible_scalar,
                             max_permissible_scalar,
                             iter_output);
 
     computeResidualAndDerivativeHelper(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)
         {
           GenericReal<is_ad> 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;
         computeResidualAndDerivativeHelper(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<bool is_ad>

virtual void SingleVariableReturnMappingSolutionTempl< is_ad >::iterationFinalize ( const GenericReal< is_ad > & )

inlineprotectedvirtual

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

Parameters

scalar Inelastic strain increment magnitude being solved for

Reimplemented in IsotropicPlasticityStressUpdateTempl< is_ad >, and CombinedNonlinearHardeningPlasticityTempl< is_ad >.

Definition at line 128 of file SingleVariableReturnMappingSolution.h.

128 {}

◆ maximumPermissibleValue()

template<bool is_ad>

GenericReal< is_ad > SingleVariableReturnMappingSolutionTempl< is_ad >::maximumPermissibleValue ( const GenericReal< is_ad > & effective_trial_stress ) const

protectedvirtual

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 in RadialReturnStressUpdateTempl< is_ad >, LAROMANCEStressUpdateBaseTempl< is_ad >, and PowerLawCreepTestTempl< is_ad >.

Definition at line 92 of file SingleVariableReturnMappingSolution.C.

 {
   return std::numeric_limits<Real>::max();
 }

◆ minimumPermissibleValue()

template<bool is_ad>

GenericReal< is_ad > SingleVariableReturnMappingSolutionTempl< is_ad >::minimumPermissibleValue ( const GenericReal< is_ad > & effective_trial_stress ) const

protectedvirtual

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 in RadialReturnStressUpdateTempl< is_ad >, and PowerLawCreepTestTempl< is_ad >.

Definition at line 84 of file SingleVariableReturnMappingSolution.C.

 {
   return std::numeric_limits<Real>::lowest();
 }

◆ outputIterationStep()

template<bool is_ad>

void SingleVariableReturnMappingSolutionTempl< is_ad >::outputIterationStep	(	std::stringstream *	iter_output,
		const GenericReal< is_ad > &	effective_trial_stress,
		const GenericReal< is_ad > &	scalar,
		const Real	reference_residual
	)

protectedvirtual

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

Parameters

iter_output	Output stream
effective_trial_stress	Effective trial stress
residual	Current value of the residual
reference	Current value of the reference quantity

Reimplemented in LAROMANCEStressUpdateBaseTempl< is_ad >.

Definition at line 419 of file SingleVariableReturnMappingSolution.C.

Referenced by LAROMANCEStressUpdateBaseTempl< is_ad >::outputIterationStep().

 {
   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<bool is_ad>

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

protectedvirtual

Output summary information for the convergence history of the model.

Parameters

iter_output	Output stream
total_it	Total iteration count

Reimplemented in RadialReturnStressUpdateTempl< is_ad >, LAROMANCEStressUpdateBaseTempl< is_ad >, and ADViscoplasticityStressUpdate.

Definition at line 442 of file SingleVariableReturnMappingSolution.C.

Referenced by ADViscoplasticityStressUpdate::outputIterationSummary(), LAROMANCEStressUpdateBaseTempl< is_ad >::outputIterationSummary(), and RadialReturnStressUpdateTempl< is_ad >::outputIterationSummary().

 {
   if (iter_output)
     *iter_output << "In " << total_it << " iterations the residual went from "
                  << MetaPhysicL::raw_value(_initial_residual) << " to "
                  << MetaPhysicL::raw_value(_residual) << " in '" << _svrms_name << "'."
                  << std::endl;
 }

◆ preStep()

template<bool is_ad>

virtual void SingleVariableReturnMappingSolutionTempl< is_ad >::preStep	(	const GenericReal< is_ad > &	,
		const GenericReal< is_ad > &	,
		const GenericReal< is_ad > &
	)

inlineprotectedvirtual

This method is called before taking a step in the return mapping algorithm.

A typical use case is to accumulate the exact algorithmic tangent during return mapping.

Definition at line 118 of file SingleVariableReturnMappingSolution.h.

121 {

122 }

◆ returnMappingSolve()

template<bool is_ad>

void SingleVariableReturnMappingSolutionTempl< is_ad >::returnMappingSolve	(	const GenericReal< is_ad > &	effective_trial_stress,
		GenericReal< is_ad > &	scalar,
		const ConsoleStream &	console
	)

protected

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

Referenced by ADViscoplasticityStressUpdate::computeInelasticStrainIncrement(), and ComputeSimoHughesJ2PlasticityStress::computeQpPK1Stress().

 {
   // 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)
           ? std::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)
       mooseException("");
 
     // user expects some kind of output, if necessary setup output stream now
     if (!iter_output)
       iter_output = std::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);
     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() << std::flush;
   }
 }

◆ updateBounds()

template<bool is_ad>

void SingleVariableReturnMappingSolutionTempl< is_ad >::updateBounds	(	const GenericReal< is_ad > &	scalar,
		const GenericReal< is_ad > &	residual,
		const Real	init_resid_sign,
		GenericReal< is_ad > &	scalar_upper_bound,
		GenericReal< is_ad > &	scalar_lower_bound,
		std::stringstream *	iter_output
	)

private

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 390 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;
 }

◆ validParams()

template<bool is_ad>

InputParameters SingleVariableReturnMappingSolutionTempl< is_ad >::validParams ( )

static

Definition at line 26 of file SingleVariableReturnMappingSolution.C.

Referenced by ADViscoplasticityStressUpdate::validParams(), ComputeSimoHughesJ2PlasticityStress::validParams(), and RadialReturnStressUpdateTempl< is_ad >::validParams().

 {
   InputParameters params = emptyInputParameters();
   params.addParam<Real>(
       "relative_tolerance", 1e-8, "Relative convergence tolerance for Newton iteration");
   params.addParam<Real>(
       "absolute_tolerance", 1e-11, "Absolute convergence tolerance for Newton iteration");
   params.addParam<Real>("acceptable_multiplier",
                         10,
                         "Factor applied to relative and absolute "
                         "tolerance for acceptable convergence if "
                         "iterations are no longer making progress");
 
   // diagnostic output parameters
   MooseEnum internal_solve_output_on_enum("never on_error always", "on_error");
   params.addParam<MooseEnum>("internal_solve_output_on",
                              internal_solve_output_on_enum,
                              "When to output internal Newton solve information");
   params.addParam<bool>("internal_solve_full_iteration_history",
                         false,
                         "Set true to output full internal Newton iteration history at times "
                         "determined by `internal_solve_output_on`. If false, only a summary is "
                         "output.");
   params.addParamNamesToGroup("internal_solve_output_on internal_solve_full_iteration_history",
                               "Debug");
 
   params.addParam<bool>("automatic_differentiation_return_mapping",
                         false,
                         "Whether to use automatic differentiation to compute the derivative.");
   return params;
 }