Detailed Description

Convergence criterion applying a single absolute or relative tolerance to the whole residual vector.

A check of the solution increment is not done. If both an absolute and a relative tolerance are specified, at least one of them has to be satisfied.

Definition at line 26 of file ConvergenceCriterionResidual.h.

#include <ConvergenceCriterionResidual.h>

Inheritance diagram for NumLib::ConvergenceCriterionResidual:

[legend]

Collaboration diagram for NumLib::ConvergenceCriterionResidual:

[legend]

Public Member Functions
	ConvergenceCriterionResidual (std::optional< double > &&absolute_tolerance, std::optional< double > &&relative_tolerance, const MathLib::VecNormType norm_type)

bool	hasDeltaXCheck () const override

bool	hasResidualCheck () const override

void	checkDeltaX (const GlobalVector &minus_delta_x, GlobalVector const &x) override

void	checkResidual (const GlobalVector &residual) override
	Check if the residual satisfies the convergence criterion. More...

Public Member Functions inherited from NumLib::ConvergenceCriterion
	ConvergenceCriterion (const MathLib::VecNormType norm_type)

virtual void	preFirstIteration ()

virtual void	setNoFirstIteration ()

virtual void	reset ()

virtual bool	isSatisfied () const
	Tell if the convergence criterion is satisfied. More...

MathLib::VecNormType	getVectorNormType () const

virtual	~ConvergenceCriterion ()=default

Private Attributes
const std::optional< double >	_abstol

const std::optional< double >	_reltol

double	_residual_norm_0

Additional Inherited Members
Protected Attributes inherited from NumLib::ConvergenceCriterion
bool	_satisfied = true

bool	_is_first_iteration = true

const MathLib::VecNormType	_norm_type

Constructor & Destructor Documentation

◆ ConvergenceCriterionResidual()

NumLib::ConvergenceCriterionResidual::ConvergenceCriterionResidual	(	std::optional< double > &&	absolute_tolerance,
		std::optional< double > &&	relative_tolerance,
		const MathLib::VecNormType	norm_type
	)

Definition at line 19 of file ConvergenceCriterionResidual.cpp.

     : ConvergenceCriterion(norm_type),
       _abstol(std::move(absolute_tolerance)),
       _reltol(std::move(relative_tolerance))
 {
     if ((!_abstol) && (!_reltol))
     {
         OGS_FATAL(
             "At least one of absolute or relative tolerance has to be "
             "specified.");
     }
 }

References _abstol, _reltol, and OGS_FATAL.

Member Function Documentation

◆ checkDeltaX()

void NumLib::ConvergenceCriterionResidual::checkDeltaX	(	const GlobalVector &	minus_delta_x,
		GlobalVector const &	x
	)

overridevirtual

The function will only do diagnostic output and no actual check of the solution increment is made

Implements NumLib::ConvergenceCriterion.

Definition at line 35 of file ConvergenceCriterionResidual.cpp.

 {
     auto error_dx = MathLib::LinAlg::norm(minus_delta_x, _norm_type);
     auto norm_x = MathLib::LinAlg::norm(x, _norm_type);
  
     INFO("Convergence criterion: |dx|={:.4e}, |x|={:.4e}, |dx|/|x|={:.4e}",
          error_dx, norm_x,
          (norm_x == 0. ? std::numeric_limits<double>::quiet_NaN()
                        : (error_dx / norm_x)));
 }

References NumLib::ConvergenceCriterion::_norm_type, INFO(), and MathLib::LinAlg::norm().

◆ checkResidual()

void NumLib::ConvergenceCriterionResidual::checkResidual ( const GlobalVector & residual )

overridevirtual

Check if the residual satisfies the convergence criterion.

Implements NumLib::ConvergenceCriterion.

Definition at line 47 of file ConvergenceCriterionResidual.cpp.

 {
     auto norm_res = MathLib::LinAlg::norm(residual, _norm_type);
  
     if (_is_first_iteration)
     {
         INFO("Convergence criterion: |r0|={:.4e}", norm_res);
         _residual_norm_0 = norm_res;
     }
     else
     {
         _residual_norm_0 =
             (_residual_norm_0 < std::numeric_limits<double>::epsilon())
                 ? norm_res
                 : _residual_norm_0;
         if (_residual_norm_0 < std::numeric_limits<double>::epsilon())
         {
             INFO("Convergence criterion: |r|={:.4e} |r0|={:.4e}", norm_res,
                  _residual_norm_0);
         }
         else
         {
             INFO(
                 "Convergence criterion: |r|={:.4e} |r0|={:.4e} |r|/|r0|={:.4e}",
                 norm_res, _residual_norm_0,
                 (_residual_norm_0 == 0.
                      ? std::numeric_limits<double>::quiet_NaN()
                      : (norm_res / _residual_norm_0)));
         }
     }
  
     bool satisfied_abs = false;
     bool satisfied_rel = false;
  
     if (_abstol)
     {
         satisfied_abs = norm_res < *_abstol;
     }
     if (_reltol && !_is_first_iteration)
     {
         satisfied_rel =
             checkRelativeTolerance(*_reltol, norm_res, _residual_norm_0);
     }
  
     _satisfied = _satisfied && (satisfied_abs || satisfied_rel);
 }