loadpath 0.1.1__py3-none-any.whl

loadpath/checks/networks.py

@@ -0,0 +1,260 @@
+"""
+Dual-network isolation verifier for exchanger-class parts (heat exchangers,
+manifolds, anything carrying two fluids). Watertightness is not the interesting
+invariant for these — NETWORK TOPOLOGY is: each fluid domain must connect its
+own inlet/outlet pair, with zero cross-leak paths.
+
+`check_networks(part, ports)` voxelizes the part, labels the void space with
+26-connectivity, and maps each declared port to the void component it lands
+in. Port naming convention: ports of the same circuit share the prefix before
+the first underscore ("a_in" / "a_out" are one pair).
+
+The part is a trimesh or, for a part built from a field, the implicit field
+itself (f(P) < 0 inside, with bounds=(lo, hi)): sampling the field at the
+voxel centres skips meshing and voxelizing the STL, which is most of the
+time on a multi-million-triangle part. Meshes go through the scanline
+rasterizer in voxels.py, which never touches trimesh's ray tree.
+
+Resolution honesty: isolation verified at voxel pitch p means "no leak path
+wider than ~p" — a pinhole narrower than a voxel can slip through the
+occupancy grid. The report always carries the pitch used, and the thinnest
+wall between circuits in mm with its +/- pitch; state exactly that bound, not
+"leak-free".
+"""
+import os
+
+import numpy as np
+from scipy import ndimage
+
+from ..voxels import solid_grid, tiled_edt_min
+
+__all__ = ["check_networks"]
+
+# Voxel-count ceiling for the occupancy grid (bool grid + int32 labels, about
+# 5 bytes per cell). The pitch chooser coarsens to fit under this rather than
+# allocating unboundedly on a huge part.
+_VOXEL_BUDGET = int(os.environ.get("LOADPATH_NETWORKS_VOXEL_BUDGET",
+                                   os.environ.get("CAD_NETWORKS_VOXEL_BUDGET", str(128_000_000))))
+
+# 3x3x3 ones = 26-connectivity. Deliberately the LEAKIEST connectivity for the
+# void: a diagonal voxel chain counts as a connected fluid path, so we err
+# toward reporting leaks rather than hiding them.
+_CONN = np.ones((3, 3, 3), bool)
+
+_DILATION_CAP = 20  # min-wall search cutoff, in voxels
+
+
+def _gap_cells(mask_a, mask_b):
+    """Solid separation between two void components: the Euclidean distance,
+    in cells, between their nearest voxel centres (None beyond the cap). The
+    nearest pair is the one whose centres sit closest to their surfaces
+    (about half a cell off), and the grid counts every voxel the surface
+    touches as solid (about another half), so the wall is about d - 1 cells,
+    +/- one."""
+    small, big = (mask_a, mask_b) if mask_a.sum() <= mask_b.sum() else (mask_b, mask_a)
+    return tiled_edt_min(small, big, _DILATION_CAP + 1)
+
+
+def _refill_plugs(solid, origin, pitch, plugs):
+    """Virtually refill port openings before flood-fill. A real exchanger's
+    ports open to the outside world, which connects BOTH plenums to the same
+    air component and would flag every part as a leak. Two plug shapes:
+      - capsule {"a", "b", "r"} — a port bore, refilled; with "ends": "flat"
+        a flat-ended cylinder instead, from the inner end `a` (cut square,
+        so a wide plug never bulges into the cavity past its probes) to `b`
+        (the outer end, carried 1.5 voxels further out);
+      - box {"c": center, "h": half-extents} — a full-face manifold window
+        (hood lofts open the whole rectangular face; no capsule can cap
+        that without bulging into the plenum and swallowing the probes).
+    Both are rasterized with a 1.5-voxel dilation so grid aliasing can't
+    leave a void thread along the wall. Plugs only ADD solid: they can mask
+    a genuine leak only if the leak runs through the plugged volume itself,
+    which the opening's subtraction already made void by construction."""
+    shape = np.asarray(solid.shape)
+    for plug in plugs:
+        if "c" in plug and "h" in plug:
+            c = np.asarray(plug["c"], float)
+            h = np.asarray(plug["h"], float) + 1.5 * pitch
+            lo = np.maximum(
+                np.floor((c - h - origin) / pitch).astype(int), 0)
+            hi = np.minimum(
+                np.ceil((c + h - origin) / pitch).astype(int) + 1, shape)
+            if np.any(lo >= hi):
+                continue  # box entirely off-grid
+            solid[lo[0]:hi[0], lo[1]:hi[1], lo[2]:hi[2]] = True
+            continue
+        a = np.asarray(plug["a"], float)
+        b = np.asarray(plug["b"], float)
+        r = float(plug["r"]) + 1.5 * pitch
+        flat = plug.get("ends", "round") == "flat"
+        if flat and np.linalg.norm(b - a) > 0.0:
+            b = b + (b - a) / np.linalg.norm(b - a) * 1.5 * pitch
+        lo = np.maximum(
+            np.floor((np.minimum(a, b) - r - origin) / pitch).astype(int), 0)
+        hi = np.minimum(
+            np.ceil((np.maximum(a, b) + r - origin) / pitch).astype(int) + 1,
+            shape)
+        if np.any(lo >= hi):
+            continue  # plug entirely off-grid
+        idx = np.moveaxis(np.indices(tuple(hi - lo)), 0, -1) + lo
+        centers = origin + idx * pitch
+        ab = b - a
+        denom = float(ab @ ab)
+        if denom <= 0.0:
+            t_raw = np.zeros(centers.shape[:-1])
+        else:
+            t_raw = ((centers - a) @ ab) / denom
+        t = np.clip(t_raw, 0.0, 1.0)
+        dist = np.linalg.norm(centers - (a + t[..., None] * ab), axis=-1)
+        inside = dist <= r
+        if flat:
+            inside &= (t_raw >= 0.0) & (t_raw <= 1.0)
+        sub = solid[lo[0]:hi[0], lo[1]:hi[1], lo[2]:hi[2]]
+        sub[inside] = True
+
+
+def check_networks(mesh, ports, pitch=None, plugs=None, min_feature=None, bounds=None):
+    """Verify fluid-network isolation of `mesh` against declared `ports`.
+
+    mesh: a trimesh, or an implicit field f(P) (negative inside the solid, P
+    an (N, 3) array in mm) together with bounds=(lo, hi) — the fast path for
+    a part built from a field.
+
+    ports: list of {"name": str, "point": [x, y, z] mm, "r": mm} spheres —
+    inlet/outlet locations in the void space, named `<circuit>_<role>`.
+    plugs: optional list of {"a", "b", "r"} capsules (add "ends": "flat" for a
+    square-cut inner end) or {"c", "h"} boxes to virtually refill
+    before labeling — pass each port bore here whenever the ports open to the
+    outside, or the shared outside air reads as a cross-circuit leak.
+    min_feature: the smallest structure (mm) the verdict must resolve —
+    typically min(wall thickness, channel width). Declaring it makes the
+    pitch chooser fine enough to resolve it (pitch <= min_feature/2), and
+    makes the check refuse to render a verdict it can't stand behind: a
+    probe coarser than the walls reads aliasing as leaks (measured: a
+    sound 1.2mm-wall exchanger "leaked" at a 2.66mm probe).
+
+    Returns {
+      "pitch": voxel pitch used (mm) — the honesty bound on leak width,
+      "components": void components touching any port,
+      "ports": {name: component id or None (port found no void)},
+      "isolated": every port hit exactly one component, same-prefix ports
+                  share a component, and no component carries two prefixes,
+      "minWallMm": thinnest solid separation between port-bearing
+                   components, in mm, None if single/too far,
+      "minWallToleranceMm": the +/- on it (one pitch),
+      "minWallVoxels": the same in voxels (kept for older callers),
+      "plugs": number of plug capsules refilled,
+    }
+    OR, when the part is so large that a min_feature-resolving pitch would
+    blow the voxel budget, an INCONCLUSIVE report {"pitch", "inconclusive":
+    True, "reason", "plugs"} — no isolated verdict at all, because a verdict
+    at that resolution would be noise. Callers must treat inconclusive as
+    "not verified", never as "leaked".
+
+    Default pitch (no min_feature) = bounding-box max extent / 64, floored
+    at 0.4mm — coarse on purpose: cheap enough to always run. Declare
+    min_feature (or pass an explicit pitch) when the geometry has walls or
+    channels finer than that.
+    """
+    is_field = callable(mesh) and not hasattr(mesh, "faces")
+    if is_field:
+        if bounds is None:
+            raise ValueError("check_networks on a field needs bounds=(lo, hi) in mm")
+        bounds = tuple(np.asarray(b, float) for b in bounds)
+        extents = bounds[1] - bounds[0]
+    else:
+        extents = np.asarray(mesh.extents, float)
+    if pitch is None:
+        pitch = max(float(np.max(extents)) / 64.0, 0.4)
+        if min_feature is not None:
+            # Resolve the declared finest feature with >=2 voxels across it.
+            pitch = min(pitch, max(float(min_feature) / 2.0, 0.2))
+    pitch = float(pitch)
+
+    # Coarsen (never refine) to fit the voxel budget on huge parts.
+    def _cells(p):
+        return float(np.prod(np.ceil(extents / p) + 4))
+
+    while _cells(pitch) > _VOXEL_BUDGET:
+        pitch = round(pitch * 1.25, 4)
+
+    if min_feature is not None and pitch > float(min_feature) / 2.0 + 1e-9:
+        return {
+            "pitch": pitch,
+            "inconclusive": True,
+            "reason": (
+                f"probe pitch {pitch:g}mm cannot resolve the declared "
+                f"{float(min_feature):g}mm minimum feature within the voxel "
+                "budget — isolation is UNVERIFIED at this scale (a verdict "
+                "here would alias walls into phantom leaks)"
+            ),
+            "plugs": len(plugs) if plugs else 0,
+        }
+
+    solid, origin, _info = solid_grid(mesh, pitch, pad=2, bounds=bounds, touch=True)
+    if plugs:
+        _refill_plugs(solid, origin, pitch, plugs)
+    labels, _ = ndimage.label(~solid, structure=_CONN)
+    shape = np.asarray(labels.shape)
+
+    assignment = {}
+    ambiguous = False
+    for port in ports:
+        pt = np.asarray(port["point"], float)
+        r = float(port["r"])
+        lo = np.maximum(np.floor((pt - r - origin) / pitch).astype(int), 0)
+        hi = np.minimum(np.ceil((pt + r - origin) / pitch).astype(int) + 1, shape)
+        if np.any(lo >= hi):
+            assignment[port["name"]] = None  # sphere entirely off-grid
+            continue
+        sub = labels[lo[0]:hi[0], lo[1]:hi[1], lo[2]:hi[2]]
+        idx = np.moveaxis(np.indices(sub.shape), 0, -1) + lo
+        centers = origin + idx * pitch
+        hits = sub[np.linalg.norm(centers - pt, axis=-1) <= r]
+        hits = hits[hits > 0]
+        if hits.size == 0:
+            assignment[port["name"]] = None  # sphere touched only solid
+            continue
+        ids, counts = np.unique(hits, return_counts=True)
+        if ids.size > 1:
+            ambiguous = True  # straddles two voids — cannot claim isolation
+        assignment[port["name"]] = int(ids[np.argmax(counts)])
+
+    port_comps = sorted({c for c in assignment.values() if c is not None})
+
+    # isolation: every port resolved cleanly, each circuit prefix lives in
+    # exactly one component, and no component hosts two circuits.
+    isolated = not ambiguous and all(c is not None for c in assignment.values())
+    if isolated and assignment:
+        prefix_of = {}  # component -> circuit prefix
+        comp_of = {}    # circuit prefix -> component
+        for name, comp in assignment.items():
+            prefix = name.split("_")[0]
+            if prefix_of.setdefault(comp, prefix) != prefix:
+                isolated = False  # two circuits share a void — a leak
+                break
+            if comp_of.setdefault(prefix, comp) != comp:
+                isolated = False  # one circuit split across voids — a blockage
+                break
+
+    gap = None
+    if len(port_comps) >= 2:
+        gaps = [
+            _gap_cells(labels == a, labels == b)
+            for i, a in enumerate(port_comps)
+            for b in port_comps[i + 1:]
+        ]
+        gaps = [g for g in gaps if g is not None]
+        gap = min(gaps) if gaps else None
+
+    return {
+        "pitch": pitch,
+        "components": len(port_comps),
+        "ports": assignment,
+        "isolated": bool(isolated),
+        "minWallMm": None if gap is None else round(max(gap - 1.0, 0.0) * pitch, 3),
+        "minWallToleranceMm": round(pitch, 4),
+        "minWallVoxels": None if gap is None else int(round(max(gap - 1.0, 0.0))),
+        "plugs": len(plugs) if plugs else 0,
+        "source": "field" if is_field else "mesh",
+    }

loadpath/checks/opening.py

@@ -0,0 +1,67 @@
+"""
+Does the part OPEN from above? The "can you put things in it" probe.
+
+A container read as a container only when its cavities break through the top.
+Concept blockouts kept coming back as closed pills with the compartments
+inside them, or with cavities that only nicked the rounded ends, and neither
+the fill ratio (a sealed hollow is mostly empty) nor the trapped-void probe (a
+nicked cavity drains) can tell those apart from a real organizer.
+
+Looking straight down can. Sample the surface densely, keep the HIGHEST point
+in each grid cell (the first thing you'd hit from above), and measure how much
+of the footprint's interior sits deep below the top. An open pocket shows its
+floor; a lidded hollow or a solid shows its top. The footprint is eroded first
+so a soft rounded rim, which is low near the edge, doesn't count as open.
+"""
+import numpy as np
+from scipy import ndimage
+import trimesh
+
+# How far below the top a cell must sit to count as open, as a share of the
+# part's height.
+_DEPTH_FRACTION = 0.3
+# Footprint erosion, as a share of the smaller plan dimension.
+_ERODE_FRACTION = 0.12
+
+
+def check_opening(mesh, spec=None):
+    spec = spec or {}
+    lo, hi = mesh.bounds
+    size = hi - lo
+    height = float(size[2])
+    plan = float(min(size[0], size[1]))
+    if height <= 0 or plan <= 0:
+        return {"error": "degenerate bounds"}
+
+    cell = float(spec.get("cellMm") or max(plan / 60.0, 0.5))
+    nx = int(np.ceil(size[0] / cell)) + 1
+    ny = int(np.ceil(size[1] / cell)) + 1
+
+    count = int(min(max(mesh.area / (cell * cell) * 6, 20_000), 400_000))
+    pts, _ = trimesh.sample.sample_surface(mesh, count, seed=7)
+    ix = np.clip(((pts[:, 0] - lo[0]) / cell).astype(int), 0, nx - 1)
+    iy = np.clip(((pts[:, 1] - lo[1]) / cell).astype(int), 0, ny - 1)
+
+    top = np.full((nx, ny), -np.inf)
+    np.maximum.at(top, (ix, iy), pts[:, 2])
+    covered = np.isfinite(top)
+    # Cells a pocket's vertical walls cover only sparsely can miss samples;
+    # close small holes so the footprint is the part's silhouette.
+    footprint = ndimage.binary_closing(covered, iterations=2)
+    footprint = ndimage.binary_fill_holes(footprint)
+    erode = max(1, int(round(plan * _ERODE_FRACTION / cell)))
+    interior = ndimage.binary_erosion(footprint, iterations=erode)
+    n_interior = int(interior.sum())
+    if n_interior == 0:
+        return {"error": "footprint too small to probe", "cellMm": round(cell, 3)}
+
+    deep = float(hi[2]) - _DEPTH_FRACTION * height
+    # An empty interior cell (no surface at all beneath it) is a through-hole:
+    # open by definition.
+    open_cells = interior & (~covered | (top < deep))
+    frac = float(open_cells.sum()) / n_interior
+    return {
+        "openFraction": round(frac, 4),
+        "cellMm": round(cell, 3),
+        "interiorCells": n_interior,
+    }

loadpath/checks/sdf_kit.py

@@ -0,0 +1,7 @@
+"""Moved to `loadpath.sdf_kit` (it generates geometry; it is not a check). This
+alias keeps `loadpath.checks.sdf_kit` imports working."""
+import sys
+
+from .. import sdf_kit as _moved
+
+sys.modules[__name__] = _moved

loadpath/conjugate.py

@@ -0,0 +1,267 @@
+"""
+Conjugate heat transfer on a voxel grid, for heat sinks and cold plates in a
+duct: the flow from flow.py's lattice Boltzmann run, the heat by finite
+volumes, solid and fluid in one linear system.
+
+Topology optimization of heat sinks usually rates a design with a fixed
+convection coefficient h on its surface (thermal.py does). That is fine for
+choosing where metal goes in conduction, but it cannot say what a design
+costs in pressure drop, or that the fluid warms as it passes the first fins,
+or that a fine lattice chokes its own flow. To compare a solid topology
+against a lattice fairly, both are rated here the same way:
+
+- the flow through the design (`duct_flow`): flow.network_flow on the fluid
+  voxels, from a plug at the duct's inlet face to a fixed-pressure outlet,
+  time-averaged; the flow rate is searched until the pressure drop matches a
+  target (`at_pressure_drop`), since a fair comparison of sinks holds the fan
+  fixed, not the flow;
+- the heat (`solve_heat`): steady conduction in the solid and the fluid,
+  advection in the fluid (first-order upwind on the voxel faces, from the
+  averaged velocity), the heat entering through given faces of the solid
+  (a die under the base), the fluid entering at the inlet temperature.
+  Walls not named are adiabatic. One sparse solve.
+
+The result is the thermal resistance (the hottest point of the heated face
+over the inlet temperature, per watt) and the mean one, with the energy
+balance as a check (what the fluid carries out over what went in).
+
+Units: mm for geometry, SI for properties, W, K.
+"""
+from __future__ import annotations
+
+import numpy as np
+import scipy.sparse as sp
+
+__all__ = ["solve_heat", "duct_flow", "at_pressure_drop"]
+
+
+def solve_heat(solid: np.ndarray, fluid: np.ndarray, velocity, h: float, k_solid: float, fluid_props,
+               heat_faces: np.ndarray, power: float, flow_axis: int = 0, outlet=None, inlet=None,
+               project: bool = False) -> dict:
+    """Steady temperature rise over the inlet (K) in every solid and fluid voxel.
+
+    solid, fluid: bool voxel masks (disjoint; everything else is an
+    adiabatic wall). velocity: (3, *shape) m/s on the voxels (zero in the
+    solid). heat_faces: bool mask of solid voxels whose face on the low side
+    of axis 2 takes the heat (spread evenly by area), or a float field of
+    weights (several dies at different powers), `power` W in all. The fluid
+    enters through the voxels on the grid's low face along `flow_axis` at
+    temperature 0 and leaves through the high one; or, with `inlet` and
+    `outlet` = (mask, axis, sign), enters and leaves through the masked
+    fluid voxels, inward (inlet) or outward (outlet) along `sign` x `axis`.
+    project: first make the face fluxes conserve volume (`_project`); for a
+    lattice Boltzmann flow through a fine network, without it the heat
+    balance can be far off.
+
+    Returns {"T": field (nan outside), "maxRise", "meanRise" (over the heated
+    faces), "resistance" K/W (max), "meanResistance", "balance" (heat carried
+    out over power)}."""
+    shape = solid.shape
+    hm = h * 1e-3
+    live = solid | fluid
+    idx = -np.ones(shape, np.int64)
+    n = int(live.sum())
+    idx[live] = np.arange(n)
+    k = np.where(solid, k_solid, fluid_props.k)
+    rc = fluid_props.rho * fluid_props.cp
+    U = np.asarray(velocity, float)
+    rows, cols, vals = [], [], []
+    rhs = np.zeros(n)
+    # the faces: conduction across every live pair, volume flux (m^3/s,
+    # a to b positive) across fluid pairs from the averaged cell velocities
+    fa, fb, flux = [], [], []
+    for ax in range(3):
+        a = [slice(None)] * 3
+        b = [slice(None)] * 3
+        a[ax] = slice(0, -1)
+        b[ax] = slice(1, None)
+        a, b = tuple(a), tuple(b)
+        both = live[a] & live[b]
+        ia, ib = idx[a][both], idx[b][both]
+        ka, kb = k[a][both], k[b][both]
+        g = 2.0 * ka * kb / (ka + kb) * hm                    # W/K across the face
+        rows += [ia, ib, ia, ib]
+        cols += [ib, ia, ia, ib]
+        vals += [-g, -g, g, g]
+        ff = fluid[a] & fluid[b]
+        fa.append(idx[a][ff])
+        fb.append(idx[b][ff])
+        flux.append(0.5 * (U[ax][a][ff] + U[ax][b][ff]) * hm * hm)
+    fa, fb, flux = np.concatenate(fa), np.concatenate(fb), np.concatenate(flux)
+    # inlet and outlet: (cells, volume flux in / out)
+    if inlet is None:
+        lo = [slice(None)] * 3
+        lo[flow_axis] = 0
+        lo = tuple(lo)
+        ii = idx[lo][fluid[lo]]
+        qi = np.maximum(U[flow_axis][lo][fluid[lo]] * hm * hm, 0.0)
+    else:
+        im, iax, isign = inlet
+        im = np.asarray(im, bool) & fluid
+        ii, qi = idx[im], np.maximum(isign * U[iax][im] * hm * hm, 0.0)
+    if outlet is None:
+        hi = [slice(None)] * 3
+        hi[flow_axis] = -1
+        hi = tuple(hi)
+        io = idx[hi][fluid[hi]]
+        qo = np.maximum(U[flow_axis][hi][fluid[hi]] * hm * hm, 0.0)
+    else:
+        om, oax, osign = outlet
+        om = np.asarray(om, bool) & fluid
+        io, qo = idx[om], np.maximum(osign * U[oax][om] * hm * hm, 0.0)
+    if project:
+        flux, qo = _project(n, fa, fb, flux, ii, qi, io, qo)
+    F = rc * flux                                             # W/K
+    fp, fm = np.maximum(F, 0.0), np.maximum(-F, 0.0)
+    Fo = rc * qo
+    # upwind advection, conservative: each cell gives out at its own T and
+    # takes in F T_upwind. A cell's diagonal is its outflow; where (the LBM's
+    # averaged velocity is weakly compressible) a cell's inflow beats it, the
+    # matrix loses diagonal dominance and AIR can diverge, so the diagonal
+    # is max(outflow, inflow): exact for a divergence-free flow, and with
+    # `project` the flow is made divergence-free first.
+    outs = np.zeros(n)
+    ins = np.zeros(n)
+    np.add.at(outs, fa, fp)
+    np.add.at(outs, fb, fm)
+    np.add.at(ins, fb, fp)
+    np.add.at(ins, fa, fm)
+    np.add.at(ins, ii, rc * qi)                               # inflow at temperature 0
+    np.add.at(outs, io, Fo)
+    rows += [fb, fa]
+    cols += [fa, fb]
+    vals += [-fp, -fm]
+    diag = np.maximum(outs, ins)
+    # heat in
+    wq = np.where(solid, np.asarray(heat_faces, float), 0.0)
+    q = wq > 0
+    if not q.any():
+        raise ValueError("no heated face on the solid")
+    np.add.at(rhs, idx[q], power * wq[q] / wq[q].sum())
+    A = sp.coo_matrix((np.concatenate(vals), (np.concatenate(rows), np.concatenate(cols))), shape=(n, n)).tocsr()
+    A = A + sp.diags(diag)
+    t = _solve(A, rhs)
+    T = np.full(shape, np.nan)
+    T[live] = t
+    carried = float((Fo * t[io]).sum())
+    tq = T[q]
+    return {"T": T, "maxRise": float(tq.max()), "meanRise": float(tq.mean()),
+            "resistance": float(tq.max() / power), "meanResistance": float(tq.mean() / power),
+            "balance": carried / power, "inletCells": int(ii.size)}
+
+
+def _project(n, fa, fb, flux, ii, qi, io, qo):
+    """The nearest face fluxes to `flux` that conserve volume in every cell
+    (least squares, the inlet fluxes held, the outlet ones free): flux -
+    grad phi with L phi = div, L the fluid cells' graph Laplacian (the
+    outlets tied to phi = 0). The averaged LBM velocity, interpolated to
+    faces, gains and loses volume cell by cell; advected heat with it does
+    the same, and on a water cold plate that lost 99% of the heat."""
+    import pyamg
+
+    div = np.zeros(n)
+    np.add.at(div, fa, flux)
+    np.add.at(div, fb, -flux)
+    np.add.at(div, io, qo)
+    np.add.at(div, ii, -qi)
+    used = np.zeros(n, bool)
+    used[fa] = used[fb] = used[io] = used[ii] = True
+    m = np.flatnonzero(used)
+    loc = -np.ones(n, np.int64)
+    loc[m] = np.arange(m.size)
+    a, b = loc[fa], loc[fb]
+    d = np.zeros(m.size)
+    np.add.at(d, a, 1.0)
+    np.add.at(d, b, 1.0)
+    np.add.at(d, loc[io], 1.0)
+    d += 1e-9                                                 # pockets cut off from the outlet
+    Lm = sp.coo_matrix((np.concatenate([-np.ones(a.size), -np.ones(a.size)]),
+                        (np.concatenate([a, b]), np.concatenate([b, a]))), shape=(m.size, m.size)).tocsr()
+    Lm = Lm + sp.diags(d)
+    rhs = -div[m]
+    ml = pyamg.smoothed_aggregation_solver(Lm)
+    phi = ml.solve(rhs, tol=1e-12, accel="cg", maxiter=500)
+    flux = flux - (phi[b] - phi[a])
+    qo = qo + phi[loc[io]]
+    return flux, qo
+
+
+def _solve(A, b):
+    """Advection-diffusion is nonsymmetric and, on a 0.5 mm air sink of ~300k
+    cells, more than SuperLU's fill-in can take (not done in 20 minutes),
+    while GMRES on the symmetric part's multigrid stalls (metal and air
+    conductances 10^4 apart). Rows scaled by the diagonal, then pyamg's AIR
+    (built for upwinded advection) under GMRES: ~20 s to 1e-9."""
+    import pyamg
+
+    A = A.tocsr()
+    d = 1.0 / A.diagonal()
+    As = (sp.diags(d) @ A).tocsr()
+    bs = d * b
+    for make in (lambda: pyamg.air_solver(As),
+                 lambda: pyamg.smoothed_aggregation_solver(As, symmetry="nonsymmetric")):
+        x = make().solve(bs, tol=1e-10, accel="gmres", maxiter=300)
+        if np.linalg.norm(b - A @ x) <= 1e-7 * np.linalg.norm(b):
+            return x
+    raise RuntimeError("conjugate heat solve did not converge")
+
+
+def duct_flow(fluid: np.ndarray, h: float, flow_lpm: float, medium="air", flow_axis: int = 0, **kw) -> dict:
+    """flow.network_flow through a duct whose inlet is the grid's low face
+    along `flow_axis` and outlet the high one (the fluid voxels there).
+    Returns the network_flow report with "velocity" (3, *shape) m/s on the
+    unpadded grid and "dp" Pa (inlet to outlet)."""
+    from .flow import network_flow
+
+    shape = np.asarray(fluid.shape)
+    o = [a for a in range(3) if a != flow_axis]
+    sel_in = np.take(fluid, 0, axis=flow_axis)
+    ij = np.argwhere(sel_in)
+    c = 0.5 * (ij.min(0) + ij.max(0)) * h
+    rad = 0.5 * np.linalg.norm((ij.max(0) - ij.min(0) + 1) * h) + h
+
+    def port(end):
+        p = np.zeros(3)
+        p[flow_axis] = 0.0 if end == 0 else (shape[flow_axis] - 1) * h
+        p[o[0]], p[o[1]] = c
+        ax = np.zeros(3)
+        ax[flow_axis] = -1.0 if end == 0 else 1.0
+        return {"point": p.tolist(), "axis": ax.tolist(), "radius": float(rad)}
+
+    rep = network_flow(fluid, h, port(0), port(1), medium=medium, flow_lpm=flow_lpm, fields=True, **kw)
+    fld = rep.pop("fields")
+    rep["velocity"] = fld["velocity"][:, 1:-1, 1:-1, 1:-1]
+    rep["pressure"] = fld["pressure"][1:-1, 1:-1, 1:-1]
+    rep["dp"] = float(rep["totalPressureDrop"]) if "totalPressureDrop" in rep else _dp(rep, fluid, flow_axis)
+    return rep
+
+
+def _dp(rep, fluid, ax):
+    p = rep["pressure"]
+    a = np.take(p, 0, axis=ax)[np.take(fluid, 0, axis=ax)].mean()
+    b = np.take(p, -1, axis=ax)[np.take(fluid, -1, axis=ax)].mean()
+    return float(a - b)
+
+
+def at_pressure_drop(fluid: np.ndarray, h: float, dp: float, guess_lpm: float, medium="air", flow_axis: int = 0,
+                     rtol: float = 0.05, tries: int = 5, **kw) -> dict:
+    """duct_flow at the flow rate whose pressure drop is `dp` Pa (within
+    rtol): secant on log(flow) against log(dp) from `guess_lpm`."""
+    q = float(guess_lpm)
+    seen = []
+    rep = None
+    for _ in range(tries):
+        rep = duct_flow(fluid, h, q, medium, flow_axis, **kw)
+        rep["flowLpm"] = q
+        seen.append((np.log(q), np.log(max(rep["dp"], 1e-9))))
+        if abs(rep["dp"] / dp - 1.0) <= rtol:
+            break
+        if len(seen) == 1:
+            slope = 1.6                                  # dp ~ Q^1.6 between laminar and turbulent
+        else:
+            (x0, y0), (x1, y1) = seen[-2], seen[-1]
+            slope = (y1 - y0) / (x1 - x0) if abs(x1 - x0) > 1e-9 else 1.6
+            slope = float(np.clip(slope, 1.0, 2.0))
+        q = float(np.exp(seen[-1][0] + (np.log(dp) - seen[-1][1]) / slope))
+    rep["searched"] = [(float(np.exp(a)), float(np.exp(b))) for a, b in seen]
+    return rep