#include <opm/common/ErrorMacros.hpp>
#include <opm/common/TimingMacros.hpp>
#include <opm/simulators/linalg/matrixblock.hh>
#include <opm/simulators/linalg/ilufirstelement.hh>
#include <opm/simulators/linalg/FlexibleSolver.hpp>
#include <opm/simulators/linalg/PreconditionerFactory.hpp>
#include <opm/simulators/linalg/PropertyTree.hpp>
#include <opm/simulators/linalg/Preconditioner2InverseOperator.hpp>
#include <opm/simulators/linalg/WellOperators.hpp>
#include <opm/simulators/linalg/PreconditionerFactoryGPUIncludeWrapper.hpp>
#include <opm/simulators/linalg/is_gpu_operator.hpp>
#include <dune/common/fmatrix.hh>
#include <dune/istl/bcrsmatrix.hh>
#include <dune/istl/multitypeblockvector.hh>
#include <dune/istl/solvers.hh>
#include <dune/istl/umfpack.hh>
#include <dune/istl/owneroverlapcopy.hh>
#include <dune/istl/paamg/pinfo.hh>
#include <type_traits>

Include dependency graph for FlexibleSolver_impl.hpp:

Classes
struct	Opm::detail::is_multi_type_block_vector< T >

struct	Opm::detail::is_multi_type_block_vector< Dune::MultiTypeBlockVector< Args... > >

Namespaces
namespace	Opm

namespace	Opm::detail

namespace	Dune

Macros
#define	INSTANTIATE_FLEXIBLESOLVER_OP(...)

#define	INSTANTIATE_FLEXIBLESOLVER(T, N)

Typedefs
template<class Scalar , int N>
using	BV = Dune::BlockVector< Dune::FieldVector< Scalar, N > >

template<class Scalar , int N>
using	OBM = Dune::BCRSMatrix< Opm::MatrixBlock< Scalar, N, N > >

template<class Scalar , int N>
using	SeqOpM = Dune::MatrixAdapter< OBM< Scalar, N >, BV< Scalar, N >, BV< Scalar, N > >

template<class Scalar , int N>
using	SeqOpW = Opm::WellModelMatrixAdapter< OBM< Scalar, N >, BV< Scalar, N >, BV< Scalar, N > >

using	Comm = Dune::OwnerOverlapCopyCommunication< int, int >

template<class Scalar , int N>
using	ParOpM = Opm::GhostLastMatrixAdapter< OBM< Scalar, N >, BV< Scalar, N >, BV< Scalar, N >, Comm >

template<class Scalar , int N>
using	ParOpW = Opm::WellModelGhostLastMatrixAdapter< OBM< Scalar, N >, BV< Scalar, N >, BV< Scalar, N >, true >

template<class Scalar , int N>
using	ParOpD = Dune::OverlappingSchwarzOperator< OBM< Scalar, N >, BV< Scalar, N >, BV< Scalar, N >, Comm >

Functions
	Dune::if (!linsolver_)

Variables
template<typename T >
constexpr bool	Opm::detail::is_multi_type_block_vector_v = is_multi_type_block_vector<T>::value

Macro Definition Documentation

◆ INSTANTIATE_FLEXIBLESOLVER

#define INSTANTIATE_FLEXIBLESOLVER	(	T,
		N
	)

Value:

    INSTANTIATE_FLEXIBLESOLVER_OP(SeqOpM<T,N>); \
    INSTANTIATE_FLEXIBLESOLVER_OP(SeqOpW<T,N>); \
    INSTANTIATE_FLEXIBLESOLVER_OP(ParOpM<T,N>); \
    INSTANTIATE_FLEXIBLESOLVER_OP(ParOpW<T,N>); \
    INSTANTIATE_FLEXIBLESOLVER_OP(ParOpD<T,N>);

◆ INSTANTIATE_FLEXIBLESOLVER_OP

#define INSTANTIATE_FLEXIBLESOLVER_OP ( ... )

Value:

    template class Dune::FlexibleSolver<__VA_ARGS__>;                                               \
    template Dune::FlexibleSolver<__VA_ARGS__>::                                                    \
        FlexibleSolver(__VA_ARGS__& op,                                                             \
                       const Comm& comm,                                                            \
                       const Opm::PropertyTree& prm,                                                \
                       const std::function<typename __VA_ARGS__::domain_type()>& weightsCalculator, \
                       std::size_t pressureIndex);