My Project
Opm::ISTLSolverEbos< TypeTag > Class Template Reference

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 . More...

#include <ISTLSolverEbos.hpp>

Public Types

using AssembledLinearOperatorType = Dune::AssembledLinearOperator< Matrix, Vector, Vector >
 

Public Member Functions

 ISTLSolverEbos (const Simulator &simulator)
 Construct a system solver. More...
 
void eraseMatrix ()
 
void prepare (const SparseMatrixAdapter &M, Vector &b)
 
void setResidual (Vector &)
 
void getResidual (Vector &b) const
 
void setMatrix (const SparseMatrixAdapter &)
 
bool solve (Vector &x)
 
int iterations () const
 Solve the system of linear equations Ax = b, with A being the combined derivative matrix of the residual and b being the residual itself. More...
 
const std::any & parallelInformation () const
 

Static Public Member Functions

static void registerParameters ()
 

Protected Types

using GridView = GetPropType< TypeTag, Properties::GridView >
 
using Scalar = GetPropType< TypeTag, Properties::Scalar >
 
using SparseMatrixAdapter = GetPropType< TypeTag, Properties::SparseMatrixAdapter >
 
using Vector = GetPropType< TypeTag, Properties::GlobalEqVector >
 
using Indices = GetPropType< TypeTag, Properties::Indices >
 
using WellModel = GetPropType< TypeTag, Properties::EclWellModel >
 
using Simulator = GetPropType< TypeTag, Properties::Simulator >
 
using Matrix = typename SparseMatrixAdapter::IstlMatrix
 
using ThreadManager = GetPropType< TypeTag, Properties::ThreadManager >
 
using ElementContext = GetPropType< TypeTag, Properties::ElementContext >
 
using FlexibleSolverType = Dune::FlexibleSolver< Matrix, Vector >
 
using AbstractOperatorType = Dune::AssembledLinearOperator< Matrix, Vector, Vector >
 
using WellModelOperator = WellModelAsLinearOperator< WellModel, Vector, Vector >
 
using ElementMapper = GetPropType< TypeTag, Properties::ElementMapper >
 
using CommunicationType = Dune::CollectiveCommunication< int >
 
typedef ParallelOverlappingILU0< Dune::BCRSMatrix< Dune::MatrixBlock< typename Matrix::field_type, Matrix::block_type::rows, Matrix::block_type::cols > >, Vector, Vector > SeqPreconditioner
 

Protected Member Functions

void checkConvergence (const Dune::InverseOperatorResult &result) const
 
bool isParallel () const
 
void prepareFlexibleSolver ()
 
bool shouldCreateSolver () const
 Return true if we should (re)create the whole solver, instead of just calling update() on the preconditioner.
 
std::function< Vector()> getWeightsCalculator () const
 Return an appropriate weight function if a cpr preconditioner is asked for.
 
Vector getTrueImpesWeights (int pressureVarIndex) const
 
void makeOverlapRowsInvalid (Matrix &matrix) const
 Zero out off-diagonal blocks on rows corresponding to overlap cells Diagonal blocks on ovelap rows are set to diag(1.0).
 
Matrix & getMatrix ()
 
const Matrix & getMatrix () const
 

Protected Attributes

const Simulator & simulator_
 
int iterations_
 
bool converged_
 
std::any parallelInformation_
 
Matrix * matrix_
 
Vector * rhs_
 
std::unique_ptr< FlexibleSolverTypeflexibleSolver_
 
std::unique_ptr< AbstractOperatorType > linearOperatorForFlexibleSolver_
 
std::unique_ptr< WellModelAsLinearOperator< WellModel, Vector, Vector > > wellOperator_
 
std::vector< int > overlapRows_
 
std::vector< int > interiorRows_
 
std::vector< std::set< int > > wellConnectionsGraph_
 
bool useWellConn_
 
size_t interiorCellNum_
 
FlowLinearSolverParameters parameters_
 
PropertyTree prm_
 
bool scale_variables_
 
std::shared_ptr< CommunicationType > comm_
 

Static Protected Attributes

constexpr static std::size_t pressureIndex = GetPropType<TypeTag, Properties::Indices>::pressureSwitchIdx
 

Detailed Description

template<class TypeTag>
class Opm::ISTLSolverEbos< TypeTag >

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 .

Constructor & Destructor Documentation

◆ ISTLSolverEbos()

template<class TypeTag >
Opm::ISTLSolverEbos< TypeTag >::ISTLSolverEbos ( const Simulator &  simulator)
inlineexplicit

Construct a system solver.

Parameters
[in]parallelInformationIn the case of a parallel run with dune-istl the information about the parallelization.

Member Function Documentation

◆ iterations()

template<class TypeTag >
int Opm::ISTLSolverEbos< TypeTag >::iterations ( ) const
inline

Solve the system of linear equations Ax = b, with A being the combined derivative matrix of the residual and b being the residual itself.

Parameters
[in]residualresidual object containing A and b.
Returns
the solution x

◆ parallelInformation()

template<class TypeTag >
const std::any& Opm::ISTLSolverEbos< TypeTag >::parallelInformation ( ) const
inline


The documentation for this class was generated from the following files: