www.mooseframework.org
Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
ADLAROMANCEStressUpdateBase< compute_stage > Class Template Referenceabstract

#include <ADLAROMANCEStressUpdateBase.h>

Inheritance diagram for ADLAROMANCEStressUpdateBase< compute_stage >:
[legend]

Public Member Functions

 ADLAROMANCEStressUpdateBase (const InputParameters &parameters)
 
virtual void updateState (ADRankTwoTensor &strain_increment, ADRankTwoTensor &inelastic_strain_increment, const ADRankTwoTensor &rotation_increment, ADRankTwoTensor &stress_new, const RankTwoTensor &stress_old, const ADRankFourTensor &elasticity_tensor, const RankTwoTensor &elastic_strain_old) override
 A radial return (J2) mapping method is performed with return mapping iterations. More...
 
virtual Real computeReferenceResidual (const ADReal &effective_trial_stress, const ADReal &scalar_effective_inelastic_strain) override
 Compute a reference quantity to be used for checking relative convergence. More...
 
virtual ADReal minimumPermissibleValue (const ADReal &) const override
 Compute the minimum permissible value of the scalar. More...
 
virtual ADReal maximumPermissibleValue (const ADReal &effective_trial_stress) const override
 Compute the maximum permissible value of the scalar. More...
 
bool requiresIsotropicTensor () override
 Does the model require the elasticity tensor to be isotropic? More...
 
void setQp (unsigned int qp)
 Sets the value of the global variable _qp for inheriting classes. More...
 
void resetQpProperties () final
 Retained as empty methods to avoid a warning from Material.C in framework. These methods are unused in all inheriting classes and should not be overwritten. More...
 
void resetProperties () final
 

Static Public Member Functions

static InputParameters validParams ()
 

Protected Types

enum  WindowFailure { WindowFailure::ERROR, WindowFailure::WARN, WindowFailure::IGNORE }
 Enum to error, warn, or ignore checks that ensure ROM input is within applicability window. More...
 

Protected Member Functions

virtual void initialSetup () override
 
virtual void initQpStatefulProperties () override
 
virtual ADReal computeResidual (const ADReal &effective_trial_stress, const ADReal &scalar) override
 Compute the residual for a predicted value of the scalar. More...
 
virtual ADReal computeDerivative (const ADReal &, const ADReal &) override
 Compute the derivative of the residual as a function of the scalar variable. More...
 
virtual void computeStressFinalize (const ADRankTwoTensor &plastic_strain_increment) override
 Perform any necessary steps to finalize state after return mapping iterations. More...
 
virtual Real computeTimeStepLimit () override
 Compute the limiting value of the time step for this material. More...
 
void computeROMStrainRate (const Real dt, const Real &mobile_dislocations_old, const Real &immobile_dislocations_old, const ADReal &trial_stress, const Real &effective_strain_old, const ADReal &temperature, const ADReal &environmental, ADReal &mobile_dislocation_increment, ADReal &immobile_dislocation_increment, ADReal &rom_effective_strain, ADReal &rom_effective_strain_derivative)
 Computes the ROM Strain rate. More...
 
void checkInputWindows (std::vector< ADReal > &input)
 Function to check input values against applicability windows set by ROM data set. More...
 
void convertInput (const std::vector< ADReal > &input, std::vector< std::vector< ADReal >> &converted, std::vector< std::vector< ADReal >> &dconverted)
 Convert the input variables into the form expected by the ROM Legendre polynomials to have a normalized space from [-1, 1] so that every variable has equal weight. More...
 
void buildPolynomials (const std::vector< std::vector< ADReal >> &rom_inputs, const std::vector< std::vector< ADReal >> &drom_inputs, std::vector< std::vector< std::vector< ADReal >>> &polynomial_inputs, std::vector< std::vector< std::vector< ADReal >>> &dpolynomial_inputs)
 Assemble the array of Legendre polynomials to be multiplied by the ROM coefficients. More...
 
void computeValues (const std::vector< std::vector< Real >> &coefs, const std::vector< std::vector< std::vector< ADReal >>> &polynomial_inputs, const std::vector< std::vector< std::vector< ADReal >>> &dpolynomial_inputs, std::vector< ADReal > &rom_outputs, std::vector< ADReal > &drom_outputs)
 Arranges the calculated Legendre polynomials into the order expected by the ROM coefficients and ultiplies the Legendre polynomials by the ROM coefficients to compute the the predicted output values. More...
 
void convertOutput (const Real dt, const std::vector< ADReal > &old_input_values, const std::vector< ADReal > &rom_outputs, const std::vector< ADReal > &drom_outputs, std::vector< ADReal > &input_value_increments, std::vector< ADReal > &dinput_value_increments)
 Computes the output variable increments from the ROM predictions by bringing out of the normalized map to the actual physical values. More...
 
ADReal computePolynomial (const ADReal &value, const unsigned int degree, const bool derivative=false)
 Calculate the value or derivative of Legendre polynomial up to 3rd order. More...
 
std::vector< std::vector< std::vector< Real > > > getTransformedLimits () const
 
std::vector< std::vector< unsigned int > > getMakeFrameHelper () const
 
virtual std::vector< std::vector< ROMInputTransform > > getTransform ()=0
 
virtual std::vector< std::vector< Real > > getTransformCoefs ()=0
 
virtual std::vector< std::vector< Real > > getInputLimits ()=0
 
virtual std::vector< std::vector< Real > > getCoefs ()=0
 
 ADMaterialProperty (Real) &_creep_rate
 Creep rate material property. More...
 
virtual void propagateQpStatefulProperties () override
 If updateState is not called during a timestep, this will be. More...
 
 ADMaterialProperty (RankTwoTensor) &_creep_strain
 Creep strain material property. More...
 
void propagateQpStatefulPropertiesRadialReturn ()
 Propagate the properties pertaining to this intermediate class. More...
 
virtual void computeStressInitialize (const ADReal &, const ADRankFourTensor &)
 Perform any necessary initialization before return mapping iterations. 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 ADReal &effective_trial_stress, ADReal &scalar, const ConsoleStream &console)
 Perform the return mapping iterations. More...
 
virtual ADReal initialGuess (const ADReal &)
 Compute an initial guess for the value of the scalar. More...
 
virtual void iterationFinalize (ADReal)
 Finalize internal state variables for a model for a given iteration. More...
 
virtual void outputIterationStep (std::stringstream *iter_output, const ADReal &effective_trial_stress, const ADReal &scalar, const Real reference_residual)
 Output information for a single iteration step to build the convergence history of the model. More...
 
bool converged (const ADReal &residual, const Real reference)
 Check to see whether the residual is within the convergence limits. More...
 

Protected Attributes

const ADVariableValue & _temperature
 Coupled temperature variable. More...
 
const ADVariableValue & _environmental
 Optionally coupled environmental factor. More...
 
const Real _window
 Window applied to input maximum and minimum values. More...
 
enum ADLAROMANCEStressUpdateBase::WindowFailure _window_failure
 
const bool _extrapolate_stress
 Flag to optinoally allow model extrapolation to zero stress. More...
 
const bool _verbose
 Flag to output verbose infromation. More...
 
const Real _initial_mobile_dislocations
 Initial mobile dislocation value. More...
 
const Real _max_mobile_increment
 Maximum mobile dislocation increment. More...
 
const Function *const _mobile_function
 Optional mobile dislocation forcing function. More...
 
ADReal _mobile_dislocation_increment
 Container for mobile dislocation increment. More...
 
Real _mobile_old
 Container for old mobile dislocation value. More...
 
const Real _initial_immobile_dislocations
 Initial immobile dislocation value. More...
 
const Real _max_immobile_increment
 Maximum immobile dislocation increment. More...
 
const Function *const _immobile_function
 Optional immobile dislocation forcing function. More...
 
ADReal _immobile_dislocation_increment
 Container for immobile dislocation increment. More...
 
Real _immobile_old
 Container for old immobile dislocation value. More...
 
const unsigned int _stress_index
 Index corresponding to the position for the stress in the input vector. More...
 
const Function *const _creep_strain_old_forcing_function
 Optional old creep strain forcing function. More...
 
unsigned int _num_inputs
 Number of inputs for the ROM data set. More...
 
unsigned int _num_outputs
 Number of inputs to the ROM data set. More...
 
unsigned int _degree
 Legendre polynomial degree for the ROM data set. More...
 
unsigned int _num_coefs
 Total number of Legendre polynomial coefficients for the ROM data set. More...
 
std::vector< std::vector< ROMInputTransform > > _transform
 Transform rules defined by the ROM data set. More...
 
std::vector< std::vector< Real > > _transform_coefs
 Transform coefficients defined by the ROM data set. More...
 
std::vector< std::vector< Real > > _input_limits
 Input limits defined by the ROM data set. More...
 
std::vector< std::vector< Real > > _coefs
 Coefficients used with Legendre polynomials defined by the ROM data set. More...
 
bool _use_env
 Flag that checks if environmental factor is included in ROM data set. More...
 
std::vector< std::vector< std::vector< Real > > > _transformed_limits
 Limits transformed from readabile input to ROM readable limits. More...
 
std::vector< std::vector< unsigned int > > _makeframe_helper
 Helper container defined by the ROM data set. More...
 
MaterialProperty< Real > & _failed
 Material property to indicate if material point is outside of input limits. More...
 
ADReal _derivative
 Container for derivative of creep rate with respect to strain. More...
 
 usingRadialReturnCreepStressUpdateBaseMembers
 
const MaterialProperty< RankTwoTensor > & _creep_strain_old
 
 usingRadialReturnStressUpdateMembers
 
ADReal _three_shear_modulus
 3 * shear modulus More...
 
const MaterialProperty< Real > & _effective_inelastic_strain_old
 
Real _max_inelastic_increment
 
const bool _apply_strain
 
 usingStressUpdateBaseMembers
 
 usingSingleVariableReturnMappingSolutionMembers
 
const std::string _base_name
 Name used as a prefix for all material properties related to the stress update model. More...
 
 usingMaterialMembers
 
bool _check_range
 Whether to check to see whether iterative solution is within admissible range, and set within that range if outside. More...
 
bool _line_search
 Whether to use line searches to improve convergence. More...
 
bool _bracket_solution
 Whether to save upper and lower bounds of root for scalar, and set solution to the midpoint between those bounds if outside them. More...
 

Private Types

enum  InternalSolveOutput { InternalSolveOutput::NEVER, InternalSolveOutput::ON_ERROR, InternalSolveOutput::ALWAYS }
 
enum  SolveState { SolveState::SUCCESS, SolveState::NAN_INF, SolveState::EXCEEDED_ITERATIONS }
 

Private Member Functions

SolveState internalSolve (const ADReal effective_trial_stress, ADReal &scalar, std::stringstream *iter_output=nullptr)
 Method called from within this class to perform the actual return mappping iterations. More...
 
bool convergedAcceptable (const unsigned int it, const Real reference)
 Check to see whether the residual is within acceptable convergence limits. More...
 
void checkPermissibleRange (ADReal &scalar, ADReal &scalar_increment, const ADReal &scalar_old, const ADReal min_permissible_scalar, const ADReal max_permissible_scalar, std::stringstream *iter_output)
 Check to see whether solution is within admissible range, and set it within that range if it is not. More...
 
void updateBounds (const ADReal &scalar, const ADReal &residual, const Real init_resid_sign, ADReal &scalar_upper_bound, ADReal &scalar_lower_bound, std::stringstream *iter_output)
 Update the upper and lower bounds of the root for the effective inelastic strain. More...
 

Private Attributes

enum ADSingleVariableReturnMappingSolution::InternalSolveOutput _internal_solve_output_on
 
const unsigned int _max_its
 Maximum number of return mapping iterations. More...
 
const bool _internal_solve_full_iteration_history
 Whether to output iteration information all the time (regardless of whether iterations converge) More...
 
Real _relative_tolerance
 Relative convergence tolerance. More...
 
Real _absolute_tolerance
 Absolute convergence tolerance. More...
 
Real _acceptable_multiplier
 Multiplier applied to relative and absolute tolerances for acceptable convergence. More...
 
const std::size_t _num_resids
 Number of residuals to be stored in history. More...
 
std::vector< Real > _residual_history
 History of residuals used to check whether progress is still being made on decreasing the residual. More...
 
unsigned int _iteration
 iteration number More...
 
const std::string _svrms_name
 MOOSE input name of the object performing the solve. More...
 
ADReal _initial_residual
 Residual values, kept as members to retain solver state for summary outputting. More...
 
ADReal _residual
 
const MaterialProperty< Real > & _mobile_dislocations_old
 
 ADMaterialProperty (Real) &_mobile_dislocations
 Material properties for mobile (glissile) dislocation densities (1/m^2) More...
 
const MaterialProperty< Real > & _immobile_dislocations_old
 
 ADMaterialProperty (Real) &_immobile_dislocations
 Material properties for immobile (locked) dislocation densities (1/m^2) More...
 

Detailed Description

template<ComputeStage compute_stage>
class ADLAROMANCEStressUpdateBase< compute_stage >

Definition at line 22 of file ADLAROMANCEStressUpdateBase.h.

Member Enumeration Documentation

◆ InternalSolveOutput

template<ComputeStage compute_stage>
enum ADSingleVariableReturnMappingSolution::InternalSolveOutput
strongprivateinherited
Enumerator
NEVER 
ON_ERROR 
ALWAYS 

Definition at line 156 of file ADSingleVariableReturnMappingSolution.h.

157  {
158  NEVER,
159  ON_ERROR,
160  ALWAYS
161  } _internal_solve_output_on;

◆ SolveState

template<ComputeStage compute_stage>
enum ADSingleVariableReturnMappingSolution::SolveState
strongprivateinherited
Enumerator
SUCCESS 
NAN_INF 
EXCEEDED_ITERATIONS 

Definition at line 163 of file ADSingleVariableReturnMappingSolution.h.

164  {
165  SUCCESS,
166  NAN_INF,
167  EXCEEDED_ITERATIONS
168  };

◆ WindowFailure

template<ComputeStage compute_stage>
enum ADLAROMANCEStressUpdateBase::WindowFailure
strongprotected

Enum to error, warn, or ignore checks that ensure ROM input is within applicability window.

Enumerator
ERROR 
WARN 
IGNORE 

Definition at line 220 of file ADLAROMANCEStressUpdateBase.h.

220 { ERROR, WARN, IGNORE } _window_failure;

Constructor & Destructor Documentation

◆ ADLAROMANCEStressUpdateBase()

template<ComputeStage compute_stage>
ADLAROMANCEStressUpdateBase< compute_stage >::ADLAROMANCEStressUpdateBase ( const InputParameters &  parameters)

Definition at line 86 of file ADLAROMANCEStressUpdateBase.C.

88  : ADRadialReturnCreepStressUpdateBase<compute_stage>(parameters),
89  _temperature(adCoupledValue("temperature")),
90  _environmental(adCoupledValue("environmental_factor")),
91  _window(getParam<Real>("input_window_limit")),
92  _window_failure(
93  parameters.get<MooseEnum>("input_window_failure_action").getEnum<WindowFailure>()),
94  _extrapolate_stress(getParam<bool>("extrapolate_to_zero_stress")),
95  _verbose(getParam<bool>("verbose")),
96  _mobile_dislocations(declareADProperty<Real>(_base_name + "mobile_dislocations")),
97  _mobile_dislocations_old(getMaterialPropertyOld<Real>(_base_name + "mobile_dislocations")),
98  _initial_mobile_dislocations(getParam<Real>("initial_mobile_dislocation_density")),
99  _max_mobile_increment(getParam<Real>("max_relative_mobile_dislocation_increment")),
100  _mobile_function(isParamValid("mobile_dislocation_density_forcing_function")
101  ? &getFunction("mobile_dislocation_density_forcing_function")
102  : NULL),
103  _mobile_dislocation_increment(0.0),
104  _mobile_old(0.0),
105  _immobile_dislocations(declareADProperty<Real>(_base_name + "immobile_dislocations")),
106  _immobile_dislocations_old(getMaterialPropertyOld<Real>(_base_name + "immobile_dislocations")),
107  _initial_immobile_dislocations(getParam<Real>("initial_immobile_dislocation_density")),
108  _max_immobile_increment(getParam<Real>("max_relative_immobile_dislocation_increment")),
109  _immobile_function(isParamValid("immobile_dislocation_density_forcing_function")
110  ? &getFunction("immobile_dislocation_density_forcing_function")
111  : NULL),
112  _immobile_dislocation_increment(0.0),
113  _immobile_old(0.0),
114  _stress_index(2),
115 
116  _creep_strain_old_forcing_function(isParamValid("old_creep_strain_forcing_function")
117  ? &getFunction("old_creep_strain_forcing_function")
118  : NULL),
119 
120  _creep_rate(declareADProperty<Real>(_base_name + "creep_rate")),
121  _failed(declareProperty<Real>("ROM_failure")),
122 
123  _derivative(0.0)
124 {
125 }

Member Function Documentation

◆ ADMaterialProperty() [1/4]

template<ComputeStage compute_stage>
ADRadialReturnCreepStressUpdateBase< compute_stage >::ADMaterialProperty ( RankTwoTensor  ) &
protectedinherited

Creep strain material property.

◆ ADMaterialProperty() [2/4]

template<ComputeStage compute_stage>
ADLAROMANCEStressUpdateBase< compute_stage >::ADMaterialProperty ( Real  ) &
protected

Creep rate material property.

◆ ADMaterialProperty() [3/4]

template<ComputeStage compute_stage>
ADLAROMANCEStressUpdateBase< compute_stage >::ADMaterialProperty ( Real  ) &
protected

Material properties for immobile (locked) dislocation densities (1/m^2)

◆ ADMaterialProperty() [4/4]

template<ComputeStage compute_stage>
ADLAROMANCEStressUpdateBase< compute_stage >::ADMaterialProperty ( Real  ) &
protected

Material properties for mobile (glissile) dislocation densities (1/m^2)

◆ buildPolynomials()

template<ComputeStage compute_stage>
void ADLAROMANCEStressUpdateBase< compute_stage >::buildPolynomials ( const std::vector< std::vector< ADReal >> &  rom_inputs,
const std::vector< std::vector< ADReal >> &  drom_inputs,
std::vector< std::vector< std::vector< ADReal >>> &  polynomial_inputs,
std::vector< std::vector< std::vector< ADReal >>> &  dpolynomial_inputs 
)
protected

Assemble the array of Legendre polynomials to be multiplied by the ROM coefficients.

Parameters
rom_inputsVector of converted input values
drom_inputsVector of derivative of converted input values with respect to stress
polynomial_inputsVector of Legendre polynomial transformation
dpolynomial_inputsVector of derivative of Legendre polynomial transformation with respect to stress

Definition at line 451 of file ADLAROMANCEStressUpdateBase.C.

456 {
457  for (unsigned int i = 0; i < _num_outputs; ++i)
458  {
459  for (unsigned int j = 0; j < _num_inputs; ++j)
460  {
461  for (unsigned int k = 0; k < _degree; ++k)
462  {
463  polynomial_inputs[i][j][k] = computePolynomial(rom_inputs[i][j], k);
464 
465  if (j != _stress_index)
466  dpolynomial_inputs[i][j][k] = 0.0;
467  else
468  {
469  // This is not the true derivative, but rather an optimization for computeValues
470  dpolynomial_inputs[i][j][k] = drom_inputs[i][j] *
471  computePolynomial(rom_inputs[i][j], k, true) /
472  polynomial_inputs[i][j][k];
473  }
474  }
475  }
476  }
477 }

◆ checkInputWindows()

template<ComputeStage compute_stage>
void ADLAROMANCEStressUpdateBase< compute_stage >::checkInputWindows ( std::vector< ADReal > &  input)
protected

Function to check input values against applicability windows set by ROM data set.

Parameters
inputVector of input values

Definition at line 360 of file ADLAROMANCEStressUpdateBase.C.

361 {
362  if (compute_stage != RESIDUAL)
363  return;
364 
365  _failed[_qp] = 0.0;
366  for (unsigned int i = 0; i < _num_outputs; ++i)
367  {
368  for (unsigned int j = 0; j < _num_inputs; ++j)
369  {
370  Real high_limit = _input_limits[j][1] * _window;
371  Real low_limit = _input_limits[j][0] * (2.0 - _window);
372  if (j == _stress_index && _extrapolate_stress)
373  low_limit = 0.0;
374  if (input[j] < low_limit || input[j] > high_limit)
375  {
376  _failed[_qp] += (j + 1) * (j + 1);
377  if (_window_failure == WindowFailure::WARN)
378  mooseWarning("In ",
379  _name,
380  ": input parameter number input=",
381  j,
382  " output=",
383  i,
384  " with value (",
385  input[j],
386  ") is out of range (",
387  _input_limits[j][0],
388  " - ",
389  _input_limits[j][1],
390  "), window (",
391  _window,
392  ")");
393  else if (_window_failure == WindowFailure::ERROR)
394  mooseError("In ",
395  _name,
396  ": input parameter number input=",
397  j,
398  " output=",
399  i,
400  " with value (",
401  input[j],
402  ") is out of range (",
403  _input_limits[j][0],
404  " - ",
405  _input_limits[j][1],
406  "), window (",
407  _window,
408  ")");
409  }
410  }
411  }
412 }

◆ checkPermissibleRange()

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

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

Parameters
scalarCurrent value of the inelastic strain increment
scalar_incrementIncremental change in scalar from the previous iteration
scalar_oldPrevious value of scalar
min_permissible_scalarMinimum permissible value of scalar
max_permissible_scalarMaximum permissible value of scalar
iter_outputOutput stream

Definition at line 334 of file ADSingleVariableReturnMappingSolution.C.

341 {
342  if (scalar > max_permissible_scalar)
343  {
344  scalar_increment = (max_permissible_scalar - scalar_old) / 2.0;
345  scalar = scalar_old + scalar_increment;
346  if (iter_output)
347  *iter_output << "Scalar greater than maximum ("
348  << MetaPhysicL::raw_value(max_permissible_scalar)
349  << ") adjusted scalar=" << MetaPhysicL::raw_value(scalar)
350  << " scalar_increment=" << MetaPhysicL::raw_value(scalar_increment) << std::endl;
351  }
352  else if (scalar < min_permissible_scalar)
353  {
354  scalar_increment = (min_permissible_scalar - scalar_old) / 2.0;
355  scalar = scalar_old + scalar_increment;
356  if (iter_output)
357  *iter_output << "Scalar less than minimum (" << MetaPhysicL::raw_value(min_permissible_scalar)
358  << ") adjusted scalar=" << MetaPhysicL::raw_value(scalar)
359  << " scalar_increment=" << MetaPhysicL::raw_value(scalar_increment) << std::endl;
360  }
361 }

◆ computeDerivative()

template<ComputeStage compute_stage>
virtual ADReal ADLAROMANCEStressUpdateBase< compute_stage >::computeDerivative ( const ADReal &  effective_trial_stress,
const ADReal &  scalar 
)
inlineoverrideprotectedvirtual

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_stressEffective trial stress
scalarInelastic strain increment magnitude being solved for

Implements ADSingleVariableReturnMappingSolution< compute_stage >.

Definition at line 49 of file ADLAROMANCEStressUpdateBase.h.

51  {
52  return _derivative;
53  }

◆ computePolynomial()

template<ComputeStage compute_stage>
ADReal ADLAROMANCEStressUpdateBase< compute_stage >::computePolynomial ( const ADReal &  value,
const unsigned int  degree,
const bool  derivative = false 
)
protected

Calculate the value or derivative of Legendre polynomial up to 3rd order.

Parameters
valueInput to Legendre polynomial
degreeDegree of Legendre polynomial
derivativeFlag to return derivative of Legendre polynomial Legendre
Returns
Computed value from Legendre polynomial

Definition at line 535 of file ADLAROMANCEStressUpdateBase.C.

538 {
539  if (degree == 0)
540  {
541  if (derivative)
542  return 0.0;
543  return 1.0;
544  }
545  else if (degree == 1)
546  {
547  if (derivative)
548  return 1.0;
549  return value;
550  }
551  else if (degree == 2)
552  {
553  if (derivative)
554  return 3.0 * value;
555  return 1.5 * Utility::pow<2>(value) - 0.5;
556  }
557  else
558  {
559  if (derivative)
560  return 7.5 * Utility::pow<2>(value) - 1.5;
561  return 2.5 * Utility::pow<3>(value) - 1.5 * value;
562  }
563 }

◆ computeReferenceResidual()

template<ComputeStage compute_stage>
Real ADRadialReturnStressUpdate< compute_stage >::computeReferenceResidual ( const ADReal &  effective_trial_stress,
const ADReal &  scalar 
)
overridevirtualinherited

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

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

Parameters
effective_trial_stressEffective trial stress
scalarInelastic strain increment magnitude being solved for

Implements ADSingleVariableReturnMappingSolution< compute_stage >.

Definition at line 124 of file ADRadialReturnStressUpdate.C.

126 {
127  return MetaPhysicL::raw_value(effective_trial_stress / _three_shear_modulus) -
128  MetaPhysicL::raw_value(scalar_effective_inelastic_strain);
129 }

◆ computeResidual()

template<ComputeStage compute_stage>
ADReal ADLAROMANCEStressUpdateBase< compute_stage >::computeResidual ( const ADReal &  effective_trial_stress,
const ADReal &  scalar 
)
overrideprotectedvirtual

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_stressEffective trial stress
scalarInelastic strain increment magnitude being solved for

Implements ADSingleVariableReturnMappingSolution< compute_stage >.

Definition at line 180 of file ADLAROMANCEStressUpdateBase.C.

182 {
183  if (_immobile_function)
184  _immobile_old = _immobile_function->value(_t, _q_point[_qp]);
185  else
186  _immobile_old = _immobile_dislocations_old[_qp];
187 
188  if (_mobile_function)
189  _mobile_old = _mobile_function->value(_t, _q_point[_qp]);
190  else
191  _mobile_old = _mobile_dislocations_old[_qp];
192 
193  const ADReal trial_stress_mpa = (effective_trial_stress - _three_shear_modulus * scalar) * 1.0e-6;
194 
195  if (trial_stress_mpa < 0.0)
196  mooseException("In ",
197  _name,
198  ": previously calculated scalar (",
199  MetaPhysicL::raw_value(scalar),
200  ") is too high resulting in a negative trial stress (",
201  MetaPhysicL::raw_value(trial_stress_mpa),
202  "). Cutting timestep.");
203 
204  Real effective_strain_old;
205  if (_creep_strain_old_forcing_function)
206  effective_strain_old = _creep_strain_old_forcing_function->value(_t, _q_point[_qp]);
207  else
208  effective_strain_old =
209  std::sqrt(_creep_strain_old[_qp].doubleContraction(_creep_strain_old[_qp]) / 1.5);
210 
211  ADReal rom_effective_strain = 0.0;
212  ADReal derivative_rom_effective_strain = 0.0;
213 
214  computeROMStrainRate(_dt,
215  _mobile_old,
216  _immobile_old,
217  trial_stress_mpa,
218  effective_strain_old,
219  _temperature[_qp],
220  _environmental[_qp],
221  _mobile_dislocation_increment,
222  _immobile_dislocation_increment,
223  rom_effective_strain,
224  derivative_rom_effective_strain);
225 
226  if (_verbose && compute_stage == RESIDUAL)
227  {
228  Moose::out << "Verbose information from " << _name << ": \n";
229  Moose::out << " dt: " << _dt << "\n";
230  Moose::out << " old mobile disl: " << _mobile_old << "\n";
231  Moose::out << " old immobile disl: " << _immobile_old << "\n";
232  Moose::out << " initial stress (MPa): " << effective_trial_stress * 1.0e-6 << "\n";
233  Moose::out << " temperature: " << _temperature[_qp] << "\n";
234  Moose::out << " environmental factor: " << _environmental[_qp] << "\n";
235  Moose::out << " calculated scalar strain value: " << scalar << "\n";
236  Moose::out << " trial stress into rom (MPa): " << trial_stress_mpa << "\n";
237  Moose::out << " old effective strain: " << effective_strain_old << "\n";
238  Moose::out << " ROM outputs \n";
239  Moose::out << " effective incremental strain from rom: " << rom_effective_strain << "\n";
240  Moose::out << " new effective strain: " << effective_strain_old + rom_effective_strain << "\n";
241  Moose::out << " new mobile dislocations: " << _mobile_old + _mobile_dislocation_increment
242  << "\n";
243  Moose::out << " new immobile dislocations: " << _immobile_old + _immobile_dislocation_increment
244  << "\n"
245  << std::endl;
246  }
247 
248  _creep_rate[_qp] = rom_effective_strain / _dt;
249  _derivative = derivative_rom_effective_strain * -_three_shear_modulus * 1.0e-6 - 1.0;
250 
251  return rom_effective_strain - scalar;
252 }

◆ computeROMStrainRate()

template<ComputeStage compute_stage>
void ADLAROMANCEStressUpdateBase< compute_stage >::computeROMStrainRate ( const Real  dt,
const Real &  mobile_dislocations_old,
const Real &  immobile_dislocations_old,
const ADReal &  trial_stress,
const Real &  effective_strain_old,
const ADReal &  temperature,
const ADReal &  environmental,
ADReal &  mobile_dislocation_increment,
ADReal &  immobile_dislocation_increment,
ADReal &  rom_effective_strain,
ADReal &  rom_effective_strain_derivative 
)
protected

Computes the ROM Strain rate.

Parameters
dtTimestep size
mobile_dislocations_oldMobile dislocation density from previous timestep
immobile_dislocations_oldImmobile dislocation density from previous timestep
trial_stressTrial stress from radial return method
effective_strain_oldEffective strain from the previous timestep
temperatureTemperature variable value
environmentalEnvironmental variable value
mobile_dislocation_incrementMobile dislocation density incremental change
immobile_dislocation_incrementImmobile dislocation density incremental change
rom_effective_strainROM calculated effective strain
rom_effective_strain_derivativeDerivative of ROM calculated effective strain with respect to stress

Definition at line 301 of file ADLAROMANCEStressUpdateBase.C.

313 {
314  // Prepare input
315  std::vector<ADReal> input_values = {mobile_dislocations_old,
316  immobile_dislocations_old,
317  trial_stress,
318  effective_strain_old,
319  temperature};
320  if (_use_env)
321  input_values.push_back(environmental);
322 
323  std::vector<std::vector<ADReal>> rom_inputs(_num_outputs, std::vector<ADReal>(_num_inputs));
324  std::vector<std::vector<ADReal>> drom_inputs(_num_outputs, std::vector<ADReal>(_num_inputs));
325 
326  checkInputWindows(input_values);
327  convertInput(input_values, rom_inputs, drom_inputs);
328 
329  std::vector<ADReal> old_input_values = {
330  mobile_dislocations_old, immobile_dislocations_old, effective_strain_old};
331 
332  std::vector<std::vector<std::vector<ADReal>>> polynomial_inputs(
333  _num_outputs, std::vector<std::vector<ADReal>>(_num_inputs, std::vector<ADReal>(_degree)));
334  std::vector<ADReal> rom_outputs(_num_outputs);
335  std::vector<ADReal> input_value_increments(_num_outputs);
336 
337  std::vector<std::vector<std::vector<ADReal>>> dpolynomial_inputs(
338  _num_outputs, std::vector<std::vector<ADReal>>(_num_inputs, std::vector<ADReal>(_degree)));
339  std::vector<ADReal> drom_outputs(_num_outputs);
340  std::vector<ADReal> dinput_value_increments(_num_outputs);
341 
342  buildPolynomials(rom_inputs, drom_inputs, polynomial_inputs, dpolynomial_inputs);
343  computeValues(_coefs, polynomial_inputs, dpolynomial_inputs, rom_outputs, drom_outputs);
344  convertOutput(dt,
345  old_input_values,
346  rom_outputs,
347  drom_outputs,
348  input_value_increments,
349  dinput_value_increments);
350 
351  mobile_dislocation_increment = input_value_increments[0];
352  immobile_dislocation_increment = input_value_increments[1];
353  rom_effective_strain = input_value_increments[2];
354 
355  rom_effective_strain_derivative = dinput_value_increments[2];
356 }

◆ computeStressFinalize()

template<ComputeStage compute_stage>
void ADLAROMANCEStressUpdateBase< compute_stage >::computeStressFinalize ( const ADRankTwoTensor &  )
overrideprotectedvirtual

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

Parameters
inelasticStrainIncrementInelastic strain increment

Reimplemented from ADRadialReturnCreepStressUpdateBase< compute_stage >.

Definition at line 256 of file ADLAROMANCEStressUpdateBase.C.

258 {
259  _mobile_dislocations[_qp] = _mobile_old + _mobile_dislocation_increment;
260  _immobile_dislocations[_qp] = _immobile_old + _immobile_dislocation_increment;
261 
262  if (_verbose && compute_stage == RESIDUAL)
263  {
264  Moose::out << "Finalized verbose information from " << _name << "\n";
265  Moose::out << " increment effective creep strain: "
266  << std::sqrt(2.0 / 3.0 *
267  plastic_strain_increment.doubleContraction(plastic_strain_increment))
268  << "\n";
269  Moose::out << " effective_creep_strain: "
270  << std::sqrt(2.0 / 3.0 * _creep_strain[_qp].doubleContraction(_creep_strain[_qp]))
271  << "\n";
272  Moose::out << " new mobile dislocations: " << _mobile_dislocations[_qp] << "\n";
273  Moose::out << " new immobile dislocations: " << _immobile_dislocations[_qp] << "\n"
274  << std::endl;
275  }
276 
277  ADRadialReturnCreepStressUpdateBase<compute_stage>::computeStressFinalize(
278  plastic_strain_increment);
279 }

◆ computeStressInitialize()

template<ComputeStage compute_stage>
virtual void ADRadialReturnStressUpdate< compute_stage >::computeStressInitialize ( const ADReal &  ,
const ADRankFourTensor &   
)
inlineprotectedvirtualinherited

Perform any necessary initialization before return mapping iterations.

Parameters
effective_trial_stressEffective trial stress
elasticityTensorElasticity tensor

Reimplemented in ADIsotropicPlasticityStressUpdate< compute_stage >, and ADPowerLawCreepStressUpdate< compute_stage >.

Definition at line 109 of file ADRadialReturnStressUpdate.h.

111  {
112  }

◆ computeTimeStepLimit()

template<ComputeStage compute_stage>
Real ADLAROMANCEStressUpdateBase< compute_stage >::computeTimeStepLimit ( )
overrideprotectedvirtual

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

Returns
Limiting time step

Reimplemented from ADRadialReturnStressUpdate< compute_stage >.

Definition at line 283 of file ADLAROMANCEStressUpdateBase.C.

284 {
285  Real limited_dt = ADRadialReturnStressUpdate<compute_stage>::computeTimeStepLimit();
286 
287  Real mobile_strain_inc = std::abs(MetaPhysicL::raw_value(_mobile_dislocation_increment));
288  if (mobile_strain_inc && _mobile_old)
289  limited_dt =
290  std::min(limited_dt, _dt * _max_mobile_increment * _mobile_old / mobile_strain_inc);
291  Real immobile_strain_inc = std::abs(MetaPhysicL::raw_value(_immobile_dislocation_increment));
292  if (immobile_strain_inc && _immobile_old)
293  limited_dt =
294  std::min(limited_dt, _dt * _max_immobile_increment * _immobile_old / immobile_strain_inc);
295 
296  return limited_dt;
297 }

◆ computeValues()

template<ComputeStage compute_stage>
void ADLAROMANCEStressUpdateBase< compute_stage >::computeValues ( const std::vector< std::vector< Real >> &  coefs,
const std::vector< std::vector< std::vector< ADReal >>> &  polynomial_inputs,
const std::vector< std::vector< std::vector< ADReal >>> &  dpolynomial_inputs,
std::vector< ADReal > &  rom_outputs,
std::vector< ADReal > &  drom_outputs 
)
protected

Arranges the calculated Legendre polynomials into the order expected by the ROM coefficients and ultiplies the Legendre polynomials by the ROM coefficients to compute the the predicted output values.

Parameters
coefsLegendre polynomials
polynomial_inputsVector of Legendre polynomial transformation
dpolynomial_inputsVector of derivative of Legendre polynomial transformation with respect to stress
rom_outputsOutputs from ROM
drom_outputsDerivative of outputs from ROM with respect to stress

Definition at line 481 of file ADLAROMANCEStressUpdateBase.C.

487 {
488  for (unsigned int i = 0; i < _num_outputs; ++i)
489  {
490  rom_outputs[i] = 0.0;
491  drom_outputs[i] = 0.0;
492  for (unsigned int j = 0; j < _num_coefs; ++j)
493  {
494  ADReal xvals = coefs[i][j];
495  ADReal dxvals = 0.0;
496  for (unsigned int k = 0; k < _num_inputs; ++k)
497  {
498  xvals *= polynomial_inputs[i][k][_makeframe_helper[j][k]];
499  dxvals += dpolynomial_inputs[i][k][_makeframe_helper[j][k]];
500  }
501 
502  rom_outputs[i] += xvals;
503  drom_outputs[i] += dxvals * xvals;
504  }
505  }
506 }

◆ converged()

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

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

Parameters
residualCurrent value of the residual
referenceCurrent value of the reference quantity
Returns
Whether the model converged

Definition at line 301 of file ADSingleVariableReturnMappingSolution.C.

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

◆ convergedAcceptable()

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

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

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

Parameters
residualCurrent iteration count
residualCurrent value of the residual
referenceCurrent value of the reference quantity
Returns
Whether the model converged

Definition at line 311 of file ADSingleVariableReturnMappingSolution.C.

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

◆ convertInput()

template<ComputeStage compute_stage>
void ADLAROMANCEStressUpdateBase< compute_stage >::convertInput ( const std::vector< ADReal > &  input,
std::vector< std::vector< ADReal >> &  converted,
std::vector< std::vector< ADReal >> &  dconverted 
)
protected

Convert the input variables into the form expected by the ROM Legendre polynomials to have a normalized space from [-1, 1] so that every variable has equal weight.

Parameters
inputVector of input values
convertedVector of converted input values
dconvertedVector of derivative of converted input values with respect to stress

Definition at line 416 of file ADLAROMANCEStressUpdateBase.C.

420 {
421  for (unsigned int i = 0; i < _num_outputs; ++i)
422  {
423  for (unsigned int j = 0; j < _num_inputs; ++j)
424  {
425  ADReal x = input[j];
426  ADReal dx = 1.0;
427  if (_transform[i][j] == ROMInputTransform::EXP)
428  {
429  x = std::exp(x / _transform_coefs[i][j]);
430  dx = x / _transform_coefs[i][j];
431  }
432  else if (_transform[i][j] == ROMInputTransform::LOG)
433  {
434  dx = 1.0 / (x + _transform_coefs[i][j]);
435  x = std::log(x + _transform_coefs[i][j]);
436  }
437 
438  converted[i][j] = 2.0 * (x - _transformed_limits[i][j][0]) /
439  (_transformed_limits[i][j][1] - _transformed_limits[i][j][0]) -
440  1.0;
441  if (j == _stress_index)
442  dconverted[i][j] = dx * 2.0 / (_transformed_limits[i][j][1] - _transformed_limits[i][j][0]);
443  else
444  dconverted[i][j] = 0.0;
445  }
446  }
447 }

◆ convertOutput()

template<ComputeStage compute_stage>
void ADLAROMANCEStressUpdateBase< compute_stage >::convertOutput ( const Real  dt,
const std::vector< ADReal > &  old_input_values,
const std::vector< ADReal > &  rom_outputs,
const std::vector< ADReal > &  drom_outputs,
std::vector< ADReal > &  input_value_increments,
std::vector< ADReal > &  dinput_value_increments 
)
protected

Computes the output variable increments from the ROM predictions by bringing out of the normalized map to the actual physical values.

Parameters
dtTimestep size
old_input_valuesPrevious timestep values of ROM inputs
rom_outputsOutputs from ROM
drom_outputsDerivative of outputs from ROM with respect to stress
input_value_incrementsIncremental change of input values
input_value_incrementsDerivative of the incremental change of input values with respect to stress

Definition at line 510 of file ADLAROMANCEStressUpdateBase.C.

517 {
518  for (unsigned int i = 0; i < _num_outputs; ++i)
519  {
520  input_value_increments[i] = std::exp(rom_outputs[i]) * dt;
521  if (i == 0 || i == 1)
522  {
523  dinput_value_increments[i] = 0.0;
524  input_value_increments[i] *= old_input_values[i];
525  if (i == 0)
526  input_value_increments[i] *= -1.0;
527  }
528  else
529  dinput_value_increments[i] = input_value_increments[i] * drom_outputs[i];
530  }
531 }

◆ getCoefs()

template<ComputeStage compute_stage>
virtual std::vector<std::vector<Real> > ADLAROMANCEStressUpdateBase< compute_stage >::getCoefs ( )
protectedpure virtual

Implemented in SS316HLAROMANCEStressUpdateTest< compute_stage >.

◆ getInputLimits()

template<ComputeStage compute_stage>
virtual std::vector<std::vector<Real> > ADLAROMANCEStressUpdateBase< compute_stage >::getInputLimits ( )
protectedpure virtual

Implemented in SS316HLAROMANCEStressUpdateTest< compute_stage >.

◆ getMakeFrameHelper()

template<ComputeStage compute_stage>
std::vector< std::vector< unsigned int > > ADLAROMANCEStressUpdateBase< compute_stage >::getMakeFrameHelper ( ) const
protected

Definition at line 593 of file ADLAROMANCEStressUpdateBase.C.

594 {
595  std::vector<std::vector<unsigned int>> v(_num_coefs, std::vector<unsigned int>(_num_inputs));
596 
597  for (unsigned int numcoeffs = 0; numcoeffs < _num_coefs; ++numcoeffs)
598  for (unsigned int invar = 0; invar < _num_inputs; ++invar)
599  v[numcoeffs][invar] = numcoeffs / MathUtils::pow(_degree, invar) % _degree;
600 
601  return v;
602 }

◆ getTransform()

template<ComputeStage compute_stage>
virtual std::vector<std::vector<ROMInputTransform> > ADLAROMANCEStressUpdateBase< compute_stage >::getTransform ( )
protectedpure virtual

Implemented in SS316HLAROMANCEStressUpdateTest< compute_stage >.

◆ getTransformCoefs()

template<ComputeStage compute_stage>
virtual std::vector<std::vector<Real> > ADLAROMANCEStressUpdateBase< compute_stage >::getTransformCoefs ( )
protectedpure virtual

Implemented in SS316HLAROMANCEStressUpdateTest< compute_stage >.

◆ getTransformedLimits()

template<ComputeStage compute_stage>
std::vector< std::vector< std::vector< Real > > > ADLAROMANCEStressUpdateBase< compute_stage >::getTransformedLimits ( ) const
protected

Definition at line 567 of file ADLAROMANCEStressUpdateBase.C.

568 {
569  std::vector<std::vector<std::vector<Real>>> transformed_limits(
570  _num_outputs, std::vector<std::vector<Real>>(_num_inputs, std::vector<Real>(2)));
571 
572  for (unsigned int i = 0; i < _num_outputs; ++i)
573  {
574  for (unsigned int j = 0; j < _num_inputs; ++j)
575  {
576  for (unsigned int k = 0; k < 2; ++k)
577  {
578  if (_transform[i][j] == ROMInputTransform::EXP)
579  transformed_limits[i][j][k] = std::exp(_input_limits[j][k] / _transform_coefs[i][j]);
580  else if (_transform[i][j] == ROMInputTransform::LOG)
581  transformed_limits[i][j][k] = std::log(_input_limits[j][k] + _transform_coefs[i][j]);
582  else
583  transformed_limits[i][j][k] = _input_limits[j][k];
584  }
585  }
586  }
587 
588  return transformed_limits;
589 }

◆ initialGuess()

template<ComputeStage compute_stage>
virtual ADReal ADSingleVariableReturnMappingSolution< compute_stage >::initialGuess ( const ADReal &  )
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_stressEffective trial stress

Reimplemented in ADViscoplasticityStressUpdate< compute_stage >.

Definition at line 82 of file ADSingleVariableReturnMappingSolution.h.

82 { return 0.0; }

◆ initialSetup()

template<ComputeStage compute_stage>
void ADLAROMANCEStressUpdateBase< compute_stage >::initialSetup ( )
overrideprotectedvirtual

Definition at line 129 of file ADLAROMANCEStressUpdateBase.C.

130 {
131  _transform = getTransform();
132 
133  _num_outputs = _transform.size();
134  if (_num_outputs != 3)
135  mooseError("In ", _name, ": _num_outputs (", _num_outputs, ") is not 3");
136 
137  _num_inputs = _transform[0].size();
138  if (_num_inputs != 5 && _num_inputs != 6)
139  mooseError("In ", _name, ": _num_inputs (", _num_inputs, ") is not 5 or 6");
140  _use_env = _num_inputs == 6 ? true : false;
141 
142  _transform_coefs = getTransformCoefs();
143  if (_transform_coefs.size() != _num_outputs || _transform_coefs[0].size() != _num_inputs)
144  mooseError("In ", _name, ": transform_coef is the wrong shape!");
145 
146  _input_limits = getInputLimits();
147  if (_input_limits.size() != _num_inputs || _input_limits[0].size() != 2)
148  mooseError("In ", _name, ": input_limits is the wrong shape!");
149 
150  _coefs = getCoefs();
151  if (_coefs.size() != _num_outputs)
152  mooseError("In ", _name, ": coefs is the wrong shape!");
153 
154  _num_coefs = _coefs[0].size();
155  _degree = std::pow(_num_coefs, 1.0 / _num_inputs);
156  if (!_degree || _degree > 4)
157  mooseError("In ", _name, ": degree must be 1, 2, 3 or 4.");
158 
159  _transformed_limits = getTransformedLimits();
160  _makeframe_helper = getMakeFrameHelper();
161 
162  Moose::out << "ROM model info:\n name:\t" << _name << "\n number of outputs:\t" << _num_outputs
163  << "\n number of inputs:\t" << _num_inputs
164  << "\n degree (max Legendre degree + constant):\t" << _degree
165  << "\n number of coefficients:\t" << _num_coefs << std::endl;
166 }

◆ initQpStatefulProperties()

template<ComputeStage compute_stage>
void ADLAROMANCEStressUpdateBase< compute_stage >::initQpStatefulProperties ( )
overrideprotectedvirtual

Reimplemented from ADRadialReturnCreepStressUpdateBase< compute_stage >.

Definition at line 170 of file ADLAROMANCEStressUpdateBase.C.

171 {
172  _mobile_dislocations[_qp] = _initial_mobile_dislocations;
173  _immobile_dislocations[_qp] = _initial_immobile_dislocations;
174 
175  ADRadialReturnCreepStressUpdateBase<compute_stage>::initQpStatefulProperties();
176 }

◆ internalSolve()

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

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

Parameters
effective_trial_stressEffective trial stress
scalarInelastic strain increment magnitude being solved for
iter_outputOutput stream – if null, no output is produced
Returns
Whether the solution was successful

Definition at line 162 of file ADSingleVariableReturnMappingSolution.C.

164 {
165  scalar = initialGuess(effective_trial_stress);
166  ADReal scalar_old = scalar;
167  ADReal scalar_increment = 0.0;
168  const ADReal min_permissible_scalar = minimumPermissibleValue(effective_trial_stress);
169  const ADReal max_permissible_scalar = maximumPermissibleValue(effective_trial_stress);
170  ADReal scalar_upper_bound = max_permissible_scalar;
171  ADReal scalar_lower_bound = min_permissible_scalar;
172  _iteration = 0;
173 
174  _initial_residual = _residual = computeResidual(effective_trial_stress, scalar);
175 
176  ADReal residual_old = _residual;
177  Real init_resid_sign = MathUtils::sign(MetaPhysicL::raw_value(_residual));
178  Real reference_residual = computeReferenceResidual(effective_trial_stress, scalar);
179 
180  if (converged(_residual, reference_residual))
181  {
182  iterationFinalize(scalar);
183  outputIterationStep(iter_output, effective_trial_stress, scalar, reference_residual);
184  return SolveState::SUCCESS;
185  }
186 
187  _residual_history.assign(_num_resids, std::numeric_limits<Real>::max());
188  _residual_history[0] = MetaPhysicL::raw_value(_residual);
189 
190  while (_iteration < _max_its && !converged(_residual, reference_residual) &&
191  !convergedAcceptable(_iteration, reference_residual))
192  {
193  scalar_increment = -_residual / computeDerivative(effective_trial_stress, scalar);
194  scalar = scalar_old + scalar_increment;
195 
196  if (_check_range)
197  checkPermissibleRange(scalar,
198  scalar_increment,
199  scalar_old,
200  min_permissible_scalar,
201  max_permissible_scalar,
202  iter_output);
203 
204  _residual = computeResidual(effective_trial_stress, scalar);
205  reference_residual = computeReferenceResidual(effective_trial_stress, scalar);
206  iterationFinalize(scalar);
207 
208  if (_bracket_solution)
209  updateBounds(
210  scalar, _residual, init_resid_sign, scalar_upper_bound, scalar_lower_bound, iter_output);
211 
212  if (converged(_residual, reference_residual))
213  {
214  outputIterationStep(iter_output, effective_trial_stress, scalar, reference_residual);
215  break;
216  }
217  else
218  {
219  bool modified_increment = false;
220 
221  // Line Search
222  if (_line_search)
223  {
224  if (residual_old - _residual != 0.0)
225  {
226  ADReal alpha = residual_old / (residual_old - _residual);
227  alpha = MathUtils::clamp(alpha, 1.0e-2, 1.0);
228 
229  if (alpha != 1.0)
230  {
231  modified_increment = true;
232  scalar_increment *= alpha;
233  if (iter_output)
234  *iter_output << " Line search alpha = " << MetaPhysicL::raw_value(alpha)
235  << " increment = " << MetaPhysicL::raw_value(scalar_increment)
236  << std::endl;
237  }
238  }
239  }
240 
241  if (_bracket_solution)
242  {
243  // Check to see whether trial scalar_increment is outside the bounds, and set it to a point
244  // within the bounds if it is
245  if (scalar_old + scalar_increment >= scalar_upper_bound ||
246  scalar_old + scalar_increment <= scalar_lower_bound)
247  {
248  if (scalar_upper_bound != max_permissible_scalar &&
249  scalar_lower_bound != min_permissible_scalar)
250  {
251  const Real frac = 0.5;
252  scalar_increment =
253  (1.0 - frac) * scalar_lower_bound + frac * scalar_upper_bound - scalar_old;
254  modified_increment = true;
255  if (iter_output)
256  *iter_output << " Trial scalar_increment exceeded bounds. Setting between "
257  "lower/upper bounds. frac: "
258  << frac << std::endl;
259  }
260  }
261  }
262 
263  // Update the trial scalar and recompute residual if the line search or bounds checking
264  // modified the increment
265  if (modified_increment)
266  {
267  scalar = scalar_old + scalar_increment;
268  _residual = computeResidual(effective_trial_stress, scalar);
269  reference_residual = computeReferenceResidual(effective_trial_stress, scalar);
270  iterationFinalize(scalar);
271 
272  if (_bracket_solution)
273  updateBounds(scalar,
274  _residual,
275  init_resid_sign,
276  scalar_upper_bound,
277  scalar_lower_bound,
278  iter_output);
279  }
280  }
281 
282  outputIterationStep(iter_output, effective_trial_stress, scalar, reference_residual);
283 
284  ++_iteration;
285  residual_old = _residual;
286  scalar_old = scalar;
287  _residual_history[_iteration % _num_resids] = MetaPhysicL::raw_value(_residual);
288  }
289 
290  if (std::isnan(_residual) || std::isinf(MetaPhysicL::raw_value(_residual)))
291  return SolveState::NAN_INF;
292 
293  if (_iteration == _max_its)
294  return SolveState::EXCEEDED_ITERATIONS;
295 
296  return SolveState::SUCCESS;
297 }

◆ iterationFinalize()

template<ComputeStage compute_stage>
virtual void ADSingleVariableReturnMappingSolution< compute_stage >::iterationFinalize ( ADReal  )
inlineprotectedvirtualinherited

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

Parameters
scalarInelastic strain increment magnitude being solved for

Reimplemented in ADIsotropicPlasticityStressUpdate< compute_stage >.

Definition at line 114 of file ADSingleVariableReturnMappingSolution.h.

114 {}

◆ maximumPermissibleValue()

template<ComputeStage compute_stage>
ADReal ADRadialReturnStressUpdate< compute_stage >::maximumPermissibleValue ( const ADReal &  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_stressEffective trial stress

Reimplemented from ADSingleVariableReturnMappingSolution< compute_stage >.

Definition at line 133 of file ADRadialReturnStressUpdate.C.

135 {
136  return effective_trial_stress / _three_shear_modulus;
137 }

◆ minimumPermissibleValue()

template<ComputeStage compute_stage>
virtual ADReal ADRadialReturnStressUpdate< compute_stage >::minimumPermissibleValue ( const ADReal &  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_stressEffective trial stress

Reimplemented from ADSingleVariableReturnMappingSolution< compute_stage >.

Definition at line 73 of file ADRadialReturnStressUpdate.h.

74  {
75  return 0.0;
76  }

◆ outputIterationStep()

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

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

Parameters
iter_outputOutput stream
itCurrent iteration count
effective_trial_stressEffective trial stress
scalarInelastic strain increment magnitude being solved for
residualCurrent value of the residual
referenceCurrent value of the reference quantity

Definition at line 393 of file ADSingleVariableReturnMappingSolution.C.

398 {
399  if (iter_output)
400  {
401  const unsigned int it = _iteration;
402  const Real residual = MetaPhysicL::raw_value(_residual);
403 
404  *iter_output << " iteration=" << it
405  << " trial_stress=" << MetaPhysicL::raw_value(effective_trial_stress)
406  << " scalar=" << MetaPhysicL::raw_value(scalar) << " residual=" << residual
407  << " ref_res=" << reference_residual
408  << " rel_res=" << std::abs(residual) / reference_residual
409  << " rel_tol=" << _relative_tolerance << " abs_res=" << std::abs(residual)
410  << " abs_tol=" << _absolute_tolerance << '\n';
411  }
412 }

◆ outputIterationSummary()

template<ComputeStage compute_stage>
void ADRadialReturnStressUpdate< compute_stage >::outputIterationSummary ( std::stringstream *  iter_output,
const unsigned int  total_it 
)
overrideprotectedvirtualinherited

Output summary information for the convergence history of the model.

Parameters
iter_outputOutput stream
total_itTotal iteration count

Reimplemented from ADSingleVariableReturnMappingSolution< compute_stage >.

Definition at line 153 of file ADRadialReturnStressUpdate.C.

155 {
156  if (iter_output)
157  {
158  *iter_output << "At element " << _current_elem->id() << " _qp=" << _qp << " Coordinates "
159  << _q_point[_qp] << " block=" << _current_elem->subdomain_id() << '\n';
160  }
161  ADSingleVariableReturnMappingSolution<compute_stage>::outputIterationSummary(iter_output,
162  total_it);
163 }

◆ propagateQpStatefulProperties()

template<ComputeStage compute_stage>
void ADRadialReturnCreepStressUpdateBase< compute_stage >::propagateQpStatefulProperties ( )
overrideprotectedvirtualinherited

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

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

Reimplemented from ADStressUpdateBase< compute_stage >.

Definition at line 44 of file ADRadialReturnCreepStressUpdateBase.C.

45 {
46  _creep_strain[_qp] = _creep_strain_old[_qp];
47 
48  propagateQpStatefulPropertiesRadialReturn();
49 }

◆ propagateQpStatefulPropertiesRadialReturn()

template<ComputeStage compute_stage>
void ADRadialReturnStressUpdate< compute_stage >::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 61 of file ADRadialReturnStressUpdate.C.

62 {
63  _effective_inelastic_strain[_qp] = _effective_inelastic_strain_old[_qp];
64 }

◆ requiresIsotropicTensor()

template<ComputeStage compute_stage>
bool ADRadialReturnStressUpdate< compute_stage >::requiresIsotropicTensor ( )
inlineoverridevirtualinherited

Does the model require the elasticity tensor to be isotropic?

Implements ADStressUpdateBase< compute_stage >.

Definition at line 89 of file ADRadialReturnStressUpdate.h.

89 { return true; }

◆ resetProperties()

template<ComputeStage compute_stage>
void ADStressUpdateBase< compute_stage >::resetProperties ( )
inlinefinalinherited

Definition at line 104 of file ADStressUpdateBase.h.

104 {}

◆ resetQpProperties()

template<ComputeStage compute_stage>
void ADStressUpdateBase< compute_stage >::resetQpProperties ( )
inlinefinalinherited

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

Definition at line 103 of file ADStressUpdateBase.h.

103 {}

◆ returnMappingSolve()

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

Perform the return mapping iterations.

Parameters
effective_trial_stressEffective trial stress
scalarInelastic strain increment magnitude being solved for
consoleConsole output

Definition at line 101 of file ADSingleVariableReturnMappingSolution.C.

103 {
104  // construct the stringstream here only if the debug level is set to ALL
105  std::unique_ptr<std::stringstream> iter_output =
106  (_internal_solve_output_on == InternalSolveOutput::ALWAYS)
107  ? libmesh_make_unique<std::stringstream>()
108  : nullptr;
109 
110  // do the internal solve and capture iteration info during the first round
111  // iff full history output is requested regardless of whether the solve failed or succeeded
112  auto solve_state =
113  internalSolve(effective_trial_stress,
114  scalar,
115  _internal_solve_full_iteration_history ? iter_output.get() : nullptr);
116  if (solve_state != SolveState::SUCCESS &&
117  _internal_solve_output_on != InternalSolveOutput::ALWAYS)
118  {
119  // output suppressed by user, throw immediately
120  if (_internal_solve_output_on == InternalSolveOutput::NEVER)
121  throw MooseException("");
122 
123  // user expects some kind of output, if necessary setup output stream now
124  if (!iter_output)
125  iter_output = libmesh_make_unique<std::stringstream>();
126 
127  // add the appropriate error message to the output
128  switch (solve_state)
129  {
130  case SolveState::NAN_INF:
131  *iter_output << "Encountered inf or nan in material return mapping iterations.\n";
132  break;
133 
134  case SolveState::EXCEEDED_ITERATIONS:
135  *iter_output << "Exceeded maximum iterations in material return mapping iterations.\n";
136  break;
137 
138  default:
139  mooseError("Unhandled solver state");
140  }
141 
142  // if full history output is only requested for failed solves we have to repeat
143  // the solve a second time
144  if (_internal_solve_full_iteration_history)
145  internalSolve(effective_trial_stress, scalar, iter_output.get());
146 
147  // Append summary and throw exception
148  outputIterationSummary(iter_output.get(), _iteration);
149  throw MooseException(iter_output->str());
150  }
151 
152  if (_internal_solve_output_on == InternalSolveOutput::ALWAYS)
153  {
154  // the solve did not fail but the user requested debug output anyways
155  outputIterationSummary(iter_output.get(), _iteration);
156  console << iter_output->str();
157  }
158 }

◆ setQp()

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

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

Definition at line 47 of file ADStressUpdateBase.C.

48 {
49  _qp = qp;
50 }

◆ updateBounds()

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

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

Parameters
scalarCurrent value of the inelastic strain increment
residualCurrent value of the residual
init_resid_signSign of the initial value of the residual
scalar_upper_boundUpper bound value of scalar
scalar_lower_boundLower bound value of scalar
iter_outputOutput stream

Definition at line 365 of file ADSingleVariableReturnMappingSolution.C.

371 {
372  // Update upper/lower bounds as applicable
373  if (residual * init_resid_sign < 0.0 && scalar < scalar_upper_bound)
374  {
375  scalar_upper_bound = scalar;
376  if (scalar_upper_bound < scalar_lower_bound)
377  {
378  scalar_upper_bound = scalar_lower_bound;
379  scalar_lower_bound = 0.0;
380  if (iter_output)
381  *iter_output << " Corrected for scalar_upper_bound < scalar_lower_bound" << std::endl;
382  }
383  }
384  // Don't permit setting scalar_lower_bound > scalar_upper_bound (but do permit the reverse).
385  // This ensures that if we encounter multiple roots, we pick the lowest one.
386  else if (residual * init_resid_sign > 0.0 && scalar > scalar_lower_bound &&
387  scalar < scalar_upper_bound)
388  scalar_lower_bound = scalar;
389 }

◆ updateState()

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

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

Parameters
strain_incrementSum of elastic and inelastic strain increments
inelastic_strain_incrementInelastic strain increment calculated by this class
rotationincrement Not used by this class
stress_newNew trial stress from pure elastic calculation
stress_oldOld state of stress
elasticity_tensorRank 4 C_{ijkl}, must be isotropic
elastic_strain_oldOld state of total elastic strain

Implements ADStressUpdateBase< compute_stage >.

Definition at line 68 of file ADRadialReturnStressUpdate.C.

76 {
77  // compute the deviatoric trial stress and trial strain from the current intermediate
78  // configuration
79  ADRankTwoTensor deviatoric_trial_stress = stress_new.deviatoric();
80 
81  // compute the effective trial stress
82  ADReal dev_trial_stress_squared =
83  deviatoric_trial_stress.doubleContraction(deviatoric_trial_stress);
84  ADReal effective_trial_stress =
85  dev_trial_stress_squared == 0.0 ? 0.0 : std::sqrt(3.0 / 2.0 * dev_trial_stress_squared);
86 
87  // Set the value of 3 * shear modulus for use as a reference residual value
88  _three_shear_modulus = 3.0 * ElasticityTensorTools::getIsotropicShearModulus(elasticity_tensor);
89 
90  computeStressInitialize(effective_trial_stress, elasticity_tensor);
91 
92  // Use Newton iteration to determine the scalar effective inelastic strain increment
93  ADReal scalar_effective_inelastic_strain = 0.0;
94  if (!MooseUtils::absoluteFuzzyEqual(effective_trial_stress, 0.0))
95  {
96  returnMappingSolve(effective_trial_stress, scalar_effective_inelastic_strain, _console);
97  if (scalar_effective_inelastic_strain != 0.0)
98  inelastic_strain_increment =
99  deviatoric_trial_stress *
100  (1.5 * scalar_effective_inelastic_strain / effective_trial_stress);
101  else
102  inelastic_strain_increment.zero();
103  }
104  else
105  inelastic_strain_increment.zero();
106 
107  if (_apply_strain)
108  {
109  strain_increment -= inelastic_strain_increment;
110  _effective_inelastic_strain[_qp] =
111  _effective_inelastic_strain_old[_qp] + scalar_effective_inelastic_strain;
112 
113  // Use the old elastic strain here because we require tensors used by this class
114  // to be isotropic and this method natively allows for changing in time
115  // elasticity tensors
116  stress_new = elasticity_tensor * (elastic_strain_old + strain_increment);
117  }
118 
119  computeStressFinalize(inelastic_strain_increment);
120 }

◆ validParams()

template<ComputeStage compute_stage>
InputParameters ADLAROMANCEStressUpdateBase< compute_stage >::validParams ( )
static

Definition at line 19 of file ADLAROMANCEStressUpdateBase.C.

20 {
21  InputParameters params = ADRadialReturnCreepStressUpdateBase<compute_stage>::validParams();
22  params.addClassDescription(
23  "Calculates the effective creep strain based on the rates predicted by a material "
24  "specific Los Alamos Reduced Order Model derived from a Visco-Plastic Self Consistent "
25  "calculations.");
26 
27  params.addRequiredCoupledVar("temperature", "The coupled temperature (K)");
28  params.addCoupledVar("environmental_factor", 0.0, "Optional coupled environmental factor");
29  params.addRangeCheckedParam<Real>("input_window_limit",
30  1.0,
31  "input_window_limit>0.0",
32  "Multiplier for the input minium/maximum input window");
33  MooseEnum window_failure("ERROR WARN IGNORE", "WARN");
34  params.addParam<MooseEnum>("input_window_failure_action",
35  window_failure,
36  "What to do if ROM input is outside the window of applicability.");
37  params.addParam<bool>("extrapolate_to_zero_stress",
38  true,
39  "Flag to allow for extrapolation of input J2 stress to zero");
40 
41  params.addRangeCheckedParam<Real>("initial_mobile_dislocation_density",
42  0.0,
43  "initial_mobile_dislocation_density >= 0.0",
44  "Initial density of mobile (glissile) dislocations (1/m^2)");
45  params.addRangeCheckedParam<Real>(
46  "max_relative_mobile_dislocation_increment",
47  0.5,
48  "max_relative_mobile_dislocation_increment > 0.0",
49  "Maximum increment of density of mobile (glissile) dislocations.");
50  params.addParam<FunctionName>(
51  "mobile_dislocation_density_forcing_function",
52  "Optional forcing function for immobile dislocation. If provided, the immobile dislocation "
53  "density will be reset to the function value at the beginning of the timestep. Used for "
54  "testing purposes only.");
55  params.addRangeCheckedParam<Real>("initial_immobile_dislocation_density",
56  0.0,
57  "initial_immobile_dislocation_density >= 0.0",
58  "Immobile (locked) dislocation density initial value (1/m^2).");
59  params.addRangeCheckedParam<Real>(
60  "max_relative_immobile_dislocation_increment",
61  0.5,
62  "max_relative_immobile_dislocation_increment > 0.0",
63  "Maximum increment of immobile (locked) dislocation density initial value (1/m^2).");
64  params.addParam<FunctionName>(
65  "immobile_dislocation_density_forcing_function",
66  "Optional forcing function for immobile dislocation. If provided, the immobile dislocation "
67  "density will be reset to the function value at the beginning of the timestep. Used for "
68  "testing purposes only.");
69 
70  params.addParam<FunctionName>(
71  "old_creep_strain_forcing_function",
72  "Optional forcing function for the creep strain from the previous timestep. If provided, "
73  "the old creep strain will be reset to the function value at the beginning of the "
74  "timestep. Used for testing purposes only.");
75 
76  params.addParam<bool>("verbose", false, "Flag to add verbose output");
77 
78  params.addParamNamesToGroup(
79  "mobile_dislocation_density_forcing_function immobile_dislocation_density_forcing_function "
80  "old_creep_strain_forcing_function",
81  "Advanced");
82  return params;
83 }

Referenced by SS316HLAROMANCEStressUpdateTest< compute_stage >::validParams().

Member Data Documentation

◆ _absolute_tolerance

template<ComputeStage compute_stage>
Real ADSingleVariableReturnMappingSolution< compute_stage >::_absolute_tolerance
privateinherited

Absolute convergence tolerance.

Definition at line 181 of file ADSingleVariableReturnMappingSolution.h.

◆ _acceptable_multiplier

template<ComputeStage compute_stage>
Real ADSingleVariableReturnMappingSolution< compute_stage >::_acceptable_multiplier
privateinherited

Multiplier applied to relative and absolute tolerances for acceptable convergence.

Definition at line 184 of file ADSingleVariableReturnMappingSolution.h.

◆ _apply_strain

template<ComputeStage compute_stage>
const bool ADRadialReturnStressUpdate< compute_stage >::_apply_strain
protectedinherited

Definition at line 129 of file ADRadialReturnStressUpdate.h.

◆ _base_name

template<ComputeStage compute_stage>
const std::string ADStressUpdateBase< compute_stage >::_base_name
protectedinherited

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

Definition at line 109 of file ADStressUpdateBase.h.

◆ _bracket_solution

template<ComputeStage compute_stage>
bool ADSingleVariableReturnMappingSolution< compute_stage >::_bracket_solution
protectedinherited

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

Definition at line 131 of file ADSingleVariableReturnMappingSolution.h.

◆ _check_range

template<ComputeStage compute_stage>
bool ADSingleVariableReturnMappingSolution< compute_stage >::_check_range
protectedinherited

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

Definition at line 124 of file ADSingleVariableReturnMappingSolution.h.

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

◆ _coefs

template<ComputeStage compute_stage>
std::vector<std::vector<Real> > ADLAROMANCEStressUpdateBase< compute_stage >::_coefs
protected

Coefficients used with Legendre polynomials defined by the ROM data set.

Definition at line 296 of file ADLAROMANCEStressUpdateBase.h.

◆ _creep_strain_old

template<ComputeStage compute_stage>
const MaterialProperty<RankTwoTensor>& ADRadialReturnCreepStressUpdateBase< compute_stage >::_creep_strain_old
protectedinherited

Definition at line 44 of file ADRadialReturnCreepStressUpdateBase.h.

◆ _creep_strain_old_forcing_function

template<ComputeStage compute_stage>
const Function* const ADLAROMANCEStressUpdateBase< compute_stage >::_creep_strain_old_forcing_function
protected

Optional old creep strain forcing function.

Definition at line 272 of file ADLAROMANCEStressUpdateBase.h.

◆ _degree

template<ComputeStage compute_stage>
unsigned int ADLAROMANCEStressUpdateBase< compute_stage >::_degree
protected

Legendre polynomial degree for the ROM data set.

Definition at line 281 of file ADLAROMANCEStressUpdateBase.h.

◆ _derivative

template<ComputeStage compute_stage>
ADReal ADLAROMANCEStressUpdateBase< compute_stage >::_derivative
protected

Container for derivative of creep rate with respect to strain.

Definition at line 314 of file ADLAROMANCEStressUpdateBase.h.

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

◆ _effective_inelastic_strain_old

template<ComputeStage compute_stage>
const MaterialProperty<Real>& ADRadialReturnStressUpdate< compute_stage >::_effective_inelastic_strain_old
protectedinherited

Definition at line 127 of file ADRadialReturnStressUpdate.h.

◆ _environmental

template<ComputeStage compute_stage>
const ADVariableValue& ADLAROMANCEStressUpdateBase< compute_stage >::_environmental
protected

Optionally coupled environmental factor.

Definition at line 214 of file ADLAROMANCEStressUpdateBase.h.

◆ _extrapolate_stress

template<ComputeStage compute_stage>
const bool ADLAROMANCEStressUpdateBase< compute_stage >::_extrapolate_stress
protected

Flag to optinoally allow model extrapolation to zero stress.

Definition at line 223 of file ADLAROMANCEStressUpdateBase.h.

◆ _failed

template<ComputeStage compute_stage>
MaterialProperty<Real>& ADLAROMANCEStressUpdateBase< compute_stage >::_failed
protected

Material property to indicate if material point is outside of input limits.

Definition at line 311 of file ADLAROMANCEStressUpdateBase.h.

◆ _immobile_dislocation_increment

template<ComputeStage compute_stage>
ADReal ADLAROMANCEStressUpdateBase< compute_stage >::_immobile_dislocation_increment
protected

Container for immobile dislocation increment.

Definition at line 263 of file ADLAROMANCEStressUpdateBase.h.

◆ _immobile_dislocations_old

template<ComputeStage compute_stage>
const MaterialProperty<Real>& ADLAROMANCEStressUpdateBase< compute_stage >::_immobile_dislocations_old
protected

Definition at line 250 of file ADLAROMANCEStressUpdateBase.h.

◆ _immobile_function

template<ComputeStage compute_stage>
const Function* const ADLAROMANCEStressUpdateBase< compute_stage >::_immobile_function
protected

Optional immobile dislocation forcing function.

Definition at line 260 of file ADLAROMANCEStressUpdateBase.h.

◆ _immobile_old

template<ComputeStage compute_stage>
Real ADLAROMANCEStressUpdateBase< compute_stage >::_immobile_old
protected

Container for old immobile dislocation value.

Definition at line 266 of file ADLAROMANCEStressUpdateBase.h.

◆ _initial_immobile_dislocations

template<ComputeStage compute_stage>
const Real ADLAROMANCEStressUpdateBase< compute_stage >::_initial_immobile_dislocations
protected

Initial immobile dislocation value.

Definition at line 254 of file ADLAROMANCEStressUpdateBase.h.

◆ _initial_mobile_dislocations

template<ComputeStage compute_stage>
const Real ADLAROMANCEStressUpdateBase< compute_stage >::_initial_mobile_dislocations
protected

Initial mobile dislocation value.

Definition at line 234 of file ADLAROMANCEStressUpdateBase.h.

◆ _initial_residual

template<ComputeStage compute_stage>
ADReal ADSingleVariableReturnMappingSolution< compute_stage >::_initial_residual
privateinherited

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

Definition at line 196 of file ADSingleVariableReturnMappingSolution.h.

◆ _input_limits

template<ComputeStage compute_stage>
std::vector<std::vector<Real> > ADLAROMANCEStressUpdateBase< compute_stage >::_input_limits
protected

Input limits defined by the ROM data set.

Definition at line 293 of file ADLAROMANCEStressUpdateBase.h.

◆ _internal_solve_full_iteration_history

template<ComputeStage compute_stage>
const bool ADSingleVariableReturnMappingSolution< compute_stage >::_internal_solve_full_iteration_history
privateinherited

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

Definition at line 175 of file ADSingleVariableReturnMappingSolution.h.

◆ _internal_solve_output_on

template<ComputeStage compute_stage>
enum ADSingleVariableReturnMappingSolution::InternalSolveOutput ADSingleVariableReturnMappingSolution< compute_stage >::_internal_solve_output_on
privateinherited

◆ _iteration

template<ComputeStage compute_stage>
unsigned int ADSingleVariableReturnMappingSolution< compute_stage >::_iteration
privateinherited

iteration number

Definition at line 193 of file ADSingleVariableReturnMappingSolution.h.

◆ _line_search

template<ComputeStage compute_stage>
bool ADSingleVariableReturnMappingSolution< compute_stage >::_line_search
protectedinherited

Whether to use line searches to improve convergence.

Definition at line 127 of file ADSingleVariableReturnMappingSolution.h.

◆ _makeframe_helper

template<ComputeStage compute_stage>
std::vector<std::vector<unsigned int> > ADLAROMANCEStressUpdateBase< compute_stage >::_makeframe_helper
protected

Helper container defined by the ROM data set.

Definition at line 305 of file ADLAROMANCEStressUpdateBase.h.

◆ _max_immobile_increment

template<ComputeStage compute_stage>
const Real ADLAROMANCEStressUpdateBase< compute_stage >::_max_immobile_increment
protected

Maximum immobile dislocation increment.

Definition at line 257 of file ADLAROMANCEStressUpdateBase.h.

◆ _max_inelastic_increment

template<ComputeStage compute_stage>
Real ADRadialReturnStressUpdate< compute_stage >::_max_inelastic_increment
protectedinherited

Definition at line 128 of file ADRadialReturnStressUpdate.h.

◆ _max_its

template<ComputeStage compute_stage>
const unsigned int ADSingleVariableReturnMappingSolution< compute_stage >::_max_its
privateinherited

Maximum number of return mapping iterations.

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

Definition at line 172 of file ADSingleVariableReturnMappingSolution.h.

◆ _max_mobile_increment

template<ComputeStage compute_stage>
const Real ADLAROMANCEStressUpdateBase< compute_stage >::_max_mobile_increment
protected

Maximum mobile dislocation increment.

Definition at line 237 of file ADLAROMANCEStressUpdateBase.h.

◆ _mobile_dislocation_increment

template<ComputeStage compute_stage>
ADReal ADLAROMANCEStressUpdateBase< compute_stage >::_mobile_dislocation_increment
protected

Container for mobile dislocation increment.

Definition at line 243 of file ADLAROMANCEStressUpdateBase.h.

◆ _mobile_dislocations_old

template<ComputeStage compute_stage>
const MaterialProperty<Real>& ADLAROMANCEStressUpdateBase< compute_stage >::_mobile_dislocations_old
protected

Definition at line 230 of file ADLAROMANCEStressUpdateBase.h.

◆ _mobile_function

template<ComputeStage compute_stage>
const Function* const ADLAROMANCEStressUpdateBase< compute_stage >::_mobile_function
protected

Optional mobile dislocation forcing function.

Definition at line 240 of file ADLAROMANCEStressUpdateBase.h.

◆ _mobile_old

template<ComputeStage compute_stage>
Real ADLAROMANCEStressUpdateBase< compute_stage >::_mobile_old
protected

Container for old mobile dislocation value.

Definition at line 246 of file ADLAROMANCEStressUpdateBase.h.

◆ _num_coefs

template<ComputeStage compute_stage>
unsigned int ADLAROMANCEStressUpdateBase< compute_stage >::_num_coefs
protected

Total number of Legendre polynomial coefficients for the ROM data set.

Definition at line 284 of file ADLAROMANCEStressUpdateBase.h.

◆ _num_inputs

template<ComputeStage compute_stage>
unsigned int ADLAROMANCEStressUpdateBase< compute_stage >::_num_inputs
protected

Number of inputs for the ROM data set.

Definition at line 275 of file ADLAROMANCEStressUpdateBase.h.

◆ _num_outputs

template<ComputeStage compute_stage>
unsigned int ADLAROMANCEStressUpdateBase< compute_stage >::_num_outputs
protected

Number of inputs to the ROM data set.

Definition at line 278 of file ADLAROMANCEStressUpdateBase.h.

◆ _num_resids

template<ComputeStage compute_stage>
const std::size_t ADSingleVariableReturnMappingSolution< compute_stage >::_num_resids
privateinherited

Number of residuals to be stored in history.

Definition at line 187 of file ADSingleVariableReturnMappingSolution.h.

◆ _relative_tolerance

template<ComputeStage compute_stage>
Real ADSingleVariableReturnMappingSolution< compute_stage >::_relative_tolerance
privateinherited

Relative convergence tolerance.

Definition at line 178 of file ADSingleVariableReturnMappingSolution.h.

◆ _residual

template<ComputeStage compute_stage>
ADReal ADSingleVariableReturnMappingSolution< compute_stage >::_residual
privateinherited

Definition at line 197 of file ADSingleVariableReturnMappingSolution.h.

◆ _residual_history

template<ComputeStage compute_stage>
std::vector<Real> ADSingleVariableReturnMappingSolution< compute_stage >::_residual_history
privateinherited

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

Definition at line 190 of file ADSingleVariableReturnMappingSolution.h.

◆ _stress_index

template<ComputeStage compute_stage>
const unsigned int ADLAROMANCEStressUpdateBase< compute_stage >::_stress_index
protected

Index corresponding to the position for the stress in the input vector.

Definition at line 269 of file ADLAROMANCEStressUpdateBase.h.

◆ _svrms_name

template<ComputeStage compute_stage>
const std::string ADSingleVariableReturnMappingSolution< compute_stage >::_svrms_name
privateinherited

MOOSE input name of the object performing the solve.

Definition at line 201 of file ADSingleVariableReturnMappingSolution.h.

◆ _temperature

template<ComputeStage compute_stage>
const ADVariableValue& ADLAROMANCEStressUpdateBase< compute_stage >::_temperature
protected

Coupled temperature variable.

Definition at line 211 of file ADLAROMANCEStressUpdateBase.h.

◆ _three_shear_modulus

template<ComputeStage compute_stage>
ADReal ADRadialReturnStressUpdate< compute_stage >::_three_shear_modulus
protectedinherited

3 * shear modulus

Definition at line 124 of file ADRadialReturnStressUpdate.h.

◆ _transform

template<ComputeStage compute_stage>
std::vector<std::vector<ROMInputTransform> > ADLAROMANCEStressUpdateBase< compute_stage >::_transform
protected

Transform rules defined by the ROM data set.

Definition at line 287 of file ADLAROMANCEStressUpdateBase.h.

◆ _transform_coefs

template<ComputeStage compute_stage>
std::vector<std::vector<Real> > ADLAROMANCEStressUpdateBase< compute_stage >::_transform_coefs
protected

Transform coefficients defined by the ROM data set.

Definition at line 290 of file ADLAROMANCEStressUpdateBase.h.

◆ _transformed_limits

template<ComputeStage compute_stage>
std::vector<std::vector<std::vector<Real> > > ADLAROMANCEStressUpdateBase< compute_stage >::_transformed_limits
protected

Limits transformed from readabile input to ROM readable limits.

Definition at line 302 of file ADLAROMANCEStressUpdateBase.h.

◆ _use_env

template<ComputeStage compute_stage>
bool ADLAROMANCEStressUpdateBase< compute_stage >::_use_env
protected

Flag that checks if environmental factor is included in ROM data set.

Definition at line 299 of file ADLAROMANCEStressUpdateBase.h.

◆ _verbose

template<ComputeStage compute_stage>
const bool ADLAROMANCEStressUpdateBase< compute_stage >::_verbose
protected

Flag to output verbose infromation.

Definition at line 226 of file ADLAROMANCEStressUpdateBase.h.

◆ _window

template<ComputeStage compute_stage>
const Real ADLAROMANCEStressUpdateBase< compute_stage >::_window
protected

Window applied to input maximum and minimum values.

Definition at line 217 of file ADLAROMANCEStressUpdateBase.h.

◆ _window_failure

template<ComputeStage compute_stage>
enum ADLAROMANCEStressUpdateBase::WindowFailure ADLAROMANCEStressUpdateBase< compute_stage >::_window_failure
protected

◆ usingMaterialMembers

template<ComputeStage compute_stage>
ADStressUpdateBase< compute_stage >::usingMaterialMembers
protectedinherited

Definition at line 111 of file ADStressUpdateBase.h.

◆ usingRadialReturnCreepStressUpdateBaseMembers

template<ComputeStage compute_stage>
ADLAROMANCEStressUpdateBase< compute_stage >::usingRadialReturnCreepStressUpdateBaseMembers
protected

Definition at line 316 of file ADLAROMANCEStressUpdateBase.h.

◆ usingRadialReturnStressUpdateMembers

template<ComputeStage compute_stage>
ADRadialReturnCreepStressUpdateBase< compute_stage >::usingRadialReturnStressUpdateMembers
protectedinherited

Definition at line 46 of file ADRadialReturnCreepStressUpdateBase.h.

◆ usingSingleVariableReturnMappingSolutionMembers

template<ComputeStage compute_stage>
ADRadialReturnStressUpdate< compute_stage >::usingSingleVariableReturnMappingSolutionMembers
protectedinherited

Definition at line 132 of file ADRadialReturnStressUpdate.h.

◆ usingStressUpdateBaseMembers

template<ComputeStage compute_stage>
ADRadialReturnStressUpdate< compute_stage >::usingStressUpdateBaseMembers
protectedinherited

Definition at line 131 of file ADRadialReturnStressUpdate.h.

The documentation for this class was generated from the following files:
ADLAROMANCEStressUpdateBase::computeROMStrainRate
void computeROMStrainRate(const Real dt, const Real &mobile_dislocations_old, const Real &immobile_dislocations_old, const ADReal &trial_stress, const Real &effective_strain_old, const ADReal &temperature, const ADReal &environmental, ADReal &mobile_dislocation_increment, ADReal &immobile_dislocation_increment, ADReal &rom_effective_strain, ADReal &rom_effective_strain_derivative)
Computes the ROM Strain rate.
Definition: ADLAROMANCEStressUpdateBase.C:301
ADLAROMANCEStressUpdateBase::_window
const Real _window
Window applied to input maximum and minimum values.
Definition: ADLAROMANCEStressUpdateBase.h:217
ADLAROMANCEStressUpdateBase::_immobile_dislocation_increment
ADReal _immobile_dislocation_increment
Container for immobile dislocation increment.
Definition: ADLAROMANCEStressUpdateBase.h:263
ADRadialReturnStressUpdate::_effective_inelastic_strain_old
const MaterialProperty< Real > & _effective_inelastic_strain_old
Definition: ADRadialReturnStressUpdate.h:127
ADSingleVariableReturnMappingSolution::initialGuess
virtual ADReal initialGuess(const ADReal &)
Compute an initial guess for the value of the scalar.
Definition: ADSingleVariableReturnMappingSolution.h:82
ADSingleVariableReturnMappingSolution::InternalSolveOutput::NEVER
ADLAROMANCEStressUpdateBase::checkInputWindows
void checkInputWindows(std::vector< ADReal > &input)
Function to check input values against applicability windows set by ROM data set.
Definition: ADLAROMANCEStressUpdateBase.C:360
ADLAROMANCEStressUpdateBase::_initial_mobile_dislocations
const Real _initial_mobile_dislocations
Initial mobile dislocation value.
Definition: ADLAROMANCEStressUpdateBase.h:234
ADLAROMANCEStressUpdateBase::WindowFailure::ERROR
ADRadialReturnCreepStressUpdateBase::validParams
static InputParameters validParams()
Definition: ADRadialReturnCreepStressUpdateBase.C:17
ADSingleVariableReturnMappingSolution::_internal_solve_full_iteration_history
const bool _internal_solve_full_iteration_history
Whether to output iteration information all the time (regardless of whether iterations converge)
Definition: ADSingleVariableReturnMappingSolution.h:175
ADLAROMANCEStressUpdateBase::_immobile_old
Real _immobile_old
Container for old immobile dislocation value.
Definition: ADLAROMANCEStressUpdateBase.h:266
ADSingleVariableReturnMappingSolution::returnMappingSolve
void returnMappingSolve(const ADReal &effective_trial_stress, ADReal &scalar, const ConsoleStream &console)
Perform the return mapping iterations.
Definition: ADSingleVariableReturnMappingSolution.C:101
ADLAROMANCEStressUpdateBase::_mobile_old
Real _mobile_old
Container for old mobile dislocation value.
Definition: ADLAROMANCEStressUpdateBase.h:246
ADRadialReturnStressUpdate::_apply_strain
const bool _apply_strain
Definition: ADRadialReturnStressUpdate.h:129
ADSingleVariableReturnMappingSolution::SolveState::EXCEEDED_ITERATIONS
ADRadialReturnStressUpdate::computeStressInitialize
virtual void computeStressInitialize(const ADReal &, const ADRankFourTensor &)
Perform any necessary initialization before return mapping iterations.
Definition: ADRadialReturnStressUpdate.h:109
ADLAROMANCEStressUpdateBase::_mobile_dislocation_increment
ADReal _mobile_dislocation_increment
Container for mobile dislocation increment.
Definition: ADLAROMANCEStressUpdateBase.h:243
ADSingleVariableReturnMappingSolution::SolveState::NAN_INF
pow
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)
Definition: ExpressionBuilder.h:673
ADSingleVariableReturnMappingSolution::_bracket_solution
bool _bracket_solution
Whether to save upper and lower bounds of root for scalar, and set solution to the midpoint between t...
Definition: ADSingleVariableReturnMappingSolution.h:131
ADLAROMANCEStressUpdateBase::_environmental
const ADVariableValue & _environmental
Optionally coupled environmental factor.
Definition: ADLAROMANCEStressUpdateBase.h:214
ROMInputTransform::EXP
ADSingleVariableReturnMappingSolution::outputIterationStep
virtual void outputIterationStep(std::stringstream *iter_output, const ADReal &effective_trial_stress, const ADReal &scalar, const Real reference_residual)
Output information for a single iteration step to build the convergence history of the model.
Definition: ADSingleVariableReturnMappingSolution.C:393
ADSingleVariableReturnMappingSolution::_iteration
unsigned int _iteration
iteration number
Definition: ADSingleVariableReturnMappingSolution.h:193
ADLAROMANCEStressUpdateBase::_extrapolate_stress
const bool _extrapolate_stress
Flag to optinoally allow model extrapolation to zero stress.
Definition: ADLAROMANCEStressUpdateBase.h:223
ADSingleVariableReturnMappingSolution::_initial_residual
ADReal _initial_residual
Residual values, kept as members to retain solver state for summary outputting.
Definition: ADSingleVariableReturnMappingSolution.h:196
ADLAROMANCEStressUpdateBase::_temperature
const ADVariableValue & _temperature
Coupled temperature variable.
Definition: ADLAROMANCEStressUpdateBase.h:211
ADRadialReturnCreepStressUpdateBase::_creep_strain_old
const MaterialProperty< RankTwoTensor > & _creep_strain_old
Definition: ADRadialReturnCreepStressUpdateBase.h:44
ADSingleVariableReturnMappingSolution::convergedAcceptable
bool convergedAcceptable(const unsigned int it, const Real reference)
Check to see whether the residual is within acceptable convergence limits.
Definition: ADSingleVariableReturnMappingSolution.C:311
ADLAROMANCEStressUpdateBase::WindowFailure
WindowFailure
Enum to error, warn, or ignore checks that ensure ROM input is within applicability window.
Definition: ADLAROMANCEStressUpdateBase.h:220
ADLAROMANCEStressUpdateBase::_transform_coefs
std::vector< std::vector< Real > > _transform_coefs
Transform coefficients defined by the ROM data set.
Definition: ADLAROMANCEStressUpdateBase.h:290
ADSingleVariableReturnMappingSolution::_residual_history
std::vector< Real > _residual_history
History of residuals used to check whether progress is still being made on decreasing the residual.
Definition: ADSingleVariableReturnMappingSolution.h:190
ADLAROMANCEStressUpdateBase::_max_immobile_increment
const Real _max_immobile_increment
Maximum immobile dislocation increment.
Definition: ADLAROMANCEStressUpdateBase.h:257
ADSingleVariableReturnMappingSolution::maximumPermissibleValue
virtual ADReal maximumPermissibleValue(const ADReal &effective_trial_stress) const
Compute the maximum permissible value of the scalar.
Definition: ADSingleVariableReturnMappingSolution.C:93
ADLAROMANCEStressUpdateBase::getInputLimits
virtual std::vector< std::vector< Real > > getInputLimits()=0
ADSingleVariableReturnMappingSolution::_relative_tolerance
Real _relative_tolerance
Relative convergence tolerance.
Definition: ADSingleVariableReturnMappingSolution.h:178
ADLAROMANCEStressUpdateBase::convertOutput
void convertOutput(const Real dt, const std::vector< ADReal > &old_input_values, const std::vector< ADReal > &rom_outputs, const std::vector< ADReal > &drom_outputs, std::vector< ADReal > &input_value_increments, std::vector< ADReal > &dinput_value_increments)
Computes the output variable increments from the ROM predictions by bringing out of the normalized ma...
Definition: ADLAROMANCEStressUpdateBase.C:510
ADLAROMANCEStressUpdateBase::_window_failure
enum ADLAROMANCEStressUpdateBase::WindowFailure _window_failure
ADLAROMANCEStressUpdateBase::_mobile_dislocations_old
const MaterialProperty< Real > & _mobile_dislocations_old
Definition: ADLAROMANCEStressUpdateBase.h:230
ADLAROMANCEStressUpdateBase::_max_mobile_increment
const Real _max_mobile_increment
Maximum mobile dislocation increment.
Definition: ADLAROMANCEStressUpdateBase.h:237
ADLAROMANCEStressUpdateBase::_mobile_function
const Function *const _mobile_function
Optional mobile dislocation forcing function.
Definition: ADLAROMANCEStressUpdateBase.h:240
ADSingleVariableReturnMappingSolution::_internal_solve_output_on
enum ADSingleVariableReturnMappingSolution::InternalSolveOutput _internal_solve_output_on
ADRadialReturnStressUpdate::propagateQpStatefulPropertiesRadialReturn
void propagateQpStatefulPropertiesRadialReturn()
Propagate the properties pertaining to this intermediate class.
Definition: ADRadialReturnStressUpdate.C:61
ADLAROMANCEStressUpdateBase::_derivative
ADReal _derivative
Container for derivative of creep rate with respect to strain.
Definition: ADLAROMANCEStressUpdateBase.h:314
ADLAROMANCEStressUpdateBase::getTransform
virtual std::vector< std::vector< ROMInputTransform > > getTransform()=0
ADLAROMANCEStressUpdateBase::_use_env
bool _use_env
Flag that checks if environmental factor is included in ROM data set.
Definition: ADLAROMANCEStressUpdateBase.h:299
ADLAROMANCEStressUpdateBase::_immobile_dislocations_old
const MaterialProperty< Real > & _immobile_dislocations_old
Definition: ADLAROMANCEStressUpdateBase.h:250
ADSingleVariableReturnMappingSolution::_residual
ADReal _residual
Definition: ADSingleVariableReturnMappingSolution.h:197
ADLAROMANCEStressUpdateBase::WindowFailure::WARN
ADLAROMANCEStressUpdateBase::_transform
std::vector< std::vector< ROMInputTransform > > _transform
Transform rules defined by the ROM data set.
Definition: ADLAROMANCEStressUpdateBase.h:287
ADSingleVariableReturnMappingSolution::_acceptable_multiplier
Real _acceptable_multiplier
Multiplier applied to relative and absolute tolerances for acceptable convergence.
Definition: ADSingleVariableReturnMappingSolution.h:184
ADLAROMANCEStressUpdateBase::_creep_strain_old_forcing_function
const Function *const _creep_strain_old_forcing_function
Optional old creep strain forcing function.
Definition: ADLAROMANCEStressUpdateBase.h:272
ADLAROMANCEStressUpdateBase::_degree
unsigned int _degree
Legendre polynomial degree for the ROM data set.
Definition: ADLAROMANCEStressUpdateBase.h:281
ADSingleVariableReturnMappingSolution::converged
bool converged(const ADReal &residual, const Real reference)
Check to see whether the residual is within the convergence limits.
Definition: ADSingleVariableReturnMappingSolution.C:301
ADSingleVariableReturnMappingSolution::updateBounds
void updateBounds(const ADReal &scalar, const ADReal &residual, const Real init_resid_sign, ADReal &scalar_upper_bound, ADReal &scalar_lower_bound, std::stringstream *iter_output)
Update the upper and lower bounds of the root for the effective inelastic strain.
Definition: ADSingleVariableReturnMappingSolution.C:365
ADLAROMANCEStressUpdateBase::computeValues
void computeValues(const std::vector< std::vector< Real >> &coefs, const std::vector< std::vector< std::vector< ADReal >>> &polynomial_inputs, const std::vector< std::vector< std::vector< ADReal >>> &dpolynomial_inputs, std::vector< ADReal > &rom_outputs, std::vector< ADReal > &drom_outputs)
Arranges the calculated Legendre polynomials into the order expected by the ROM coefficients and ulti...
Definition: ADLAROMANCEStressUpdateBase.C:481
ADSingleVariableReturnMappingSolution::InternalSolveOutput::ALWAYS
ADLAROMANCEStressUpdateBase::getMakeFrameHelper
std::vector< std::vector< unsigned int > > getMakeFrameHelper() const
Definition: ADLAROMANCEStressUpdateBase.C:593
ADLAROMANCEStressUpdateBase::buildPolynomials
void buildPolynomials(const std::vector< std::vector< ADReal >> &rom_inputs, const std::vector< std::vector< ADReal >> &drom_inputs, std::vector< std::vector< std::vector< ADReal >>> &polynomial_inputs, std::vector< std::vector< std::vector< ADReal >>> &dpolynomial_inputs)
Assemble the array of Legendre polynomials to be multiplied by the ROM coefficients.
Definition: ADLAROMANCEStressUpdateBase.C:451
ADLAROMANCEStressUpdateBase::_input_limits
std::vector< std::vector< Real > > _input_limits
Input limits defined by the ROM data set.
Definition: ADLAROMANCEStressUpdateBase.h:293
ROMInputTransform::LOG
ADSingleVariableReturnMappingSolution::_max_its
const unsigned int _max_its
Maximum number of return mapping iterations.
Definition: ADSingleVariableReturnMappingSolution.h:172
ADRadialReturnCreepStressUpdateBase
This class provides baseline functionallity for creep models based on the stress update material in a...
Definition: ADRadialReturnCreepStressUpdateBase.h:21
ADLAROMANCEStressUpdateBase::getTransformCoefs
virtual std::vector< std::vector< Real > > getTransformCoefs()=0
ADLAROMANCEStressUpdateBase::_makeframe_helper
std::vector< std::vector< unsigned int > > _makeframe_helper
Helper container defined by the ROM data set.
Definition: ADLAROMANCEStressUpdateBase.h:305
ADLAROMANCEStressUpdateBase::getCoefs
virtual std::vector< std::vector< Real > > getCoefs()=0
ADLAROMANCEStressUpdateBase::computePolynomial
ADReal computePolynomial(const ADReal &value, const unsigned int degree, const bool derivative=false)
Calculate the value or derivative of Legendre polynomial up to 3rd order.
Definition: ADLAROMANCEStressUpdateBase.C:535
ADLAROMANCEStressUpdateBase::getTransformedLimits
std::vector< std::vector< std::vector< Real > > > getTransformedLimits() const
Definition: ADLAROMANCEStressUpdateBase.C:567
ADLAROMANCEStressUpdateBase::_stress_index
const unsigned int _stress_index
Index corresponding to the position for the stress in the input vector.
Definition: ADLAROMANCEStressUpdateBase.h:269
ADSingleVariableReturnMappingSolution::checkPermissibleRange
void checkPermissibleRange(ADReal &scalar, ADReal &scalar_increment, const ADReal &scalar_old, const ADReal min_permissible_scalar, const ADReal max_permissible_scalar, std::stringstream *iter_output)
Check to see whether solution is within admissible range, and set it within that range if it is not.
Definition: ADSingleVariableReturnMappingSolution.C:334
ADSingleVariableReturnMappingSolution::iterationFinalize
virtual void iterationFinalize(ADReal)
Finalize internal state variables for a model for a given iteration.
Definition: ADSingleVariableReturnMappingSolution.h:114
ADLAROMANCEStressUpdateBase::_coefs
std::vector< std::vector< Real > > _coefs
Coefficients used with Legendre polynomials defined by the ROM data set.
Definition: ADLAROMANCEStressUpdateBase.h:296
ADSingleVariableReturnMappingSolution::minimumPermissibleValue
virtual ADReal minimumPermissibleValue(const ADReal &effective_trial_stress) const
Compute the minimum permissible value of the scalar.
Definition: ADSingleVariableReturnMappingSolution.C:85
ADRadialReturnStressUpdate::_three_shear_modulus
ADReal _three_shear_modulus
3 * shear modulus
Definition: ADRadialReturnStressUpdate.h:124
ADSingleVariableReturnMappingSolution::_check_range
bool _check_range
Whether to check to see whether iterative solution is within admissible range, and set within that ra...
Definition: ADSingleVariableReturnMappingSolution.h:124
ElasticityTensorTools::getIsotropicShearModulus
T getIsotropicShearModulus(const RankFourTensorTempl< T > &elasticity_tensor)
Get the shear modulus for an isotropic elasticity tensor param elasticity_tensor the tensor (must be ...
Definition: ElasticityTensorTools.h:71
ADRadialReturnStressUpdate::computeStressFinalize
virtual void computeStressFinalize(const ADRankTwoTensor &)
Perform any necessary steps to finalize state after return mapping iterations.
Definition: ADRadialReturnStressUpdate.h:118
ADRadialReturnCreepStressUpdateBase::computeStressFinalize
virtual void computeStressFinalize(const ADRankTwoTensor &plastic_strain_increment) override
Perform any necessary steps to finalize state after return mapping iterations.
Definition: ADRadialReturnCreepStressUpdateBase.C:53
NS::temperature
const std::string temperature
Definition: NS.h:26
ADLAROMANCEStressUpdateBase::_immobile_function
const Function *const _immobile_function
Optional immobile dislocation forcing function.
Definition: ADLAROMANCEStressUpdateBase.h:260
ADSingleVariableReturnMappingSolution::_num_resids
const std::size_t _num_resids
Number of residuals to be stored in history.
Definition: ADSingleVariableReturnMappingSolution.h:187
ADLAROMANCEStressUpdateBase::_num_outputs
unsigned int _num_outputs
Number of inputs to the ROM data set.
Definition: ADLAROMANCEStressUpdateBase.h:278
ADLAROMANCEStressUpdateBase::_num_coefs
unsigned int _num_coefs
Total number of Legendre polynomial coefficients for the ROM data set.
Definition: ADLAROMANCEStressUpdateBase.h:284
ADSingleVariableReturnMappingSolution::SolveState::SUCCESS
ADStressUpdateBase::_base_name
const std::string _base_name
Name used as a prefix for all material properties related to the stress update model.
Definition: ADStressUpdateBase.h:109
ADRadialReturnCreepStressUpdateBase::initQpStatefulProperties
virtual void initQpStatefulProperties() override
Definition: ADRadialReturnCreepStressUpdateBase.C:35
ADRadialReturnStressUpdate::computeTimeStepLimit
virtual Real computeTimeStepLimit() override
Compute the limiting value of the time step for this material.
Definition: ADRadialReturnStressUpdate.C:141
ADSingleVariableReturnMappingSolution::_absolute_tolerance
Real _absolute_tolerance
Absolute convergence tolerance.
Definition: ADSingleVariableReturnMappingSolution.h:181
ADLAROMANCEStressUpdateBase::convertInput
void convertInput(const std::vector< ADReal > &input, std::vector< std::vector< ADReal >> &converted, std::vector< std::vector< ADReal >> &dconverted)
Convert the input variables into the form expected by the ROM Legendre polynomials to have a normaliz...
Definition: ADLAROMANCEStressUpdateBase.C:416
ADLAROMANCEStressUpdateBase::_transformed_limits
std::vector< std::vector< std::vector< Real > > > _transformed_limits
Limits transformed from readabile input to ROM readable limits.
Definition: ADLAROMANCEStressUpdateBase.h:302
ADLAROMANCEStressUpdateBase::_failed
MaterialProperty< Real > & _failed
Material property to indicate if material point is outside of input limits.
Definition: ADLAROMANCEStressUpdateBase.h:311
ADSingleVariableReturnMappingSolution::_line_search
bool _line_search
Whether to use line searches to improve convergence.
Definition: ADSingleVariableReturnMappingSolution.h:127
ADLAROMANCEStressUpdateBase::_verbose
const bool _verbose
Flag to output verbose infromation.
Definition: ADLAROMANCEStressUpdateBase.h:226
ADSingleVariableReturnMappingSolution::computeResidual
virtual ADReal computeResidual(const ADReal &effective_trial_stress, const ADReal &scalar)=0
Compute the residual for a predicted value of the scalar.
ADSingleVariableReturnMappingSolution::outputIterationSummary
virtual void outputIterationSummary(std::stringstream *iter_output, const unsigned int total_it)
Output summary information for the convergence history of the model.
Definition: ADSingleVariableReturnMappingSolution.C:416
ADLAROMANCEStressUpdateBase::_num_inputs
unsigned int _num_inputs
Number of inputs for the ROM data set.
Definition: ADLAROMANCEStressUpdateBase.h:275
ADSingleVariableReturnMappingSolution::internalSolve
SolveState internalSolve(const ADReal effective_trial_stress, ADReal &scalar, std::stringstream *iter_output=nullptr)
Method called from within this class to perform the actual return mappping iterations.
Definition: ADSingleVariableReturnMappingSolution.C:162
ADLAROMANCEStressUpdateBase::_initial_immobile_dislocations
const Real _initial_immobile_dislocations
Initial immobile dislocation value.
Definition: ADLAROMANCEStressUpdateBase.h:254
ADSingleVariableReturnMappingSolution::computeDerivative
virtual ADReal computeDerivative(const ADReal &effective_trial_stress, const ADReal &scalar)=0
Compute the derivative of the residual as a function of the scalar variable.
ADSingleVariableReturnMappingSolution::computeReferenceResidual
virtual Real computeReferenceResidual(const ADReal &effective_trial_stress, const ADReal &scalar)=0
Compute a reference quantity to be used for checking relative convergence.
Generated on Sat Jan 25 2020 12:04:53 for www.mooseframework.org by   doxygen 1.8.16