From bfbee5cd95f37aedd1d736ec2dd0461901d0d390 Mon Sep 17 00:00:00 2001
From: Timo Koch <timokoch@uio.no>
Date: Sat, 27 May 2023 14:26:42 +0200
Subject: [PATCH] [solvers] Remove deprecated solvers and deprecate now
obsolete helper interface
---
dumux/linear/seqsolverbackend.hh | 717 +------------------------------
1 file changed, 4 insertions(+), 713 deletions(-)
diff --git a/dumux/linear/seqsolverbackend.hh b/dumux/linear/seqsolverbackend.hh
index 916740a315..103961b4b7 100644
--- a/dumux/linear/seqsolverbackend.hh
+++ b/dumux/linear/seqsolverbackend.hh
@@ -18,8 +18,6 @@
#include <dune/istl/preconditioners.hh>
#include <dune/istl/solvers.hh>
-#include <dune/istl/superlu.hh>
-#include <dune/istl/umfpack.hh>
#include <dune/istl/io.hh>
#include <dune/common/indices.hh>
#include <dune/common/hybridutilities.hh>
@@ -55,6 +53,7 @@ class IterativePreconditionedSolverImpl
public:
template<class Preconditioner, class Solver, class SolverInterface, class Matrix, class Vector>
+ [[deprecated("Removed after 3.8. Use solver from istlsolvers.hh")]]
static bool solve(const SolverInterface& s, const Matrix& A, Vector& x, const Vector& b,
const std::string& modelParamGroup = "")
{
@@ -75,6 +74,7 @@ public:
}
template<class Preconditioner, class Solver, class SolverInterface, class Matrix, class Vector>
+ [[deprecated("Removed after 3.8. Use solver from istlsolvers.hh")]]
static bool solveWithGMRes(const SolverInterface& s, const Matrix& A, Vector& x, const Vector& b,
const std::string& modelParamGroup = "")
{
@@ -98,6 +98,7 @@ public:
}
template<class Preconditioner, class Solver, class SolverInterface, class Matrix, class Vector>
+ [[deprecated("Removed after 3.8. Use solver from istlsolvers.hh")]]
static bool solveWithILU0Prec(const SolverInterface& s, const Matrix& A, Vector& x, const Vector& b,
const std::string& modelParamGroup = "")
{
@@ -118,6 +119,7 @@ public:
// solve with RestartedGMRes (needs restartGMRes as additional argument)
template<class Preconditioner, class Solver, class SolverInterface, class Matrix, class Vector>
+ [[deprecated("Removed after 3.8. Use solver from istlsolvers.hh")]]
static bool solveWithILU0PrecGMRes(const SolverInterface& s, const Matrix& A, Vector& x, const Vector& b,
const std::string& modelParamGroup = "")
{
@@ -172,565 +174,6 @@ constexpr std::size_t preconditionerBlockLevel() noexcept
return isMultiTypeBlockMatrix<M>::value ? 2 : 1;
}
-/*!
- * \ingroup Linear
- * \brief Sequential ILU(n)-preconditioned BiCSTAB solver.
- *
- * Solver: The BiCGSTAB (stabilized biconjugate gradients method) solver has
- * faster and smoother convergence than the original BiCG. It can be applied to
- * nonsymmetric matrices.\n
- * See: Van der Vorst, H. A. (1992). "Bi-CGSTAB: A Fast and Smoothly Converging
- * Variant of Bi-CG for the Solution of Nonsymmetric Linear Systems".
- * SIAM J. Sci. and Stat. Comput. 13 (2): 631–644. doi:10.1137/0913035.
- *
- * Preconditioner: ILU(n) incomplete LU factorization. The order n can be
- * provided by the parameter LinearSolver.PreconditionerIterations and controls
- * the fill-in. It can be damped by the relaxation parameter
- * LinearSolver.PreconditionerRelaxation.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] ILUnBiCGSTABBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqILU<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::BiCGSTABSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solve<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "ILUn preconditioned BiCGSTAB solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential SOR-preconditioned BiCSTAB solver.
- *
- * Solver: The BiCGSTAB (stabilized biconjugate gradients method) solver has
- * faster and smoother convergence than the original BiCG. It can be applied to
- * nonsymmetric matrices.\n
- * See: Van der Vorst, H. A. (1992). "Bi-CGSTAB: A Fast and Smoothly Converging
- * Variant of Bi-CG for the Solution of Nonsymmetric Linear Systems".
- * SIAM J. Sci. and Stat. Comput. 13 (2): 631–644. doi:10.1137/0913035.
- *
- * Preconditioner: SOR successive overrelaxation method. The relaxation is
- * controlled by the parameter LinearSolver.PreconditionerRelaxation. In each
- * preconditioning step, it is applied as often as given by the parameter
- * LinearSolver.PreconditionerIterations.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] SORBiCGSTABBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqSOR<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::BiCGSTABSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solve<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "SOR preconditioned BiCGSTAB solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential SSOR-preconditioned BiCGSTAB solver.
- *
- * Solver: The BiCGSTAB (stabilized biconjugate gradients method) solver has
- * faster and smoother convergence than the original BiCG. While, it can be
- * applied to nonsymmetric matrices, the preconditioner SSOR assumes symmetry.\n
- * See: Van der Vorst, H. A. (1992). "Bi-CGSTAB: A Fast and Smoothly Converging
- * Variant of Bi-CG for the Solution of Nonsymmetric Linear Systems".
- * SIAM J. Sci. and Stat. Comput. 13 (2): 631–644. doi:10.1137/0913035.
- *
- * Preconditioner: SSOR symmetric successive overrelaxation method. The
- * relaxation is controlled by the parameter LinearSolver.PreconditionerRelaxation.
- * In each preconditioning step, it is applied as often as given by the parameter
- * LinearSolver.PreconditionerIterations.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] SSORBiCGSTABBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqSSOR<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::BiCGSTABSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solve<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "SSOR preconditioned BiCGSTAB solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential GS-preconditioned BiCGSTAB solver.
- *
- * Solver: The BiCGSTAB (stabilized biconjugate gradients method) solver has
- * faster and smoother convergence than the original BiCG. While, it can be
- * applied to nonsymmetric matrices, the preconditioner SSOR assumes symmetry.\n
- * See: Van der Vorst, H. A. (1992). "Bi-CGSTAB: A Fast and Smoothly Converging
- * Variant of Bi-CG for the Solution of Nonsymmetric Linear Systems".
- * SIAM J. Sci. and Stat. Comput. 13 (2): 631–644. doi:10.1137/0913035.
- *
- * Preconditioner: GS Gauss-Seidel method. It can be damped by the relaxation
- * parameter LinearSolver.PreconditionerRelaxation. In each preconditioning step,
- * it is applied as often as given by the parameter
- * LinearSolver.PreconditionerIterations.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] GSBiCGSTABBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqGS<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::BiCGSTABSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solve<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "SSOR preconditioned BiCGSTAB solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential Jacobi-preconditioned BiCSTAB solver.
- *
- * Solver: The BiCGSTAB (stabilized biconjugate gradients method) solver has
- * faster and smoother convergence than the original BiCG. While, it can be
- * applied to nonsymmetric matrices, the preconditioner SSOR assumes symmetry.\n
- * See: Van der Vorst, H. A. (1992). "Bi-CGSTAB: A Fast and Smoothly Converging
- * Variant of Bi-CG for the Solution of Nonsymmetric Linear Systems".
- * SIAM J. Sci. and Stat. Comput. 13 (2): 631–644. doi:10.1137/0913035.
- *
- * Preconditioner: Jacobi method. It can be damped by the relaxation parameter
- * LinearSolver.PreconditionerRelaxation. In each preconditioning step, it is
- * applied as often as given by the parameter LinearSolver.PreconditionerIterations.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] JacBiCGSTABBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqJac<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::BiCGSTABSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solve<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "Jac preconditioned BiCGSTAB solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential ILU(n)-preconditioned CG solver.
- *
- * Solver: CG (conjugate gradient) is an iterative method for solving linear
- * systems with a symmetric, positive definite matrix.\n
- * See: Helfenstein, R., Koko, J. (2010). "Parallel preconditioned conjugate
- * gradient algorithm on GPU", Journal of Computational and Applied Mathematics,
- * Volume 236, Issue 15, Pages 3584–3590, http://dx.doi.org/10.1016/j.cam.2011.04.025.
- *
- * Preconditioner: ILU(n) incomplete LU factorization. The order n can be
- * provided by the parameter LinearSolver.PreconditionerIterations and controls
- * the fill-in. It can be damped by the relaxation parameter
- * LinearSolver.PreconditionerRelaxation.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] ILUnCGBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqILU<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::CGSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solve<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "ILUn preconditioned CG solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential SOR-preconditioned CG solver.
- *
- * Solver: CG (conjugate gradient) is an iterative method for solving linear
- * systems with a symmetric, positive definite matrix.\n
- * See: Helfenstein, R., Koko, J. (2010). "Parallel preconditioned conjugate
- * gradient algorithm on GPU", Journal of Computational and Applied Mathematics,
- * Volume 236, Issue 15, Pages 3584–3590, http://dx.doi.org/10.1016/j.cam.2011.04.025.
- *
- * Preconditioner: SOR successive overrelaxation method. The relaxation is
- * controlled by the parameter LinearSolver.PreconditionerRelaxation. In each
- * preconditioning step, it is applied as often as given by the parameter
- * LinearSolver.PreconditionerIterations.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] SORCGBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqSOR<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::CGSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solve<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "SOR preconditioned CG solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential SSOR-preconditioned CG solver.
- *
- * Solver: CG (conjugate gradient) is an iterative method for solving linear
- * systems with a symmetric, positive definite matrix.\n
- * See: Helfenstein, R., Koko, J. (2010). "Parallel preconditioned conjugate
- * gradient algorithm on GPU", Journal of Computational and Applied Mathematics,
- * Volume 236, Issue 15, Pages 3584–3590, http://dx.doi.org/10.1016/j.cam.2011.04.025.
- *
- * Preconditioner: SSOR symmetric successive overrelaxation method. The
- * relaxation is controlled by the parameter LinearSolver.PreconditionerRelaxation.
- * In each preconditioning step, it is applied as often as given by the parameter
- * LinearSolver.PreconditionerIterations.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] SSORCGBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqSSOR<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::CGSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solve<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "SSOR preconditioned CG solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential GS-preconditioned CG solver.
- *
- * Solver: CG (conjugate gradient) is an iterative method for solving linear
- * systems with a symmetric, positive definite matrix.\n
- * See: Helfenstein, R., Koko, J. (2010). "Parallel preconditioned conjugate
- * gradient algorithm on GPU", Journal of Computational and Applied Mathematics,
- * Volume 236, Issue 15, Pages 3584–3590, http://dx.doi.org/10.1016/j.cam.2011.04.025.
- *
- * Preconditioner: GS Gauss-Seidel method. It can be damped by the relaxation
- * parameter LinearSolver.PreconditionerRelaxation. In each preconditioning step,
- * it is applied as often as given by the parameter
- * LinearSolver.PreconditionerIterations.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] GSCGBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqGS<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::CGSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solve<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "GS preconditioned CG solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential Jacobi-preconditioned CG solver.
- *
- * Solver: CG (conjugate gradient) is an iterative method for solving linear
- * systems with a symmetric, positive definite matrix.\n
- * See: Helfenstein, R., Koko, J. (2010). "Parallel preconditioned conjugate
- * gradient algorithm on GPU", Journal of Computational and Applied Mathematics,
- * Volume 236, Issue 15, Pages 3584–3590, http://dx.doi.org/10.1016/j.cam.2011.04.025.
- *
- * Preconditioner: Jacobi method. It can be damped by the relaxation parameter
- * LinearSolver.PreconditionerRelaxation. In each preconditioning step, it is
- * applied as often as given by the parameter LinearSolver.PreconditionerIterations.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] JacCGBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqJac<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::CGSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solve<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "GS preconditioned CG solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential SSOR-preconditioned GMRes solver.
- *
- * Solver: The GMRes (generalized minimal residual) method is an iterative
- * method for the numerical solution of a nonsymmetric system of linear
- * equations.\n
- * See: Saad, Y., Schultz, M. H. (1986). "GMRES: A generalized minimal residual
- * algorithm for solving nonsymmetric linear systems." SIAM J. Sci. and Stat.
- * Comput. 7: 856–869.
- *
- * Preconditioner: SSOR symmetric successive overrelaxation method. The
- * relaxation is controlled by the parameter LinearSolver.PreconditionerRelaxation.
- * In each preconditioning step, it is applied as often as given by the parameter
- * LinearSolver.PreconditionerIterations.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] SSORRestartedGMResBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqSSOR<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::RestartedGMResSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solveWithGMRes<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "SSOR preconditioned GMRes solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential ILU(0)-preconditioned BiCGSTAB solver.
- *
- * Solver: The BiCGSTAB (stabilized biconjugate gradients method) solver has
- * faster and smoother convergence than the original BiCG. It can be applied to
- * nonsymmetric matrices.\n
- * See: Van der Vorst, H. A. (1992). "Bi-CGSTAB: A Fast and Smoothly Converging
- * Variant of Bi-CG for the Solution of Nonsymmetric Linear Systems".
- * SIAM J. Sci. and Stat. Comput. 13 (2): 631–644. doi:10.1137/0913035.
- *
- * Preconditioner: ILU(0) incomplete LU factorization. The order 0 indicates
- * that no fill-in is allowed. It can be damped by the relaxation parameter
- * LinearSolver.PreconditionerRelaxation.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] ILU0BiCGSTABBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqILU<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::BiCGSTABSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solveWithILU0Prec<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "ILU0 preconditioned BiCGSTAB solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential ILU(0)-preconditioned CG solver.
- *
- * Solver: CG (conjugate gradient) is an iterative method for solving linear
- * systems with a symmetric, positive definite matrix.\n
- * See: Helfenstein, R., Koko, J. (2010). "Parallel preconditioned conjugate
- * gradient algorithm on GPU", Journal of Computational and Applied Mathematics,
- * Volume 236, Issue 15, Pages 3584–3590, http://dx.doi.org/10.1016/j.cam.2011.04.025.
- *
- * Preconditioner: ILU(0) incomplete LU factorization. The order 0 indicates
- * that no fill-in is allowed. It can be damped by the relaxation parameter
- * LinearSolver.PreconditionerRelaxation.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] ILU0CGBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqILU<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::CGSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solveWithILU0Prec<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "ILU0 preconditioned BiCGSTAB solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential ILU0-preconditioned GMRes solver.
- *
- * Solver: The GMRes (generalized minimal residual) method is an iterative
- * method for the numerical solution of a nonsymmetric system of linear
- * equations.\n
- * See: Saad, Y., Schultz, M. H. (1986). "GMRES: A generalized minimal residual
- * algorithm for solving nonsymmetric linear systems." SIAM J. Sci. and Stat.
- * Comput. 7: 856–869.
- *
- * Preconditioner: ILU(0) incomplete LU factorization. The order 0 indicates
- * that no fill-in is allowed. It can be damped by the relaxation parameter
- * LinearSolver.PreconditionerRelaxation.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] ILU0RestartedGMResBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqILU<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::RestartedGMResSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solveWithILU0PrecGMRes<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "ILU0 preconditioned BiCGSTAB solver";
- }
-};
-
-/*!
- * \ingroup Linear
- * \brief Sequential ILU(n)-preconditioned GMRes solver.
- *
- * Solver: The GMRes (generalized minimal residual) method is an iterative
- * method for the numerical solution of a nonsymmetric system of linear
- * equations.\n
- * See: Saad, Y., Schultz, M. H. (1986). "GMRES: A generalized minimal residual
- * algorithm for solving nonsymmetric linear systems." SIAM J. Sci. and Stat.
- * Comput. 7: 856–869.
- *
- * Preconditioner: ILU(n) incomplete LU factorization. The order n can be
- * provided by the parameter LinearSolver.PreconditionerIterations and controls
- * the fill-in. It can be damped by the relaxation parameter
- * LinearSolver.PreconditionerRelaxation.\n
- * See: Golub, G. H., and Van Loan, C. F. (2012). Matrix computations. JHU Press.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] ILUnRestartedGMResBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- constexpr auto precondBlockLevel = preconditionerBlockLevel<Matrix>();
- using Preconditioner = Dune::SeqILU<Matrix, Vector, Vector, precondBlockLevel>;
- using Solver = Dune::RestartedGMResSolver<Vector>;
-
- return IterativePreconditionedSolverImpl::template solveWithGMRes<Preconditioner, Solver>(*this, A, x, b, this->paramGroup());
- }
-
- std::string name() const
- {
- return "ILUn preconditioned GMRes solver";
- }
-};
-
/*!
* \ingroup Linear
* \brief Solver for simple block-diagonal matrices (e.g. from explicit time stepping schemes)
@@ -761,158 +204,6 @@ public:
}
};
-#if HAVE_SUPERLU
-/*!
- * \ingroup Linear
- * \brief Direct linear solver using the SuperLU library.
- *
- * See: Li, X. S. (2005). "An overview of SuperLU: Algorithms, implementation,
- * and user interface." ACM Transactions on Mathematical Software (TOMS) 31(3): 302-325.
- * http://crd-legacy.lbl.gov/~xiaoye/SuperLU/
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] SuperLUBackend : public LinearSolver
-{
-public:
- using LinearSolver::LinearSolver;
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- static_assert(isBCRSMatrix<Matrix>::value, "SuperLU only works with BCRS matrices!");
- using BlockType = typename Matrix::block_type;
- static_assert(BlockType::rows == BlockType::cols, "Matrix block must be quadratic!");
- constexpr auto blockSize = BlockType::rows;
-
- Dune::SuperLU<Matrix> solver(A, this->verbosity() > 0);
-
- Vector bTmp(b);
- solver.apply(x, bTmp, result_);
-
- int size = x.size();
- for (int i = 0; i < size; i++)
- {
- for (int j = 0; j < blockSize; j++)
- {
- using std::isnan;
- using std::isinf;
- if (isnan(x[i][j]) || isinf(x[i][j]))
- {
- result_.converged = false;
- break;
- }
- }
- }
-
- return result_.converged;
- }
-
- std::string name() const
- {
- return "SuperLU solver";
- }
-
- const Dune::InverseOperatorResult& result() const
- {
- return result_;
- }
-
-private:
- Dune::InverseOperatorResult result_;
-};
-#endif // HAVE_SUPERLU
-
-#if HAVE_UMFPACK
-/*!
- * \ingroup Linear
- * \brief Direct linear solver using the UMFPack library.
- *
- * See: Davis, Timothy A. (2004). "Algorithm 832". ACM Transactions on
- * Mathematical Software 30 (2): 196–199. doi:10.1145/992200.992206.
- * http://faculty.cse.tamu.edu/davis/suitesparse.html
- *
- * You can choose from one of the following ordering strategies using the input
- * parameter "LinearSolver.UMFPackOrdering":
- * \verbatim
- * 0: UMFPACK_ORDERING_CHOLMOD
- * 1: UMFPACK_ORDERING_AMD (default)
- * 2: UMFPACK_ORDERING_GIVEN
- * 3: UMFPACK_ORDERING_METIS
- * 4: UMFPACK_ORDERING_BEST
- * 5: UMFPACK_ORDERING_NONE
- * 6: UMFPACK_ORDERING_USER
- * \endverbatim
- *
- * See https://fossies.org/linux/SuiteSparse/UMFPACK/Doc/UMFPACK_UserGuide.pdf page 17 for details.
- */
-class [[deprecated("Removed after 3.7. Use solver from istlsolvers.hh")]] UMFPackBackend : public LinearSolver
-{
-public:
-
- UMFPackBackend(const std::string& paramGroup = "")
- : LinearSolver(paramGroup)
- {
- ordering_ = getParamFromGroup<int>(this->paramGroup(), "LinearSolver.UMFPackOrdering", 1);
- }
-
- //! set ordering strategy
- void setOrdering(int i)
- { ordering_ = i; }
-
- //! the ordering strategy
- int ordering() const
- { return ordering_; }
-
- template<class Matrix, class Vector>
- bool solve(const Matrix& A, Vector& x, const Vector& b)
- {
- static_assert(isBCRSMatrix<Matrix>::value, "UMFPack only works with BCRS matrices!");
- using BlockType = typename Matrix::block_type;
- static_assert(BlockType::rows == BlockType::cols, "Matrix block must be quadratic!");
- constexpr auto blockSize = BlockType::rows;
-
- Dune::UMFPack<Matrix> solver;
- solver.setVerbosity(this->verbosity() > 0);
- solver.setOption(UMFPACK_ORDERING, ordering_);
- solver.setMatrix(A);
-
- Vector bTmp(b);
- solver.apply(x, bTmp, result_);
-
- int size = x.size();
- for (int i = 0; i < size; i++)
- {
- for (int j = 0; j < blockSize; j++)
- {
- using std::isnan;
- using std::isinf;
- if (isnan(x[i][j]) || isinf(x[i][j]))
- {
- result_.converged = false;
- break;
- }
- }
- }
-
- return result_.converged;
- }
-
- std::string name() const
- {
- return "UMFPack solver";
- }
-
- const Dune::InverseOperatorResult& result() const
- {
- return result_;
- }
-
-private:
- Dune::InverseOperatorResult result_;
- int ordering_;
-};
-#endif // HAVE_UMFPACK
-
-
/*!
* \name Solver for MultiTypeBlockMatrix's
*/
--
GitLab