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.

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.

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