Detailed Description

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

A residual check 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 20 of file ConvergenceCriterionPerComponentDeltaX.h.

#include <ConvergenceCriterionPerComponentDeltaX.h>

Inheritance diagram for NumLib::ConvergenceCriterionPerComponentDeltaX:

[legend]

Collaboration diagram for NumLib::ConvergenceCriterionPerComponentDeltaX:

[legend]

Public Member Functions
	ConvergenceCriterionPerComponentDeltaX (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
DampingPolicy const *	dampingPolicy () const override
void	checkDeltaX (const GlobalVector &minus_delta_x, GlobalVector const &x) override
void	checkResidual (const GlobalVector &) override
	Check if the residual satisfies the convergence criterion.
double	apply (GlobalVector const &minus_delta_x, GlobalVector const &x, double const base_damping) const override
void	reset () 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 bool	isSatisfied () const
	Tell if the convergence criterion is satisfied.
MathLib::VecNormType	getVectorNormType () const
virtual	~ConvergenceCriterion ()=default
Public Member Functions inherited from NumLib::DampingPolicy
virtual	~DampingPolicy ()=default

Private Attributes
const std::vector< double >	_abstols
const std::vector< double >	_reltols
const std::vector< double >	_damping_alpha
bool	_damping_alpha_switch
LocalToGlobalIndexMap const *	_dof_table = nullptr
MeshLib::Mesh const *	_mesh = nullptr

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

◆ ConvergenceCriterionPerComponentDeltaX()

NumLib::ConvergenceCriterionPerComponentDeltaX::ConvergenceCriterionPerComponentDeltaX	(	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 17 of file ConvergenceCriterionPerComponentDeltaX.cpp.

    : ConvergenceCriterionPerComponent(norm_type),
      _abstols(std::move(absolute_tolerances)),
      _reltols(std::move(relative_tolerances)),
      _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 NumLib::ConvergenceCriterionPerComponent::ConvergenceCriterionPerComponent(), _abstols, _damping_alpha, _damping_alpha_switch, and _reltols.

Member Function Documentation

◆ apply()

double NumLib::ConvergenceCriterionPerComponentDeltaX::apply	(	GlobalVector const &	minus_delta_x,
		GlobalVector const &	x,
		double const	base_damping ) const

overridevirtual

Implements NumLib::DampingPolicy.

Definition at line 73 of file ConvergenceCriterionPerComponentDeltaX.cpp.

{
    if (!_dof_table)
    {
        OGS_FATAL("D.o.f. table has 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,
                base_damping / 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(), MeshLib::views::meshLocations(), MeshLib::Node, OGS_FATAL, and MathLib::LinAlg::setLocalAccessibleVector().

◆ checkDeltaX()

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

overridevirtual

Check if the change of the solution between iterations satisfies the convergence criterion.

Parameters

minus_delta_x	the current solution update
x	the new solution from the current iteration

Remarks: The Newton-Raphson solver computes minus_delta_x. x is needed for relative tolerances.

Implements NumLib::ConvergenceCriterion.

Definition at line 42 of file ConvergenceCriterionPerComponentDeltaX.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)));
 
        bool const satisfied_abs = error_dx < _abstols[global_component];
        bool const satisfied_rel = checkRelativeTolerance(
            _reltols[global_component], error_dx, norm_x);
 
        _satisfied = _satisfied && (satisfied_abs || satisfied_rel);
    }
}

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

◆ checkResidual()

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

inlineoverridevirtual

Check if the residual satisfies the convergence criterion.

Implements NumLib::ConvergenceCriterion.

Definition at line 41 of file ConvergenceCriterionPerComponentDeltaX.h.

41{}

◆ dampingPolicy()

DampingPolicy const * NumLib::ConvergenceCriterionPerComponentDeltaX::dampingPolicy ( ) const

inlineoverridevirtual

Returns the DampingPolicy implemented by this criterion, or nullptr if this criterion does not constrain the step length.

Reimplemented from NumLib::ConvergenceCriterion.

Definition at line 34 of file ConvergenceCriterionPerComponentDeltaX.h.

    {
        return _damping_alpha_switch ? this : nullptr;
    }

References _damping_alpha_switch.

◆ hasDeltaXCheck()

bool NumLib::ConvergenceCriterionPerComponentDeltaX::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 32 of file ConvergenceCriterionPerComponentDeltaX.h.

32{ return true; }

◆ hasResidualCheck()

bool NumLib::ConvergenceCriterionPerComponentDeltaX::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 33 of file ConvergenceCriterionPerComponentDeltaX.h.

33{ return false; }

◆ reset()

void NumLib::ConvergenceCriterionPerComponentDeltaX::reset ( )

inlineoverridevirtual

Indicate that a new iteration now starts.

A concrete implementation of ConvergenceCriterion might want to check both delta x and the residual. I.e., in a new iteration both checks have to be done anew. This method will make the ConvergenceCriterion forget the result of all checks already done, s.t. all necessary checks will have to be repeated in order to satisfy the ConvergenceCriterion.

Reimplemented from NumLib::ConvergenceCriterion.

Definition at line 46 of file ConvergenceCriterionPerComponentDeltaX.h.

46{ this->_satisfied = true; }

References NumLib::ConvergenceCriterion::_satisfied.

◆ setDOFTable()

void NumLib::ConvergenceCriterionPerComponentDeltaX::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 108 of file ConvergenceCriterionPerComponentDeltaX.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 ({:d}) and the number "
            "of tolerances given ({:d}) do not match.",
            _dof_table->getNumberOfGlobalComponents(),
            static_cast<int>(_abstols.size()));
    }
}