https://mooseframework.inl.gov
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
GeneralizedReturnMappingSolutionTempl< is_ad > Class Template Referenceabstract

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

#include <GeneralizedReturnMappingSolution.h>

Inheritance diagram for GeneralizedReturnMappingSolutionTempl< is_ad >:
[legend]

Public Member Functions

 GeneralizedReturnMappingSolutionTempl (const InputParameters &parameters)
 
virtual ~GeneralizedReturnMappingSolutionTempl ()
 

Static Public Member Functions

static InputParameters validParams ()
 

Protected Member Functions

void returnMappingSolve (const GenericDenseVector< is_ad > &effective_trial_stress, const GenericDenseVector< is_ad > &stress_new, GenericReal< is_ad > &scalar, const ConsoleStream &console)
 Perform the return mapping iterations. More...
 
virtual GenericReal< is_ad > minimumPermissibleValue (const GenericDenseVector< is_ad > &effective_trial_stress) const
 Compute the minimum permissible value of the scalar. More...
 
virtual GenericReal< is_ad > maximumPermissibleValue (const GenericDenseVector< is_ad > &effective_trial_stress) const
 Compute the maximum permissible value of the scalar. More...
 
virtual GenericReal< is_ad > initialGuess (const GenericDenseVector< is_ad > &)
 Compute an initial guess for the value of the scalar. More...
 
virtual GenericReal< is_ad > computeResidual (const GenericDenseVector< is_ad > &effective_trial_stress, const GenericDenseVector< is_ad > &stress_new, const GenericReal< is_ad > &delta_gamma)=0
 Compute the residual for a predicted value of the scalar. More...
 
virtual Real computeReferenceResidual (const GenericDenseVector< is_ad > &effective_trial_stress, const GenericDenseVector< is_ad > &stress_new, const GenericReal< is_ad > &residual, const GenericReal< is_ad > &scalar_effective_inelastic_strain)=0
 Compute a reference quantity to be used for checking relative convergence. More...
 
virtual GenericReal< is_ad > computeDerivative (const GenericDenseVector< is_ad > &effective_trial_stress, const GenericDenseVector< is_ad > &stress_new, const GenericReal< is_ad > &scalar)=0
 
virtual void iterationFinalize (const GenericReal< is_ad > &)
 Finalize internal state variables for a model for a given iteration. More...
 
virtual void outputIterationSummary (std::stringstream *iter_output, const unsigned int total_it)
 Output summary information for the convergence history of the model. More...
 
virtual void outputIterationStep (std::stringstream *iter_output, const GenericDenseVector< is_ad > &effective_trial_stress, const GenericReal< is_ad > &scalar, const GenericReal< is_ad > reference_residual)
 Output information for a single iteration step to build the convergence history of the model. More...
 
bool converged (const GenericReal< is_ad > &residual, const Real &reference)
 Check to see whether the residual is within the convergence limits. More...
 

Protected Attributes

bool _check_range
 Whether to check to see whether iterative solution is within admissible range, and set within that range if outside. More...
 
bool _line_search
 Whether to use line searches to improve convergence. More...
 
bool _bracket_solution
 Whether to save upper and lower bounds of root for scalar, and set solution to the midpoint between those bounds if outside them. More...
 

Private Types

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

Private Member Functions

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

Private Attributes

enum GeneralizedReturnMappingSolutionTempl::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...
 
GenericReal< is_ad > _initial_residual
 Residual values, kept as members to retain solver state for summary outputting. More...
 
GenericReal< is_ad > _residual
 

Detailed Description

template<bool is_ad>
class GeneralizedReturnMappingSolutionTempl< is_ad >

Base class that provides capability for Newton generalized (anisotropic) return mapping iterations on a single variable.

Definition at line 22 of file GeneralizedReturnMappingSolution.h.

Member Enumeration Documentation

◆ InternalSolveOutput

template<bool is_ad>
enum GeneralizedReturnMappingSolutionTempl::InternalSolveOutput
strongprivate
Enumerator
NEVER 
ON_ERROR 
ALWAYS 

Definition at line 143 of file GeneralizedReturnMappingSolution.h.

144  {
145  NEVER,
146  ON_ERROR,
147  ALWAYS
enum GeneralizedReturnMappingSolutionTempl::InternalSolveOutput _internal_solve_output_on

◆ SolveState

template<bool is_ad>
enum GeneralizedReturnMappingSolutionTempl::SolveState
strongprivate
Enumerator
SUCCESS 
NAN_INF 
EXCEEDED_ITERATIONS 

Definition at line 150 of file GeneralizedReturnMappingSolution.h.

151  {
152  SUCCESS,
153  NAN_INF,
154  EXCEEDED_ITERATIONS
155  };

Constructor & Destructor Documentation

◆ GeneralizedReturnMappingSolutionTempl()

Definition at line 54 of file GeneralizedReturnMappingSolution.C.

56  : _check_range(false),
57  _line_search(true),
58  _bracket_solution(false),
60  parameters.get<MooseEnum>("internal_solve_output_on").getEnum<InternalSolveOutput>()),
61  _max_its(50),
63  parameters.get<bool>("internal_solve_full_iteration_history")),
64  _relative_tolerance(parameters.get<Real>("relative_tolerance")),
65  _absolute_tolerance(parameters.get<Real>("absolute_tolerance")),
66  _acceptable_multiplier(parameters.get<Real>("acceptable_multiplier")),
67  _num_resids(30),
68  _residual_history(_num_resids, std::numeric_limits<Real>::max()),
69  _iteration(0),
70  _initial_residual(0.0),
71  _residual(0.0),
72  _svrms_name(parameters.get<std::string>("_object_name"))
73 {
74 }
Real _relative_tolerance
Relative convergence tolerance.
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
std::vector< Real > _residual_history
History of residuals used to check whether progress is still being made on decreasing the residual...
enum GeneralizedReturnMappingSolutionTempl::InternalSolveOutput _internal_solve_output_on
Real _absolute_tolerance
Absolute convergence tolerance.
T getEnum() const
GenericReal< is_ad > _initial_residual
Residual values, kept as members to retain solver state for summary outputting.
const std::string _svrms_name
MOOSE input name of the object performing the solve.
const bool _internal_solve_full_iteration_history
Whether to output iteration information all the time (regardless of whether iterations converge) ...
bool _check_range
Whether to check to see whether iterative solution is within admissible range, and set within that ra...
bool _bracket_solution
Whether to save upper and lower bounds of root for scalar, and set solution to the midpoint between t...
const std::size_t _num_resids
Number of residuals to be stored in history.
const unsigned int _max_its
Maximum number of return mapping iterations.
Real _acceptable_multiplier
Multiplier applied to relative and absolute tolerances for acceptable convergence.
bool _line_search
Whether to use line searches to improve convergence.

◆ ~GeneralizedReturnMappingSolutionTempl()

template<bool is_ad>
virtual GeneralizedReturnMappingSolutionTempl< is_ad >::~GeneralizedReturnMappingSolutionTempl ( )
inlinevirtual

Definition at line 28 of file GeneralizedReturnMappingSolution.h.

28 {}

Member Function Documentation

◆ checkPermissibleRange()

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

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

Parameters
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 319 of file GeneralizedReturnMappingSolution.C.

326 {
327  if (scalar > max_permissible_scalar)
328  {
329  scalar_increment = (max_permissible_scalar - scalar_old) / 2.0;
330  scalar = scalar_old + scalar_increment;
331  if (iter_output)
332  *iter_output << "Scalar greater than maximum ("
333  << MetaPhysicL::raw_value(max_permissible_scalar)
334  << ") adjusted scalar=" << MetaPhysicL::raw_value(scalar)
335  << " scalar_increment=" << MetaPhysicL::raw_value(scalar_increment) << std::endl;
336  }
337  else if (scalar < min_permissible_scalar)
338  {
339  scalar_increment = (min_permissible_scalar - scalar_old) / 2.0;
340  scalar = scalar_old + scalar_increment;
341  if (iter_output)
342  *iter_output << "Scalar less than minimum (" << MetaPhysicL::raw_value(min_permissible_scalar)
343  << ") adjusted scalar=" << MetaPhysicL::raw_value(scalar)
344  << " scalar_increment=" << MetaPhysicL::raw_value(scalar_increment) << std::endl;
345  }
346 }
auto raw_value(const Eigen::Map< T > &in)

◆ computeDerivative()

template<bool is_ad>
virtual GenericReal<is_ad> GeneralizedReturnMappingSolutionTempl< is_ad >::computeDerivative ( const GenericDenseVector< is_ad > &  effective_trial_stress,
const GenericDenseVector< is_ad > &  stress_new,
const GenericReal< is_ad > &  scalar 
)
protectedpure virtual

◆ computeReferenceResidual()

template<bool is_ad>
virtual Real GeneralizedReturnMappingSolutionTempl< is_ad >::computeReferenceResidual ( const GenericDenseVector< is_ad > &  effective_trial_stress,
const GenericDenseVector< is_ad > &  stress_new,
const GenericReal< is_ad > &  residual,
const GenericReal< is_ad > &  scalar_effective_inelastic_strain 
)
protectedpure virtual

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

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

Parameters
effective_trial_stressEffective trial stress
scalarInelastic strain increment magnitude being solved for

Implemented in GeneralizedRadialReturnStressUpdateTempl< is_ad >.

◆ computeResidual()

template<bool is_ad>
virtual GenericReal<is_ad> GeneralizedReturnMappingSolutionTempl< is_ad >::computeResidual ( const GenericDenseVector< is_ad > &  effective_trial_stress,
const GenericDenseVector< is_ad > &  stress_new,
const GenericReal< is_ad > &  delta_gamma 
)
protectedpure virtual

Compute the residual for a predicted value of the scalar.

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

Parameters
effective_trial_stressEffective trial stress
scalarInelastic strain increment magnitude being solved for

◆ converged()

template<bool is_ad>
bool GeneralizedReturnMappingSolutionTempl< is_ad >::converged ( const GenericReal< is_ad > &  residual,
const Real reference 
)
protected

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 286 of file GeneralizedReturnMappingSolution.C.

288 {
289  const Real residual = MetaPhysicL::raw_value(ad_residual);
290  return (std::abs(residual) <= _absolute_tolerance ||
291  std::abs(residual / reference) <= _relative_tolerance);
292 }
Real _relative_tolerance
Relative convergence tolerance.
auto raw_value(const Eigen::Map< T > &in)
Real _absolute_tolerance
Absolute convergence tolerance.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ convergedAcceptable()

template<bool is_ad>
bool GeneralizedReturnMappingSolutionTempl< is_ad >::convergedAcceptable ( const unsigned int  it,
const Real reference 
)
private

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

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

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

Definition at line 296 of file GeneralizedReturnMappingSolution.C.

298 {
299  // Require that we have at least done _num_resids evaluations before we allow for
300  // acceptable convergence
301  if (it < _num_resids)
302  return false;
303 
304  // Check to see whether the residual has dropped by convergence_history_factor over
305  // the last _num_resids iterations. If it has (which means it's still making progress),
306  // don't consider it to be converged within the acceptable limits.
307  const Real convergence_history_factor = 10.0;
308  if (std::abs(_residual * convergence_history_factor) <
309  std::abs(_residual_history[(it + 1) % _num_resids]))
310  return false;
311 
312  // Now that it's determined that progress is not being made, treat it as converged if
313  // we're within the acceptable convergence limits
314  return converged(_residual / _acceptable_multiplier, reference);
315 }
std::vector< Real > _residual_history
History of residuals used to check whether progress is still being made on decreasing the residual...
bool converged(const GenericReal< is_ad > &residual, const Real &reference)
Check to see whether the residual is within the convergence limits.
const std::size_t _num_resids
Number of residuals to be stored in history.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Real _acceptable_multiplier
Multiplier applied to relative and absolute tolerances for acceptable convergence.

◆ initialGuess()

template<bool is_ad>
virtual GenericReal<is_ad> GeneralizedReturnMappingSolutionTempl< is_ad >::initialGuess ( const GenericDenseVector< is_ad > &  )
inlineprotectedvirtual

Compute an initial guess for the value of the scalar.

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

Parameters
effective_trial_stressEffective trial stress

Definition at line 65 of file GeneralizedReturnMappingSolution.h.

66  {
67  return 0.0;
68  }

◆ internalSolve()

template<bool is_ad>
GeneralizedReturnMappingSolutionTempl< is_ad >::SolveState GeneralizedReturnMappingSolutionTempl< is_ad >::internalSolve ( const GenericDenseVector< is_ad > &  effective_trial_stress,
const GenericDenseVector< is_ad > &  stress_new,
GenericReal< is_ad > &  scalar,
std::stringstream *  iter_output = nullptr 
)
private

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

Parameters
effective_trial_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 159 of file GeneralizedReturnMappingSolution.C.

164 {
165  delta_gamma = initialGuess(stress_dev);
166  GenericReal<is_ad> scalar_old = delta_gamma;
167  GenericReal<is_ad> scalar_increment = 0.0;
168  const GenericReal<is_ad> min_permissible_scalar = minimumPermissibleValue(stress_dev);
169  const GenericReal<is_ad> max_permissible_scalar = maximumPermissibleValue(stress_dev);
170  GenericReal<is_ad> scalar_upper_bound = max_permissible_scalar;
171  GenericReal<is_ad> scalar_lower_bound = min_permissible_scalar;
172  _iteration = 0;
173 
174  _initial_residual = _residual = computeResidual(stress_dev, stress_new, delta_gamma);
175 
177  Real reference_residual =
178  computeReferenceResidual(stress_dev, stress_new, _residual, delta_gamma);
179 
180  if (converged(_residual, reference_residual))
181  {
182  iterationFinalize(delta_gamma);
183  outputIterationStep(iter_output, stress_dev, delta_gamma, reference_residual);
184  return SolveState::SUCCESS;
185  }
186 
187  _residual_history.assign(_num_resids, std::numeric_limits<Real>::max());
189 
190  while (_iteration < _max_its && !converged(_residual, reference_residual) &&
191  !convergedAcceptable(_iteration, reference_residual))
192  {
193  scalar_increment = -_residual / computeDerivative(stress_dev, stress_new, delta_gamma);
194  delta_gamma = scalar_old + scalar_increment;
195 
196  if (_check_range)
197  checkPermissibleRange(delta_gamma,
198  scalar_increment,
199  scalar_old,
200  min_permissible_scalar,
201  max_permissible_scalar,
202  iter_output);
203 
204  _residual = computeResidual(stress_dev, stress_new, delta_gamma);
205 
206  reference_residual = computeReferenceResidual(stress_dev, stress_new, _residual, delta_gamma);
207  iterationFinalize(delta_gamma);
208 
209  if (_bracket_solution)
210  updateBounds(delta_gamma,
211  _residual,
212  init_resid_sign,
213  scalar_upper_bound,
214  scalar_lower_bound,
215  iter_output);
216 
217  if (converged(_residual, reference_residual))
218  {
219  outputIterationStep(iter_output, stress_dev, delta_gamma, reference_residual);
220  break;
221  }
222  else
223  {
224  bool modified_increment = false;
225 
226  if (_bracket_solution)
227  {
228  // Check to see whether trial scalar_increment is outside the bounds, and set it to a point
229  // within the bounds if it is
230  if (scalar_old + scalar_increment >= scalar_upper_bound ||
231  scalar_old + scalar_increment <= scalar_lower_bound)
232  {
233  if (scalar_upper_bound != max_permissible_scalar &&
234  scalar_lower_bound != min_permissible_scalar)
235  {
236  const Real frac = 0.5;
237  scalar_increment =
238  (1.0 - frac) * scalar_lower_bound + frac * scalar_upper_bound - scalar_old;
239  modified_increment = true;
240  if (iter_output)
241  *iter_output << " Trial scalar_increment exceeded bounds. Setting between "
242  "lower/upper bounds. frac: "
243  << frac << std::endl;
244  }
245  }
246  }
247 
248  // Update the trial scalar and recompute residual if the line search or bounds checking
249  // modified the increment
250  if (modified_increment)
251  {
252  delta_gamma = scalar_old + scalar_increment;
253  _residual = computeResidual(stress_dev, stress_new, delta_gamma);
254  reference_residual =
255  computeReferenceResidual(stress_dev, stress_new, _residual, delta_gamma);
256  iterationFinalize(delta_gamma);
257 
258  if (_bracket_solution)
259  updateBounds(delta_gamma,
260  _residual,
261  init_resid_sign,
262  scalar_upper_bound,
263  scalar_lower_bound,
264  iter_output);
265  }
266  }
267 
268  outputIterationStep(iter_output, stress_dev, delta_gamma, reference_residual);
269 
270  ++_iteration;
271  scalar_old = delta_gamma;
273  }
274 
275  if (std::isnan(_residual) || std::isinf(MetaPhysicL::raw_value(_residual)))
276  return SolveState::NAN_INF;
277 
278  if (_iteration == _max_its)
280 
281  return SolveState::SUCCESS;
282 }
Moose::GenericType< Real, is_ad > GenericReal
std::vector< Real > _residual_history
History of residuals used to check whether progress is still being made on decreasing the residual...
virtual void iterationFinalize(const GenericReal< is_ad > &)
Finalize internal state variables for a model for a given iteration.
virtual GenericReal< is_ad > initialGuess(const GenericDenseVector< is_ad > &)
Compute an initial guess for the value of the scalar.
auto raw_value(const Eigen::Map< T > &in)
void updateBounds(const GenericReal< is_ad > &scalar, const GenericReal< is_ad > &residual, const Real init_resid_sign, GenericReal< is_ad > &scalar_upper_bound, GenericReal< is_ad > &scalar_lower_bound, std::stringstream *iter_output)
Update the upper and lower bounds of the root for the effective inelastic strain. ...
virtual Real computeReferenceResidual(const GenericDenseVector< is_ad > &effective_trial_stress, const GenericDenseVector< is_ad > &stress_new, const GenericReal< is_ad > &residual, const GenericReal< is_ad > &scalar_effective_inelastic_strain)=0
Compute a reference quantity to be used for checking relative convergence.
GenericReal< is_ad > _initial_residual
Residual values, kept as members to retain solver state for summary outputting.
bool converged(const GenericReal< is_ad > &residual, const Real &reference)
Check to see whether the residual is within the convergence limits.
virtual void outputIterationStep(std::stringstream *iter_output, const GenericDenseVector< is_ad > &effective_trial_stress, const GenericReal< is_ad > &scalar, const GenericReal< is_ad > reference_residual)
Output information for a single iteration step to build the convergence history of the model...
void checkPermissibleRange(GenericReal< is_ad > &scalar, GenericReal< is_ad > &scalar_increment, const GenericReal< is_ad > &scalar_old, const GenericReal< is_ad > min_permissible_scalar, const GenericReal< is_ad > max_permissible_scalar, std::stringstream *iter_output)
Check to see whether solution is within admissible range, and set it within that range if it is not...
T sign(T x)
virtual GenericReal< is_ad > computeResidual(const GenericDenseVector< is_ad > &effective_trial_stress, const GenericDenseVector< is_ad > &stress_new, const GenericReal< is_ad > &delta_gamma)=0
Compute the residual for a predicted value of the scalar.
bool _check_range
Whether to check to see whether iterative solution is within admissible range, and set within that ra...
bool _bracket_solution
Whether to save upper and lower bounds of root for scalar, and set solution to the midpoint between t...
const std::size_t _num_resids
Number of residuals to be stored in history.
const unsigned int _max_its
Maximum number of return mapping iterations.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
bool convergedAcceptable(const unsigned int it, const Real &reference)
Check to see whether the residual is within acceptable convergence limits.
virtual GenericReal< is_ad > computeDerivative(const GenericDenseVector< is_ad > &effective_trial_stress, const GenericDenseVector< is_ad > &stress_new, const GenericReal< is_ad > &scalar)=0
virtual GenericReal< is_ad > maximumPermissibleValue(const GenericDenseVector< is_ad > &effective_trial_stress) const
Compute the maximum permissible value of the scalar.
virtual GenericReal< is_ad > minimumPermissibleValue(const GenericDenseVector< is_ad > &effective_trial_stress) const
Compute the minimum permissible value of the scalar.

◆ iterationFinalize()

template<bool is_ad>
virtual void GeneralizedReturnMappingSolutionTempl< is_ad >::iterationFinalize ( const GenericReal< is_ad > &  )
inlineprotectedvirtual

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

Parameters
scalarInelastic strain increment magnitude being solved for

Definition at line 101 of file GeneralizedReturnMappingSolution.h.

101 {}

◆ maximumPermissibleValue()

template<bool is_ad>
GenericReal< is_ad > GeneralizedReturnMappingSolutionTempl< is_ad >::maximumPermissibleValue ( const GenericDenseVector< is_ad > &  effective_trial_stress) const
protectedvirtual

Compute the maximum permissible value of the scalar.

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

Parameters
effective_trial_stressEffective trial stress

Reimplemented in GeneralizedRadialReturnStressUpdateTempl< is_ad >.

Definition at line 86 of file GeneralizedReturnMappingSolution.C.

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

◆ minimumPermissibleValue()

template<bool is_ad>
GenericReal< is_ad > GeneralizedReturnMappingSolutionTempl< is_ad >::minimumPermissibleValue ( const GenericDenseVector< is_ad > &  effective_trial_stress) const
protectedvirtual

Compute the minimum permissible value of the scalar.

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

Parameters
effective_trial_stressEffective trial stress

Reimplemented in GeneralizedRadialReturnStressUpdateTempl< is_ad >.

Definition at line 78 of file GeneralizedReturnMappingSolution.C.

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

◆ outputIterationStep()

template<bool is_ad>
void GeneralizedReturnMappingSolutionTempl< is_ad >::outputIterationStep ( std::stringstream *  iter_output,
const GenericDenseVector< is_ad > &  effective_trial_stress,
const GenericReal< is_ad > &  scalar,
const GenericReal< is_ad >  reference_residual 
)
protectedvirtual

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 378 of file GeneralizedReturnMappingSolution.C.

383 {
384  if (iter_output)
385  {
386  const unsigned int it = _iteration;
387  const Real residual = MetaPhysicL::raw_value(_residual);
388 
389  *iter_output << " iteration=" << it
390  << " trial_stress=" << MetaPhysicL::raw_value(effective_trial_stress)
391  << " scalar=" << MetaPhysicL::raw_value(scalar) << " residual=" << residual
392  << " ref_res=" << reference_residual
393  << " rel_res=" << std::abs(residual) / reference_residual
394  << " rel_tol=" << _relative_tolerance << " abs_res=" << std::abs(residual)
395  << " abs_tol=" << _absolute_tolerance << '\n';
396  }
397 }
Real _relative_tolerance
Relative convergence tolerance.
auto raw_value(const Eigen::Map< T > &in)
Real _absolute_tolerance
Absolute convergence tolerance.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ outputIterationSummary()

template<bool is_ad>
void GeneralizedReturnMappingSolutionTempl< is_ad >::outputIterationSummary ( std::stringstream *  iter_output,
const unsigned int  total_it 
)
protectedvirtual

Output summary information for the convergence history of the model.

Parameters
iter_outputOutput stream
total_itTotal iteration count

Reimplemented in GeneralizedRadialReturnStressUpdateTempl< is_ad >.

Definition at line 401 of file GeneralizedReturnMappingSolution.C.

Referenced by GeneralizedRadialReturnStressUpdateTempl< is_ad >::outputIterationSummary().

403 {
404  if (iter_output)
405  *iter_output << "In " << total_it << " iterations the residual went from "
407  << MetaPhysicL::raw_value(_residual) << " in '" << _svrms_name << "'.\n";
408 }
auto raw_value(const Eigen::Map< T > &in)
GenericReal< is_ad > _initial_residual
Residual values, kept as members to retain solver state for summary outputting.
const std::string _svrms_name
MOOSE input name of the object performing the solve.

◆ returnMappingSolve()

template<bool is_ad>
void GeneralizedReturnMappingSolutionTempl< is_ad >::returnMappingSolve ( const GenericDenseVector< is_ad > &  effective_trial_stress,
const GenericDenseVector< is_ad > &  stress_new,
GenericReal< is_ad > &  scalar,
const ConsoleStream console 
)
protected

Perform the return mapping iterations.

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

Definition at line 94 of file GeneralizedReturnMappingSolution.C.

99 {
100  // construct the stringstream here only if the debug level is set to ALL
101  std::unique_ptr<std::stringstream> iter_output =
103  ? std::make_unique<std::stringstream>()
104  : nullptr;
105 
106  // do the internal solve and capture iteration info during the first round
107  // iff full history output is requested regardless of whether the solve failed or succeeded
108  auto solve_state =
109  internalSolve(stress_dev,
110  stress_new,
111  scalar,
112  _internal_solve_full_iteration_history ? iter_output.get() : nullptr);
113  if (solve_state != SolveState::SUCCESS &&
115  {
116  // output suppressed by user, throw immediately
118  mooseException("");
119 
120  // user expects some kind of output, if necessary setup output stream now
121  if (!iter_output)
122  iter_output = std::make_unique<std::stringstream>();
123 
124  // add the appropriate error message to the output
125  switch (solve_state)
126  {
127  case SolveState::NAN_INF:
128  *iter_output << "Encountered inf or nan in material return mapping iterations.\n";
129  break;
130 
132  *iter_output << "Exceeded maximum iterations in material return mapping iterations.\n";
133  break;
134 
135  default:
136  mooseError("Unhandled solver state");
137  }
138 
139  // if full history output is only requested for failed solves we have to repeat
140  // the solve a second time
142  internalSolve(stress_dev, stress_new, scalar, iter_output.get());
143 
144  // Append summary and throw exception
145  outputIterationSummary(iter_output.get(), _iteration);
146  mooseException(iter_output->str());
147  }
148 
150  {
151  // the solve did not fail but the user requested debug output anyways
152  outputIterationSummary(iter_output.get(), _iteration);
153  console << iter_output->str();
154  }
155 }
void mooseError(Args &&... args)
enum GeneralizedReturnMappingSolutionTempl::InternalSolveOutput _internal_solve_output_on
const bool _internal_solve_full_iteration_history
Whether to output iteration information all the time (regardless of whether iterations converge) ...
virtual void outputIterationSummary(std::stringstream *iter_output, const unsigned int total_it)
Output summary information for the convergence history of the model.
SolveState internalSolve(const GenericDenseVector< is_ad > &effective_trial_stress, const GenericDenseVector< is_ad > &stress_new, GenericReal< is_ad > &scalar, std::stringstream *iter_output=nullptr)
Method called from within this class to perform the actual return mappping iterations.

◆ updateBounds()

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

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

Parameters
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 350 of file GeneralizedReturnMappingSolution.C.

356 {
357  // Update upper/lower bounds as applicable
358  if (residual * init_resid_sign < 0.0 && scalar < scalar_upper_bound)
359  {
360  scalar_upper_bound = scalar;
361  if (scalar_upper_bound < scalar_lower_bound)
362  {
363  scalar_upper_bound = scalar_lower_bound;
364  scalar_lower_bound = 0.0;
365  if (iter_output)
366  *iter_output << " Corrected for scalar_upper_bound < scalar_lower_bound" << std::endl;
367  }
368  }
369  // Don't permit setting scalar_lower_bound > scalar_upper_bound (but do permit the reverse).
370  // This ensures that if we encounter multiple roots, we pick the lowest one.
371  else if (residual * init_resid_sign > 0.0 && scalar > scalar_lower_bound &&
372  scalar < scalar_upper_bound)
373  scalar_lower_bound = scalar;
374 }

◆ validParams()

template<bool is_ad>
InputParameters GeneralizedReturnMappingSolutionTempl< is_ad >::validParams ( )
static

Definition at line 26 of file GeneralizedReturnMappingSolution.C.

Referenced by GeneralizedRadialReturnStressUpdateTempl< is_ad >::validParams().

27 {
29  params.addParam<Real>(
30  "relative_tolerance", 1e-8, "Relative convergence tolerance for Newton iteration");
31  params.addParam<Real>(
32  "absolute_tolerance", 1e-11, "Absolute convergence tolerance for Newton iteration");
33  params.addParam<Real>("acceptable_multiplier",
34  10,
35  "Factor applied to relative and absolute "
36  "tolerance for acceptable convergence if "
37  "iterations are no longer making progress");
38 
39  // diagnostic output parameters
40  MooseEnum internal_solve_output_on_enum("never on_error always", "on_error");
41  params.addParam<MooseEnum>("internal_solve_output_on",
42  internal_solve_output_on_enum,
43  "When to output internal Newton solve information");
44  params.addParam<bool>("internal_solve_full_iteration_history",
45  false,
46  "Set true to output full internal Newton iteration history at times "
47  "determined by `internal_solve_output_on`. If false, only a summary is "
48  "output.");
49  params.addParamNamesToGroup("internal_solve_output_on internal_solve_full_iteration_history",
50  "Debug");
51  return params;
52 }
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
InputParameters emptyInputParameters()
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)

Member Data Documentation

◆ _absolute_tolerance

template<bool is_ad>
Real GeneralizedReturnMappingSolutionTempl< is_ad >::_absolute_tolerance
private

Absolute convergence tolerance.

Definition at line 168 of file GeneralizedReturnMappingSolution.h.

◆ _acceptable_multiplier

template<bool is_ad>
Real GeneralizedReturnMappingSolutionTempl< is_ad >::_acceptable_multiplier
private

Multiplier applied to relative and absolute tolerances for acceptable convergence.

Definition at line 171 of file GeneralizedReturnMappingSolution.h.

◆ _bracket_solution

template<bool is_ad>
bool GeneralizedReturnMappingSolutionTempl< is_ad >::_bracket_solution
protected

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 118 of file GeneralizedReturnMappingSolution.h.

◆ _check_range

template<bool is_ad>
bool GeneralizedReturnMappingSolutionTempl< is_ad >::_check_range
protected

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

Definition at line 111 of file GeneralizedReturnMappingSolution.h.

◆ _initial_residual

template<bool is_ad>
GenericReal<is_ad> GeneralizedReturnMappingSolutionTempl< is_ad >::_initial_residual
private

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

Definition at line 183 of file GeneralizedReturnMappingSolution.h.

◆ _internal_solve_full_iteration_history

template<bool is_ad>
const bool GeneralizedReturnMappingSolutionTempl< is_ad >::_internal_solve_full_iteration_history
private

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

Definition at line 162 of file GeneralizedReturnMappingSolution.h.

◆ _internal_solve_output_on

template<bool is_ad>
enum GeneralizedReturnMappingSolutionTempl::InternalSolveOutput GeneralizedReturnMappingSolutionTempl< is_ad >::_internal_solve_output_on
private

◆ _iteration

template<bool is_ad>
unsigned int GeneralizedReturnMappingSolutionTempl< is_ad >::_iteration
private

iteration number

Definition at line 180 of file GeneralizedReturnMappingSolution.h.

◆ _line_search

template<bool is_ad>
bool GeneralizedReturnMappingSolutionTempl< is_ad >::_line_search
protected

Whether to use line searches to improve convergence.

Definition at line 114 of file GeneralizedReturnMappingSolution.h.

◆ _max_its

template<bool is_ad>
const unsigned int GeneralizedReturnMappingSolutionTempl< is_ad >::_max_its
private

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 159 of file GeneralizedReturnMappingSolution.h.

◆ _num_resids

template<bool is_ad>
const std::size_t GeneralizedReturnMappingSolutionTempl< is_ad >::_num_resids
private

Number of residuals to be stored in history.

Definition at line 174 of file GeneralizedReturnMappingSolution.h.

◆ _relative_tolerance

template<bool is_ad>
Real GeneralizedReturnMappingSolutionTempl< is_ad >::_relative_tolerance
private

Relative convergence tolerance.

Definition at line 165 of file GeneralizedReturnMappingSolution.h.

◆ _residual

template<bool is_ad>
GenericReal<is_ad> GeneralizedReturnMappingSolutionTempl< is_ad >::_residual
private

Definition at line 184 of file GeneralizedReturnMappingSolution.h.

◆ _residual_history

template<bool is_ad>
std::vector<Real> GeneralizedReturnMappingSolutionTempl< is_ad >::_residual_history
private

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

Definition at line 177 of file GeneralizedReturnMappingSolution.h.

◆ _svrms_name

template<bool is_ad>
const std::string GeneralizedReturnMappingSolutionTempl< is_ad >::_svrms_name
private

MOOSE input name of the object performing the solve.

Definition at line 188 of file GeneralizedReturnMappingSolution.h.


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