Detailed Description

Convergence criterion applying absolute or relative tolerances individually to each component of the whole residual vector.

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

Definition at line 28 of file ConvergenceCriterionPerComponentResidual.h.

#include <ConvergenceCriterionPerComponentResidual.h>

Inheritance diagram for NumLib::ConvergenceCriterionPerComponentResidual:

[legend]

Collaboration diagram for NumLib::ConvergenceCriterionPerComponentResidual:

[legend]

Public Member Functions
	ConvergenceCriterionPerComponentResidual (std::vector< double > &&absolute_tolerances, std::vector< double > &&relative_tolerances, std::vector< double > &&damping_alpha, bool daming_alpha_switch, const MathLib::VecNormType norm_type)

bool	hasDeltaXCheck () const override

bool	hasResidualCheck () const override

bool	hasNonNegativeDamping () 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.

double	getDampingFactor (GlobalVector const &minus_delta_x, GlobalVector const &x, double damping_orig) override

void	setDOFTable (const LocalToGlobalIndexMap &dof_table, MeshLib::Mesh const &mesh) override
	Sets the d.o.f. table used to extract data for a specific component.

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

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::vector< double >	_abstols

const std::vector< double >	_reltols

LocalToGlobalIndexMap const *	_dof_table = nullptr

MeshLib::Mesh const *	_mesh = nullptr

std::vector< double >	_residual_norms_0

const std::vector< double >	_damping_alpha

bool	_damping_alpha_switch

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

◆ ConvergenceCriterionPerComponentResidual()

NumLib::ConvergenceCriterionPerComponentResidual::ConvergenceCriterionPerComponentResidual	(	std::vector< double > &&	absolute_tolerances,
		std::vector< double > &&	relative_tolerances,
		std::vector< double > &&	damping_alpha,
		bool	daming_alpha_switch,
		const MathLib::VecNormType	norm_type )

Definition at line 21 of file ConvergenceCriterionPerComponentResidual.cpp.

    : ConvergenceCriterionPerComponent(norm_type),
      _abstols(std::move(absolute_tolerances)),
      _reltols(std::move(relative_tolerances)),
      _residual_norms_0(_abstols.size()),
      _damping_alpha(std::move(damping_alpha)),
      _damping_alpha_switch(damping_alpha_switch)
{
    if (_abstols.size() != _reltols.size())
    {
        OGS_FATAL(
            "The number of absolute and relative tolerances given must be the "
            "same.");
    }
 
    if (_abstols.empty())
    {
        OGS_FATAL("The given tolerances vector is empty.");
    }
}

References _abstols, and _reltols.

Member Function Documentation

◆ checkDeltaX()

void NumLib::ConvergenceCriterionPerComponentResidual::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 48 of file ConvergenceCriterionPerComponentResidual.cpp.

{
    if (!_dof_table)
    {
        OGS_FATAL("D.o.f. table has not been set.");
    }
 
    for (unsigned global_component = 0; global_component < _abstols.size();
         ++global_component)
    {
        // TODO short cut if tol <= 0.0
        auto error_dx =
            norm(minus_delta_x, global_component, _norm_type, *_dof_table);
        auto norm_x = norm(x, global_component, _norm_type, *_dof_table);
 
        INFO(
            "Convergence criterion, component {:d}: |dx|={:.4e}, |x|={:.4e}, "
            "|dx|/|x|={:.4e}",
            global_component, error_dx, norm_x,
            (norm_x == 0. ? std::numeric_limits<double>::quiet_NaN()
                          : (error_dx / norm_x)));
    }
}

References _abstols, _dof_table, NumLib::ConvergenceCriterion::_norm_type, INFO(), NumLib::norm(), and OGS_FATAL.

◆ checkResidual()

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

overridevirtual

Check if the residual satisfies the convergence criterion.

Implements NumLib::ConvergenceCriterion.

Definition at line 73 of file ConvergenceCriterionPerComponentResidual.cpp.

{
    if (!_dof_table)
    {
        OGS_FATAL("D.o.f. table has not been set.");
    }
 
    for (unsigned global_component = 0; global_component < _abstols.size();
         ++global_component)
    {
        // TODO short cut if tol <= 0.0
        auto norm_res =
            norm(residual, global_component, _norm_type, *_dof_table);
 
        if (_is_first_iteration)
        {
            INFO("Convergence criterion, component {:d}: |r0|={:.4e}",
                 global_component, norm_res);
            _residual_norms_0[global_component] = norm_res;
        }
        else
        {
            auto const norm_res0 = _residual_norms_0[global_component];
            INFO(
                "Convergence criterion, component {:d}: |r|={:.4e}, "
                "|r0|={:.4e}, |r|/|r0|={:.4e}",
                global_component, norm_res, norm_res0,
                (norm_res0 == 0. ? std::numeric_limits<double>::quiet_NaN()
                                 : (norm_res / norm_res0)));
        }
 
        bool const satisfied_abs = norm_res < _abstols[global_component];
        // Make sure that in the first iteration the relative residual tolerance
        // is not satisfied.
        bool const satisfied_rel =
            !_is_first_iteration &&
            checkRelativeTolerance(_reltols[global_component], norm_res,
                                   _residual_norms_0[global_component]);
        _satisfied = _satisfied && (satisfied_abs || satisfied_rel);
    }
}

References _abstols, _dof_table, NumLib::ConvergenceCriterion::_is_first_iteration, NumLib::ConvergenceCriterion::_norm_type, _reltols, _residual_norms_0, NumLib::ConvergenceCriterion::_satisfied, NumLib::checkRelativeTolerance(), INFO(), NumLib::norm(), and OGS_FATAL.

◆ getDampingFactor()

double NumLib::ConvergenceCriterionPerComponentResidual::getDampingFactor	(	GlobalVector const &	minus_delta_x,
		GlobalVector const &	x,
		double	damping_orig )

overridevirtual

Implements NumLib::ConvergenceCriterion.

Definition at line 116 of file ConvergenceCriterionPerComponentResidual.cpp.

{
    if ((!_dof_table) || (!_mesh))
    {
        OGS_FATAL("D.o.f. table or mesh have not been set.");
    }
 
    MathLib::LinAlg::setLocalAccessibleVector(minus_delta_x);
    double damping_final = 1;
    for (unsigned global_component = 0;
         global_component < _damping_alpha.size();
         ++global_component)
    {
        auto const& ms = _dof_table->getMeshSubset(global_component);
        assert(ms.getMeshID() == _mesh->getID());
        DBUG("Non-negative damping for component: {:d} alpha: {:g}",
             global_component, _damping_alpha[global_component]);
        for (auto const& l :
             MeshLib::views::meshLocations(ms, MeshLib::MeshItemType::Node))
        {
            auto index = _dof_table->getGlobalIndex(l, global_component);
            damping_final = std::min(
                damping_final,
                damping_orig / std::max(1.0, (minus_delta_x.get(index) *
                                              _damping_alpha[global_component] /
                                              x.get(index))));
        }
    }
    DBUG("Final damping value due to non-negative damping: {:g}",
         damping_final);
    return damping_final;
}

References _damping_alpha, _dof_table, _mesh, DBUG(), MathLib::EigenVector::get(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), MeshLib::Mesh::getID(), NumLib::LocalToGlobalIndexMap::getMeshSubset(), MeshLib::views::meshLocations(), MeshLib::Node, OGS_FATAL, and MathLib::LinAlg::setLocalAccessibleVector().

◆ hasDeltaXCheck()

bool NumLib::ConvergenceCriterionPerComponentResidual::hasDeltaXCheck ( ) const

inlineoverridevirtual

Tells if the change of the solution between iterations is checked.

Remarks: This method allows to save some computations if no such check will be done.

Implements NumLib::ConvergenceCriterion.

Definition at line 39 of file ConvergenceCriterionPerComponentResidual.h.

39{ return true; }

◆ hasNonNegativeDamping()

bool NumLib::ConvergenceCriterionPerComponentResidual::hasNonNegativeDamping ( ) const

inlineoverridevirtual

Implements NumLib::ConvergenceCriterion.

Definition at line 41 of file ConvergenceCriterionPerComponentResidual.h.

42 {

43 return _damping_alpha_switch;

44 }

References _damping_alpha_switch.

◆ hasResidualCheck()

bool NumLib::ConvergenceCriterionPerComponentResidual::hasResidualCheck ( ) const

inlineoverridevirtual

Tells if the residual is checked.

Remarks: This method allows to save some computations if no such check will be done.

Implements NumLib::ConvergenceCriterion.

Definition at line 40 of file ConvergenceCriterionPerComponentResidual.h.

40{ return true; }

◆ setDOFTable()

void NumLib::ConvergenceCriterionPerComponentResidual::setDOFTable	(	const LocalToGlobalIndexMap &	dof_table,
		MeshLib::Mesh const &	mesh )

overridevirtual

Sets the d.o.f. table used to extract data for a specific component.

Implements NumLib::ConvergenceCriterionPerComponent.

Definition at line 151 of file ConvergenceCriterionPerComponentResidual.cpp.

{
    _dof_table = &dof_table;
    _mesh = &mesh;
 
    if (_dof_table->getNumberOfGlobalComponents() !=
        static_cast<int>(_abstols.size()))
    {
        OGS_FATAL(
            "The number of components in the DOF table and the number of "
            "tolerances given do not match.");
    }
}