A small, fixed‑dimension MiniVector class backed by std::array that can be used in both host and CUDA device code. More...

Namespaces
namespace	detail
	Contains wrappers to make the CuBLAS library behave as a modern C++ library with function overlading.
namespace	HypreInterface
	Unified interface for Hypre operations with both CPU and GPU data structures.

Classes
class	AmgxError
	Exception class for AMGX errors. More...
class	AmgxInterface
	Unified interface for AMGX operations with both CPU and GPU data structures. More...
class	GpuVector
class	GpuSparseMatrixWrapper
	The GpuSparseMatrixWrapper Checks CUDA/HIP version and dispatches a version either using the old or the generic CUDA API. More...
class	GpuSparseMatrixGeneric
	The GpuSparseMatrixGeneric class uses cuSPARSE Generic API for sparse matrix operations. More...
struct	is_gpu_type
	Type trait to detect if a type is a GPU type. More...
struct	is_gpu_type< GpuVector< T > >
struct	is_gpu_type< GpuSparseMatrixWrapper< T, ForceLegacy > >
struct	is_gpu_type< GpuSparseMatrixGeneric< T > >
class	PointerView
	A view towards a smart pointer to GPU-allocated memory. More...
class	PointerView< void >
	Specialization of PointerView for void type This is needed beause we cannot have a PointerView<void> specialization due to dereferincing a void ptr. More...
class	ValueAsPointer
	A value stored with a pointer interface. More...
class	GPUAwareMPISender
	Derived class of GPUSender that handles MPI made with CUDA aware MPI The copOwnerToAll function uses MPI calls refering to data that resides on the GPU in order to send it directly to other GPUs, skipping the staging step on the CPU. More...
class	GpuBlockPreconditioner
	Is an adaptation of Dune::BlockPreconditioner that works within the CuISTL framework. More...
class	GpuDILU
	DILU preconditioner on the GPU. More...
class	GpuJac
	Jacobi preconditioner on the GPU. More...
class	GPUObliviousMPISender
	Derived class of GPUSender that handles MPI calls that should NOT use GPU direct communicatoin The implementation moves data fromthe GPU to the CPU and then sends it using regular MPI. More...
class	GpuOwnerOverlapCopy
	CUDA compatiable variant of Dune::OwnerOverlapCopyCommunication. More...
class	GpuPressureTransferPolicy
class	GPUSender
	GPUSender is a wrapper class for classes which will implement copOwnerToAll This is implemented with the intention of creating communicators with generic GPUSender To hide implementation that will either use GPU aware MPI or not. More...
class	GpuSeqILU0
	Sequential ILU0 preconditioner on the GPU through the CuSparse library. More...
class	GpuSparseMatrix
	The GpuSparseMatrix class simple wrapper class for a CuSparse matrix. More...
class	GpuView
	The GpuView class is provides a view of some data allocated on the GPU Essenstially is only stores a pointer and a size. More...
struct	ParallelInfo
	Parallel domain decomposition information for HYPRE-Dune interface. More...
struct	SparsityPattern
	Compressed Sparse Row (CSR) sparsity pattern for HYPRE matrix assembly. More...
struct	HypreHostDataArrays
	Host arrays for HYPRE matrix and vector data transfers. More...
struct	HypreDeviceDataArrays
	GPU device memory arrays for HYPRE operations with GPU backend. More...
class	HypreError
	Exception class for Hypre errors. More...
class	ISTLSolverGPUISTL
	ISTL solver for GPU using the GPU ISTL backend. More...
class	MiniMatrix
	A small fixed-size square matrix class for use in CUDA kernels. More...
class	MiniVector
class	OpmGpuILU0
	ILU0 preconditioner on the GPU. More...
class	PinnedMemoryHolder
	RAII class for pinning host memory using cudaHostRegister. More...
class	PreconditionerAdapter
	Makes a CUDA preconditioner available to a CPU simulator. More...
class	PreconditionerConvertFieldTypeAdapter
	Converts the field type (eg. More...
class	PreconditionerCPUMatrixToGPUMatrix
	Convert a CPU matrix to a GPU matrix and use a CUDA preconditioner on the GPU. More...
class	PreconditionerHolder
	Common interface for adapters that hold preconditioners. More...
class	SolverAdapter
	Wraps a CUDA solver to work with CPU data. More...

Enumerations
enum class	MatrixStorageMPScheme { DOUBLE_DIAG_DOUBLE_OFFDIAG = 0 , FLOAT_DIAG_FLOAT_OFFDIAG = 1 , DOUBLE_DIAG_FLOAT_OFFDIAG = 2 }

Functions
std::string	getAmgxErrorMessage (AMGX_RC err, const std::string &expression, const std::string &file, const std::string &function, int line)
	Get a descriptive error message for an AMGX error code.
void	amgxSafeCall (AMGX_RC rc, const std::string &expression, const std::string &file, const std::string &function, int line)
	Safe call wrapper for AMGX functions.
MatrixStorageMPScheme	makeMatrixStorageMPScheme (int scheme)
void	printDevice ()
void	setDevice ()
	OPM_CREATE_GPU_RESOURCE (GPUStream, cudaStream_t, cudaStreamCreate, cudaStreamDestroy)
	Manages a CUDA stream resource.
	OPM_CREATE_GPU_RESOURCE (GPUEvent, cudaEvent_t, cudaEventCreate, cudaEventDestroy)
	Manages a CUDA event resource.
	OPM_CREATE_GPU_RESOURCE (GPUGraph, cudaGraph_t, cudaGraphCreate, cudaGraphDestroy, 0)
	Manages a CUDA graph resource.
	OPM_CREATE_GPU_RESOURCE_NO_CREATE (GPUGraphExec, cudaGraphExec_t, cudaGraphExecDestroy)
	Manages a CUDA graph execution resource.
template<typename T>
std::shared_ptr< T >	make_gpu_shared_ptr ()
	Creates a shared pointer managing GPU-allocated memory of the specified element type.
template<typename T>
std::shared_ptr< T >	make_gpu_shared_ptr (const T &value)
	Creates a shared pointer managing GPU-allocated memory of the specified element type.
template<typename T>
auto	make_gpu_unique_ptr ()
	Creates a unique pointer managing GPU-allocated memory of the specified element type.
template<typename T>
auto	make_gpu_unique_ptr (const T &value)
	Creates a unique pointer managing GPU-allocated memory of the specified element type.
template<class T>
T	copyFromGPU (const T *value)
	Copies a value from GPU-allocated memory to the host.
template<class T>
T	copyFromGPU (const std::shared_ptr< T > &value)
	Copies a value from GPU-allocated memory to the host.
template<class T, class Deleter>
T	copyFromGPU (const std::unique_ptr< T, Deleter > &value)
	Copies a value from GPU-allocated memory to the host.
template<class T>
void	copyToGPU (const T &value, T *ptr)
	Copies a value from the host to GPU-allocated memory.
template<class T>
void	copyToGPU (const T &value, const std::shared_ptr< T > &ptr)
	Copies a value from the host to GPU-allocated memory using a shared_ptr.
template<class T, class Deleter>
void	copyToGPU (const T &value, const std::unique_ptr< T, Deleter > &ptr)
	Copies a value from the host to GPU-allocated memory using a unique_ptr.
template<class T>
PointerView< T >	make_view (const std::shared_ptr< T > &ptr)
template<class T, class Deleter>
PointerView< T >	make_view (const std::unique_ptr< T, Deleter > &ptr)
template<class field_type, int block_size, class OwnerOverlapCopyCommunicationType>
std::shared_ptr< GpuOwnerOverlapCopy< field_type, OwnerOverlapCopyCommunicationType > >	makeGpuOwnerOverlapCopy (const OwnerOverlapCopyCommunicationType &cpuOwnerOverlapCopy)
	INSTANTIATE_FOR_TYPE_AND_CLASS (GpuSparseMatrix, float)
	INSTANTIATE_FOR_TYPE_AND_CLASS (GpuSparseMatrix, double)
	INSTANTIATE_FOR_TYPE_AND_CLASS (GpuSparseMatrixGeneric, float)
	INSTANTIATE_FOR_TYPE_AND_CLASS (GpuSparseMatrixGeneric, double)
void	setZeroAtIndexSet (const GpuVector< int > &indexSet)
	The GpuVector class is a simple (arithmetic) vector class for the GPU.
std::string	toDebugString ()
template<typename T>
void	writeMatrixMarket (const GpuVector< T > &vectorOnDevice, std::ostream &ostr)
std::string	getHypreErrorMessage (HYPRE_Int err, const std::string &expression, const std::string &file, const std::string &function, int line)
	Get a descriptive error message for a Hypre error code.
void	hypreSafeCall (HYPRE_Int rc, const std::string &expression, const std::string &file, const std::string &function, int line)
	Safe call wrapper for Hypre functions.
void	setDevice (int mpiRank, int numberOfMpiRanks)
	Sets the correct CUDA device in the setting of MPI.
void	printDevice (int mpiRank, int numberOfMpiRanks)

Variables
template<typename T>
constexpr bool	is_gpu_type_v = is_gpu_type<T>::value
	Helper variable template for easier usage.

Detailed Description

A small, fixed‑dimension MiniVector class backed by std::array that can be used in both host and CUDA device code.

The implementation purposefully remains lightweight, containing only the utilities required for element access, iteration, and initialization. It avoids dynamic memory and leverages the compile‑time Dimension parameter to enable full constexpr evaluation whenever possible.

Function Documentation

◆ amgxSafeCall()

void Opm::gpuistl::amgxSafeCall	(	AMGX_RC	rc,
		const std::string &	expression,
		const std::string &	file,
		const std::string &	function,
		int	line )

inline

Safe call wrapper for AMGX functions.

Checks the return code from AMGX functions and throws an AmgxError if an error occurred.

Parameters

rc	The AMGX return code to check
expression	The expression being evaluated (for error reporting)
file	The source file (typically FILE)
function	The function name (typically func)
line	The line number (typically LINE)

Exceptions

AmgxError if the return code indicates an error

◆ copyFromGPU() [1/3]

template<class T>

T Opm::gpuistl::copyFromGPU ( const std::shared_ptr< T > & value )

Copies a value from GPU-allocated memory to the host.

Parameters

value A shared pointer to the value on the GPU.

Returns: The value copied from the GPU.

Note: This function is involves a sychronization point, and should be used with care.

◆ copyFromGPU() [2/3]

template<class T, class Deleter>

T Opm::gpuistl::copyFromGPU ( const std::unique_ptr< T, Deleter > & value )

Copies a value from GPU-allocated memory to the host.

Template Parameters

Deleter The custom deleter type.

Parameters

value A unique pointer to the value on the GPU (with a custom deleter).

Returns: The value copied from the GPU.

Note: This function is involves a sychronization point, and should be used with care.

◆ copyFromGPU() [3/3]

template<class T>

T Opm::gpuistl::copyFromGPU ( const T * value )

Copies a value from GPU-allocated memory to the host.

Parameters

value A pointer to the value on the GPU.

Returns: The value copied from the GPU.

Note: This function is involves a sychronization point, and should be used with care.

◆ copyToGPU() [1/3]

template<class T>

void Opm::gpuistl::copyToGPU	(	const T &	value,
		const std::shared_ptr< T > &	ptr )

Copies a value from the host to GPU-allocated memory using a shared_ptr.

Parameters

value	The value to copy to the GPU.
ptr	A shared_ptr to the GPU-allocated memory.

Note: This function involves a synchronization point, and should be used with care.

◆ copyToGPU() [2/3]

template<class T, class Deleter>

void Opm::gpuistl::copyToGPU	(	const T &	value,
		const std::unique_ptr< T, Deleter > &	ptr )

Copies a value from the host to GPU-allocated memory using a unique_ptr.

Template Parameters

Deleter The custom deleter type.

Parameters

value	The value to copy to the GPU.
ptr	A unique_ptr to the GPU-allocated memory (with a custom deleter).

Note: This function involves a synchronization point, and should be used with care.

◆ copyToGPU() [3/3]

template<class T>

void Opm::gpuistl::copyToGPU	(	const T &	value,
		T *	ptr )

Copies a value from the host to GPU-allocated memory.

Parameters

value	The value to copy to the GPU.
ptr	A pointer to the GPU-allocated memory.

Note: This function is involves a sychronization point, and should be used with care.

◆ getAmgxErrorMessage()

std::string Opm::gpuistl::getAmgxErrorMessage	(	AMGX_RC	err,
		const std::string &	expression,
		const std::string &	file,
		const std::string &	function,
		int	line )

inline

Get a descriptive error message for an AMGX error code.

Parameters

err	The AMGX error code
expression	The AMGX expression that caused the error
file	The source file where the error occurred
function	The function where the error occurred
line	The line number where the error occurred

Returns: std::string The formatted error message

◆ getHypreErrorMessage()

std::string Opm::gpuistl::getHypreErrorMessage	(	HYPRE_Int	err,
		const std::string &	expression,
		const std::string &	file,
		const std::string &	function,
		int	line )

inline

Get a descriptive error message for a Hypre error code.

Parameters

err	The Hypre error code
expression	The Hypre expression that caused the error
file	The source file where the error occurred
function	The function where the error occurred
line	The line number where the error occurred

Returns: std::string The formatted error message

◆ hypreSafeCall()

void Opm::gpuistl::hypreSafeCall	(	HYPRE_Int	rc,
		const std::string &	expression,
		const std::string &	file,
		const std::string &	function,
		int	line )

inline

Safe call wrapper for Hypre functions.

Checks the return code from Hypre functions and throws a HypreError if an error occurred.

Parameters

rc	The Hypre return code to check
expression	The expression being evaluated (for error reporting)
file	The source file (typically FILE)
function	The function name (typically func)
line	The line number (typically LINE)

Exceptions

HypreError if the return code indicates an error

◆ make_gpu_shared_ptr() [1/2]

template<typename T>

std::shared_ptr< T > Opm::gpuistl::make_gpu_shared_ptr ( )

Creates a shared pointer managing GPU-allocated memory of the specified element type.

This function allocates memory on the GPU for the type T, using cudaMalloc. It returns a std::shared_ptr that automatically handles the release of GPU memory with cudaFree when no longer in use.

Template Parameters

T	The element type to allocate on the GPU.

Returns: A std::shared_ptr to the GPU-allocated memory.

◆ make_gpu_shared_ptr() [2/2]

template<typename T>

std::shared_ptr< T > Opm::gpuistl::make_gpu_shared_ptr ( const T & value )

Creates a shared pointer managing GPU-allocated memory of the specified element type.

This function allocates memory on the GPU for the type T, using cudaMalloc. It returns a std::shared_ptr that automatically handles the release of GPU memory with cudaFree when no longer in use.

Template Parameters

T	The element type to allocate on the GPU.

Parameters

value The value to copy to the GPU-allocated memory.

Returns: A std::shared_ptr to the GPU-allocated memory.

◆ make_gpu_unique_ptr() [1/2]

template<typename T>

auto Opm::gpuistl::make_gpu_unique_ptr ( )

Creates a unique pointer managing GPU-allocated memory of the specified element type.

This function allocates memory on the GPU for the type T, using cudaMalloc . It returns a std::unique_ptr that automatically handles the release of GPU memory with cudaFree when no longer in use.

Template Parameters

T	The element type to allocate on the GPU.

Returns: A std::unique_ptr to the GPU-allocated memory.

◆ make_gpu_unique_ptr() [2/2]

template<typename T>

auto Opm::gpuistl::make_gpu_unique_ptr ( const T & value )

Creates a unique pointer managing GPU-allocated memory of the specified element type.

This function allocates memory on the GPU for the type T, using cudaMalloc. It returns a std::unique_ptr that automatically handles the release of GPU memory with cudaFree when no longer in use.

Template Parameters

T	The element type to allocate on the GPU.

Parameters

value The value to copy to the GPU-allocated memory.

Returns: A std::unique_ptr to the GPU-allocated memory.

◆ OPM_CREATE_GPU_RESOURCE() [1/3]

Opm::gpuistl::OPM_CREATE_GPU_RESOURCE	(	GPUEvent	,
		cudaEvent_t	,
		cudaEventCreate	,
		cudaEventDestroy	)

Manages a CUDA event resource.

This resource encapsulates a cudaEvent_t handle and provides automatic creation and destruction of the CUDA event. Use this resource to measure elapsed time or synchronize GPU executions between different streams.

◆ OPM_CREATE_GPU_RESOURCE() [2/3]

Opm::gpuistl::OPM_CREATE_GPU_RESOURCE	(	GPUGraph	,
		cudaGraph_t	,
		cudaGraphCreate	,
		cudaGraphDestroy	,
		0	)

Manages a CUDA graph resource.

This resource encapsulates a cudaGraph_t handle and provides automatic creation and destruction of a CUDA graph. It represents a series of operations captured for efficient replay, execution, or modification.

◆ OPM_CREATE_GPU_RESOURCE() [3/3]

Opm::gpuistl::OPM_CREATE_GPU_RESOURCE	(	GPUStream	,
		cudaStream_t	,
		cudaStreamCreate	,
		cudaStreamDestroy	)

Manages a CUDA stream resource.

This resource encapsulates a cudaStream_t handle and provides automatic creation and destruction of the CUDA stream. Use this resource to schedule and synchronize GPU kernels or other asynchronous operations.

◆ OPM_CREATE_GPU_RESOURCE_NO_CREATE()

Opm::gpuistl::OPM_CREATE_GPU_RESOURCE_NO_CREATE	(	GPUGraphExec	,
		cudaGraphExec_t	,
		cudaGraphExecDestroy	)

Manages a CUDA graph execution resource.

This resource encapsulates a cudaGraphExec_t handle and provides automatic destruction of the CUDA graph execution object. It represents the compiled and optimized version of a CUDA graph ready for efficient execution.

◆ setDevice()

void Opm::gpuistl::setDevice	(	int	mpiRank,
		int	numberOfMpiRanks )

Sets the correct CUDA device in the setting of MPI.

Note: This assumes that every node has equally many GPUs, all of the same caliber; This probably needs to be called before MPI_Init if one uses GPUDirect transfers (see eg. https://devtalk.nvidia.com/default/topic/752046/teaching-and-curriculum-support/multi-gpu-system-running-mpi-cuda-/ ); If no CUDA device is present, this does nothing.

◆ setZeroAtIndexSet()

void Opm::gpuistl::setZeroAtIndexSet ( const GpuVector< int > & indexSet )

The GpuVector class is a simple (arithmetic) vector class for the GPU.

Note: we currently only support simple raw primitives for T (double, float and int); We currently only support arithmetic operations on double and float.; this vector has no notion of block size. The user is responsible for allocating the correct number of primitives (double or floats)

Example usage:

   #include <opm/simulators/linalg/gpuistl/GpuVector.hpp>
  
   void someFunction() {
       auto someDataOnCPU = std::vector<double>({1.0, 2.0, 42.0, 59.9451743, 10.7132692});
  
       auto dataOnGPU = GpuVector<double>(someDataOnCPU);
  
       // Multiply by 4.0:
       dataOnGPU *= 4.0;
  
       // Get data back on CPU in another vector:
       auto stdVectorOnCPU = dataOnGPU.asStdVector();
   }
  
   @tparam T the type to store. Can be either float, double or int.
  /
template <typename T>
class GpuVector
{
public:
    using field_type = T;
    using size_type = size_t;
 
    GpuVector(const GpuVector<T>& other);
    explicit GpuVector(const std::vector<T>& data);
    GpuVector& operator=(const GpuVector<T>& other);
    template<int BlockDimension>
    explicit GpuVector(const Dune::BlockVector<Dune::FieldVector<T, BlockDimension>>& bvector)
        : GpuVector(bvector.dim())
    {
        copyFromHost(bvector);
    }
    GpuVector& operator=(T scalar);
    GpuVector() : m_dataOnDevice(nullptr), m_numberOfElements(0), m_cuBlasHandle(detail::CuBlasHandle::getInstance()) {}
    explicit GpuVector(const size_t numberOfElements);
 
    GpuVector(const T* dataOnHost, const size_t numberOfElements);
    virtual ~GpuVector();
    T* data();
    const T* data() const;
    template <int BlockDimension>
    void copyFromHost(const Dune::BlockVector<Dune::FieldVector<T, BlockDimension>>& bvector)
    {
        // TODO: [perf] vector.dim() can be replaced by bvector.N() * BlockDimension
        if (detail::to_size_t(m_numberOfElements) != bvector.dim()) {
            OPM_THROW(std::runtime_error,
                      fmt::format("Given incompatible vector size. GpuVector has size {}, \n"
                                  "however, BlockVector has N() = {}, and dim = {}.",
                                  m_numberOfElements,
                                  bvector.N(),
                                  bvector.dim()));
        }
        const auto dataPointer = static_cast<const T*>(&(bvector[0][0]));
        copyFromHost(dataPointer, m_numberOfElements);
    }
    template <int BlockDimension>
    void copyFromHostAsync(const Dune::BlockVector<Dune::FieldVector<T, BlockDimension>>& bvector, cudaStream_t stream = detail::DEFAULT_STREAM)
    {
        // TODO: [perf] vector.dim() can be replaced by bvector.N() * BlockDimension
        if (detail::to_size_t(m_numberOfElements) != bvector.dim()) {
            OPM_THROW(std::runtime_error,
                      fmt::format("Given incompatible vector size. GpuVector has size {}, \n"
                                  "however, BlockVector has N() = {}, and dim = {}.",
                                  m_numberOfElements,
                                  bvector.N(),
                                  bvector.dim()));
        }
        const auto dataPointer = static_cast<const T*>(&(bvector[0][0]));
        copyFromHostAsync(dataPointer, m_numberOfElements, stream);
    }
    template <int BlockDimension>
    void copyToHost(Dune::BlockVector<Dune::FieldVector<T, BlockDimension>>& bvector) const
    {
        // TODO: [perf] vector.dim() can be replaced by bvector.N() * BlockDimension
        if (detail::to_size_t(m_numberOfElements) != bvector.dim()) {
            OPM_THROW(std::runtime_error,
                      fmt::format(fmt::runtime("Given incompatible vector size. GpuVector has size {},\n"
                                               "however, the BlockVector has has N() = {}, and dim() = {}."),
                                  m_numberOfElements,
                                  bvector.N(),
                                  bvector.dim()));
        }
        const auto dataPointer = static_cast<T*>(&(bvector[0][0]));
        copyToHost(dataPointer, m_numberOfElements);
    }
    template <int BlockDimension>
    void copyToHostAsync(Dune::BlockVector<Dune::FieldVector<T, BlockDimension>>& bvector, cudaStream_t stream = detail::DEFAULT_STREAM) const
    {
        // TODO: [perf] vector.dim() can be replaced by bvector.N() * BlockDimension
        if (detail::to_size_t(m_numberOfElements) != bvector.dim()) {
            OPM_THROW(std::runtime_error,
                      fmt::format("Given incompatible vector size. GpuVector has size {},\n however, the BlockVector "
                                  "has has N() = {}, and dim() = {}.",
                                  m_numberOfElements,
                                  bvector.N(),
                                  bvector.dim()));
        }
        const auto dataPointer = static_cast<T*>(&(bvector[0][0]));
        copyToHostAsync(dataPointer, m_numberOfElements, stream);
    }
    void copyFromHost(const T* dataPointer, size_t numberOfElements);
    void copyFromHostAsync(const T* dataPointer, size_t numberOfElements, cudaStream_t stream = detail::DEFAULT_STREAM);
 
 
    void copyToHost(T* dataPointer, size_t numberOfElements) const;
    void copyToHostAsync(T* dataPointer, size_t numberOfElements, cudaStream_t stream = detail::DEFAULT_STREAM) const;
 
 
    void copyFromHost(const std::vector<T>& data);
    void copyFromHostAsync(const std::vector<T>& data, cudaStream_t stream = detail::DEFAULT_STREAM);
    void copyToHost(std::vector<T>& data) const;
    void copyToHostAsync(std::vector<T>& data, cudaStream_t stream = detail::DEFAULT_STREAM) const;
 
 
    void copyFromDeviceToDevice(const GpuVector<T>& other) const;
 
    void prepareSendBuf(GpuVector<T>& buffer, const GpuVector<int>& indexSet) const;
    void syncFromRecvBuf(GpuVector<T>& buffer, const GpuVector<int>& indexSet) const;
    GpuVector<T>& operator*=(const T& scalar);
    GpuVector<T>& axpy(T alpha, const GpuVector<T>& y);
    GpuVector<T>& operator+=(const GpuVector<T>& other);
    GpuVector<T>& operator-=(const GpuVector<T>& other);
    T dot(const GpuVector<T>& other) const;
    T two_norm() const;
    T dot(const GpuVector<T>& other, const GpuVector<int>& indexSet, GpuVector<T>& buffer) const;
    T two_norm(const GpuVector<int>& indexSet, GpuVector<T>& buffer) const;
 
    T dot(const GpuVector<T>& other, const GpuVector<int>& indexSet) const;
    T two_norm(const GpuVector<int>& indexSet) const;
 
    size_type dim() const;
    void resize(size_t new_size);
    std::vector<T> asStdVector() const;
    template <int blockSize>
    Dune::BlockVector<Dune::FieldVector<T, blockSize>> asDuneBlockVector() const
    {
        OPM_ERROR_IF(dim() % blockSize != 0,
                     fmt::format("blockSize is not a multiple of dim(). Given blockSize = {}, and dim() = {}",
                                 blockSize,
                                 dim()));
 
        Dune::BlockVector<Dune::FieldVector<T, blockSize>> returnValue(dim() / blockSize);
        copyToHost(returnValue);
        return returnValue;
    }
 

Namespaces

Classes

Enumerations

Functions

Variables

Detailed Description

Function Documentation

◆ amgxSafeCall()

◆ copyFromGPU() [1/3]

◆ copyFromGPU() [2/3]

◆ copyFromGPU() [3/3]

◆ copyToGPU() [1/3]

◆ copyToGPU() [2/3]

◆ copyToGPU() [3/3]

◆ getAmgxErrorMessage()

◆ getHypreErrorMessage()

◆ hypreSafeCall()

◆ make_gpu_shared_ptr() [1/2]

◆ make_gpu_shared_ptr() [2/2]

◆ make_gpu_unique_ptr() [1/2]

◆ make_gpu_unique_ptr() [2/2]

◆ OPM_CREATE_GPU_RESOURCE() [1/3]

◆ OPM_CREATE_GPU_RESOURCE() [2/3]

◆ OPM_CREATE_GPU_RESOURCE() [3/3]

◆ OPM_CREATE_GPU_RESOURCE_NO_CREATE()

◆ setDevice()

◆ setZeroAtIndexSet()