solvers (MCEq.solvers)

The module contains functions which are called by MCEq.core.MCEqRun.solve() method.

The implementation is a simple Forward-Euler stepper. The stability is under control since the smallest Eigenvalues are known a priory. The step size is “adaptive”, but it is deterministic and known before the integration starts.

The steps that each solver routine does are:

\[\Phi_{i + 1} = \Delta X_i\boldsymbol{M}_{int} \cdot \Phi_i + \frac{\Delta X_i}{\rho(X_i)}\cdot\boldsymbol{M}_{dec} \cdot \Phi_i)\]

with

(1)\[\boldsymbol{M}_{int} = (-\boldsymbol{1} + \boldsymbol{C}){\boldsymbol{\Lambda}}_{int}\]

and

(2)\[\boldsymbol{M}_{dec} = (-\boldsymbol{1} + \boldsymbol{D}){\boldsymbol{\Lambda}}_{dec}.\]

As one can easily see, each step can be represented by two sparse gemv calls and one vector addition. This is what happens in the MKL and CUDA functions below.

The fastest solver is using NVidia’s cuSparse library provided via the cupy matrix library. Intel MKL is recommended for Intel CPUs, in particular since MKL is using AVX instructions. The plain numpy solver is for compatibility and hacking, but not recommended for general use.

Reference/API

MCEq.solvers Module

Functions

info(min_dbg_level, *message, **kwargs)	Print to console if min_debug_level <= config.debug_level
solv_CUDA_sparse(nsteps, dX, rho_inv, ...)	NVIDIA CUDA cuSPARSE implementation of forward-euler integration.
solv_MKL_sparse(nsteps, dX, rho_inv, int_m, ...)	Intel MKL sparse BLAS implementation of forward-euler integration.
solv_numpy(nsteps, dX, rho_inv, int_m, ...)	numpy implementation of forward-euler integration.
solv_spacc_sparse(nsteps, dX, rho_inv, ...)	Apple Accelerate (vecLib) implementation.

Classes

CUDASparseContext(int_m, dec_m[, device_id])

This class handles the transfer between CPU and GPU memory, and the calling of GPU kernels.

Class Inheritance Diagram