ADSingleVariableReturnMappingSolution.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "MooseTypes.h"
#include "InputParameters.h"
 
#define usingSingleVariableReturnMappingSolutionMembers                                            \
  using ADSingleVariableReturnMappingSolution<compute_stage>::returnMappingSolve;                  \
  using ADSingleVariableReturnMappingSolution<compute_stage>::minimumPermissibleValue;             \
  using ADSingleVariableReturnMappingSolution<compute_stage>::maximumPermissibleValue;             \
  using ADSingleVariableReturnMappingSolution<compute_stage>::initialGuess;                        \
  using ADSingleVariableReturnMappingSolution<compute_stage>::computeResidual;                     \
  using ADSingleVariableReturnMappingSolution<compute_stage>::computeDerivative;                   \
  using ADSingleVariableReturnMappingSolution<compute_stage>::computeReferenceResidual;            \
  using ADSingleVariableReturnMappingSolution<compute_stage>::iterationFinalize;                   \
  using ADSingleVariableReturnMappingSolution<compute_stage>::outputIterationSummary;              \
  using ADSingleVariableReturnMappingSolution<compute_stage>::_check_range;                        \
  using ADSingleVariableReturnMappingSolution<compute_stage>::_line_search;                        \
  using ADSingleVariableReturnMappingSolution<compute_stage>::_bracket_solution;                   \
  using ADSingleVariableReturnMappingSolution<compute_stage>::converged
 
// Forward declarations
template <ComputeStage>
class ADSingleVariableReturnMappingSolution;
class ConsoleStream;
 
declareADValidParams(ADSingleVariableReturnMappingSolution);
 
template <ComputeStage compute_stage>
class ADSingleVariableReturnMappingSolution
{
public:
  static InputParameters validParams();
 
  ADSingleVariableReturnMappingSolution(const InputParameters & parameters);
  virtual ~ADSingleVariableReturnMappingSolution() {}
 
protected:
  void returnMappingSolve(const ADReal & effective_trial_stress,
                          ADReal & scalar,
                          const ConsoleStream & console);
 
  virtual ADReal minimumPermissibleValue(const ADReal & effective_trial_stress) const;
 
  virtual ADReal maximumPermissibleValue(const ADReal & effective_trial_stress) const;
 
  virtual ADReal initialGuess(const ADReal & /*effective_trial_stress*/) { return 0.0; }
 
  virtual ADReal computeResidual(const ADReal & effective_trial_stress, const ADReal & scalar) = 0;
 
  virtual ADReal computeDerivative(const ADReal & effective_trial_stress,
                                   const ADReal & scalar) = 0;
 
  virtual Real computeReferenceResidual(const ADReal & effective_trial_stress,
                                        const ADReal & scalar) = 0;
 
  virtual void iterationFinalize(ADReal /*scalar*/) {}
 
  virtual void outputIterationSummary(std::stringstream * iter_output, const unsigned int total_it);
 
  bool _check_range;
 
  bool _line_search;
 
  bool _bracket_solution;
 
  virtual void outputIterationStep(std::stringstream * iter_output,
                                   const ADReal & effective_trial_stress,
                                   const ADReal & scalar,
                                   const Real reference_residual);
 
  bool converged(const ADReal & residual, const Real reference);
 
private:
  enum class InternalSolveOutput
  {
    NEVER,
    ON_ERROR,
    ALWAYS
  } _internal_solve_output_on;
 
  enum class SolveState
  {
    SUCCESS,
    NAN_INF,
    EXCEEDED_ITERATIONS
  };
 
  const unsigned int _max_its;
 
  const bool _internal_solve_full_iteration_history;
 
  Real _relative_tolerance;
 
  Real _absolute_tolerance;
 
  Real _acceptable_multiplier;
 
  const std::size_t _num_resids;
 
  std::vector<Real> _residual_history;
 
  unsigned int _iteration;
 
  ADReal _initial_residual;
  ADReal _residual;
 
  const std::string _svrms_name;
 
  SolveState internalSolve(const ADReal effective_trial_stress,
                           ADReal & scalar,
                           std::stringstream * iter_output = nullptr);
 
  bool convergedAcceptable(const unsigned int it, const Real reference);
 
  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);
 
  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);
};