Solver

SchurComplementLinearSolver(inner_alg::SciMLBase.AbstractLinearAlgorithm)

A solver for block systems of the form

\[\begin{bmatrix} A_{11} & A_{12} \\ A_{21} & 0 \end{bmatrix} \begin{bmatrix} u_1 \\ u_2 \end{bmatrix} = \begin{bmatrix} b_1 \\ b_2 \end{bmatrix}\]

with small zero block of size $N_2 \times N_2$ and invertible $A_{11}$ with size $N_1 \times N_1$. The inner linear solver is responsible to solve for $N_2$ systems of the form $A_{11} z_i = c_i$.

L1GSPrecBuilder(device::AbstractDevice)

A builder for the L1 Gauss-Seidel preconditioner. This struct encapsulates the backend and provides a method to build the preconditioner.

Fields

• device::AbstractDevice: The backend used for the preconditioner. More info AbstractDevice.

L1GSPreconditioner{Partitioning, SweepPlanType}

The ℓ₁ Gauss–Seidel preconditioner is a robust and parallel-friendly preconditioner for sparse matrices.

Algorithm

The L1-GS preconditioner is constructed by dividing the matrix into diagonal blocks nparts:

• Let Ωₖ denote the block with index k.
• For each Ωₖ, we define the following sets:
  • $ Ωⁱ := {j ∈ Ωₖ : i ∈ Ωₖ} $ → the set of columns in the diagonal block for row i
  • $ Ωⁱₒ := {j ∉ Ωₖ : i ∈ Ωₖ} $ → the remaining "off-diagonal" columns in row i

The preconditioner matrix $M_{ℓ_1}$ is defined as:

\[M_{ℓ_1GS} = M_{HGS} + D^{ℓ_1} \\\]

Where $D^{ℓ_1}$ is a diagonal matrix with entries: $d_{ii}^{ℓ_1} = \sum_{j ∈ Ωⁱₒ} |a_{ij}|$, and $M_{HGS}$ is obtained when the diagonal partitions are chosen to be the Gauss–Seidel sweeps on $A_{kk}$ However, we use another convergant variant, which takes adavantage of the local estimation of θ ( $a_{ii} >= θ * d_{ii}$):

\[M_{ℓ_1GS*} = M_{HGS} + D^{ℓ_1*}, \quad \text{where} \quad d_{ii}^{ℓ_1*} = \begin{cases} 0, & \text{if } a_{ii} \geq \eta d_{ii}^{ℓ_1}; \\ d_{ii}^{ℓ_1}/2, & \text{otherwise.} \end{cases}\]

Fields

• partitioning: Encapsulates partitioning data (e.g. nparts, partsize, backend).
• sweep: The sweep plan containing the cache and diagonal data ($D + D^{ℓ_1}$).

Reference

Baker, A. H., Falgout, R. D., Kolev, T. V., & Yang, U. M. (2011). Multigrid Smoothers for Ultraparallel Computing, SIAM J. Sci. Comput., 33(5), 2864–2887.

Example

builder = L1GSPrecBuilder(PolyesterDevice(4))
N = 128 * 16
A = spdiagm(0 => 2 * ones(N), -1 => -ones(N-1), 1 => -ones(N-1))
partsize = 16

# Basic usage
prec = builder(A, partsize)

# With options
prec = builder(A, partsize;
    isSymA = true,              # set true for symmetric matrices (better performance)
    η = 1.5,                    # threshold parameter
    sweep = SymmetricSweep(),   # ForwardSweep(), BackwardSweep(), or SymmetricSweep()
    cache_strategy = MatrixViewCache()  # or PackedBufferCache() for GPU
)

ForwardSweep <: AbstractSweep

Forward sweep using lower triangular part: $M = D + L$

BackwardSweep <: AbstractSweep

Backward sweep using upper triangular part: $M = D + U$

SymmetricSweep <: AbstractSweep

Symmetric sweep combining forward and backward: $M = (D + L) D^{-1} (D + U)$ saad2003iterative.

PackedBufferCache <: AbstractCacheStrategy

Store the to-be-applied sweeps in a packed dense buffer. Efficient for small partitions (e.g., GPU).

MatrixViewCache <: AbstractCacheStrategy

Store the to-be-applied sweeps in a matrix view. Efficient for large partitions (CPU).

NewtonRaphsonSolver{T}

Classical Newton-Raphson solver to solve nonlinear problems of the form F(u) = 0. To use the Newton-Raphson solver you have to dispatch on

• update_linearization!

MultilevelNewtonRaphsonSolver{T}

Multilevel Newton-Raphson solver RabSanHsu:1979:mna for nonlinear problems of the form F(u,v) = 0; G(u,v) = 0. To use the Multilevel solver you have to dispatch on

• update_linearization!

Simple forward euler to solve the cell model.

HomotopyPathSolver{IS, T, PFUN}

Solve the nonlinear problem F(u,t)=0 with given time increments Δton some interval [t_begin, t_end] where t is some pseudo-time parameter.

ReactionTangentController{LTG <: OS.LieTrotterGodunov, T <: Real} <: OS.AbstractOperatorSplittingAlgorithm

A timestep length controller for LieTrotterGodunov [5–7] operator splitting using the reaction tangent as proposed in [25] The next timestep length is calculated as

\[\sigma\left(R_{\max }\right):=\left(1.0-\frac{1}{1+\exp \left(\left(\sigma_{\mathrm{c}}-R_{\max }\right) \cdot \sigma_{\mathrm{s}}\right)}\right) \cdot\left(\Delta t_{\max }-\Delta t_{\min }\right)+\Delta t_{\min }\]

Fields

• ltg::LTG: LieTrotterGodunov algorithm
• σ_s::T: steepness
• σ_c::T: offset in R axis
• Δt_bounds::NTuple{2,T}: lower and upper timestep length bounds