NumLib::NonlinearSolver< NonlinearSolverTag::Picard > Class Reference

Detailed Description

Find a solution to a nonlinear equation using the Picard fixpoint iteration method.

Definition at line 160 of file NonlinearSolver.h.

#include <NonlinearSolver.h>

Inheritance diagram for NumLib::NonlinearSolver< NonlinearSolverTag::Picard >:

Collaboration diagram for NumLib::NonlinearSolver< NonlinearSolverTag::Picard >:

Public Types
using	System = NonlinearSystem< NonlinearSolverTag::Picard >
	Type of the nonlinear equation system to be solved. More...

Public Member Functions
	NonlinearSolver (GlobalLinearSolver &linear_solver, const int maxiter)
	~NonlinearSolver ()
void	setEquationSystem (System &eq, ConvergenceCriterion &conv_crit)
void	calculateNonEquilibriumInitialResiduum (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id) override
NonlinearSolverStatus	solve (std::vector< GlobalVector * > &x, std::vector< GlobalVector * > const &x_prev, std::function< void(int, std::vector< GlobalVector * > const &)> const &postIterationCallback, int const process_id) override
void	compensateNonEquilibriumInitialResiduum (bool const value)
Public Member Functions inherited from NumLib::NonlinearSolverBase
virtual	~NonlinearSolverBase ()=default

Private Attributes
GlobalLinearSolver &	_linear_solver
System *	_equation_system = nullptr
ConvergenceCriterion *	_convergence_criterion = nullptr
const int	_maxiter
	maximum number of iterations More...
GlobalVector *	_r_neq = nullptr
	non-equilibrium initial residuum. More...
std::size_t	_A_id = 0u
	ID of the $A$ matrix. More...
std::size_t	_rhs_id = 0u
	ID of the right-hand side vector. More...
std::size_t	_x_new_id = 0u
std::size_t	_r_neq_id = 0u
bool	_compensate_non_equilibrium_initial_residuum = false

Member Typedef Documentation

System

using NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::System = NonlinearSystem<NonlinearSolverTag::Picard>

Type of the nonlinear equation system to be solved.

Definition at line 165 of file NonlinearSolver.h.

Constructor & Destructor Documentation

NonlinearSolver()

NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::NonlinearSolver ( GlobalLinearSolver &  linear_solver, const int  maxiter  )

inlineexplicit

Constructs a new instance.

Parameters

linear_solver	the linear solver used by this nonlinear solver.
maxiter	the maximum number of iterations used to solve the equation.

Definition at line 173 of file NonlinearSolver.h.

        : _linear_solver(linear_solver), _maxiter(maxiter)
    {
    }

~NonlinearSolver()

NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::~NonlinearSolver

(

)

Definition at line 457 of file NonlinearSolver.cpp.

{
    if (_r_neq != nullptr)
    {
        NumLib::GlobalVectorProvider::provider.releaseVector(*_r_neq);
    }
}

References NumLib::GlobalVectorProvider::provider, and NumLib::VectorProvider::releaseVector().

Member Function Documentation

calculateNonEquilibriumInitialResiduum()

void NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::calculateNonEquilibriumInitialResiduum ( std::vector< GlobalVector * > const &  x, std::vector< GlobalVector * > const &  x_prev, int const  process_id  )

overridevirtual

Implements NumLib::NonlinearSolverBase.

Definition at line 27 of file NonlinearSolver.cpp.

{
    if (!_compensate_non_equilibrium_initial_residuum)
    {
        return;
    }
 
    auto& A = NumLib::GlobalMatrixProvider::provider.getMatrix(_A_id);
    auto& rhs = NumLib::GlobalVectorProvider::provider.getVector(_rhs_id);
    _equation_system->assemble(x, x_prev, process_id);
    _equation_system->getA(A);
    _equation_system->getRhs(*x_prev[process_id], rhs);
 
    // r_neq = A * x - rhs
    _r_neq = &NumLib::GlobalVectorProvider::provider.getVector(_r_neq_id);
    MathLib::LinAlg::matMult(A, *x[process_id], *_r_neq);
    MathLib::LinAlg::axpy(*_r_neq, -1.0, rhs);  // res -= rhs
}

References MathLib::LinAlg::axpy(), NumLib::MatrixProvider::getMatrix(), NumLib::VectorProvider::getVector(), MathLib::LinAlg::matMult(), NumLib::GlobalVectorProvider::provider, and NumLib::GlobalMatrixProvider::provider.

compensateNonEquilibriumInitialResiduum()

void NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::compensateNonEquilibriumInitialResiduum ( bool const  value )

inline

Definition at line 201 of file NonlinearSolver.h.

    {
        _compensate_non_equilibrium_initial_residuum = value;
    }

setEquationSystem()

void NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::setEquationSystem ( System &  eq, ConvergenceCriterion &  conv_crit  )

inline

Set the nonlinear equation system that will be solved. TODO doc

Definition at line 183 of file NonlinearSolver.h.

    {
        _equation_system = &eq;
        _convergence_criterion = &conv_crit;
    }

solve()

NonlinearSolverStatus NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::solve ( std::vector< GlobalVector * > &  x, std::vector< GlobalVector * > const &  x_prev, std::function< void(int, std::vector< GlobalVector * > const &)> const &  postIterationCallback, int const  process_id  )

overridevirtual

Assemble and solve the equation system.

Parameters

x	in: the initial guess, out: the solution.
x_prev	previous time step solution.
postIterationCallback	called after each iteration if set.
process_id	usually used in staggered schemes.

Return values

true	if the equation system could be solved
false	otherwise

Implements NumLib::NonlinearSolverBase.

Definition at line 49 of file NonlinearSolver.cpp.

{
    namespace LinAlg = MathLib::LinAlg;
    auto& sys = *_equation_system;
 
    auto& A = NumLib::GlobalMatrixProvider::provider.getMatrix(_A_id);
    auto& rhs = NumLib::GlobalVectorProvider::provider.getVector(_rhs_id);
 
    std::vector<GlobalVector*> x_new{x};
    x_new[process_id] =
        &NumLib::GlobalVectorProvider::provider.getVector(_x_new_id);
    LinAlg::copy(*x[process_id], *x_new[process_id]);  // set initial guess
 
    bool error_norms_met = false;
 
    _convergence_criterion->preFirstIteration();
 
    int iteration = 1;
    for (; iteration <= _maxiter; ++iteration, _convergence_criterion->reset())
    {
        BaseLib::RunTime timer_dirichlet;
        double time_dirichlet = 0.0;
 
        BaseLib::RunTime time_iteration;
        time_iteration.start();
 
        timer_dirichlet.start();
        sys.computeKnownSolutions(*x_new[process_id], process_id);
        sys.applyKnownSolutions(*x_new[process_id]);
        time_dirichlet += timer_dirichlet.elapsed();
 
        sys.preIteration(iteration, *x_new[process_id]);
 
        BaseLib::RunTime time_assembly;
        time_assembly.start();
        sys.assemble(x_new, x_prev, process_id);
        sys.getA(A);
        sys.getRhs(*x_prev[process_id], rhs);
        INFO("[time] Assembly took {:g} s.", time_assembly.elapsed());
 
        // Subtract non-equilibrium initial residuum if set
        if (_r_neq != nullptr)
        {
            LinAlg::axpy(rhs, -1, *_r_neq);
        }
 
        timer_dirichlet.start();
        sys.applyKnownSolutionsPicard(A, rhs, *x_new[process_id]);
        time_dirichlet += timer_dirichlet.elapsed();
        INFO("[time] Applying Dirichlet BCs took {:g} s.", time_dirichlet);
 
        if (!sys.isLinear() && _convergence_criterion->hasResidualCheck())
        {
            GlobalVector res;
            LinAlg::matMult(A, *x_new[process_id], res);  // res = A * x_new
            LinAlg::axpy(res, -1.0, rhs);                 // res -= rhs
            _convergence_criterion->checkResidual(res);
        }
 
        BaseLib::RunTime time_linear_solver;
        time_linear_solver.start();
        bool iteration_succeeded =
            _linear_solver.solve(A, rhs, *x_new[process_id]);
        INFO("[time] Linear solver took {:g} s.", time_linear_solver.elapsed());
 
        if (!iteration_succeeded)
        {
            ERR("Picard: The linear solver failed.");
        }
        else
        {
            if (postIterationCallback)
            {
                postIterationCallback(iteration, x_new);
            }
 
            switch (sys.postIteration(*x_new[process_id]))
            {
                case IterationResult::SUCCESS:
                    // Don't copy here. The old x might still be used further
                    // below. Although currently it is not.
                    break;
                case IterationResult::FAILURE:
                    ERR("Picard: The postIteration() hook reported a "
                        "non-recoverable error.");
                    iteration_succeeded = false;
                    // Copy new solution to x.
                    // Thereby the failed solution can be used by the caller for
                    // debugging purposes.
                    LinAlg::copy(*x_new[process_id], *x[process_id]);
                    break;
                case IterationResult::REPEAT_ITERATION:
                    INFO(
                        "Picard: The postIteration() hook decided that this "
                        "iteration has to be repeated.");
                    LinAlg::copy(
                        *x[process_id],
                        *x_new[process_id]);  // throw the iteration result away
                    continue;
            }
        }
 
        if (!iteration_succeeded)
        {
            // Don't compute error norms, break here.
            error_norms_met = false;
            break;
        }
 
        if (sys.isLinear())
        {
            error_norms_met = true;
        }
        else
        {
            if (_convergence_criterion->hasDeltaXCheck())
            {
                GlobalVector minus_delta_x(*x[process_id]);
                LinAlg::axpy(minus_delta_x, -1.0,
                             *x_new[process_id]);  // minus_delta_x = x - x_new
                _convergence_criterion->checkDeltaX(minus_delta_x,
                                                    *x_new[process_id]);
            }
 
            error_norms_met = _convergence_criterion->isSatisfied();
        }
 
        // Update x s.t. in the next iteration we will compute the right delta x
        LinAlg::copy(*x_new[process_id], *x[process_id]);
 
        INFO("[time] Iteration #{:d} took {:g} s.", iteration,
             time_iteration.elapsed());
 
        if (error_norms_met)
        {
            break;
        }
 
        // Avoid increment of the 'iteration' if the error norms are not met,
        // but maximum number of iterations is reached.
        if (iteration >= _maxiter)
        {
            break;
        }
    }
 
    if (iteration > _maxiter)
    {
        ERR("Picard: Could not solve the given nonlinear system within {:d} "
            "iterations",
            _maxiter);
    }
 
    NumLib::GlobalMatrixProvider::provider.releaseMatrix(A);
    NumLib::GlobalVectorProvider::provider.releaseVector(rhs);
    NumLib::GlobalVectorProvider::provider.releaseVector(*x_new[process_id]);
 
    return {error_norms_met, iteration};
}

References MathLib::LinAlg::axpy(), MathLib::LinAlg::copy(), BaseLib::RunTime::elapsed(), ERR(), NumLib::FAILURE, NumLib::MatrixProvider::getMatrix(), NumLib::VectorProvider::getVector(), INFO(), MathLib::LinAlg::matMult(), NumLib::GlobalVectorProvider::provider, NumLib::GlobalMatrixProvider::provider, NumLib::MatrixProvider::releaseMatrix(), NumLib::VectorProvider::releaseVector(), NumLib::REPEAT_ITERATION, BaseLib::RunTime::start(), and NumLib::SUCCESS.

Member Data Documentation

_A_id

std::size_t NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::_A_id = 0u

private

ID of the $A$ matrix.

Definition at line 215 of file NonlinearSolver.h.

_compensate_non_equilibrium_initial_residuum

bool NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::_compensate_non_equilibrium_initial_residuum = false

private

Enables computation of the non-equilibrium initial residuum $r_{\rm neq}$ before the first time step. The forces are zero if the external forces are in equilibrium with the initial state/initial conditions. During the simulation the new residuum reads $\tilde r = r - r_{\rm neq}$.

Definition at line 224 of file NonlinearSolver.h.

_convergence_criterion

ConvergenceCriterion* NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::_convergence_criterion = nullptr

private

Definition at line 211 of file NonlinearSolver.h.

_equation_system

System* NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::_equation_system = nullptr

private

Definition at line 208 of file NonlinearSolver.h.

_linear_solver

GlobalLinearSolver& NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::_linear_solver

private

Definition at line 207 of file NonlinearSolver.h.

_maxiter

const int NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::_maxiter

private

maximum number of iterations

Definition at line 212 of file NonlinearSolver.h.

_r_neq

GlobalVector* NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::_r_neq = nullptr

private

non-equilibrium initial residuum.

Definition at line 214 of file NonlinearSolver.h.

_r_neq_id

std::size_t NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::_r_neq_id = 0u

private

ID of the non-equilibrium initial residuum vector.

Definition at line 219 of file NonlinearSolver.h.

_rhs_id

std::size_t NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::_rhs_id = 0u

private

ID of the right-hand side vector.

Definition at line 216 of file NonlinearSolver.h.

_x_new_id

std::size_t NumLib::NonlinearSolver< NonlinearSolverTag::Picard >::_x_new_id = 0u

private

ID of the vector storing the solution of the linearized equation.

Definition at line 217 of file NonlinearSolver.h.

---

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

• NumLib/ODESolver/NonlinearSolver.h
• NumLib/ODESolver/NonlinearSolver.cpp