step2torque 0.1.0__cp313-cp313-win_amd64.whl

step2torque/__init__.py

@@ -0,0 +1,28 @@
+"""Load a STEP, configure its components, and solve without blocking.
+
+motor = Motor("motor.step")
+motor.components["coil"].make_coil(phase=1, turns=72, direction="+z")
+motor.components["magnet"].make_magnet(direction="radial")
+solution = motor.solve(current="optimized", power=5.5)
+solution.wait()
+print(solution.torque)  # N m
+"""
+
+
+# start delvewheel patch
+def _delvewheel_patch_1_13_2():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'step2torque.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_13_2()
+del _delvewheel_patch_1_13_2
+# end delvewheel patch
+
+from .model import Motor
+from .solution import Solution, solve_position
+from .visualization import Plane, Viewer
+
+__all__ = ["Motor", "Solution", "solve_position", "Plane", "Viewer"]
+__version__ = "0.1.0"

step2torque/_assembly.cpp

@@ -0,0 +1,161 @@
+// Same affine P2, degree-6 iron quadrature and B(H) energy as _field.py.
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include "_parallel.hpp"
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <stdexcept>
+namespace py = pybind11;
+using Real = py::array_t<double, py::array::c_style>;
+using Int = py::array_t<int, py::array::c_style | py::array::forcecast>;
+using Index = py::array_t<int64_t, py::array::c_style | py::array::forcecast>;
+struct Curve {
+    std::vector<double> h,b,slope,area;
+    std::array<double,3> evaluate(double value) const {
+        int i=std::upper_bound(h.begin(),h.end(),value)-h.begin()-1;
+        i=std::max(0,std::min(i,int(h.size())-2));
+        double t=value-h[i];
+        return {b[i]+t*slope[i],slope[i],area[i]+t*(b[i]+.5*t*slope[i])};
+    }
+};
+class Assembly {
+    int n,ne,nq;
+    int64_t nnz;
+    std::vector<int64_t> ptr,entries,cell_ptr,cell_entries;
+    std::vector<int> col,dofs,curve;
+    std::vector<double> inverse,volume,reference,weights,points,source;
+    std::vector<double> local_matrix,local_load,local_energy;
+    std::vector<Curve> curves;
+    Parallel pool;
+    const double *potential=nullptr;
+    double *matrix=nullptr,*residual=nullptr;
+    double factor=1,floor=.1;
+public:
+    Assembly(Index pointers,Int columns,Int indices,Int labels,Real jac,
+             Real volumes,Real shapes,Real quadrature,Real locations,
+             py::list laws,int threads)
+      : n(pointers.size()-1),ne(labels.size()),nq(quadrature.size()),nnz(columns.size()),
+        ptr(pointers.data(),pointers.data()+pointers.size()),
+        col(columns.data(),columns.data()+columns.size()),
+        dofs(indices.data(),indices.data()+indices.size()),
+        curve(labels.data(),labels.data()+labels.size()),
+        inverse(jac.data(),jac.data()+jac.size()),
+        volume(volumes.data(),volumes.data()+volumes.size()),
+        reference(shapes.data(),shapes.data()+shapes.size()),
+        weights(quadrature.data(),quadrature.data()+quadrature.size()),
+        points(locations.data(),locations.data()+locations.size()),
+        source(size_t(ne)*12),local_matrix(size_t(ne)*55),local_load(size_t(ne)*10),
+        local_energy(ne),pool(threads) {
+        if(indices.size()!=int64_t(ne)*10 || shapes.size()!=nq*30 || jac.size()!=int64_t(ne)*9)
+            throw std::runtime_error("Compiled assembly requires the affine P2 tetrahedron map");
+        for(auto record:laws) {
+            py::tuple pair=py::cast<py::tuple>(record);
+            Real h=py::cast<Real>(pair[0]),b=py::cast<Real>(pair[1]);
+            Curve c;
+            c.h.assign(h.data(),h.data()+h.size());c.b.assign(b.data(),b.data()+b.size());
+            c.slope.resize(h.size()-1);c.area.assign(h.size(),0);
+            for(int i=0;i<h.size()-1;++i) {
+                c.slope[i]=(c.b[i+1]-c.b[i])/(c.h[i+1]-c.h[i]);
+                c.area[i+1]=c.area[i]+.5*(c.b[i]+c.b[i+1])*(c.h[i+1]-c.h[i]);
+            }
+            curves.push_back(std::move(c));
+        }
+        entries.resize(size_t(ne)*100);cell_ptr.assign(n+1,0);cell_entries.resize(size_t(ne)*10);
+        for(int row:dofs) {
+            if(row<0 || row>=n)throw std::runtime_error("Invalid P2 degree of freedom");
+            ++cell_ptr[row+1];
+        }
+        for(int i=1;i<=n;++i)cell_ptr[i]+=cell_ptr[i-1];
+        auto cursor=cell_ptr;
+        for(int64_t i=0;i<int64_t(ne)*10;++i)cell_entries[cursor[dofs[i]]++]=i;
+        for(int e=0;e<ne;++e)for(int i=0;i<10;++i)for(int j=0;j<10;++j) {
+            int row=dofs[e*10+i],column=dofs[e*10+j];
+            auto it=std::lower_bound(col.begin()+ptr[row],col.begin()+ptr[row+1],column);
+            if(it==col.begin()+ptr[row+1] || *it!=column)
+                throw std::runtime_error("Tangent graph differs from finite element map");
+            entries[int64_t(e)*100+i*10+j]=it-col.begin();
+        }
+    }
+    void set_source(Real values) {
+        if(values.size()!=int64_t(ne)*12)throw std::runtime_error("Winding source differs from mesh");
+        std::copy(values.data(),values.data()+values.size(),source.begin());
+    }
+    void assemble(Real phi,double scale,double lower,Real values,Real load) {
+        potential=phi.data();factor=scale;floor=lower;
+        if(phi.size()!=n || values.size()!=nnz || load.size()!=n)
+            throw std::runtime_error("Tangent arrays differ from finite element map");
+        matrix=values.mutable_data();residual=load.mutable_data();
+        py::gil_scoped_release release;
+        integrate(true);
+    }
+    double energy(Real phi,double scale) {
+        potential=phi.data();factor=scale;
+        py::gil_scoped_release release;
+        return integrate(false);
+    }
+private:
+    double integrate(bool assemble) {
+        if(assemble) {std::fill(matrix,matrix+nnz,0);std::fill(residual,residual+n,0);}
+        pool.run(ne,[&](int begin,int end,int){for(int e=begin;e<end;++e) {
+            const double *jac=inverse.data()+9*e,*hs=source.data()+12*e;
+            const int *ids=dofs.data()+10*e;
+            const Curve &law=curves[curve[e]];
+            double local[55]={},load[10]={},cell_energy=0;
+            double offset=law.evaluate(.0001)[2];
+            for(int q=0;q<nq;++q) {
+                const double *ref=reference.data()+30*q,*point=points.data()+3*q;
+                double gradient[10][3],h[3],s[3];
+                for(int c=0;c<3;++c) {
+                    s[c]=factor*(hs[c]+point[0]*(hs[3+c]-hs[c])+point[1]*(hs[6+c]-hs[c])+point[2]*(hs[9+c]-hs[c]));
+                    h[c]=s[c];
+                }
+                for(int i=0;i<10;++i) for(int c=0;c<3;++c) {
+                    gradient[i][c]=ref[3*i]*jac[c]+ref[3*i+1]*jac[3+c]+ref[3*i+2]*jac[6+c];
+                    h[c]-=potential[ids[i]]*gradient[i][c];
+                }
+                double norm2=h[0]*h[0]+h[1]*h[1]+h[2]*h[2]+1e-8;
+                double hn=std::sqrt(norm2),w=volume[e]*weights[q];
+                auto bh=law.evaluate(hn);
+                constexpr double mu0=1.2566370614359173e-6;
+                cell_energy+=w*(bh[2]-offset-.5*mu0*(s[0]*s[0]+s[1]*s[1]+s[2]*s[2]));
+                if(!assemble) continue;
+                double secant=bh[0]/hn;
+                double anisotropic=(std::max(bh[1],floor*secant)-secant)/norm2;
+                double hg[10];
+                for(int i=0;i<10;++i) {
+                    hg[i]=h[0]*gradient[i][0]+h[1]*gradient[i][1]+h[2]*gradient[i][2];
+                    load[i]+=w*secant*hg[i];
+                }
+                for(int i=0;i<10;++i) for(int j=0;j<=i;++j) {
+                    double gram=gradient[i][0]*gradient[j][0]+gradient[i][1]*gradient[j][1]+gradient[i][2]*gradient[j][2];
+                    local[i*(i+1)/2+j]+=w*(secant*gram+anisotropic*hg[i]*hg[j]);
+                }
+            }
+            local_energy[e]=cell_energy;
+            if(assemble) {
+                std::copy(local,local+55,local_matrix.begin()+e*55);
+                std::copy(load,load+10,local_load.begin()+e*10);
+            }
+        }});
+        if(assemble)pool.run(n,[&](int begin,int end,int){for(int row=begin;row<end;++row) {
+            for(int64_t k=cell_ptr[row];k<cell_ptr[row+1];++k) {
+                int64_t entry=cell_entries[k];int e=entry/10,i=entry%10;
+                residual[row]+=local_load[entry];
+                for(int j=0;j<10;++j) {
+                    int a=std::max(i,j),b=std::min(i,j);
+                    matrix[entries[int64_t(e)*100+i*10+j]]+=local_matrix[e*55+a*(a+1)/2+b];
+                }
+            }
+        }});
+        double energy=0;for(double value:local_energy)energy+=value;
+        return energy;
+    }
+};
+PYBIND11_MODULE(_assembly,m) {
+    py::class_<Assembly>(m,"Assembly")
+        .def(py::init<Index,Int,Int,Int,Real,Real,Real,Real,Real,py::list,int>())
+        .def("set_source",&Assembly::set_source)
+        .def("assemble",&Assembly::assemble)
+        .def("energy",&Assembly::energy);
+}

step2torque/_assembly_version.py

@@ -0,0 +1 @@
+SHA256 = 'e14b65543e07120fb0dabd8dddab806d8618979dda1f412211678ea15706bd02'

step2torque/_contact.py

@@ -0,0 +1,289 @@
+"""Zero-thickness air-gap contact: B_n = (mu0 / gap) * [phi]."""
+
+import ngsolve as ng
+import numpy as np
+import pyngcore as core
+import netgen.meshing as nm
+from scipy.sparse import coo_matrix
+from scipy.sparse.csgraph import connected_components
+
+from .materials import MU0
+
+
+def add_contact(mesh, space, matrix, contact):
+    """Add the exact P2 surface mass matrix on paired, coincident traces.
+
+    The mesh is continuous away from the contact. Its physical contact rim
+    shares vertex/edge DOFs, so the jump vanishes at the rim. Rotational
+    sector cuts retain independent, periodically identified contact traces.
+    This is a physical Robin term, with no penalty or stabilization factor.
+    """
+    gap = float(contact["gap"])
+    if gap <= 0:
+        raise ValueError("Contact gap must be positive")
+    points = np.asarray(mesh.ngmesh.Coordinates())
+    cells = mesh.ngmesh.Elements3D().NumPy()["nodes"] - 1
+    rule = ng.IntegrationRule(ng.ET.TRIG, 4)
+    q = np.array([p.point[:2] for p in rule])
+    weights = np.array([p.weight for p in rule])
+    rows, columns, entries = [], [], []
+    for face in contact["faces"]:
+        triangle = points[face["vertices"]]
+        locations = (
+            triangle[0]
+            + q[:, :1] * (triangle[1] - triangle[0])
+            + q[:, 1:] * (triangle[2] - triangle[0])
+        )
+        jacobian = np.linalg.norm(
+            np.cross(triangle[1] - triangle[0], triangle[2] - triangle[0])
+        )
+        traces, dofs = [], []
+        for side, sign in (("minus_cell", 1), ("plus_cell", -1)):
+            cell = int(face[side])
+            element = ng.ElementId(ng.VOL, cell)
+            xyz = points[cells[cell]]
+            reference = np.linalg.solve((xyz[:3] - xyz[3]).T, (locations - xyz[3]).T).T
+            fe = space.GetFE(element)
+            shape = np.array([fe.CalcShape(*p) for p in reference])
+            shape[abs(shape) < 1e-12] = 0
+            traces.append(sign * shape)
+            dofs.extend(space.GetDofNrs(element))
+        unique, inverse = np.unique(dofs, return_inverse=True)
+        jump = np.zeros((len(rule), len(unique)))
+        for j, values in enumerate(np.concatenate(traces, axis=1).T):
+            jump[:, inverse[j]] += values
+        local = MU0 / gap * jacobian * (jump.T * weights) @ jump
+        i, j = np.nonzero(local)
+        rows.extend(unique[i])
+        columns.extend(unique[j])
+        entries.extend(local[i, j])
+    values, cols, ptr = (np.asarray(x) for x in matrix.CSR())
+    volume_rows = np.repeat(np.arange(matrix.height), np.diff(ptr).astype(np.int64))
+    # Fill native arrays directly; Python conversion of the full volume graph
+    # would cost more than assembling the contact itself.
+    count = len(values)
+    i, j = core.Array_I_S(count + len(rows)), core.Array_I_S(count + len(rows))
+    data = core.Array_D_S(count + len(rows))
+    i.NumPy()[:count], i.NumPy()[count:] = volume_rows, rows
+    j.NumPy()[:count], j.NumPy()[count:] = cols, columns
+    data.NumPy()[:count], data.NumPy()[count:] = values, entries
+    return ng.la.SparseMatrixd.CreateFromCOO(i, j, data, matrix.height, matrix.width)
+
+
+def split(mesh, gap, materials, moving=()):
+    """Separate potential traces on actual, conforming iron mating faces."""
+    if not gap:
+        return mesh, None
+    names = mesh.GetMaterials()
+    iron = {
+        name
+        for name, law in materials.items()
+        if "h" in law or ("br" not in law and law.get("mur", 1) > 1)
+    }
+    descriptors = [nm.FaceDescriptor(fd) for fd in mesh.ngmesh.FaceDescriptors()]
+    selected = {}
+    for i, fd in enumerate(descriptors, 1):
+        if not fd.domin or not fd.domout:
+            continue
+        a, b = names[fd.domin - 1], names[fd.domout - 1]
+        if a != b and a in iron and b in iron and (a in moving) == (b in moving):
+            selected[i] = tuple(sorted((a, b)))
+    if not selected:
+        return mesh, None
+    tets = mesh.ngmesh.Elements3D().NumPy()["nodes"] - 1
+    boundary = mesh.ngmesh.Elements2D().NumPy().copy()
+    triangles, indices = boundary["nodes"] - 1, boundary["index"]
+    contact = np.isin(indices, list(selected))
+    local = np.array([[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3]])
+    faces = tets[:, local].reshape(-1, 3)
+    corners = np.argsort(faces, axis=1)
+    occurrences = (4 * np.arange(mesh.ne)[:, None, None] + local).reshape(-1, 3)
+    occurrences = np.take_along_axis(occurrences, corners, axis=1)
+    keys = face_keys(faces)
+    order = np.argsort(keys)
+    keys, occurrences = keys[order], occurrences[order]
+    positions = np.searchsorted(keys, face_keys(triangles))
+    if not np.all(keys[positions] == face_keys(triangles)):
+        raise ValueError("Contact mesh has an unmatched surface face")
+    same = keys[1:] == keys[:-1]
+    if np.any(same[:-1] & same[1:]):
+        raise ValueError("Contact mesh has a nonmanifold face")
+    paired = np.flatnonzero(same)
+    cut = positions[contact]
+    if not np.all(same[cut]):
+        raise ValueError("Contact must have iron on both sides")
+    joined = paired[~np.isin(paired, cut)]
+    a, b = occurrences[joined].ravel(), occurrences[joined + 1].ravel()
+    graph = coo_matrix(
+        (np.ones(len(a), dtype=np.int8), (a, b)), shape=(4 * mesh.ne, 4 * mesh.ne)
+    ).tocsr()
+    _, labels = connected_components(graph, directed=False)
+    _, first = np.unique(labels, return_index=True)
+    nodes = tets.ravel()[first]
+    _, original = np.unique(nodes, return_index=True)
+    copies = np.isin(nodes, triangles[contact])
+    copies[original] = False
+    points = np.asarray(mesh.ngmesh.Coordinates())
+    new_points = np.concatenate([points, points[nodes[copies]]])
+    numbers = nodes.copy()
+    numbers[copies] = mesh.nv + np.arange(copies.sum())
+    new_tets = numbers[labels].reshape(-1, 4)
+
+    owners = order[positions] // 4
+
+    def trace(cell, vertices):
+        return new_tets[cell, np.argmax(tets[cell, :, None] == vertices, axis=0)]
+
+    new_triangles = np.array([trace(ci, tri) for ci, tri in zip(owners, triangles)])
+    # Interior contact edges need independent P2 edge DOFs even when both
+    # endpoints lie on the physical rim. One conforming bisection supplies them.
+    edges, tied = {}, set()
+    for si in np.flatnonzero(contact):
+        pos = positions[si]
+        lo, hi = order[pos] // 4, order[pos + 1] // 4
+        tri = triangles[si]
+        equal = trace(lo, tri) == trace(hi, tri)
+        for i, j in ((0, 1), (0, 2), (1, 2)):
+            edge = tuple(sorted((int(tri[i]), int(tri[j]))))
+            key = selected[int(indices[si])], edge
+            edges[key] = edges.get(key, 0) + 1
+            if equal[i] and equal[j]:
+                tied.add(key)
+    refine = sorted({edge for pair, edge in tied if edges[pair, edge] == 2})
+    if refine:
+        return split(bisect(mesh, refine), gap, materials, moving)
+
+    interfaces, pairs, records = [], {}, []
+    extra_triangles, extra_indices = [], []
+    domains = mesh.ngmesh.Elements3D().NumPy()["index"]
+    for index, pair in selected.items():
+        if pair not in pairs:
+            pairs[pair] = len(interfaces)
+            interfaces.append(dict(parts=list(pair), area_m2=0.0))
+        fd = descriptors[index - 1]
+        other = nm.FaceDescriptor(fd)
+        other.domin, other.domout = fd.domout, 0
+        fd.domout = 0
+        k = pairs[pair]
+        fd.bcname = f"contact_{k}_minus"
+        other.bc = len(descriptors) + 1
+        other.bcname = f"contact_{k}_plus"
+        descriptors.append(other)
+        for si in np.flatnonzero(indices == index):
+            pos = positions[si]
+            lo, hi = int(order[pos] // 4), int(order[pos + 1] // 4)
+            if domains[lo] != fd.domin:
+                lo, hi = hi, lo
+            tri = triangles[si]
+            lower, upper = trace(lo, tri), trace(hi, tri)
+            new_triangles[si] = lower
+            extra_triangles.append(upper)
+            extra_indices.append(len(descriptors))
+            xyz = points[tri]
+            interfaces[k]["area_m2"] += float(
+                np.linalg.norm(np.cross(xyz[1] - xyz[0], xyz[2] - xyz[0])) / 2
+            )
+            records.append(
+                dict(
+                    interface=k,
+                    minus_cell=lo,
+                    plus_cell=hi,
+                    vertices=lower.tolist(),
+                    plus_vertices=upper.tolist(),
+                )
+            )
+    # Match each periodic boundary triangle's two traces independently. This
+    # works for rotational or translated sectors without assuming a face normal.
+    surface_lookup = {tuple(sorted(tri)): i for i, tri in enumerate(triangles)}
+    identifications = set()
+    groups = {}
+    for a, b, ident in mesh.ngmesh.GetIdentifications():
+        groups.setdefault(ident, {})[a.nr - 1] = b.nr - 1
+    for ident, mapping in groups.items():
+        for si, tri in enumerate(triangles):
+            target = [mapping.get(int(i), -1) for i in tri]
+            other = surface_lookup.get(tuple(sorted(target)))
+            if other is None:
+                continue
+            for j, node in enumerate(target):
+                k = list(triangles[other]).index(node)
+                identifications.add(
+                    (int(new_triangles[si, j]), int(new_triangles[other, k]), ident)
+                )
+    native = rebuild(
+        mesh,
+        new_points,
+        new_tets,
+        domains,
+        np.concatenate([new_triangles, extra_triangles]),
+        np.r_[indices, extra_indices],
+        descriptors,
+        identifications,
+    )
+    return native, dict(gap=gap, faces=records, interfaces=interfaces)
+
+
+def face_keys(vertices):
+    dtype = np.dtype([(name, np.int32) for name in ("a", "b", "c")])
+    return (
+        np.ascontiguousarray(np.sort(vertices, axis=1), dtype=np.int32)
+        .view(dtype)
+        .ravel()
+    )
+
+
+def rebuild(
+    mesh, points, tets, domains, triangles, indices, descriptors, identifications
+):
+    native = nm.Mesh(dim=3)
+    for fd in descriptors:
+        native.Add(fd)
+        native.SetBCName(fd.bc - 1, fd.bcname)
+    for p in points:
+        native.Add(nm.MeshPoint(nm.Pnt(*p)))
+    for tet, domain in zip(tets, domains):
+        native.Add(nm.Element3D(index=int(domain), vertices=(tet + 1).tolist()))
+    for tri, index in zip(triangles, indices):
+        native.Add(nm.Element2D(index=int(index), vertices=(tri + 1).tolist()))
+    for i, name in enumerate(mesh.GetMaterials(), 1):
+        native.SetMaterial(i, name)
+    for a, b, ident in sorted(identifications):
+        native.AddPointIdentification(
+            a + 1, b + 1, ident, mesh.ngmesh.GetIdentificationType(ident)
+        )
+    return ng.Mesh(native)
+
+
+def bisect(mesh, edges):
+    points = np.asarray(mesh.ngmesh.Coordinates()).tolist()
+    cells = mesh.ngmesh.Elements3D().NumPy()
+    tets, domains = cells["nodes"] - 1, cells["index"].copy()
+    surfaces = mesh.ngmesh.Elements2D().NumPy()
+    triangles, indices = surfaces["nodes"] - 1, surfaces["index"].copy()
+    for a, b in edges:
+        c = len(points)
+        points.append(((np.array(points[a]) + points[b]) / 2).tolist())
+        for volume in (True, False):
+            nodes, labels = (tets, domains) if volume else (triangles, indices)
+            hit = np.any(nodes == a, axis=1) & np.any(nodes == b, axis=1)
+            first, second = nodes[hit].copy(), nodes[hit].copy()
+            first[first == a], second[second == b] = c, c
+            nodes = np.concatenate([nodes[~hit], first, second])
+            labels = np.r_[labels[~hit], labels[hit], labels[hit]]
+            if volume:
+                tets, domains = nodes, labels
+            else:
+                triangles, indices = nodes, labels
+    identifications = {
+        (a.nr - 1, b.nr - 1, ident) for a, b, ident in mesh.ngmesh.GetIdentifications()
+    }
+    return rebuild(
+        mesh,
+        points,
+        tets,
+        domains,
+        triangles,
+        indices,
+        [nm.FaceDescriptor(fd) for fd in mesh.ngmesh.FaceDescriptors()],
+        identifications,
+    )

step2torque/_cuda.py

@@ -0,0 +1,110 @@
+"""Stateful cuDSS Cholesky for real NGSolve matrices with fixed sparsity."""
+
+import importlib.metadata as metadata
+import logging
+import time
+import weakref
+
+import numpy as np
+import scipy.sparse as sp
+
+
+class CuDSS:
+    def __init__(self, matrix, free_dofs):
+        import nvmath.sparse.advanced as sparse
+
+        self.matrix = matrix
+        self.free = np.flatnonzero(np.asarray(free_dofs, dtype=bool))
+        self.rhs = np.zeros(len(self.free))
+        self.solver = None
+        self.sparse = sparse
+        self.stats = dict(
+            export_s=0.0,
+            setup_s=0.0,
+            factor_s=0.0,
+            solve_s=0.0,
+            factorizations=0,
+            solves=0,
+        )
+        self.Update()
+
+    def Update(self):
+        started = time.perf_counter()
+        values, columns, pointers = (np.asarray(x) for x in self.matrix.CSR())
+        if self.solver is None:
+            rows = np.repeat(
+                np.arange(self.matrix.height), np.diff(pointers).astype(np.int64)
+            )
+            mapping = np.full(self.matrix.height, -1, dtype=np.int32)
+            mapping[self.free] = np.arange(len(self.free), dtype=np.int32)
+            active = (mapping[rows] >= 0) & (mapping[columns] >= 0)
+            if np.any(active & (rows > columns)) and not np.any(
+                active & (rows < columns)
+            ):
+                raise ValueError("NGSolve CSR must expose the full symmetric matrix.")
+            self.entries = np.flatnonzero(active & (rows <= columns))
+            r, c = mapping[rows[self.entries]], mapping[columns[self.entries]]
+            assert np.count_nonzero(r == c) == len(self.free)
+            order = np.lexsort((c, r))
+            self.entries = self.entries[order]
+            indptr = np.r_[
+                0, np.cumsum(np.bincount(r, minlength=len(self.free)), dtype=np.int64)
+            ]
+            assert indptr[-1] < 2**31
+            self.upper = sp.csr_matrix(
+                (values[self.entries].copy(), c[order], indptr.astype(np.int32)),
+                shape=(len(self.free), len(self.free)),
+            )
+        else:
+            # CSR values share NGSolve storage; the sparsity map stays fixed.
+            self.upper.data[:] = values[self.entries]
+        self.stats["last_export_s"] = time.perf_counter() - started
+        self.stats["export_s"] += self.stats["last_export_s"]
+        if self.solver is None:
+            library = metadata.distribution("nvidia-cudss-cu12")
+            threading = [
+                library.locate_file(path)
+                for path in library.files
+                if str(path).endswith("libcudss_mtlayer_gomp.so.0")
+            ]
+            logger = logging.Logger("cudss", level=logging.ERROR)
+            options = dict(
+                sparse_system_type=self.sparse.DirectSolverMatrixType.SPD,
+                sparse_system_view=self.sparse.DirectSolverMatrixViewType.UPPER,
+                blocking=True,
+                logger=logger,
+            )
+            if threading:
+                options["multithreading_lib"] = str(threading[0])
+            started = time.perf_counter()
+            self.solver = self.sparse.DirectSolver(
+                self.upper, self.rhs, options=options, execution="cuda"
+            )
+            # The native object requires explicit cleanup, including after the last pose.
+            self.cleanup = weakref.finalize(self, self.solver.free)
+            self.solver.plan()
+            self.stats["setup_s"] += time.perf_counter() - started
+        else:
+            self.solver.reset_operands(a=self.upper)
+        started = time.perf_counter()
+        self.solver.factorize()
+        self.stats["factor_s"] += time.perf_counter() - started
+        self.stats["factorizations"] += 1
+
+    def __mul__(self, rhs):
+        started = time.perf_counter()
+        self.rhs[:] = rhs.FV().NumPy()[self.free]
+        self.solver.reset_operands(b=self.rhs)
+        values = self.solver.solve()
+        if not np.isfinite(values).all():
+            raise RuntimeError("CUDA linear solve returned a non-finite field")
+        answer = self.matrix.CreateColVector()
+        array = answer.FV().NumPy()
+        array[:] = 0
+        array[self.free] = values
+        self.stats["solve_s"] += time.perf_counter() - started
+        self.stats["solves"] += 1
+        return answer
+
+    def close(self):
+        self.cleanup()