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:
/*****************************************************************************
 *   See the file COPYING for full copying permissions.                      *
 *                                                                           *
 *   This program is free software: you can redistribute it and/or modify    *
 *   it under the terms of the GNU General Public License as published by    *
 *   the Free Software Foundation, either version 3 of the License, or       *
 *   (at your option) any later version.                                     *
 *                                                                           *
 *   This program is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
 *   GNU General Public License for more details.                            *
 *                                                                           *
 *   You should have received a copy of the GNU General Public License       *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.   *
 *****************************************************************************/
#ifndef DUMUX_LINEAR_SOLVER_HH
#define DUMUX_LINEAR_SOLVER_HH
 
#include <dune/common/exceptions.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<double>(paramGroup, "LinearSolver.ResidualReduction", 1e-13);
 
        // for deprecation period we ask also for the "old" parameters but print a warning
        // the "new" style parameter takes precedence
        // TODO: Remove all this code after 3.2 and use commented code below
        if (hasParamInGroup(paramGroup, "LinearSolver.PreconditionerRelaxation"))
        {
            std::cerr << "Deprecation warning: parameter LinearSolver.PreconditionerRelaxation is deprecated and will be removed after 3.2. "
                      << "Use LinearSolver.Preconditioner.Relaxation instead (Preconditioner subgroup)." << std::endl;
            relaxation_ = getParamFromGroup<double>(paramGroup, "LinearSolver.PreconditionerRelaxation");
        }
        else
            relaxation_ = getParamFromGroup<double>(paramGroup, "LinearSolver.Preconditioner.Relaxation", 1);
 
        if (hasParamInGroup(paramGroup, "LinearSolver.PreconditionerIterations"))
        {
            std::cerr << "Deprecation warning: parameter LinearSolver.PreconditionerIterations is deprecated and will be removed after 3.2. "
                      << "Use LinearSolver.Preconditioner.Iterations instead (Preconditioner subgroup)." << std::endl;
            precondIter_ = getParamFromGroup<int>(paramGroup, "LinearSolver.PreconditionerIterations");
        }
        else
            precondIter_ = getParamFromGroup<int>(paramGroup, "LinearSolver.Preconditioner.Iterations", 1);
 
        if (hasParamInGroup(paramGroup, "LinearSolver.PreconditionerVerbosity"))
        {
            std::cerr << "Deprecation warning: parameter LinearSolver.PreconditionerVerbosity is deprecated and will be removed after 3.2. "
                      << "Use LinearSolver.Preconditioner.Verbosity instead (Preconditioner subgroup)." << std::endl;
            precondVerbosity_ = getParamFromGroup<int>(paramGroup, "LinearSolver.PreconditionerVerbosity");
        }
        else
            precondVerbosity_ = getParamFromGroup<int>(paramGroup, "LinearSolver.Preconditioner.Verbosity", 0);
 
        // TODO: use this code instead of the above code after release 3.2
        // relaxation_ = getParamFromGroup<double>(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!");
    }
 
    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; }
 
    double residReduction() const
    { return residReduction_; }
 
    void setResidualReduction(double r)
    { residReduction_ = r; }
 
    double relaxation() const
    { return relaxation_; }
 
    void setRelaxation(double 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_;
    double residReduction_;
    double relaxation_;
    int precondIter_;
    int precondVerbosity_;
    const std::string paramGroup_;
};
 
} // end namespace Dumux
 
#endif