Loading...
Searching...
No Matches
superlubackend.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:
/*
This file is part of the Open Porous Media project (OPM).
OPM 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 2 of the License, or
(at your option) any later version.
OPM 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 OPM. If not, see <http://www.gnu.org/licenses/>.
Consult the COPYING file in the top-level source directory of this
module for the precise wording of the license and the list of
copyright holders.
*/
#ifndef EWOMS_SUPER_LU_BACKEND_HH
#define EWOMS_SUPER_LU_BACKEND_HH
#if HAVE_SUPERLU
#include <dune/common/fmatrix.hh>
#include <dune/common/version.hh>
#include <dune/istl/superlu.hh>
#include <opm/material/common/Unused.hpp>
#include <opm/models/linear/istlsparsematrixbackend.hh>
#include <opm/models/utils/parametersystem.hh>
#include <opm/simulators/linalg/linalgproperties.hh>
namespace Opm::Properties::TTag {
struct SuperLULinearSolver {};
} // namespace Opm::Properties::TTag
namespace Opm::Linear {
template <class Scalar, class TypeTag, class Matrix, class Vector>
class SuperLUSolve_;
template <class TypeTag>
class SuperLUBackend
{
using Scalar = GetPropType<TypeTag, Properties::Scalar>;
using Simulator = GetPropType<TypeTag, Properties::Simulator>;
using SparseMatrixAdapter = GetPropType<TypeTag, Properties::SparseMatrixAdapter>;
using Matrix = typename SparseMatrixAdapter::block_type;
static_assert(std::is_same<SparseMatrixAdapter, IstlSparseMatrixAdapter<MatrixBlock>::value,
"The SuperLU linear solver backend requires the IstlSparseMatrixAdapter");
public:
SuperLUBackend(Simulator&)
{}
static void registerParameters()
{
Parameters::Register<Parameters::LinearSolverVerbosity>
("The verbosity level of the linear solver");
}
void eraseMatrix()
{ }
void prepare(const SparseMatrixAdapter& M, const Vector& b)
{ }
void setResidual(const Vector& b)
{ b_ = &b; }
void getResidual(Vector& b) const
{ b = *b_; }
void setMatrix(const SparseMatrixAdapter& M)
{ M_ = &M; }
bool solve(Vector& x)
{ return SuperLUSolve_<Scalar, TypeTag, Matrix, Vector>::solve_(*M_, x, *b_); }
private:
const Matrix* M_;
Vector* b_;
};
template <class Scalar, class TypeTag, class Matrix, class Vector>
class SuperLUSolve_
{
public:
static bool solve_(const Matrix& A, Vector& x, const Vector& b)
{
Vector bTmp(b);
int verbosity = Parameters::Get<Parameters::LinearSolverVerbosity>();
Dune::InverseOperatorResult result;
Dune::SuperLU<Matrix> solver(A, verbosity > 0);
solver.apply(x, bTmp, result);
if (result.converged) {
// make sure that the result only contains finite values.
Scalar tmp = 0;
for (unsigned i = 0; i < x.size(); ++i) {
const auto& xi = x[i];
for (unsigned j = 0; j < Vector::block_type::dimension; ++j)
tmp += xi[j];
}
result.converged = std::isfinite(tmp);
}
return result.converged;
}
};
// the following is required to make the SuperLU adapter of dune-istl happy with
// quadruple precision math on Dune 2.4. this is because the most which SuperLU can
// handle is double precision (i.e., the linear systems of equations are always solved
// with at most double precision if chosing SuperLU as the linear solver...)
#if HAVE_QUAD
template <class TypeTag, class Matrix, class Vector>
class SuperLUSolve_<__float128, TypeTag, Matrix, Vector>
{
public:
static bool solve_(const Matrix& A,
Vector& x,
const Vector& b)
{
static const int numEq = getPropValue<TypeTag, Properties::NumEq>();
using DoubleEqVector = Dune::FieldVector<double, numEq>;
using DoubleEqMatrix = Dune::FieldMatrix<double, numEq, numEq>;
using DoubleVector = Dune::BlockVector<DoubleEqVector>;
using DoubleMatrix = Dune::BCRSMatrix<DoubleEqMatrix>;
// copy the inputs into the double precision data structures
DoubleVector bDouble(b);
DoubleVector xDouble(x);
DoubleMatrix ADouble(A);
bool res =
SuperLUSolve_<double, TypeTag, Matrix, Vector>::solve_(ADouble,
xDouble,
bDouble);
// copy the result back into the quadruple precision vector.
x = xDouble;
return res;
}
};
#endif
} // namespace Linear
} // namespace Opm
namespace Opm::Properties {
template<class TypeTag>
struct LinearSolverVerbosity<TypeTag, TTag::SuperLULinearSolver>
{ static constexpr int value = 0; };
template<class TypeTag>
struct LinearSolverBackend<TypeTag, TTag::SuperLULinearSolver>
{ using type = Opm::Linear::SuperLUBackend<TypeTag>; };
} // namespace Opm::Properties
#endif // HAVE_SUPERLU
#endif
linalgproperties.hh
Declares the properties required by the black oil model.
Opm::Properties::TTag
The generic type tag for problems using the immiscible multi-phase model.
Definition blackoilmodel.hh:81
Opm::Properties::LinearSolverBackend
The type of the linear solver to be used.
Definition linalgproperties.hh:38