openseespy-solvers 0.1.0__py3-none-any.whl

openseespy_solvers/__init__.py

@@ -0,0 +1,41 @@
+"""Ready-to-use PythonSparse solvers for OpenSeesPy."""
+
+from __future__ import annotations
+
+from importlib import import_module
+from typing import TYPE_CHECKING
+
+from openseespy_solvers.exceptions import (
+    BackendNotAvailableError,
+    InvalidOpenSeesDataError,
+    OpenSeesSolverError,
+    SolverConvergenceError,
+    UnsupportedComputeDtypeError,
+    UnsupportedStorageSchemeError,
+)
+from openseespy_solvers.hybrid import hybrid
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "BackendNotAvailableError",
+    "InvalidOpenSeesDataError",
+    "OpenSeesSolverError",
+    "SolverConvergenceError",
+    "UnsupportedComputeDtypeError",
+    "UnsupportedStorageSchemeError",
+    "__version__",
+    "cupy",
+    "hybrid",
+    "scipy",
+]
+
+if TYPE_CHECKING:
+    from openseespy_solvers import cupy as cupy
+    from openseespy_solvers import scipy as scipy
+
+
+def __getattr__(name: str):
+    if name in {"scipy", "cupy"}:
+        return import_module(f"openseespy_solvers.{name}")
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

openseespy_solvers/_base.py

@@ -0,0 +1,428 @@
+"""Base solver classes for the OpenSees PythonSparse interfaces.
+
+These bases own the parts that are *identical for every backend*: wrapping the
+OpenSees memoryviews, the ``matrix_status`` caching pattern, writing the solution
+in place, statistics, ``formAp``, ``to_openseespy`` and ``copy`` support.
+
+Backend-specific numerics are provided by small hooks that each namespace
+(``openseespy_solvers.scipy``, ``.cupy``, ...) implements:
+
+* ``_build_matrix`` / ``_update_matrix`` - assemble the cached sparse matrix
+* ``_to_device`` / ``_to_host`` - host<->device transfer (identity on CPU)
+* ``_matvec`` - ``A @ v``
+* ``_is_sparse`` / ``_is_linear_operator`` - preconditioner detection
+* ``_solve_system`` (linear) / ``_solve_eigen`` (eigen) - the actual library call
+
+A backend that does not fit this shape (e.g. a distributed PETSc backend) can
+override ``solve`` directly; nothing here is mandatory beyond the hooks a given
+solver uses.
+"""
+
+from __future__ import annotations
+
+import copy
+import time
+from abc import ABC, abstractmethod
+from typing import Any
+
+import numpy as np
+
+from openseespy_solvers._dtype import OPENSEES_BUFFER_DTYPE, resolve_compute_dtype
+from openseespy_solvers._sparse import parse_eigen_values, parse_sparse_arrays
+from openseespy_solvers.exceptions import InvalidOpenSeesDataError
+from openseespy_solvers.stats import EigenSolverStats, LinearSolverStats
+
+
+def _normalize_writable(writable: str | list[str]) -> str:
+    if isinstance(writable, list):
+        return ",".join(writable)
+    return writable
+
+
+class BaseOpenSeesSolver(ABC):
+    """Shared behavior for linear and eigen solvers."""
+
+    #: Backend name, set as a class attribute by each namespace mixin.
+    backend: str = "base"
+    #: Whether matrices/vectors live on a device (GPU) rather than host memory.
+    _on_device: bool = False
+
+    def __init__(
+        self,
+        *,
+        scheme: str = "CSR",
+        debug: bool = False,
+        dtype: Any = np.float64,
+    ) -> None:
+        self.scheme = scheme
+        self.debug = debug
+        self._compute_dtype = resolve_compute_dtype(dtype)
+        self._matrix: Any | None = None
+        self._k_matrix: Any | None = None
+        self._m_matrix: Any | None = None
+        self._params: dict[str, Any] = {}
+
+    # -- backend hooks ---------------------------------------------------
+
+    @abstractmethod
+    def _build_matrix(
+        self,
+        values: np.ndarray,
+        indices: np.ndarray,
+        indptr: np.ndarray,
+        shape: tuple[int, int],
+        fmt: str,
+    ) -> Any:
+        """Build a new sparse matrix in the backend's format (owns its data)."""
+
+    @abstractmethod
+    def _update_matrix(self, matrix: Any, values: np.ndarray) -> Any:
+        """Refresh coefficients (in place where possible) and return the matrix."""
+
+    @abstractmethod
+    def _to_device(self, array: np.ndarray) -> Any:
+        """Transfer a host array to the backend (identity on CPU)."""
+
+    @abstractmethod
+    def _to_host(self, array: Any) -> np.ndarray:
+        """Transfer a backend array back to a NumPy host array."""
+
+    @abstractmethod
+    def _matvec(self, matrix: Any, vector: Any) -> Any:
+        """Return ``matrix @ vector`` in the backend."""
+
+    # -- OpenSees config -------------------------------------------------
+
+    def to_openseespy(
+        self,
+        *,
+        scheme: str | None = None,
+        writable: str | list[str] | None = None,
+    ) -> dict[str, Any]:
+        """Return the configuration dict for OpenSeesPy ``PythonSparse`` commands.
+
+        Parameters
+        ----------
+        scheme : {'CSR', 'CSC'}, optional
+            Sparse storage scheme. Default is the value given at construction.
+        writable : str or list of str, optional
+            Writable buffers declared to OpenSees. Overrides the constructor
+            value when provided.
+
+        Returns
+        -------
+        config : dict
+            Dictionary with keys ``solver``, ``scheme``, and optionally
+            ``writable``. Pass directly to ``ops.system('PythonSparse', ...)``
+            or ``ops.eigen('PythonSparse', ...)``.
+
+        Examples
+        --------
+        >>> from openseespy_solvers.scipy import cg
+        >>> solver = cg()
+        >>> cfg = solver.to_openseespy()
+        >>> sorted(cfg.keys())
+        ['scheme', 'solver', 'writable']
+        """
+        cfg: dict[str, Any] = {
+            "solver": self,
+            "scheme": scheme or self.scheme,
+        }
+        if writable is not None:
+            cfg["writable"] = _normalize_writable(writable)
+        elif hasattr(self, "writable"):
+            cfg["writable"] = _normalize_writable(self.writable)
+        return cfg
+
+    # -- matrix caching --------------------------------------------------
+
+    def _values_for_compute(self, values: np.ndarray) -> np.ndarray:
+        return np.asarray(values, dtype=self._compute_dtype)
+
+    def _write_opensees_buffer(self, buf: np.ndarray, value: Any) -> None:
+        buf[:] = np.asarray(self._to_host(value), dtype=OPENSEES_BUFFER_DTYPE)
+
+    def _current_matrix(self, kwargs: dict[str, Any], *, values_key: str = "values") -> Any:
+        arrays = parse_sparse_arrays(kwargs, values_key=values_key)
+        values = self._values_for_compute(arrays.values)
+        status = kwargs["matrix_status"]
+        if status == "STRUCTURE_CHANGED" or self._matrix is None:
+            self._matrix = self._build_matrix(
+                values, arrays.indices, arrays.indptr, arrays.shape, arrays.fmt
+            )
+        elif status == "COEFFICIENTS_CHANGED":
+            self._matrix = self._update_matrix(self._matrix, values)
+        return self._matrix
+
+    def _current_eigen_matrices(self, kwargs: dict[str, Any]) -> tuple[Any, Any]:
+        arrays = parse_sparse_arrays(kwargs, values_key="k_values")
+        k_values = self._values_for_compute(arrays.values)
+        m_values = self._values_for_compute(parse_eigen_values(kwargs))
+        status = kwargs["matrix_status"]
+        if status == "STRUCTURE_CHANGED" or self._k_matrix is None:
+            self._k_matrix = self._build_matrix(
+                k_values, arrays.indices, arrays.indptr, arrays.shape, arrays.fmt
+            )
+            self._m_matrix = self._build_matrix(
+                m_values, arrays.indices, arrays.indptr, arrays.shape, arrays.fmt
+            )
+        elif status == "COEFFICIENTS_CHANGED":
+            self._k_matrix = self._update_matrix(self._k_matrix, k_values)
+            self._m_matrix = self._update_matrix(self._m_matrix, m_values)
+        return self._k_matrix, self._m_matrix
+
+    # -- copy ------------------------------------------------------------
+
+    def copy(self) -> BaseOpenSeesSolver:
+        return copy.copy(self)
+
+    def __copy__(self) -> BaseOpenSeesSolver:
+        return type(self)(**self._params)
+
+    def __deepcopy__(self, memo: dict[int, Any]) -> BaseOpenSeesSolver:
+        return self.__copy__()
+
+
+class LinearSolver(BaseOpenSeesSolver, ABC):
+    """Base class for linear system solvers (``Ax = b``).
+
+    Instances are created by backend factories such as :func:`openseespy_solvers.scipy.cg`.
+    OpenSees calls :meth:`solve` with sparse buffer memoryviews; the solution is
+    written in place to the ``x`` buffer.
+
+    Attributes
+    ----------
+    A : sparse matrix or None
+        Cached system matrix from the last :meth:`solve` or :meth:`formAp` call.
+    b : ndarray
+        Right-hand side from the last :meth:`solve` call.
+    x : ndarray
+        Last solution vector.
+    stats : LinearSolverStats
+        Runtime statistics updated after each :meth:`solve`.
+    """
+
+    stats: LinearSolverStats
+
+    def __init__(
+        self,
+        *,
+        scheme: str = "CSR",
+        writable: str | list[str] = "none",
+        debug: bool = False,
+        preconditioner: Any = None,
+        dtype: Any = np.float64,
+    ) -> None:
+        super().__init__(scheme=scheme, debug=debug, dtype=dtype)
+        self.writable = _normalize_writable(writable)
+        self._preconditioner = preconditioner
+        self._preconditioner_cached: Any | None = None
+        self.stats = LinearSolverStats()
+        self._A: Any | None = None
+        self._b: Any | None = None
+        self._x: Any | None = None
+
+    @property
+    def A(self) -> Any | None:
+        return self._A
+
+    @property
+    def b(self) -> Any | None:
+        return self._b
+
+    @property
+    def x(self) -> Any | None:
+        return self._x
+
+    def _resolve_preconditioner(self, A: Any, matrix_status: str) -> Any | None:
+        M = self._preconditioner
+        if M is None:
+            return None
+        if self._is_sparse(M) or self._is_linear_operator(M):
+            return M
+        if callable(M):
+            if matrix_status == "UNCHANGED" and self._preconditioner_cached is not None:
+                return self._preconditioner_cached
+            self._preconditioner_cached = M(A)
+            return self._preconditioner_cached
+        return M
+
+    def solve(self, **kwargs: Any) -> int:
+        """Solve ``Ax = b`` using buffers supplied by OpenSees.
+
+        This method is called by OpenSeesPy; application code normally does not
+        invoke it directly.
+
+        Parameters
+        ----------
+        **kwargs
+            OpenSees ``PythonSparse`` buffers, including ``values``, ``rhs``,
+            ``x``, ``num_eqn``, ``nnz``, ``matrix_status``, and
+            ``storage_scheme``.
+
+        Returns
+        -------
+        info : int
+            ``0`` if the solve succeeded; a negative value otherwise. When
+            ``debug=True``, failures raise the underlying exception instead.
+        """
+        try:
+            matrix_status = kwargs["matrix_status"]
+            num_eqn = int(kwargs["num_eqn"])
+            if "rhs" not in kwargs or "x" not in kwargs:
+                raise InvalidOpenSeesDataError("Linear solve requires rhs and x buffers")
+
+            A = self._current_matrix(kwargs)
+            rhs = np.frombuffer(kwargs["rhs"], dtype=OPENSEES_BUFFER_DTYPE, count=num_eqn)
+            x_buf = np.frombuffer(kwargs["x"], dtype=OPENSEES_BUFFER_DTYPE, count=num_eqn)
+
+            self._A = A
+            b = self._to_device(np.asarray(rhs, dtype=self._compute_dtype))
+            self._b = b
+
+            M = self._resolve_preconditioner(A, matrix_status)
+            start = time.perf_counter()
+            result, info, num_iter = self._solve_system(A, b, M, matrix_status)
+            elapsed = time.perf_counter() - start
+
+            self._write_opensees_buffer(x_buf, result)
+            self._x = result if self._on_device else x_buf
+
+            residual = None
+            if num_eqn > 0:
+                ax = np.asarray(self._to_host(self._matvec(A, result)), dtype=OPENSEES_BUFFER_DTYPE)
+                r = rhs - ax
+                norm_b = float(np.linalg.norm(rhs))
+                residual = (
+                    float(np.linalg.norm(r) / norm_b) if norm_b > 0 else float(np.linalg.norm(r))
+                )
+
+            self.stats.num_solves += 1
+            self.stats.last_solve_time = elapsed
+            self.stats.last_info = info
+            self.stats.last_num_iterations = num_iter
+            self.stats.last_residual_norm = residual
+            self.stats.last_error = None
+            return 0 if info == 0 else -abs(int(info))
+        except Exception as exc:
+            self.stats.last_error = exc
+            if self.debug:
+                raise
+            return -1
+
+    def formAp(self, **kwargs: Any) -> int:
+        try:
+            num_eqn = int(kwargs["num_eqn"])
+            if "p" not in kwargs or "Ap" not in kwargs:
+                raise InvalidOpenSeesDataError("formAp requires p and Ap buffers")
+
+            A = self._current_matrix(kwargs)
+            self._A = A
+            p = np.frombuffer(kwargs["p"], dtype=OPENSEES_BUFFER_DTYPE, count=num_eqn)
+            ap_buf = np.frombuffer(kwargs["Ap"], dtype=OPENSEES_BUFFER_DTYPE, count=num_eqn)
+
+            result = self._matvec(A, self._to_device(np.asarray(p, dtype=self._compute_dtype)))
+            self._write_opensees_buffer(ap_buf, result)
+            return 0
+        except Exception as exc:
+            self.stats.last_error = exc
+            if self.debug:
+                raise
+            return -1
+
+    @abstractmethod
+    def _is_sparse(self, obj: Any) -> bool:
+        """Return True if *obj* is a sparse matrix for this backend."""
+
+    @abstractmethod
+    def _is_linear_operator(self, obj: Any) -> bool:
+        """Return True if *obj* is a LinearOperator for this backend."""
+
+    @abstractmethod
+    def _solve_system(
+        self,
+        A: Any,
+        b: Any,
+        M: Any | None,
+        matrix_status: str,
+    ) -> tuple[Any, int, int | None]:
+        """Return (solution, info, num_iterations)."""
+
+
+class EigenSolver(BaseOpenSeesSolver, ABC):
+    """Base class for generalized eigenvalue solvers (``K phi = lambda M phi``)."""
+
+    stats: EigenSolverStats
+
+    def __init__(
+        self, *, scheme: str = "CSR", debug: bool = False, dtype: Any = np.float64
+    ) -> None:
+        super().__init__(scheme=scheme, debug=debug, dtype=dtype)
+        self.stats = EigenSolverStats()
+        self._K: Any | None = None
+        self._M: Any | None = None
+
+    @property
+    def K(self) -> Any | None:
+        return self._K
+
+    @property
+    def M(self) -> Any | None:
+        return self._M
+
+    def solve(self, **kwargs: Any) -> None:
+        num_modes = int(kwargs["num_modes"])
+        num_eqn = int(kwargs["num_eqn"])
+        find_smallest = bool(kwargs["find_smallest"])
+
+        eigenvalues_buf = np.frombuffer(
+            kwargs["eigenvalues"], dtype=OPENSEES_BUFFER_DTYPE, count=num_modes
+        )
+        eigenvectors_buf = np.frombuffer(
+            kwargs["eigenvectors"], dtype=OPENSEES_BUFFER_DTYPE, count=num_modes * num_eqn
+        )
+
+        K, M = self._current_eigen_matrices(kwargs)
+        self._K = K
+        self._M = M
+
+        start = time.perf_counter()
+        try:
+            eigvals, eigvecs = self._solve_eigen(
+                K, M, num_modes=num_modes, find_smallest=find_smallest
+            )
+            elapsed = time.perf_counter() - start
+
+            eigvals_host = np.asarray(self._to_host(eigvals), dtype=OPENSEES_BUFFER_DTYPE)
+            eigvecs_host = np.asarray(self._to_host(eigvecs), dtype=OPENSEES_BUFFER_DTYPE)
+
+            order = np.argsort(eigvals_host)
+            if not find_smallest:
+                order = order[::-1]
+            eigvals_host = eigvals_host[order]
+            eigvecs_host = eigvecs_host[:, order]
+
+            eigenvalues_buf[:] = eigvals_host[:num_modes]
+            eigenvectors_buf[:] = eigvecs_host[:, :num_modes].T.reshape(-1)
+
+            self.stats.num_solves += 1
+            self.stats.last_solve_time = elapsed
+            self.stats.last_num_modes = num_modes
+            self.stats.last_info = 0
+            self.stats.last_eigenvalues = eigvals_host[:num_modes].copy()
+            self.stats.last_error = None
+        except Exception as exc:
+            self.stats.last_error = exc
+            self.stats.last_info = -1
+            raise
+
+    @abstractmethod
+    def _solve_eigen(
+        self,
+        K: Any,
+        M: Any,
+        *,
+        num_modes: int,
+        find_smallest: bool,
+    ) -> tuple[Any, Any]:
+        """Return (eigenvalues, eigenvectors) with eigenvectors column-major."""

openseespy_solvers/_docstrings.py

@@ -0,0 +1,64 @@
+"""Shared NumPy-style docstring fragments for public factory functions."""
+
+_OPENSEES_LINEAR = """
+scheme : {'CSR', 'CSC'}, optional
+    Sparse storage scheme for :meth:`~openseespy_solvers._base.BaseOpenSeesSolver.to_openseespy`.
+    Default is ``'CSR'``.
+writable : str or list of str, optional
+    Writable buffers declared to OpenSees. Default is ``'none'``.
+debug : bool, optional
+    If ``True``, exceptions raised during :meth:`~openseespy_solvers._base.LinearSolver.solve`
+    or :meth:`~openseespy_solvers._base.LinearSolver.formAp` are re-raised. Otherwise a
+    negative status code is returned. Default is ``False``.
+dtype : dtype or str, optional
+    Floating-point precision for the numerical solve (``float32`` or ``float64``).
+    OpenSees buffer I/O remains ``float64``; values are cast at the boundary.
+    Default is ``float64``.
+"""
+
+_OPENSEES_EIGEN = """
+scheme : {'CSR', 'CSC'}, optional
+    Sparse storage scheme for :meth:`~openseespy_solvers._base.BaseOpenSeesSolver.to_openseespy`.
+    Default is ``'CSR'``.
+debug : bool, optional
+    If ``True``, exceptions raised during
+    :meth:`~openseespy_solvers._base.EigenSolver.solve` are re-raised. Default is ``False``.
+dtype : dtype or str, optional
+    Floating-point precision for the eigen solve (``float32`` or ``float64``).
+    OpenSees buffer I/O remains ``float64``. Default is ``float64``.
+"""
+
+_LINEAR_RETURNS = """
+Returns
+-------
+solver : LinearSolver
+    Configured linear solver. Pass ``solver.to_openseespy()`` to
+    ``ops.system('PythonSparse', ...)``.
+"""
+
+_EIGEN_RETURNS = """
+Returns
+-------
+solver : EigenSolver
+    Configured eigen solver. Pass ``solver.to_openseespy()`` to
+    ``ops.eigen('PythonSparse', num_modes, ...)``.
+"""
+
+_LINEAR_NOTES = """
+Notes
+-----
+OpenSees assembles the sparse system matrix and right-hand side and calls
+:meth:`~openseespy_solvers._base.LinearSolver.solve` with buffer memoryviews.
+The solution is written in place to the ``x`` buffer. After each solve,
+``solver.A``, ``solver.b``, and ``solver.x`` refer to the cached matrix and
+vectors from the last call.
+"""
+
+_EIGEN_NOTES = """
+Notes
+-----
+OpenSees assembles ``K`` and ``M`` and calls
+:meth:`~openseespy_solvers._base.EigenSolver.solve`. Eigenvalues and
+eigenvectors are written in place to the output buffers. After each solve,
+``solver.K`` and ``solver.M`` refer to the cached matrices from the last call.
+"""

openseespy_solvers/_dtype.py

@@ -0,0 +1,45 @@
+"""Compute precision for solver numerics (OpenSees buffers remain float64)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+from openseespy_solvers.exceptions import UnsupportedComputeDtypeError
+
+# OpenSees PythonSparse memoryviews are double precision.
+OPENSEES_BUFFER_DTYPE = np.dtype(np.float64)
+
+_ALLOWED_COMPUTE_DTYPES = frozenset({np.dtype(np.float32), np.dtype(np.float64)})
+
+
+def resolve_compute_dtype(dtype: Any = np.float64) -> np.dtype:
+    """Normalize ``dtype`` to ``float32`` or ``float64`` for internal solves.
+
+    Parameters
+    ----------
+    dtype : dtype or str, optional
+        ``numpy.float32``, ``numpy.float64``, ``'float32'``, ``'f32'``, etc.
+        Default is ``float64``.
+
+    Returns
+    -------
+    numpy.dtype
+        Resolved compute dtype.
+
+    Raises
+    ------
+    UnsupportedComputeDtypeError
+        If *dtype* is not single- or double-precision float.
+    """
+    try:
+        resolved = np.dtype(dtype)
+    except TypeError as exc:
+        raise UnsupportedComputeDtypeError(f"Invalid dtype {dtype!r}") from exc
+    if resolved not in _ALLOWED_COMPUTE_DTYPES:
+        raise UnsupportedComputeDtypeError(
+            f"Compute dtype must be float32 or float64, got {resolved!r}. "
+            "OpenSees buffers are always float64; lower precision applies inside the solver."
+        )
+    return resolved

openseespy_solvers/_factorization.py

@@ -0,0 +1,86 @@
+"""Apply an inner direct solver's cached factorization to a vector."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+from openseespy_solvers._base import LinearSolver
+from openseespy_solvers._sparse import _host_array, csr_linear_kwargs_from_matrix
+from openseespy_solvers.exceptions import SolverConvergenceError
+
+
+def apply_inner_factorization(
+    inner: LinearSolver,
+    matrix: Any,
+    vec: Any,
+    *,
+    refactor: bool,
+    on_device: bool,
+    structure_changed: bool = False,
+) -> Any:
+    """Apply ``inner`` direct solver's factorization of ``matrix`` to ``vec``.
+
+    When ``refactor`` is ``True``, the inner solver (re)factorizes ``matrix`` and
+    applies the factorization. When ``False``, the cached factorization is reused
+    (``matrix_status='UNCHANGED'``) even if ``matrix`` coefficients were updated
+    elsewhere.
+
+    Parameters
+    ----------
+    inner : LinearSolver
+        Direct solver whose factorization is applied.
+    matrix : sparse matrix
+        System matrix in the inner solver's backend format.
+    vec : array
+        Right-hand side vector (host or device).
+    refactor : bool
+        If ``True``, refresh the factorization before applying it.
+    on_device : bool
+        If ``True``, call ``inner._solve_system`` without a host round-trip.
+        If ``False``, marshal through OpenSees-style buffers and ``inner.solve``.
+    structure_changed : bool, optional
+        When ``refactor`` is ``True``, use ``STRUCTURE_CHANGED`` instead of
+        ``COEFFICIENTS_CHANGED``.
+
+    Returns
+    -------
+    array
+        Solution vector on the inner solver's compute device.
+
+    Raises
+    ------
+    SolverConvergenceError
+        If the inner solve reports failure.
+    """
+    if refactor:
+        matrix_status = "STRUCTURE_CHANGED" if structure_changed else "COEFFICIENTS_CHANGED"
+    else:
+        matrix_status = "UNCHANGED"
+
+    if on_device:
+        rhs = inner._to_device(np.asarray(_host_array(vec), dtype=inner._compute_dtype))
+        result, info, _ = inner._solve_system(matrix, rhs, None, matrix_status)
+        if info != 0:
+            raise SolverConvergenceError(
+                f"Inner direct solve failed with info={info} (matrix_status={matrix_status!r})"
+            )
+        return result
+
+    n = matrix.shape[0]
+    rhs_host = np.asarray(_host_array(vec), dtype=np.float64).ravel()
+    x_host = np.zeros(n, dtype=np.float64)
+    lin_kwargs = csr_linear_kwargs_from_matrix(
+        matrix,
+        rhs_host,
+        matrix_status=matrix_status,
+        x=x_host,
+    )
+    info = inner.solve(**lin_kwargs)
+    if info != 0:
+        raise SolverConvergenceError(
+            f"Inner direct solve failed with info={info} (matrix_status={matrix_status!r})"
+        )
+    solution = np.frombuffer(lin_kwargs["x"], dtype=np.float64, count=n).copy()
+    return inner._to_device(solution)