loadpath 0.1.1__py3-none-any.whl

loadpath/am.py

@@ -0,0 +1,316 @@
+"""
+Overhang control for additive manufacturing: Langelaar's AM filter
+(Langelaar 2017, "An additive manufacturing filter for topology
+optimization of print-ready designs", SMO 55).
+
+The part is printed layer by layer along a build direction. A cell can only
+be printed if the layer below supports it, so its "printed" density is the
+smaller of its own density and the strongest support beneath it:
+
+    printed_i = smin(x_i, smax(printed_j for j in S_i))
+
+where S_i is the cell directly below and its four neighbors in that layer.
+That stencil allows overhangs up to 45 degrees, the usual self-supporting
+limit for FDM and for metal powder-bed printing. The first layer sits on the
+build plate. Running the optimizer on printed densities means material that
+would need support simply earns nothing, so the design grows its own
+supports: Y-shapes instead of flat ceilings.
+
+smax/smin are smooth so gradients exist; the backward pass carries
+sensitivities down through the layers (each layer's support depends on
+every layer under it).
+
+Any build direction works, not only the six grid axes. For a tilted one
+(`TiltedAMFilter`) the support stencil is every neighbor among the 26 that
+lies within 45 degrees of straight down, and the "layers" are bands of the
+height along the build direction narrow enough that a cell's supports are
+always in an earlier band. Along a grid axis that stencil is exactly
+Langelaar's five cells.
+
+The module also carries what a layered process does to the material
+(`layered_elasticity`): FDM parts are slightly softer and much weaker across
+layers than along them. Verification always solves with the layered
+stiffness and checks the bond. The optimizer can design with it too
+(process.anisotropic: true), or with the across-layer terms cut to the
+bond's strength ratio ("bond"), a surrogate meant to stop compliance
+minimization leaning on material loaded across its layers. Measured on the
+motor mount and the printed hook at fixed volume fraction (2026-10-29),
+neither beat the isotropic design reliably: compliance cannot tell tension
+across layers (which breaks bonds) from compression (which doesn't), and
+the layout shift moved the von Mises peak more than it saved the bond. So
+the default designs isotropic; the bond enters through the safety-factor
+search (verified margins include it) and the choice of build direction
+(orient.py).
+"""
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = ["AMFilter", "TiltedAMFilter", "parse_build_direction", "build_vector", "layered_elasticity",
+           "direction_label"]
+
+_P = 40.0
+_XI0 = 0.5
+_EPS = 1e-4
+_N_SUPPORT = 5
+_Q = _P + np.log(_N_SUPPORT) / np.log(_XI0)
+
+
+def parse_build_direction(spec):
+    """'+z' -> (axis 2, +1). Layers stack along the direction; the build
+    plate is at the far end opposite it. A vector [x, y, z] gives a tilted
+    build: returned as a unit 3-tuple, or as (axis, sign) when it lies on a
+    grid axis."""
+    if spec is None:
+        return None
+    if isinstance(spec, (list, tuple, np.ndarray)) and len(spec) == 3:
+        v = np.asarray(spec, float)
+        nrm = np.linalg.norm(v)
+        if not np.isfinite(nrm) or nrm == 0:
+            raise ValueError("printDirection vector must be nonzero")
+        v = v / nrm
+        ax = int(np.argmax(np.abs(v)))
+        if abs(v[ax]) > 1 - 1e-9:
+            return ax, (1 if v[ax] > 0 else -1)
+        return tuple(float(c) for c in v)
+    if isinstance(spec, tuple) and len(spec) == 2:
+        return int(spec[0]), int(spec[1])
+    s = str(spec).strip().lower()
+    if len(s) == 1:
+        s = "+" + s
+    if len(s) != 2 or s[0] not in "+-" or s[1] not in "xyz":
+        raise ValueError("printDirection must be one of +x, -x, +y, -y, +z, -z (the direction layers stack), "
+                         "or a vector [x, y, z]")
+    return "xyz".index(s[1]), (1 if s[0] == "+" else -1)
+
+
+def build_vector(direction) -> np.ndarray:
+    """Unit vector of a build direction in either form."""
+    if len(direction) == 2:
+        v = np.zeros(3)
+        v[int(direction[0])] = float(direction[1])
+        return v
+    v = np.asarray(direction, float)
+    return v / np.linalg.norm(v)
+
+
+def direction_label(direction) -> str:
+    if direction is None:
+        return "none"
+    if len(direction) == 2:
+        return ("+" if direction[1] > 0 else "-") + "xyz"[direction[0]]
+    return "[" + ", ".join(f"{c:.3f}" for c in direction) + "]"
+
+
+# Layered stiffness, as fractions of the in-plane values. Printed at full
+# density FDM loses little stiffness across layers (published tensile
+# moduli across layers sit at 80-95% of in-plane for PLA/PETG/ABS) but the
+# bond carries 50-70% of the strength, and less in shear.
+_LAYER_STIFFNESS = {"fdm": (0.85, 0.75), "sls": (0.95, 0.9), "mjf": (0.97, 0.95), "lpbf": (0.97, 0.95)}
+
+
+def layered_elasticity(nu: float, process, design: bool = False):
+    """The elasticity a solver should use for a material made by `process`
+    (spec.Process): a plain Poisson's ratio when the process has no layers
+    worth modeling, else a fem.Layered about the build direction.
+
+    design=True is the "bond" surrogate: across-layer modulus and shear
+    capped at the bond's strength ratio (see the module note for how it
+    fared)."""
+    if process is None or process.build is None or process.build == "auto":
+        return nu
+    ez, gz = _LAYER_STIFFNESS.get(process.kind, (1.0, 1.0))
+    ez = getattr(process, "ez", None) or ez
+    gz = getattr(process, "gz", None) or gz
+    if design:
+        ez = min(ez, process.interlayer)
+        gz = min(gz, process.interlayer)
+    if ez >= 1.0 and gz >= 1.0:
+        return nu
+    from .fem import Layered
+    return Layered(nu, ez, gz, build_vector(process.build))
+
+
+def _smin(x, xi):
+    d = x - xi
+    r = np.sqrt(d * d + _EPS)
+    val = 0.5 * (x + xi - r + np.sqrt(_EPS))
+    dx = 0.5 * (1.0 - d / r)
+    dxi = 0.5 * (1.0 + d / r)
+    return val, dx, dxi
+
+
+def _neighbors(layer):
+    """The 5 support cells under each cell, as shifted copies of the layer
+    below (outside the grid counts as empty)."""
+    out = [layer]
+    for ax in (0, 1):
+        for sh in (1, -1):
+            s = np.roll(layer, sh, axis=ax)
+            idx = [slice(None), slice(None)]
+            idx[ax] = slice(0, 1) if sh == 1 else slice(-1, None)
+            s[tuple(idx)] = 0.0
+            out.append(s)
+    return out
+
+
+def _unshift(grads):
+    """Adjoint of _neighbors: route each shifted copy's gradient back to the
+    cell it came from."""
+    total = grads[0].copy()
+    k = 1
+    for ax in (0, 1):
+        for sh in (1, -1):
+            g = grads[k].copy()
+            idx = [slice(None), slice(None)]
+            idx[ax] = slice(0, 1) if sh == 1 else slice(-1, None)
+            g[tuple(idx)] = 0.0
+            total += np.roll(g, -sh, axis=ax)
+            k += 1
+    return total
+
+
+class AMFilter:
+    def __new__(cls, dims, direction, pinned=None):
+        if cls is AMFilter and len(direction) == 3:
+            return TiltedAMFilter(dims, direction, pinned)
+        return super().__new__(cls)
+
+    def __init__(self, dims, direction: tuple[int, int], pinned: np.ndarray | None = None):
+        self.dims = tuple(dims)
+        self.axis, self.sign = direction
+        # Pinned cells (preserved geometry) print as solid regardless: they
+        # are the user's, and they support what is above them.
+        self.pinned = None if pinned is None else self._to_layers(pinned.astype(float))
+        self._cache = None
+
+    def _to_layers(self, g):
+        """Move the build axis first, ordered from the build plate up."""
+        g = np.moveaxis(g, self.axis, 0)
+        return g if self.sign > 0 else g[::-1]
+
+    def _from_layers(self, g):
+        g = g if self.sign > 0 else g[::-1]
+        return np.moveaxis(g, 0, self.axis)
+
+    def forward(self, field: np.ndarray) -> np.ndarray:
+        x = self._to_layers(np.asarray(field, float))
+        n = x.shape[0]
+        printed = np.empty_like(x)
+        cache = []
+        for k in range(n):
+            if k == 0:
+                xi = np.ones_like(x[0])
+                parts, ssum = None, None
+            else:
+                parts = _neighbors(printed[k - 1])
+                ssum = sum(np.maximum(p, 0.0) ** _P for p in parts)
+                xi = np.maximum(ssum, 1e-300) ** (1.0 / _Q)
+            val, dx, dxi = _smin(x[k], xi)
+            if self.pinned is not None:
+                pin = self.pinned[k] > 0.5
+                val = np.where(pin, 1.0, val)
+                dx = np.where(pin, 0.0, dx)
+                dxi = np.where(pin, 0.0, dxi)
+            printed[k] = val
+            cache.append((parts, ssum, dx, dxi))
+        self._cache = cache
+        return self._from_layers(printed)
+
+    def backward(self, grad: np.ndarray) -> np.ndarray:
+        """Gradient wrt the input field of the last forward(), given the
+        gradient wrt its output."""
+        g = self._to_layers(np.asarray(grad, float)).copy()
+        n = g.shape[0]
+        out = np.zeros_like(g)
+        carry = np.zeros_like(g[0])
+        for k in range(n - 1, -1, -1):
+            parts, ssum, dx, dxi = self._cache[k]
+            total = g[k] + carry
+            out[k] = total * dx
+            carry = np.zeros_like(g[0])
+            if k > 0:
+                # d xi / d support_j = (P/Q) s_j^(P-1) * ssum^(1/Q - 1)
+                common = total * dxi * (_P / _Q) * np.maximum(ssum, 1e-300) ** (1.0 / _Q - 1.0)
+                grads = [common * np.maximum(p, 0.0) ** (_P - 1.0) for p in parts]
+                carry = _unshift(grads)
+        return self._from_layers(out)
+
+
+class TiltedAMFilter:
+    """The AM filter for a build direction off the grid axes (see the module
+    note). The build plate is the plane through the lowest cell of the grid
+    along the direction unless `plate` (a bool grid) says which cells sit on
+    it: a support-free tilted print has to grow from wherever it touches."""
+
+    def __init__(self, dims, direction, pinned: np.ndarray | None = None, plate: np.ndarray | None = None):
+        self.dims = tuple(int(d) for d in dims)
+        up = build_vector(direction)
+        offs = np.array([[i, j, k] for i in (-1, 0, 1) for j in (-1, 0, 1) for k in (-1, 0, 1)
+                         if (i, j, k) != (0, 0, 0)], float)
+        proj = offs @ up
+        cosang = -proj / np.linalg.norm(offs, axis=1)
+        sel = cosang >= np.cos(np.radians(45.0)) - 1e-9
+        self.offsets = offs[sel].astype(np.int64)
+        n_sup = len(self.offsets)
+        self._q = _P + np.log(n_sup) / np.log(_XI0)
+        delta = float((-proj[sel]).min())
+        ijk = np.indices(self.dims).reshape(3, -1).T
+        h = ijk @ up
+        level = np.floor((h - h.min()) / delta + 1e-9).astype(np.int64)
+        n = len(ijk)
+        self._nbr = []
+        for o in self.offsets:
+            q = ijk + o
+            ok = np.all((q >= 0) & (q < np.array(self.dims)), axis=1)
+            flat = np.full(n, -1, np.int64)
+            flat[ok] = np.ravel_multi_index(q[ok].T, self.dims)
+            self._nbr.append(flat)
+        order = np.argsort(level, kind="stable")
+        bounds = np.searchsorted(level[order], np.arange(level.max() + 2))
+        self._groups = [order[bounds[k]:bounds[k + 1]] for k in range(len(bounds) - 1)
+                        if bounds[k + 1] > bounds[k]]
+        if plate is None:
+            plate = level == 0
+        else:
+            plate = np.asarray(plate, bool).ravel()
+        self._plate = plate
+        self._pinned = None if pinned is None else np.asarray(pinned, bool).ravel()
+        self._cache = None
+
+    def forward(self, field: np.ndarray) -> np.ndarray:
+        x = np.asarray(field, float).ravel()
+        printed = np.zeros_like(x)
+        padded = np.zeros(len(x) + 1)           # slot -1 reads as empty
+        cache = []
+        for idx in self._groups:
+            nb = [f[idx] for f in self._nbr]
+            parts = [padded[b] for b in nb]
+            ssum = sum(np.maximum(p, 0.0) ** _P for p in parts)
+            xi = np.maximum(ssum, 1e-300) ** (1.0 / self._q)
+            on_plate = self._plate[idx]
+            xi = np.where(on_plate, 1.0, xi)
+            val, dx, dxi = _smin(x[idx], xi)
+            dxi = np.where(on_plate, 0.0, dxi)
+            if self._pinned is not None:
+                pin = self._pinned[idx]
+                val = np.where(pin, 1.0, val)
+                dx = np.where(pin, 0.0, dx)
+                dxi = np.where(pin, 0.0, dxi)
+            printed[idx] = val
+            padded[idx] = val
+            cache.append((nb, parts, ssum, dx, dxi))
+        self._cache = cache
+        return printed.reshape(self.dims)
+
+    def backward(self, grad: np.ndarray) -> np.ndarray:
+        gp = np.zeros(int(np.prod(self.dims)) + 1)
+        gp[:-1] = np.asarray(grad, float).ravel()
+        out = np.zeros(len(gp) - 1)
+        for idx, (nb, parts, ssum, dx, dxi) in zip(reversed(self._groups), reversed(self._cache)):
+            total = gp[idx]
+            out[idx] = total * dx
+            common = total * dxi * (_P / self._q) * np.maximum(ssum, 1e-300) ** (1.0 / self._q - 1.0)
+            for b, p in zip(nb, parts):
+                gp[b] += common * np.maximum(p, 0.0) ** (_P - 1.0)    # one offset: distinct targets
+        return out.reshape(self.dims)

loadpath/amgfast.py

@@ -0,0 +1,326 @@
+"""pyamg's Gauss-Seidel smoother without the GIL.
+
+fem.Solver.solve_many runs a study's load cases on threads, one CG each,
+sharing one AMG hierarchy: the sparse matrix products release the GIL,
+but pyamg's compiled Gauss-Seidel (amg_core.gauss_seidel,
+bsr_gauss_seidel and block_gauss_seidel, the V-cycle's smoothers and most
+of a solve's time) holds it, so the cases' smoothing ran one at a time:
+on the GRIP upper arm three cases took about as long as three solves.
+
+These are the same loops (pyamg 5.x amg_core/relaxation.h: the same
+operations in the same order, so the same bits) as numba kernels that
+release the GIL. `install()` swaps them in for pyamg's three functions;
+everything else in amg_core stays pyamg's. LOADPATH_AMGFAST=0 leaves
+pyamg alone.
+"""
+from __future__ import annotations
+
+import os
+
+import numpy as np
+
+try:
+    import numba as nb
+
+    from . import meshops as _meshops
+except ImportError:  # pragma: no cover - numba is a dependency
+    nb = None
+
+_INSTALLED = False
+
+if nb is not None:
+    # Indices go through uint64: numba wraps negative signed indices, a
+    # compare and conditional move on every load that made the kernels half
+    # pyamg's speed. The wrappers hand over the index arrays viewed unsigned.
+    U = np.uint64
+
+    @nb.njit(cache=True, nogil=True)
+    def _gs(Ap, Aj, Ax, x, b, row_start, row_stop, row_step):
+        i = row_start
+        while i != row_stop:
+            ui = U(i)
+            rsum = 0.0
+            diag = 0.0
+            jj = U(Ap[ui])
+            end = U(Ap[ui + U(1)])
+            while jj < end:
+                j = U(Aj[jj])
+                if j == ui:
+                    diag = Ax[jj]
+                else:
+                    rsum += Ax[jj] * x[j]
+                jj += U(1)
+            if diag != 0.0:
+                x[ui] = (b[ui] - rsum) / diag
+            i += row_step
+
+    @nb.njit(cache=True, nogil=True)
+    def _bsr_gs(Ap, Aj, Ax, x, b, row_start, row_stop, row_step, bs):
+        # relaxation.h bsr_gauss_seidel: off-diagonal blocks by gemm (each
+        # into zeros, then subtracted), then the diagonal block pointwise,
+        # in the sweep's direction
+        ubs = U(bs)
+        B2 = ubs * ubs
+        rsum = np.empty(bs)
+        axloc = np.empty(bs)
+        if row_step < 0:
+            step, k0, k1 = -1, bs - 1, -1
+        else:
+            step, k0, k1 = 1, 0, bs
+        i = row_start
+        while i != row_stop:
+            ui = U(i)
+            ib = ui * ubs
+            for k in range(bs):
+                rsum[k] = b[ib + U(k)]
+            diag_ptr = U(0)
+            has_diag = False
+            jj = U(Ap[ui])
+            end = U(Ap[ui + U(1)])
+            while jj < end:
+                j = U(Aj[jj])
+                if j == ui:
+                    diag_ptr = jj * B2
+                    has_diag = True
+                else:
+                    col = j * ubs
+                    blk = jj * B2
+                    for m in range(bs):
+                        acc = 0.0
+                        row = blk + U(m) * ubs
+                        for k in range(bs):
+                            acc += Ax[row + U(k)] * x[col + U(k)]
+                        axloc[m] = acc
+                    for m in range(bs):
+                        rsum[m] -= axloc[m]
+                jj += U(1)
+            if has_diag:
+                k = k0
+                while k != k1:
+                    uk = U(k)
+                    diag = 1.0
+                    kk = k0
+                    while kk != k1:
+                        ukk = U(kk)
+                        if k == kk:
+                            diag = Ax[uk * ubs + ukk + diag_ptr]
+                        else:
+                            rsum[k] -= Ax[uk * ubs + ukk + diag_ptr] * x[ib + ukk]
+                        kk += step
+                    if diag != 0.0:
+                        x[ib + uk] = rsum[k] / diag
+                    k += step
+            i += row_step
+
+    @nb.njit(cache=True, nogil=True)
+    def _block_gs(Ap, Aj, Ax, x, b, Dinv, row_start, row_stop, row_step, bs):
+        # relaxation.h block_gauss_seidel: rsum = sum of off-diagonal block
+        # products (each gemm into zeros), x_i = Dinv_i (b_i - rsum)
+        ubs = U(bs)
+        B2 = ubs * ubs
+        rsum = np.empty(bs)
+        v = np.empty(bs)
+        i = row_start
+        while i != row_stop:
+            ui = U(i)
+            ib = ui * ubs
+            for k in range(bs):
+                rsum[k] = 0.0
+            jj = U(Ap[ui])
+            end = U(Ap[ui + U(1)])
+            while jj < end:
+                j = U(Aj[jj])
+                if j != ui:
+                    col = j * ubs
+                    blk = jj * B2
+                    for m in range(bs):
+                        acc = 0.0
+                        row = blk + U(m) * ubs
+                        for k in range(bs):
+                            acc += Ax[row + U(k)] * x[col + U(k)]
+                        v[m] = acc
+                    for k in range(bs):
+                        rsum[k] += v[k]
+                jj += U(1)
+            for k in range(bs):
+                rsum[k] = b[ib + U(k)] - rsum[k]
+            dblk = ui * B2
+            for m in range(bs):
+                acc = 0.0
+                row = dblk + U(m) * ubs
+                for k in range(bs):
+                    acc += Dinv[row + U(k)] * rsum[k]
+                x[ib + U(m)] = acc
+            i += row_step
+
+    @nb.njit(cache=True, nogil=True, inline="always")
+    def _row_cols(i, Ap, Aj, Bp, Bj, mark, cols):
+        # the block row's output columns in scipy's order: first visit
+        n = 0
+        for jj in range(Ap[i], Ap[i + 1]):
+            j = U(Aj[jj])
+            for kk in range(Bp[j], Bp[j + U(1)]):
+                k = Bj[kk]
+                if mark[k] != i:
+                    mark[k] = i
+                    cols[n] = k
+                    n += 1
+        return n
+
+    @nb.njit(cache=True, parallel=True)
+    def _bsr_count(n_brow, n_bcol, Ap, Aj, Bp, Bj, counts):
+        nch = 64
+        for c in nb.prange(nch):
+            mark = np.full(n_bcol, -1, np.int64)
+            cols = np.empty(n_bcol, np.int64)
+            for i in range(c * n_brow // nch, (c + 1) * n_brow // nch):
+                counts[i] = _row_cols(i, Ap, Aj, Bp, Bj, mark, cols)
+
+    @nb.njit(cache=True, parallel=True)
+    def _bsr_fill(n_brow, n_bcol, R, C, N, Ap, Aj, Ax, Bp, Bj, Bx, Cp, Cj, Cx):
+        # scipy sparsetools bsr_matmat, a block row at a time: each output
+        # block gathers A(i, j) B(j, k) in the same (jj, kk) order, by its
+        # gemm (dot from the block's value, d ascending), so the same bits
+        RC, RN, NC = R * C, R * N, N * C
+        nch = 64
+        for c in nb.prange(nch):
+            mark = np.full(n_bcol, -1, np.int64)
+            slot = np.empty(n_bcol, np.int64)
+            cols = np.empty(n_bcol, np.int64)
+            for i in range(c * n_brow // nch, (c + 1) * n_brow // nch):
+                n = _row_cols(i, Ap, Aj, Bp, Bj, mark, cols)
+                base = Cp[i]
+                for q in range(n):
+                    Cj[base + q] = cols[q]
+                    slot[cols[q]] = base + q
+                    for t in range(RC):
+                        Cx[(base + q) * RC + t] = 0.0
+                for jj in range(Ap[i], Ap[i + 1]):
+                    j = U(Aj[jj])
+                    a0 = U(jj) * U(RN)
+                    for kk in range(Bp[j], Bp[j + U(1)]):
+                        k = Bj[kk]
+                        b0 = U(kk) * U(NC)
+                        c0 = U(slot[k]) * U(RC)
+                        for r in range(R):
+                            for cc in range(C):
+                                o = c0 + U(C * r + cc)
+                                dot = Cx[o]
+                                for d in range(N):
+                                    dot += Ax[a0 + U(N * r + d)] * Bx[b0 + U(C * d + cc)]
+                                Cx[o] = dot
+
+
+def _u(a):
+    """An index array viewed unsigned (they are never negative)."""
+    return a.view(np.uint32 if a.dtype.itemsize == 4 else np.uint64)
+
+
+def _ok(*arrays):
+    return all(a.dtype == np.float64 for a in arrays)
+
+
+from pyamg import amg_core
+
+
+class _Core:
+    """amg_core with the three Gauss-Seidel kernels replaced."""
+
+    def __init__(self, core):
+        self._core = core
+
+    def __getattr__(self, name):
+        return getattr(self._core, name)
+
+    @staticmethod
+    def gauss_seidel(Ap, Aj, Ax, x, b, row_start, row_stop, row_step):
+        if not _ok(Ax, x, b):
+            return amg_core.gauss_seidel(Ap, Aj, Ax, x, b, row_start, row_stop, row_step)
+        _gs(_u(Ap), _u(Aj), Ax, x, b, int(row_start), int(row_stop), int(row_step))
+
+    @staticmethod
+    def bsr_gauss_seidel(Ap, Aj, Ax, x, b, row_start, row_stop, row_step, R):
+        if not _ok(Ax, x, b):
+            return amg_core.bsr_gauss_seidel(Ap, Aj, Ax, x, b, row_start, row_stop, row_step, R)
+        _bsr_gs(_u(Ap), _u(Aj), Ax, x, b, int(row_start), int(row_stop), int(row_step), int(R))
+
+    @staticmethod
+    def block_gauss_seidel(Ap, Aj, Ax, x, b, Tx, row_start, row_stop, row_step, R):
+        if not _ok(Ax, x, b, Tx):
+            return amg_core.block_gauss_seidel(Ap, Aj, Ax, x, b, Tx, row_start, row_stop, row_step, R)
+        _block_gs(_u(Ap), _u(Aj), Ax, x, b, Tx, int(row_start), int(row_stop), int(row_step), int(R))
+
+
+_MATMUL_MIN = 20_000      # block nonzeros of A below which scipy's own is as quick
+
+
+def _bsr_matmul(self, other, _orig=None):
+    """scipy's BSR @ sparse (bsr._matmul_sparse) with the product itself on
+    numba's threads. pyamg's setup (R A P, the prolongation smoother) does
+    these on one core while the others wait; same entries, same order, so
+    the same bits."""
+    M = self.shape[0]
+    N = other.shape[1]
+    R, n = self.blocksize
+    C = other.blocksize[1] if other.format == "bsr" else 1
+    if (self.data.dtype != np.float64 or other.dtype != np.float64 or len(self.indices) < _MATMUL_MIN
+            or (R == 1 and n == 1 and C == 1)):
+        return _orig(self, other)
+    if other.format == "csr" and n == 1:
+        other = other.tobsr(blocksize=(n, C), copy=False)
+    else:
+        other = other.tobsr(blocksize=(n, C))
+    n_brow, n_bcol = M // R, N // C
+    Ap = np.ascontiguousarray(self.indptr, np.int64)
+    Aj = np.ascontiguousarray(self.indices, np.int64)
+    Bp = np.ascontiguousarray(other.indptr, np.int64)
+    Bj = np.ascontiguousarray(other.indices, np.int64)
+    counts = np.empty(n_brow, np.int64)
+    _bsr_count(n_brow, n_bcol, Ap, Aj, Bp, Bj, counts)
+    Cp = np.zeros(n_brow + 1, np.int64)
+    np.cumsum(counts, out=Cp[1:])
+    nnz = int(Cp[-1])
+    Cj = np.empty(nnz, np.int64)
+    Cx = np.empty(R * C * nnz, np.float64)
+    _bsr_fill(n_brow, n_bcol, R, C, n, Ap, Aj, np.ascontiguousarray(np.ravel(self.data)), Bp, Bj,
+              np.ascontiguousarray(np.ravel(other.data)), Cp, Cj, Cx)
+    idx = self._get_index_dtype((self.indptr, self.indices, other.indptr, other.indices), maxval=nnz)
+    return self._bsr_container((Cx.reshape(-1, R, C), Cj.astype(idx), Cp.astype(idx)), shape=(M, N),
+                               blocksize=(R, C))
+
+
+_SCIPY_BSR_MATMUL = None
+
+
+def _bsr_matmul_method(self, other):
+    return _bsr_matmul(self, other, _orig=_SCIPY_BSR_MATMUL)
+
+
+_bsr_matmul_method._loadpath = True
+
+
+def installed():
+    """Whether pyamg's Gauss-Seidel is the GIL-free one now."""
+    return _INSTALLED
+
+
+def install():
+    """Use the GIL-free kernels in pyamg's relaxation module (once)."""
+    global _INSTALLED
+    if _INSTALLED or nb is None or os.environ.get("LOADPATH_AMGFAST", "1") == "0":
+        return _INSTALLED
+    try:
+        import pyamg.relaxation.relaxation as rel
+    except ImportError:  # pragma: no cover
+        return False
+    if not isinstance(rel.amg_core, _Core):
+        rel.amg_core = _Core(rel.amg_core)
+    global _SCIPY_BSR_MATMUL
+    from scipy.sparse import _bsr
+
+    orig = _bsr._bsr_base._matmul_sparse
+    if not getattr(orig, "_loadpath", False):
+        _SCIPY_BSR_MATMUL = orig
+        _bsr._bsr_base._matmul_sparse = _bsr_matmul_method
+    _INSTALLED = True
+    return True