solver.hh

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
//
// SPDX-FileCopyrightInfo: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
#ifndef DUMUX_LINEAR_SOLVER_HH
#define DUMUX_LINEAR_SOLVER_HH
 
#include <dune/common/parallel/mpihelper.hh>
#include <dune/common/exceptions.hh>
#include <dune/istl/scalarproducts.hh>
#include <dumux/common/parameters.hh>
 
namespace Dumux {
 
class LinearSolver
{
public:
    using Scalar = double;
 
    LinearSolver(const std::string& paramGroup = "")
    : paramGroup_(paramGroup)
    {
        verbosity_ = getParamFromGroup<int>(paramGroup, "LinearSolver.Verbosity", 0);
        maxIter_ = getParamFromGroup<int>(paramGroup, "LinearSolver.MaxIterations", 250);
        residReduction_ = getParamFromGroup<Scalar>(paramGroup, "LinearSolver.ResidualReduction", 1e-13);
        relaxation_ = getParamFromGroup<Scalar>(paramGroup, "LinearSolver.Preconditioner.Relaxation", 1);
        precondIter_ = getParamFromGroup<int>(paramGroup, "LinearSolver.Preconditioner.Iterations", 1);
        precondVerbosity_ = getParamFromGroup<int>(paramGroup, "LinearSolver.Preconditioner.Verbosity", 0);
    }
 
    template<class Matrix, class Vector>
    bool solve(const Matrix& A, Vector& x, const Vector& b)
    {
        DUNE_THROW(Dune::NotImplemented, "Linear solver doesn't implement a solve method!");
    }
 
    template<class Vector>
    auto norm(const Vector& x) const
    {
        if (Dune::MPIHelper::getCommunication().size() > 1)
            DUNE_THROW(Dune::NotImplemented, "norm in parallel");
 
        return Dune::SeqScalarProduct<Vector>().norm(x);
    }
 
    std::string name() const
    { return "unknown solver"; }
 
    const std::string& paramGroup() const
    { return paramGroup_; }
 
    int verbosity() const
    { return verbosity_; }
 
    void setVerbosity(int v)
    { verbosity_ = v; }
 
    int maxIter() const
    { return maxIter_; }
 
    void setMaxIter(int i)
    { maxIter_ = i; }
 
    Scalar residReduction() const
    { return residReduction_; }
 
    void setResidualReduction(Scalar r)
    { residReduction_ = r; }
 
    Scalar relaxation() const
    { return relaxation_; }
 
    void setRelaxation(Scalar r)
    { relaxation_ = r; }
 
    int precondIter() const
    { return precondIter_; }
 
    void setPrecondIter(int i)
    { precondIter_ = i; }
 
    int precondVerbosity() const
    { return precondVerbosity_; }
 
    void setPrecondVerbosity(int verbosityLevel)
    { precondVerbosity_ = verbosityLevel; }
 
private:
    int verbosity_;
    int maxIter_;
    Scalar residReduction_;
    Scalar relaxation_;
    int precondIter_;
    int precondVerbosity_;
    const std::string paramGroup_;
};
 
} // end namespace Dumux
 
#endif