mirror of
https://github.com/OPM/opm-simulators.git
synced 2024-12-27 09:40:59 -06:00
307 lines
15 KiB
C++
307 lines
15 KiB
C++
/*
|
|
Copyright 2016 IRIS AS
|
|
|
|
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 3 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/>.
|
|
*/
|
|
|
|
#ifndef OPM_ISTLSOLVERCPR_EBOS_HEADER_INCLUDED
|
|
#define OPM_ISTLSOLVERCPR_EBOS_HEADER_INCLUDED
|
|
|
|
#include <opm/simulators/linalg/ISTLSolverEbos.hpp>
|
|
#include <opm/simulators/linalg/BlackoilAmgCpr.hpp>
|
|
#include <utility>
|
|
#include <memory>
|
|
|
|
namespace Opm
|
|
{
|
|
//=====================================================================
|
|
// Implementation for ISTL-matrix based operator
|
|
//=====================================================================
|
|
|
|
|
|
/// This class solves the fully implicit black-oil system by
|
|
/// solving the reduced system (after eliminating well variables)
|
|
/// as a block-structured matrix (one block for all cell variables) for a fixed
|
|
/// number of cell variables np .
|
|
/// \tparam MatrixBlockType The type of the matrix block used.
|
|
/// \tparam VectorBlockType The type of the vector block used.
|
|
/// \tparam pressureIndex The index of the pressure component in the vector
|
|
/// vector block. It is used to guide the AMG coarsening.
|
|
/// Default is zero.
|
|
template <class TypeTag>
|
|
class ISTLSolverEbosCpr : public ISTLSolverEbos<TypeTag>
|
|
{
|
|
protected:
|
|
// Types and indices from superclass.
|
|
using SuperClass = ISTLSolverEbos<TypeTag>;
|
|
using Matrix = typename SuperClass::Matrix;
|
|
using Vector = typename SuperClass::Vector;
|
|
using WellModel = typename SuperClass::WellModel;
|
|
using Simulator = typename SuperClass::Simulator;
|
|
using SparseMatrixAdapter = typename SuperClass::SparseMatrixAdapter;
|
|
enum { pressureEqnIndex = SuperClass::pressureEqnIndex };
|
|
enum { pressureVarIndex = SuperClass::pressureVarIndex };
|
|
|
|
// New properties in this subclass.
|
|
using Preconditioner = Dune::Preconditioner<Vector, Vector>;
|
|
using MatrixAdapter = Dune::MatrixAdapter<Matrix,Vector, Vector>;
|
|
|
|
using CouplingMetric = Opm::Amg::Element<pressureEqnIndex,pressureVarIndex>;
|
|
using CritBase = Dune::Amg::SymmetricCriterion<Matrix, CouplingMetric>;
|
|
using Criterion = Dune::Amg::CoarsenCriterion<CritBase>;
|
|
|
|
using CprSmootherFine = Opm::ParallelOverlappingILU0<Matrix, Vector, Vector, Dune::Amg::SequentialInformation>;
|
|
using CprSmootherCoarse = CprSmootherFine;
|
|
using BlackoilAmgType = BlackoilAmgCpr<MatrixAdapter,CprSmootherFine, CprSmootherCoarse, Criterion, Dune::Amg::SequentialInformation,
|
|
pressureEqnIndex, pressureVarIndex>;
|
|
using OperatorSerial = WellModelMatrixAdapter< Matrix, Vector, Vector, WellModel, false>;
|
|
|
|
#if HAVE_MPI
|
|
using POrComm = Dune::OwnerOverlapCopyCommunication<int,int>;
|
|
using ParallelMatrixAdapter = Dune::OverlappingSchwarzOperator<Matrix, Vector, Vector, POrComm >;
|
|
using ParallelCprSmootherFine = Opm::ParallelOverlappingILU0<Matrix, Vector, Vector, POrComm >;
|
|
using ParallelCprSmootherCoarse = ParallelCprSmootherFine;
|
|
using ParallelBlackoilAmgType = BlackoilAmgCpr<ParallelMatrixAdapter, ParallelCprSmootherFine, ParallelCprSmootherCoarse, Criterion,
|
|
POrComm, pressureEqnIndex, pressureVarIndex>;
|
|
using OperatorParallel = WellModelMatrixAdapter< Matrix, Vector, Vector, WellModel, true>;
|
|
using ParallelScalarProduct = Dune::OverlappingSchwarzScalarProduct<Vector, POrComm>;
|
|
#else
|
|
using POrComm = Dune::Amg::SequentialInformation;
|
|
using ParallelBlackoilAmgType = BlackoilAmgType;
|
|
using ParallelScalarProduct = Dune::SeqScalarProduct<Vector>;
|
|
using ParallelMatrixAdapter = MatrixAdapter;
|
|
using OperatorParallel = OperatorSerial;
|
|
#endif
|
|
|
|
public:
|
|
static void registerParameters()
|
|
{
|
|
FlowLinearSolverParameters::registerParameters<TypeTag>();
|
|
}
|
|
|
|
/// Construct a system solver.
|
|
/// \param[in] parallelInformation In the case of a parallel run
|
|
/// with dune-istl the information about the parallelization.
|
|
explicit ISTLSolverEbosCpr(const Simulator& simulator)
|
|
: SuperClass(simulator), oldMat()
|
|
{
|
|
extractParallelGridInformationToISTL(this->simulator_.vanguard().grid(), this->parallelInformation_);
|
|
detail::findOverlapAndInterior(this->simulator_.vanguard().grid(), this->overlapRows_, this->interiorRows_);
|
|
}
|
|
|
|
void prepare(const SparseMatrixAdapter& M, Vector& b)
|
|
{
|
|
if (oldMat != nullptr)
|
|
std::cout << "old was "<<oldMat<<" new is "<<&M.istlMatrix()<<std::endl;
|
|
oldMat = &M.istlMatrix();
|
|
int newton_iteration = this->simulator_.model().newtonMethod().numIterations();
|
|
if (newton_iteration < 1 or not(this->parameters_.cpr_reuse_setup_)) {
|
|
SuperClass::matrix_.reset(new Matrix(M.istlMatrix()));
|
|
} else {
|
|
*SuperClass::matrix_ = M.istlMatrix();
|
|
}
|
|
SuperClass::rhs_ = &b;
|
|
SuperClass::scaleSystem();
|
|
const WellModel& wellModel = this->simulator_.problem().wellModel();
|
|
|
|
#if HAVE_MPI
|
|
if( this->isParallel() ) {
|
|
|
|
//remove ghost rows in local matrix without doing a copy.
|
|
this->makeOverlapRowsInvalid(*(this->matrix_));
|
|
|
|
if (newton_iteration < 1 or not(this->parameters_.cpr_reuse_setup_)) {
|
|
//Not sure what actual_mat_for_prec is, so put ebosJacIgnoreOverlap as both variables
|
|
//to be certain that correct matrix is used for preconditioning.
|
|
if( ! comm_ )
|
|
{
|
|
opAParallel_.reset(new OperatorParallel(*(this->matrix_), *(this->matrix_), wellModel,
|
|
this->parallelInformation_ ));
|
|
comm_ = opAParallel_->comm();
|
|
assert(comm_->indexSet().size()==0);
|
|
const size_t size = opAParallel_->getmat().N();
|
|
|
|
const ParallelISTLInformation& info =
|
|
boost::any_cast<const ParallelISTLInformation&>( this->parallelInformation_);
|
|
|
|
// As we use a dune-istl with block size np the number of components
|
|
// per parallel is only one.
|
|
info.copyValuesTo(comm_->indexSet(), comm_->remoteIndices(),
|
|
size, 1);
|
|
}
|
|
else
|
|
{
|
|
opAParallel_.reset(new OperatorParallel(*(this->matrix_), *(this->matrix_), wellModel,
|
|
comm_ ));
|
|
}
|
|
}
|
|
|
|
constexpr Dune::SolverCategory::Category category=Dune::SolverCategory::overlapping;
|
|
auto sp = Dune::createScalarProduct<Vector,POrComm>(*comm_, category);
|
|
sp_ = std::move(sp);
|
|
|
|
using AMGOperator = Dune::OverlappingSchwarzOperator<Matrix, Vector, Vector, POrComm>;
|
|
// If clause is always execute as as Linearoperator is WellModelMatrixAdapter< Matrix, Vector, Vector, WellModel, false|true>;
|
|
if( ! std::is_same< OperatorParallel, AMGOperator > :: value &&
|
|
( newton_iteration < 1 or not(this->parameters_.cpr_reuse_setup_) ) ) {
|
|
// create new operator in case linear operator and matrix operator differ
|
|
opA_.reset( new AMGOperator( opAParallel_->getmat(), *comm_ ));
|
|
}
|
|
|
|
prepareSolver(*opAParallel_, *comm_);
|
|
|
|
} else
|
|
#endif
|
|
{
|
|
|
|
if (newton_iteration < 1 or not(this->parameters_.cpr_reuse_setup_)) {
|
|
opASerial_.reset(new OperatorSerial(*(this->matrix_), *(this->matrix_), wellModel));
|
|
}
|
|
|
|
using POrCommType = Dune::Amg::SequentialInformation;
|
|
POrCommType parallelInformation_arg;
|
|
typedef OperatorSerial LinearOperator;
|
|
|
|
constexpr Dune::SolverCategory::Category category=Dune::SolverCategory::sequential;
|
|
auto sp = Dune::createScalarProduct<Vector,POrComm>(parallelInformation_arg, category);
|
|
sp_ = std::move(sp);
|
|
|
|
// If clause is always execute as as Linearoperator is WellModelMatrixAdapter< Matrix, Vector, Vector, WellModel, false|true>;
|
|
if( ! std::is_same< LinearOperator, MatrixAdapter > :: value &&
|
|
( newton_iteration < 1 or not(this->parameters_.cpr_reuse_setup_) ) ) {
|
|
// create new operator in case linear operator and matrix operator differ
|
|
opA_.reset( new MatrixAdapter( opASerial_->getmat()));//, parallelInformation_arg ) );
|
|
}
|
|
|
|
prepareSolver(*opASerial_, parallelInformation_arg);
|
|
}
|
|
}
|
|
|
|
template<typename Operator, typename Comm>
|
|
void prepareSolver(Operator& wellOpA, Comm& comm)
|
|
{
|
|
|
|
Vector& istlb = *(this->rhs_);
|
|
comm.copyOwnerToAll(istlb, istlb);
|
|
|
|
const double relax = this->parameters_.ilu_relaxation_;
|
|
const MILU_VARIANT ilu_milu = this->parameters_.ilu_milu_;
|
|
|
|
// TODO: revise choice of parameters
|
|
// int coarsenTarget = 4000;
|
|
int coarsenTarget = 1200;
|
|
Criterion criterion(15, coarsenTarget);
|
|
criterion.setDebugLevel( this->parameters_.cpr_solver_verbose_ ); // no debug information, 1 for printing hierarchy information
|
|
criterion.setDefaultValuesIsotropic(2);
|
|
criterion.setNoPostSmoothSteps( 1 );
|
|
criterion.setNoPreSmoothSteps( 1 );
|
|
//new guesses by hmbn
|
|
//criterion.setAlpha(0.01); // criterion for connection strong 1/3 is default
|
|
//criterion.setMaxLevel(2); //
|
|
//criterion.setGamma(1); // //1 V cycle 2 WW
|
|
|
|
// Since DUNE 2.2 we also need to pass the smoother args instead of steps directly
|
|
using AmgType = typename std::conditional<std::is_same<Comm, Dune::Amg::SequentialInformation>::value,
|
|
BlackoilAmgType, ParallelBlackoilAmgType>::type;
|
|
using SpType = typename std::conditional<std::is_same<Comm, Dune::Amg::SequentialInformation>::value,
|
|
Dune::SeqScalarProduct<Vector>,
|
|
ParallelScalarProduct >::type;
|
|
using OperatorType = typename std::conditional<std::is_same<Comm, Dune::Amg::SequentialInformation>::value,
|
|
MatrixAdapter, ParallelMatrixAdapter>::type;
|
|
typedef typename AmgType::Smoother Smoother;
|
|
typedef typename Dune::Amg::SmootherTraits<Smoother>::Arguments SmootherArgs;
|
|
SmootherArgs smootherArgs;
|
|
smootherArgs.iterations = 1;
|
|
smootherArgs.relaxationFactor = relax;
|
|
const Opm::CPRParameter& params(this->parameters_); // strange conversion
|
|
ISTLUtility::setILUParameters(smootherArgs, ilu_milu);
|
|
|
|
auto& opARef = reinterpret_cast<OperatorType&>(*opA_);
|
|
int newton_iteration = this->simulator_.model().newtonMethod().numIterations();
|
|
bool update_preconditioner = false;
|
|
|
|
if (this->parameters_.cpr_reuse_setup_ < 1) {
|
|
update_preconditioner = true;
|
|
}
|
|
if (this->parameters_.cpr_reuse_setup_ < 2) {
|
|
if (newton_iteration < 1) {
|
|
update_preconditioner = true;
|
|
}
|
|
}
|
|
if (this->parameters_.cpr_reuse_setup_ < 3) {
|
|
if (this->iterations() > 10) {
|
|
update_preconditioner = true;
|
|
}
|
|
}
|
|
|
|
if ( update_preconditioner or (amg_== 0) ) {
|
|
amg_.reset( new AmgType( params, this->weights_, opARef, criterion, smootherArgs, comm ) );
|
|
} else {
|
|
if (this->parameters_.cpr_solver_verbose_) {
|
|
std::cout << " Only update amg solver " << std::endl;
|
|
}
|
|
reinterpret_cast<AmgType*>(amg_.get())->updatePreconditioner(opARef, smootherArgs, comm);
|
|
}
|
|
// Solve.
|
|
//SuperClass::solve(linearOperator, x, istlb, *sp, *amg, result);
|
|
//references seems to do something els than refering
|
|
|
|
int verbosity_linsolve = 0;
|
|
if (comm.communicator().rank() == 0) {
|
|
verbosity_linsolve = this->parameters_.linear_solver_verbosity_;
|
|
}
|
|
|
|
linsolve_.reset(new Dune::BiCGSTABSolver<Vector>(wellOpA, reinterpret_cast<SpType&>(*sp_), reinterpret_cast<AmgType&>(*amg_),
|
|
this->parameters_.linear_solver_reduction_,
|
|
this->parameters_.linear_solver_maxiter_,
|
|
verbosity_linsolve));
|
|
}
|
|
|
|
bool solve(Vector& x)
|
|
{
|
|
// Solve system.
|
|
Dune::InverseOperatorResult result;
|
|
Vector& istlb = *(this->rhs_);
|
|
linsolve_->apply(x, istlb, result);
|
|
SuperClass::checkConvergence(result);
|
|
if (this->parameters_.scale_linear_system_) {
|
|
this->scaleSolution(x);
|
|
}
|
|
return this->converged_;
|
|
}
|
|
|
|
|
|
protected:
|
|
|
|
///! \brief The dune-istl operator (either serial or parallel
|
|
std::unique_ptr< Dune::LinearOperator<Vector, Vector> > opA_;
|
|
///! \brief Serial well matrix adapter
|
|
std::unique_ptr< OperatorSerial > opASerial_;
|
|
///! \brief Parallel well matrix adapter
|
|
std::unique_ptr< OperatorParallel > opAParallel_;
|
|
///! \brief The preconditoner to use (either serial or parallel CPR with AMG)
|
|
std::unique_ptr< Preconditioner > amg_;
|
|
|
|
using SPPointer = std::shared_ptr< Dune::ScalarProduct<Vector> >;
|
|
SPPointer sp_;
|
|
std::shared_ptr< Dune::BiCGSTABSolver<Vector> > linsolve_;
|
|
const void* oldMat;
|
|
std::shared_ptr<POrComm> comm_;
|
|
}; // end ISTLSolver
|
|
|
|
} // namespace Opm
|
|
#endif
|