NestedSolveTempl< is_ad > Class Template Reference

NestedSolveTempl<is_ad> and its instantiations NestedSolve and ADNestedSolve are utility classes that implement a non-linear solver. More...

#include <NestedSolve.h>

Classes
struct	CorrespondingJacobianTempl
	Deduce the Jacobian type from the solution type. More...

Public Types
enum	State {   State::NONE, State::CONVERGED_ABS, State::CONVERGED_REL, State::CONVERGED_ACCEPTABLE_ABS,   State::CONVERGED_ACCEPTABLE_REL, State::CONVERGED_BOUNDS, State::EXACT_GUESS, State::CONVERGED_XTOL,   State::NOT_CONVERGED }
	possible solver states More...
template<int N = 0>
using	Value = typename std::conditional< N==1, NSReal, typename std::conditional< N==0, NestedSolveTempl< is_ad >::DynamicVector, Eigen::Matrix< NSReal, N, 1 > >::type >::type
	Residual and solution type. More...
template<int N = 0>
using	Jacobian = typename std::conditional< N==1, NSReal, typename std::conditional< N==0, NestedSolveTempl< is_ad >::DynamicMatrix, Eigen::Matrix< NSReal, N, N > >::type >::type
	Jacobian matrix type. More...
using	NSReal = Moose::GenericType< Real, is_ad >
	AD/non-AD switched type shortcuts. More...
using	NSRealVectorValue = Moose::GenericType< RealVectorValue, is_ad >
using	NSRankTwoTensor = Moose::GenericType< RankTwoTensor, is_ad >
using	DynamicVector = Eigen::Matrix< NSReal, Eigen::Dynamic, 1 >
	Eigen type shortcuts. More...
using	DynamicMatrix = Eigen::Matrix< NSReal, Eigen::Dynamic, Eigen::Dynamic >
template<typename T >
using	CorrespondingJacobian = typename NestedSolveInternal::CorrespondingJacobianTempl< T >::type

Public Member Functions
	NestedSolveTempl ()
	NestedSolveTempl (const InputParameters &params)
template<typename V , typename T >
void	nonlinear (V &guess, T &&compute)
	Solve the N*N nonlinear equation system using a built-in Netwon-Raphson loop. More...
template<typename V , typename T , typename C >
void	nonlinearDamped (V &guess, T &&compute, C &&computeCondition)
	Solve the N*N nonlinear equation system using the damped Netwon-Raphson loop. More...
void	setRelativeTolerance (Real rel)
void	setAbsoluteTolerance (Real abs)
void	setAcceptableMultiplier (Real am)
const State &	getState () const
	Get the solver state. More...
const std::size_t &	getIterations ()
	Get the number of iterations from the last solve. More...
template<typename R , typename J >
void	nonlinear (NestedSolveTempl< is_ad >::DynamicVector &guess, R &computeResidual, J &computeJacobian)
template<typename R , typename J >
void	nonlinearTight (NestedSolveTempl< is_ad >::DynamicVector &guess, R &computeResidual, J &computeJacobian)
template<typename R , typename J >
void	nonlinear (DynamicVector &guess, R &computeResidual, J &computeJacobian)
template<typename R , typename J >
void	nonlinear (NSReal &guess, R &computeResidual, J &computeJacobian)
template<typename R , typename J >
void	nonlinear (NSRealVectorValue &guess, R &computeResidual, J &computeJacobian)
template<typename R , typename J >
void	nonlinearTight (DynamicVector &guess, R &computeResidual, J &computeJacobian)
template<typename R , typename J >
void	nonlinearTight (NSReal &guess, R &computeResidual, J &computeJacobian)
template<typename R , typename J >
void	nonlinearTight (NSRealVectorValue &guess, R &computeResidual, J &computeJacobian)
template<typename R , typename J , typename B >
void	nonlinearBounded (NSReal &guess, R &computeResidual, J &computeJacobian, B &computeBounds)
	Perform a bounded solve use Eigen::HybridNonLinearSolver. More...

Static Public Member Functions
static InputParameters	validParams ()
static Real	relativeToleranceDefault ()
	default values More...
static Real	absoluteToleranceDefault ()
static Real	xToleranceDefault ()
static unsigned int	minIterationsDefault ()
static unsigned int	maxIterationsDefault ()
static Real	acceptableMultiplierDefault ()
static Real	dampingFactorDefault ()
static unsigned int	maxDampingIterationsDefault ()
template<typename V >
static Real	normSquare (const V &v)
	Compute squared norm of v (dropping derivatives as this is only for convergence checking) More...
static Real	normSquare (const NSReal &v)
static Real	normSquare (const NSRealVectorValue &v)
template<typename V >
static bool	isRelSmall (const V &a, const V &b, const V &c)
	Check if |a| < |b * c| for all elements in a and b. This checks if 'a' is small relative to. More...
static bool	isRelSmall (const NSReal &a, const NSReal &b, const NSReal &c)
static bool	isRelSmall (const NSRealVectorValue &a, const NSRealVectorValue &b, const NSReal &c)
static bool	isRelSmall (const DynamicVector &a, const DynamicVector &b, const NSReal &c)

Public Attributes
Real	_relative_tolerance_square
Real	_absolute_tolerance_square
Real	_delta_thresh
	Threshold for minimum step size of linear iterations. More...
Real	_damping_factor
	Damping factor. More...
unsigned int	_max_damping_iterations
unsigned int	_min_iterations
unsigned int	_max_iterations
Real	_acceptable_multiplier

Protected Member Functions
void	sizeItems (const NestedSolveTempl< is_ad >::DynamicVector &guess, NestedSolveTempl< is_ad >::DynamicVector &residual, NestedSolveTempl< is_ad >::DynamicMatrix &jacobian) const
	Size a dynamic Jacobian matrix correctly. More...
template<typename V , typename T >
void	sizeItems (const V &, V &, T &) const
	Sizing is a no-op for compile time sized types (and scalars) More...
bool	isConverged (Real r0_square, Real r_square, bool acceptable)
	Convergence check (updates _status) More...
template<typename J , typename V >
void	linear (const J &A, V &x, const V &b) const
	Solve A*x=b for x. More...
void	linear (const NSReal &A, NSReal &x, const NSReal &b) const
void	linear (const NSRankTwoTensor &A, NSRealVectorValue &x, const NSRealVectorValue &b) const

Protected Attributes
State	_state
	current solver state More...
std::size_t	_n_iterations
	number of nested iterations More...

Private Member Functions
template<bool store_residual_norm, typename R , typename J >
auto	make_adaptor (R &residual, J &jacobian)
	Build a suitable Eigen adaptor functors to interface between moose and Eigen types. More...
template<bool store_residual_norm, typename R , typename J >
auto	make_real_adaptor (R &residual, J &jacobian)
template<bool store_residual_norm, typename R , typename J >
auto	make_realvector_adaptor (R &residual, J &jacobian)

Detailed Description

template<bool is_ad>
class NestedSolveTempl< is_ad >

NestedSolveTempl<is_ad> and its instantiations NestedSolve and ADNestedSolve are utility classes that implement a non-linear solver.

These classes can be instantiated in any MOOSE object to perform local Newton-Raphson solves.

Definition at line 42 of file NestedSolve.h.

Member Typedef Documentation

CorrespondingJacobian

template<bool is_ad>

template<typename T >

using NestedSolveTempl< is_ad >::CorrespondingJacobian = typename NestedSolveInternal::CorrespondingJacobianTempl<T>::type

Definition at line 65 of file NestedSolve.h.

DynamicMatrix

template<bool is_ad>

using NestedSolveTempl< is_ad >::DynamicMatrix = Eigen::Matrix<NSReal, Eigen::Dynamic, Eigen::Dynamic>

Definition at line 58 of file NestedSolve.h.

DynamicVector

template<bool is_ad>

using NestedSolveTempl< is_ad >::DynamicVector = Eigen::Matrix<NSReal, Eigen::Dynamic, 1>

Eigen type shortcuts.

Definition at line 57 of file NestedSolve.h.

Jacobian

template<bool is_ad>

template<int N = 0>

using NestedSolveTempl< is_ad >::Jacobian = typename std::conditional<N == 1, NSReal, typename std::conditional<N == 0, NestedSolveTempl<is_ad>::DynamicMatrix, Eigen::Matrix<NSReal, N, N> >::type>::type

Jacobian matrix type.

Definition at line 84 of file NestedSolve.h.

NSRankTwoTensor

template<bool is_ad>

using NestedSolveTempl< is_ad >::NSRankTwoTensor = Moose::GenericType<RankTwoTensor, is_ad>

Definition at line 53 of file NestedSolve.h.

NSReal

template<bool is_ad>

using NestedSolveTempl< is_ad >::NSReal = Moose::GenericType<Real, is_ad>

AD/non-AD switched type shortcuts.

Definition at line 51 of file NestedSolve.h.

NSRealVectorValue

template<bool is_ad>

using NestedSolveTempl< is_ad >::NSRealVectorValue = Moose::GenericType<RealVectorValue, is_ad>

Definition at line 52 of file NestedSolve.h.

Value

template<bool is_ad>

template<int N = 0>

using NestedSolveTempl< is_ad >::Value = typename std::conditional<N == 1, NSReal, typename std::conditional<N == 0, NestedSolveTempl<is_ad>::DynamicVector, Eigen::Matrix<NSReal, N, 1> >::type>::type

Residual and solution type.

Definition at line 75 of file NestedSolve.h.

Member Enumeration Documentation

State

template<bool is_ad>

enum NestedSolveTempl::State

strong

possible solver states

Enumerator
NONE
CONVERGED_ABS
CONVERGED_REL
CONVERGED_ACCEPTABLE_ABS
CONVERGED_ACCEPTABLE_REL
CONVERGED_BOUNDS
EXACT_GUESS
CONVERGED_XTOL
NOT_CONVERGED

Definition at line 147 of file NestedSolve.h.

  {
    NONE,
    CONVERGED_ABS,
    CONVERGED_REL,
    CONVERGED_ACCEPTABLE_ABS,
    CONVERGED_ACCEPTABLE_REL,
    CONVERGED_BOUNDS,
    EXACT_GUESS,
    CONVERGED_XTOL,
    NOT_CONVERGED
  };

Constructor & Destructor Documentation

NestedSolveTempl() [1/2]

template<bool is_ad>

NestedSolveTempl< is_ad >::NestedSolveTempl

(

)

Definition at line 52 of file NestedSolve.C.

  : _relative_tolerance_square(Utility::pow<2>(relativeToleranceDefault())),
    _absolute_tolerance_square(Utility::pow<2>(absoluteToleranceDefault())),
    _delta_thresh(xToleranceDefault()),
    _damping_factor(dampingFactorDefault()),
    _max_damping_iterations(maxDampingIterationsDefault()),
    _min_iterations(minIterationsDefault()),
    _max_iterations(maxIterationsDefault()),
    _acceptable_multiplier(acceptableMultiplierDefault()),
    _state(State::NONE),
    _n_iterations(0)
{
}

NestedSolveTempl() [2/2]

template<bool is_ad>

NestedSolveTempl< is_ad >::NestedSolveTempl

(

const InputParameters &

params

)

Definition at line 67 of file NestedSolve.C.

  : _relative_tolerance_square(Utility::pow<2>(params.get<Real>("relative_tolerance"))),
    _absolute_tolerance_square(Utility::pow<2>(params.get<Real>("absolute_tolerance"))),
    _delta_thresh(params.get<Real>("step_size_tolerance")),
    _damping_factor(params.get<Real>("damping_factor")),
    _max_damping_iterations(params.get<unsigned int>("max_damping_iterations")),
    _min_iterations(params.get<unsigned int>("min_iterations")),
    _max_iterations(params.get<unsigned int>("max_iterations")),
    _acceptable_multiplier(params.get<Real>("acceptable_multiplier")),
    _state(State::NONE),
    _n_iterations(0)
{
}

Member Function Documentation

absoluteToleranceDefault()

template<bool is_ad>

static Real NestedSolveTempl< is_ad >::absoluteToleranceDefault ( )

inlinestatic

Definition at line 121 of file NestedSolve.h.

{ return 1e-13; }

acceptableMultiplierDefault()

template<bool is_ad>

static Real NestedSolveTempl< is_ad >::acceptableMultiplierDefault ( )

inlinestatic

Definition at line 125 of file NestedSolve.h.

{ return 10.0; }

dampingFactorDefault()

template<bool is_ad>

static Real NestedSolveTempl< is_ad >::dampingFactorDefault ( )

inlinestatic

Definition at line 126 of file NestedSolve.h.

{ return 0.8; }

getIterations()

template<bool is_ad>

const std::size_t& NestedSolveTempl< is_ad >::getIterations ( )

inline

Get the number of iterations from the last solve.

Definition at line 163 of file NestedSolve.h.

{ return _n_iterations; };

getState()

template<bool is_ad>

const State& NestedSolveTempl< is_ad >::getState ( ) const

inline

Get the solver state.

Definition at line 161 of file NestedSolve.h.

{ return _state; }

isConverged()

template<bool is_ad>

bool NestedSolveTempl< is_ad >::isConverged ( Real  r0_square, Real  r_square, bool  acceptable  )

protected

Convergence check (updates _status)

Definition at line 779 of file NestedSolve.h.

{
  if (acceptable)
    r_square /= _acceptable_multiplier * _acceptable_multiplier;
  if (r_square < _absolute_tolerance_square)
  {
    _state = acceptable ? State::CONVERGED_ACCEPTABLE_ABS : State::CONVERGED_ABS;
    return true;
  }
  if (r_square / r0_square < _relative_tolerance_square)
  {
    _state = acceptable ? State::CONVERGED_ACCEPTABLE_REL : State::CONVERGED_REL;
    return true;
  }
  return false;
}

isRelSmall() [1/4]

template<bool is_ad>

template<typename V >

static bool NestedSolveTempl< is_ad >::isRelSmall ( const V &  a, const V &  b, const V &  c  )

static

Check if |a| < |b * c| for all elements in a and b. This checks if 'a' is small relative to.

isRelSmall() [2/4]

template<bool is_ad>

bool NestedSolveTempl< is_ad >::isRelSmall ( const NSReal &  a, const NSReal &  b, const NSReal &  c  )

static

Definition at line 117 of file NestedSolve.C.

{
  return (abs(MetaPhysicL::raw_value(a)) <
          abs(MetaPhysicL::raw_value(c) * MetaPhysicL::raw_value(b)));
}

isRelSmall() [3/4]

template<bool is_ad>

bool NestedSolveTempl< is_ad >::isRelSmall ( const NSRealVectorValue &  a, const NSRealVectorValue &  b, const NSReal &  c  )

static

Definition at line 125 of file NestedSolve.C.

{
  for (const auto i : make_range(LIBMESH_DIM))
  {
    if (abs(MetaPhysicL::raw_value(a)(i)) >=
        abs(MetaPhysicL::raw_value(b)(i) * MetaPhysicL::raw_value(c)))
      return false;
  }
  return true;
}

isRelSmall() [4/4]

template<bool is_ad>

bool NestedSolveTempl< is_ad >::isRelSmall ( const DynamicVector &  a, const DynamicVector &  b, const NSReal &  c  )

static

Definition at line 140 of file NestedSolve.C.

{
  return (a.cwiseAbs().array() < b.cwiseAbs().array() * MetaPhysicL::raw_value(c)).all();
}

linear() [1/3]

template<bool is_ad>

template<typename J , typename V >

void NestedSolveTempl< is_ad >::linear ( const J &  A, V &  x, const V &  b  ) const

protected

Solve A*x=b for x.

Definition at line 546 of file NestedSolve.h.

{
  // we could make the linear solve method configurable here
  x = A.partialPivLu().solve(b);
}

linear() [2/3]

template<bool is_ad>

void NestedSolveTempl< is_ad >::linear ( const NSReal &  A, NSReal &  x, const NSReal &  b  ) const

inlineprotected

Definition at line 203 of file NestedSolve.h.

{ x = b / A; }

linear() [3/3]

template<bool is_ad>

void NestedSolveTempl< is_ad >::linear ( const NSRankTwoTensor &  A, NSRealVectorValue &  x, const NSRealVectorValue &  b  ) const

protected

Definition at line 94 of file NestedSolve.C.

{
  x = A.inverse() * b;
}

make_adaptor()

template<bool is_ad>

template<bool store_residual_norm, typename R , typename J >

auto NestedSolveTempl< is_ad >::make_adaptor ( R &  residual, J &  jacobian  )

private

Build a suitable Eigen adaptor functors to interface between moose and Eigen types.

Definition at line 753 of file NestedSolve.h.

{
  return NestedSolveInternal::DynamicMatrixEigenAdaptorFunctor<is_ad, R, J, store_residual_norm>(
      residual_lambda, jacobian_lambda);
}

make_real_adaptor()

template<bool is_ad>

template<bool store_residual_norm, typename R , typename J >

auto NestedSolveTempl< is_ad >::make_real_adaptor ( R &  residual, J &  jacobian  )

private

Definition at line 761 of file NestedSolve.h.

{
  return NestedSolveInternal::RealEigenAdaptorFunctor<is_ad, R, J, store_residual_norm>(
      residual_lambda, jacobian_lambda);
}

make_realvector_adaptor()

template<bool is_ad>

template<bool store_residual_norm, typename R , typename J >

auto NestedSolveTempl< is_ad >::make_realvector_adaptor ( R &  residual, J &  jacobian  )

private

Definition at line 770 of file NestedSolve.h.

{
  return NestedSolveInternal::RealVectorEigenAdaptorFunctor<is_ad, R, J, store_residual_norm>(
      residual_lambda, jacobian_lambda);
}

maxDampingIterationsDefault()

template<bool is_ad>

static unsigned int NestedSolveTempl< is_ad >::maxDampingIterationsDefault ( )

inlinestatic

Definition at line 127 of file NestedSolve.h.

{ return 100; }

maxIterationsDefault()

template<bool is_ad>

static unsigned int NestedSolveTempl< is_ad >::maxIterationsDefault ( )

inlinestatic

Definition at line 124 of file NestedSolve.h.

{ return 1000; }

minIterationsDefault()

template<bool is_ad>

static unsigned int NestedSolveTempl< is_ad >::minIterationsDefault ( )

inlinestatic

Definition at line 123 of file NestedSolve.h.

{ return 3; }

nonlinear() [1/5]

template<bool is_ad>

template<typename V , typename T >

void NestedSolveTempl< is_ad >::nonlinear	(	V &	guess,
		T &&	compute
	)

Solve the N*N nonlinear equation system using a built-in Netwon-Raphson loop.

if we exceed the max iterations, we could still be converged (considering the acceptable multiplier)

Definition at line 427 of file NestedSolve.h.

{
  V delta;
  V residual;
  CorrespondingJacobian<V> jacobian;
  sizeItems(guess, residual, jacobian);

  _n_iterations = 0;
  compute(guess, residual, jacobian);

  // compute first residual norm for relative convergence checks
  auto r0_square = normSquare(residual);
  if (r0_square == 0)
  {
    _state = State::EXACT_GUESS;
    return;
  }
  auto r_square = r0_square;

  // perform non-linear iterations
  while (_n_iterations < _max_iterations)
  {
    // check convergence
    if (_n_iterations >= _min_iterations && isConverged(r0_square, r_square, /*acceptable=*/false))
      return;

    // solve and apply next increment
    linear(jacobian, delta, residual);

    // Check if step size is smaller than the floating point tolerance
    if (isRelSmall(delta, guess, _delta_thresh))
    {
      _state = State::CONVERGED_XTOL;
      return;
    }

    guess -= delta;
    _n_iterations++;

    // compute residual and jacobian for the next iteration
    compute(guess, residual, jacobian);

    r_square = normSquare(residual);
  }

  if (!isConverged(r0_square, r_square, /*acceptable=*/true))
    _state = State::NOT_CONVERGED;
}

nonlinear() [2/5]

template<bool is_ad>

template<typename R , typename J >

void NestedSolveTempl< is_ad >::nonlinear	(	DynamicVector &	guess,
		R &	computeResidual,
		J &	computeJacobian
	)

The separate residual/Jacobian functor versions use Eigen::HybridNonLinearSolver with a custom backwards compatible convergence check that allows for looser tolerances.

nonlinear() [3/5]

template<bool is_ad>

template<typename R , typename J >

void NestedSolveTempl< is_ad >::nonlinear	(	NSReal &	guess,
		R &	computeResidual,
		J &	computeJacobian
	)

if we exceed the max iterations, we could still be converged (considering the acceptable multiplier)

Definition at line 242 of file NestedSolve.h.

{
  using V = NestedSolveTempl<is_ad>::DynamicVector;

  // adaptor functor to utilize the Eigen non-linear solver
  auto functor = make_real_adaptor<true>(computeResidual, computeJacobian);
  Eigen::HybridNonLinearSolver<decltype(functor), NSReal> solver(functor);
  V guess_eigen(1);
  guess_eigen << guess;
  const auto & r_square = functor.getResidualNorm();
  solver.solveInit(guess_eigen);

  // compute first residual norm for relative convergence checks
  auto r0_square = r_square;
  if (r0_square == 0)
  {
    _state = State::EXACT_GUESS;
    return;
  }

  // perform non-linear iterations
  _n_iterations = 1;
  while (_n_iterations <= _max_iterations &&
         solver.solveOneStep(guess_eigen) == Eigen::HybridNonLinearSolverSpace::Running)
  {
    // check convergence
    if (_n_iterations >= _min_iterations && isConverged(r0_square, r_square, /*acceptable=*/false))
    {
      guess = guess_eigen(0);
      return;
    }
    _n_iterations++;
  }

  if (!isConverged(r0_square, r_square, /*acceptable=*/true))
    _state = State::NOT_CONVERGED;

  guess = guess_eigen(0);
}

nonlinear() [4/5]

template<bool is_ad>

template<typename R , typename J >

void NestedSolveTempl< is_ad >::nonlinear	(	NSRealVectorValue &	guess,
		R &	computeResidual,
		J &	computeJacobian
	)

Definition at line 288 of file NestedSolve.h.

{
  using V = NestedSolveTempl<is_ad>::DynamicVector;

  // adaptor functor to utilize the Eigen non-linear solver
  auto functor = make_realvector_adaptor<true>(computeResidual, computeJacobian);
  Eigen::HybridNonLinearSolver<decltype(functor), NSReal> solver(functor);
  V guess_eigen(3);
  guess_eigen << guess(0), guess(1), guess(2);
  auto status = solver.solve(guess_eigen);
  guess(0) = guess_eigen(0);
  guess(1) = guess_eigen(1);
  guess(2) = guess_eigen(2);

  if (status == Eigen::HybridNonLinearSolverSpace::RelativeErrorTooSmall)
    _state = State::CONVERGED_REL;
  else
    _state = State::NOT_CONVERGED;
}

nonlinear() [5/5]

template<bool is_ad>

template<typename R , typename J >

void NestedSolveTempl< is_ad >::nonlinear	(	NestedSolveTempl< is_ad >::DynamicVector &	guess,
		R &	computeResidual,
		J &	computeJacobian
	)

Definition at line 224 of file NestedSolve.h.

{
  // adaptor functor to utilize the Eigen non-linear solver
  auto functor = make_adaptor<true>(computeResidual, computeJacobian);
  Eigen::HybridNonLinearSolver<decltype(functor), NSReal> solver(functor);
  auto status = solver.solve(guess);

  if (status == Eigen::HybridNonLinearSolverSpace::RelativeErrorTooSmall)
    _state = State::CONVERGED_REL;
  else
    _state = State::NOT_CONVERGED;
}

nonlinearBounded()

template<bool is_ad>

template<typename R , typename J , typename B >

void NestedSolveTempl< is_ad >::nonlinearBounded	(	NSReal &	guess,
		R &	computeResidual,
		J &	computeJacobian,
		B &	computeBounds
	)

Perform a bounded solve use Eigen::HybridNonLinearSolver.

Definition at line 377 of file NestedSolve.h.

{
  auto functor = make_real_adaptor<false>(computeResidual, computeJacobian);
  Eigen::HybridNonLinearSolver<decltype(functor), NSReal> solver(functor);

  NestedSolveTempl<is_ad>::DynamicVector guess_eigen(1);
  guess_eigen << guess;

  auto status = solver.solveInit(guess_eigen);
  if (status == Eigen::HybridNonLinearSolverSpace::ImproperInputParameters)
    return;

  bool bounds_hit = false;
  while (status == Eigen::HybridNonLinearSolverSpace::Running)
  {
    status = solver.solveOneStep(guess_eigen);
    const std::pair<Real, Real> & bounds = computeBounds();

    // Snap to bounds. Terminate solve if we snap twice consecutively.
    if (guess_eigen(0) < bounds.first || guess_eigen(0) > bounds.second)
    {
      if (guess_eigen(0) < bounds.first)
        guess_eigen(0) = bounds.first;
      else
        guess_eigen(0) = bounds.second;

      if (bounds_hit)
      {
        _state = State::CONVERGED_BOUNDS;
        return;
      }

      bounds_hit = true;
    }
  }

  if (status == Eigen::HybridNonLinearSolverSpace::RelativeErrorTooSmall)
    _state = State::CONVERGED_REL;
  else
    _state = State::NOT_CONVERGED;

  guess = guess_eigen(0);
}

nonlinearDamped()

template<bool is_ad>

template<typename V , typename T , typename C >

void NestedSolveTempl< is_ad >::nonlinearDamped	(	V &	guess,
		T &&	compute,
		C &&	computeCondition
	)

Solve the N*N nonlinear equation system using the damped Netwon-Raphson loop.

Definition at line 482 of file NestedSolve.h.

{
  V delta;
  V residual;
  CorrespondingJacobian<V> jacobian;
  sizeItems(guess, residual, jacobian);

  _n_iterations = 0;
  compute(guess, residual, jacobian);

  // compute first residual norm for relative convergence checks
  auto r0_square = normSquare(residual);
  if (r0_square == 0)
  {
    _state = State::EXACT_GUESS;
    return;
  }
  auto r_square = r0_square;

  // perform non-linear iterations
  while (_n_iterations < _max_iterations)
  {
    // check convergence
    if (_n_iterations >= _min_iterations && isConverged(r0_square, r_square, /*acceptable=*/false))
      return;

    // solve and apply next increment
    linear(jacobian, delta, residual);

    // Check if step size is smaller than the floating point tolerance
    if (isRelSmall(delta, guess, _delta_thresh))
    {
      _state = State::CONVERGED_XTOL;
      return;
    }

    Real alpha = 1;
    unsigned int damping_iterations = 0;
    auto prev_guess = guess;
    guess -= delta;

    while (!computeCondition(guess) && (damping_iterations < _max_damping_iterations))
    {
      alpha *= _damping_factor;
      guess = prev_guess - alpha * delta;
      damping_iterations += 1;
    }
    _n_iterations++;

    // compute residual and jacobian for the next iteration
    compute(guess, residual, jacobian);

    r_square = normSquare(residual);
  }

  // if we exceed the max iterations, we could still be converged (considering the acceptable
  // multiplier)
  if (!isConverged(r0_square, r_square, /*acceptable=*/true))
    _state = State::NOT_CONVERGED;
}

nonlinearTight() [1/4]

template<bool is_ad>

template<typename R , typename J >

void NestedSolveTempl< is_ad >::nonlinearTight	(	DynamicVector &	guess,
		R &	computeResidual,
		J &	computeJacobian
	)

The separate residual/Jacobian functor versions use Eigen::HybridNonLinearSolver with the built-in convergence check to tight numerical tolerance.

nonlinearTight() [2/4]

template<bool is_ad>

template<typename R , typename J >

void NestedSolveTempl< is_ad >::nonlinearTight	(	NSReal &	guess,
		R &	computeResidual,
		J &	computeJacobian
	)

Definition at line 331 of file NestedSolve.h.

{
  using V = NestedSolveTempl<is_ad>::DynamicVector;

  // adaptor functor to utilize the Eigen non-linear solver
  auto functor = make_real_adaptor<false>(computeResidual, computeJacobian);
  Eigen::HybridNonLinearSolver<decltype(functor), NSReal> solver(functor);
  V guess_eigen(1);
  guess_eigen << guess;
  auto status = solver.solve(guess_eigen);
  guess = guess_eigen(0);

  if (status == Eigen::HybridNonLinearSolverSpace::RelativeErrorTooSmall)
    _state = State::CONVERGED_REL;
  else
    _state = State::NOT_CONVERGED;
}

nonlinearTight() [3/4]

template<bool is_ad>

template<typename R , typename J >

void NestedSolveTempl< is_ad >::nonlinearTight	(	NSRealVectorValue &	guess,
		R &	computeResidual,
		J &	computeJacobian
	)

Definition at line 352 of file NestedSolve.h.

{
  using V = NestedSolveTempl<is_ad>::DynamicVector;

  // adaptor functor to utilize the Eigen non-linear solver
  auto functor = make_realvector_adaptor<false>(computeResidual, computeJacobian);
  Eigen::HybridNonLinearSolver<decltype(functor), NSReal> solver(functor);
  V guess_eigen(3);
  guess_eigen << guess(0), guess(1), guess(2);
  auto status = solver.solve(guess_eigen);
  guess(0) = guess_eigen(0);
  guess(1) = guess_eigen(1);
  guess(2) = guess_eigen(2);

  if (status == Eigen::HybridNonLinearSolverSpace::RelativeErrorTooSmall)
    _state = State::CONVERGED_REL;
  else
    _state = State::NOT_CONVERGED;
}

nonlinearTight() [4/4]

template<bool is_ad>

template<typename R , typename J >

void NestedSolveTempl< is_ad >::nonlinearTight	(	NestedSolveTempl< is_ad >::DynamicVector &	guess,
		R &	computeResidual,
		J &	computeJacobian
	)

Definition at line 313 of file NestedSolve.h.

{
  // adaptor functor to utilize the Eigen non-linear solver
  auto functor = make_adaptor<false>(computeResidual, computeJacobian);
  Eigen::HybridNonLinearSolver<decltype(functor), NSReal> solver(functor);
  auto status = solver.solve(guess);

  if (status == Eigen::HybridNonLinearSolverSpace::RelativeErrorTooSmall)
    _state = State::CONVERGED_REL;
  else
    _state = State::NOT_CONVERGED;
}

normSquare() [1/3]

template<bool is_ad>

template<typename V >

Real NestedSolveTempl< is_ad >::normSquare ( const V &  v )

static

Compute squared norm of v (dropping derivatives as this is only for convergence checking)

Definition at line 555 of file NestedSolve.h.

Referenced by NestedSolveInternal::DynamicMatrixEigenAdaptorFunctor< is_ad, R, J, store_residual_norm >::operator()(), NestedSolveInternal::RealEigenAdaptorFunctor< is_ad, R, J, store_residual_norm >::operator()(), and NestedSolveInternal::RealVectorEigenAdaptorFunctor< is_ad, R, J, store_residual_norm >::operator()().

{
  // we currently cannot get the raw_value of an AD Eigen Matrix, so we loop over components
  Real norm_square = 0.0;
  for (const auto i : index_range(v))
    norm_square += Utility::pow<2>(MetaPhysicL::raw_value(v.data()[i]));
  return norm_square;
}

normSquare() [2/3]

template<bool is_ad>

Real NestedSolveTempl< is_ad >::normSquare ( const NSReal &  v )

static

Definition at line 103 of file NestedSolve.C.

{
  return Utility::pow<2>(MetaPhysicL::raw_value(v));
}

normSquare() [3/3]

template<bool is_ad>

Real NestedSolveTempl< is_ad >::normSquare ( const NSRealVectorValue &  v )

static

Definition at line 110 of file NestedSolve.C.

{
  return (MetaPhysicL::raw_value(v) * MetaPhysicL::raw_value(v));
}

relativeToleranceDefault()

template<bool is_ad>

static Real NestedSolveTempl< is_ad >::relativeToleranceDefault ( )

inlinestatic

default values

Definition at line 120 of file NestedSolve.h.

{ return 1e-8; }

setAbsoluteTolerance()

template<bool is_ad>

void NestedSolveTempl< is_ad >::setAbsoluteTolerance ( Real  abs )

inline

Definition at line 131 of file NestedSolve.h.

{ _absolute_tolerance_square = abs * abs; }

setAcceptableMultiplier()

template<bool is_ad>

void NestedSolveTempl< is_ad >::setAcceptableMultiplier ( Real  am )

inline

Definition at line 132 of file NestedSolve.h.

{ _acceptable_multiplier = am; }

setRelativeTolerance()

template<bool is_ad>

void NestedSolveTempl< is_ad >::setRelativeTolerance ( Real  rel )

inline

Definition at line 130 of file NestedSolve.h.

{ _relative_tolerance_square = rel * rel; }

sizeItems() [1/2]

template<bool is_ad>

void NestedSolveTempl< is_ad >::sizeItems ( const NestedSolveTempl< is_ad >::DynamicVector &  guess, NestedSolveTempl< is_ad >::DynamicVector &  residual, NestedSolveTempl< is_ad >::DynamicMatrix &  jacobian  ) const

protected

Size a dynamic Jacobian matrix correctly.

Definition at line 83 of file NestedSolve.C.

{
  const auto N = guess.size();
  residual.resize(N, 1);
  jacobian.resize(N, N);
}

sizeItems() [2/2]

template<bool is_ad>

template<typename V , typename T >

void NestedSolveTempl< is_ad >::sizeItems ( const V &  , V &  , T &    ) const

inlineprotected

Sizing is a no-op for compile time sized types (and scalars)

Definition at line 196 of file NestedSolve.h.

  {
  }

validParams()

template<bool is_ad>

InputParameters NestedSolveTempl< is_ad >::validParams ( )

static

Definition at line 16 of file NestedSolve.C.

{
  InputParameters params = emptyInputParameters();

  // Newton iteration control parameters
  params.addParam<Real>("relative_tolerance",
                        relativeToleranceDefault(),
                        "Relative convergence tolerance for Newton iteration");
  params.addParam<Real>("absolute_tolerance",
                        absoluteToleranceDefault(),
                        "Absolute convergence tolerance for Newton iteration");
  params.addParam<Real>("step_size_tolerance",
                        xToleranceDefault(),
                        "Minimum step size of linear iterations relative to value of the solution");
  params.addParam<unsigned int>(
      "min_iterations",
      minIterationsDefault(),
      "Minimum number of nonlinear iterations to execute before accepting convergence");
  params.addParam<unsigned int>(
      "max_iterations", maxIterationsDefault(), "Maximum number of nonlinear iterations");
  params.addParam<Real>("acceptable_multiplier",
                        acceptableMultiplierDefault(),
                        "Factor applied to relative and absolute "
                        "tolerance for acceptable nonlinear convergence if "
                        "iterations are no longer making progress");
  params.addParam<Real>("damping_factor",
                        dampingFactorDefault(),
                        "Factor applied to step size if guess does not satisfy damping criteria");
  params.addParam<unsigned int>(
      "max_damping_iterations",
      maxDampingIterationsDefault(),
      "Maximum number of damping steps per linear iteration of nested solve");
  return params;
}

xToleranceDefault()

template<bool is_ad>

static Real NestedSolveTempl< is_ad >::xToleranceDefault ( )

inlinestatic

Definition at line 122 of file NestedSolve.h.

{ return 1e-15; }

Member Data Documentation

_absolute_tolerance_square

template<bool is_ad>

Real NestedSolveTempl< is_ad >::_absolute_tolerance_square

Definition at line 135 of file NestedSolve.h.

Referenced by NestedSolveTempl< is_ad >::setAbsoluteTolerance().

_acceptable_multiplier

template<bool is_ad>

Real NestedSolveTempl< is_ad >::_acceptable_multiplier

Definition at line 144 of file NestedSolve.h.

Referenced by NestedSolveTempl< is_ad >::setAcceptableMultiplier().

_damping_factor

template<bool is_ad>

Real NestedSolveTempl< is_ad >::_damping_factor

Damping factor.

Definition at line 139 of file NestedSolve.h.

_delta_thresh

template<bool is_ad>

Real NestedSolveTempl< is_ad >::_delta_thresh

Threshold for minimum step size of linear iterations.

Definition at line 137 of file NestedSolve.h.

_max_damping_iterations

template<bool is_ad>

unsigned int NestedSolveTempl< is_ad >::_max_damping_iterations

Definition at line 140 of file NestedSolve.h.

_max_iterations

template<bool is_ad>

unsigned int NestedSolveTempl< is_ad >::_max_iterations

Definition at line 143 of file NestedSolve.h.

_min_iterations

template<bool is_ad>

unsigned int NestedSolveTempl< is_ad >::_min_iterations

Definition at line 142 of file NestedSolve.h.

_n_iterations

template<bool is_ad>

std::size_t NestedSolveTempl< is_ad >::_n_iterations

protected

number of nested iterations

Definition at line 187 of file NestedSolve.h.

Referenced by NestedSolveTempl< is_ad >::getIterations().

_relative_tolerance_square

template<bool is_ad>

Real NestedSolveTempl< is_ad >::_relative_tolerance_square

Definition at line 134 of file NestedSolve.h.

Referenced by NestedSolveTempl< is_ad >::setRelativeTolerance().

_state

template<bool is_ad>

State NestedSolveTempl< is_ad >::_state

protected

current solver state

Definition at line 184 of file NestedSolve.h.

Referenced by NestedSolveTempl< is_ad >::getState().

---

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

• include/utils/NestedSolve.h
• src/utils/NestedSolve.C