SingleVariableReturnMappingSolution.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 "DualRealOps.h"
#include "ChainedReal.h"
#include "ChainedADReal.h"
#include "InputParameters.h"

class ConsoleStream;

template <bool is_ad>
class SingleVariableReturnMappingSolutionTempl
{
public:
  static InputParameters validParams();

  SingleVariableReturnMappingSolutionTempl(const InputParameters & parameters);
  virtual ~SingleVariableReturnMappingSolutionTempl() {}

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

  virtual GenericReal<is_ad>
  minimumPermissibleValue(const GenericReal<is_ad> & effective_trial_stress) const;

  virtual GenericReal<is_ad>
  maximumPermissibleValue(const GenericReal<is_ad> & effective_trial_stress) const;

  virtual GenericReal<is_ad> initialGuess(const GenericReal<is_ad> & /*effective_trial_stress*/)
  {
    return 0.0;
  }

  virtual GenericReal<is_ad> computeResidual(const GenericReal<is_ad> & /*effective_trial_stress*/,
                                             const GenericReal<is_ad> & /*scalar*/) = 0;

  virtual GenericReal<is_ad>
  computeDerivative(const GenericReal<is_ad> & /*effective_trial_stress*/,
                    const GenericReal<is_ad> & /*scalar*/) = 0;

  virtual GenericChainedReal<is_ad>
  computeResidualAndDerivative(const GenericReal<is_ad> & /*effective_trial_stress*/,
                               const GenericChainedReal<is_ad> & /*scalar*/)
  {
    mooseError("computeResidualAndDerivative has to be implemented if "
               "automatic_differentiation_return_mapping = true.");
    return 0;
  };

  virtual Real computeReferenceResidual(const GenericReal<is_ad> & effective_trial_stress,
                                        const GenericReal<is_ad> & scalar) = 0;

  virtual void preStep(const GenericReal<is_ad> & /*scalar_old*/,
                       const GenericReal<is_ad> & /*residual*/,
                       const GenericReal<is_ad> & /*jacobian*/)
  {
  }

  virtual void iterationFinalize(const GenericReal<is_ad> & /*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 GenericReal<is_ad> & effective_trial_stress,
                                   const GenericReal<is_ad> & scalar,
                                   const Real reference_residual);

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

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

  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;

  // Whether to use automatic differentiation to calculate the derivative. If set to false, you must
  // override both computeResidual and computeDerivative methods. If set to true, you must override
  // the computeResidualAndDerivative method.
  const bool _ad_derivative;

  const std::size_t _num_resids;

  std::vector<Real> _residual_history;

  unsigned int _iteration;

  GenericReal<is_ad> _initial_residual;
  GenericReal<is_ad> _residual;

  GenericReal<is_ad> _derivative;

  const std::string _svrms_name;

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

  bool convergedAcceptable(const unsigned int it, const Real reference);

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

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

typedef SingleVariableReturnMappingSolutionTempl<false> SingleVariableReturnMappingSolution;
typedef SingleVariableReturnMappingSolutionTempl<true> ADSingleVariableReturnMappingSolution;