loadpath 0.1.1__py3-none-any.whl

loadpath/lattice.py

@@ -0,0 +1,1065 @@
+"""
+Field-driven lattices: fill a part's interior with a triply periodic minimal
+surface (TPMS) sheet whose wall thickness follows the stress, keeping a solid
+skin and solid material wherever the part works hard.
+
+Everything is an implicit field:
+
+- the part as a signed distance (negative inside), from a voxelization of
+  its mesh and distance transforms;
+- the TPMS as an approximate distance, the level-set function divided by
+  its gradient's magnitude, so a sheet's wall comes out in millimetres;
+- solid zones (the skin, collars round preserved geometry, keep-outs,
+  supports and loads, and cells the sizing turned solid) as distances too,
+  joined to the lattice by a smooth union, so every sheet meets the skin
+  and every boss with a fillet instead of a crease.
+
+Two ways to grade the wall:
+
+- `target_sf` set (the sizing that means something): the core is a
+  homogenized material, a sheet of relative density rho having modulus
+  E * C rho^n and a peak wall stress A rho^-m times the stress it carries
+  on average (unit-cell FEA, `homogenize`; the fits are in SHEETS). A
+  voxel FEA of the part with the skin solid and every core cell at its
+  sheet's modulus gives each cell's stress; each cell's density is set,
+  fully-stressed-design style, to the least that keeps its walls at the
+  target safety factor, cells that would need more than `wall_max` turn
+  solid, and the analysis repeats as the load moves to wherever it is
+  stiffest. That is the lattice an engineer can sign off on: the voids are
+  where the stress is not.
+- otherwise, from a verification of the solid part (`fields`): the wall runs
+  from `wall_min` where the part idles to `wall_max`, and material above
+  `solid_above` utilization stays solid. Quick, but the solid part's stress
+  is not the lattice part's.
+
+Printability is part of the design, not an afterthought:
+
+- every wall is at least the process's minimum feature;
+- powder (SLS, MJF) and resin (SLA, volumetric) would stay trapped in a
+  lattice under a closed skin, so each enclosed void gets drain holes
+  (lowest and highest along the build, away from the stress), pockets too
+  small to drain are filled solid, and the report says what is still
+  trapped (it should be nothing);
+- FDM prints the closed skin like infill; the report gives the lattice's
+  own down-facing area (gyroid and diamond sheets self-support at the
+  usual cell sizes; Schwarz P has flat ceilings).
+
+Units are millimetres throughout.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import lru_cache
+
+import numpy as np
+from scipy import ndimage
+
+from .spec import Study
+
+__all__ = ["LatticeOptions", "tpms", "lattice_infill", "TPMS", "SHEETS", "STRUTS", "STRUT_TABLES", "lattice_fit", "homogenize",
+           "relative_density", "wall_for_density", "envelope_mesh"]
+
+
+def _gyroid(x, y, z):
+    return np.sin(x) * np.cos(y) + np.sin(y) * np.cos(z) + np.sin(z) * np.cos(x)
+
+
+def _gyroid_grad(x, y, z):
+    return (np.cos(x) * np.cos(y) - np.sin(z) * np.sin(x),
+            np.cos(y) * np.cos(z) - np.sin(x) * np.sin(y),
+            np.cos(z) * np.cos(x) - np.sin(y) * np.sin(z))
+
+
+def _schwarz_p(x, y, z):
+    return np.cos(x) + np.cos(y) + np.cos(z)
+
+
+def _schwarz_p_grad(x, y, z):
+    return -np.sin(x), -np.sin(y), -np.sin(z)
+
+
+def _diamond(x, y, z):
+    return (np.sin(x) * np.sin(y) * np.sin(z) + np.sin(x) * np.cos(y) * np.cos(z)
+            + np.cos(x) * np.sin(y) * np.cos(z) + np.cos(x) * np.cos(y) * np.sin(z))
+
+
+def _diamond_grad(x, y, z):
+    sx, cx, sy, cy, sz, cz = np.sin(x), np.cos(x), np.sin(y), np.cos(y), np.sin(z), np.cos(z)
+    return (cx * sy * sz + cx * cy * cz - sx * sy * cz - sx * cy * sz,
+            sx * cy * sz - sx * sy * cz + cx * cy * cz - cx * sy * sz,
+            sx * sy * cz - sx * cy * sz - cx * sy * sz + cx * cy * cz)
+
+
+TPMS = {"gyroid": (_gyroid, _gyroid_grad),
+        "schwarz-p": (_schwarz_p, _schwarz_p_grad),
+        "diamond": (_diamond, _diamond_grad)}
+
+# Homogenized sheets, from `homogenize` (periodic unit cell, 40 voxels per
+# cell, nu = 0.35, relative density 0.14-0.6; the fits are within 5% of
+# every point): modulus E*/E = C rho^n (uniaxial; the cells are cubic, so
+# that is every axis), and the peak wall von Mises (99.5th percentile of
+# nodal values) over the macro von Mises, = A rho^-m, the larger of a
+# uniaxial and a shear macro stress (uniaxial for gyroid and Schwarz P,
+# shear for thin diamond). Elastic first yield: the walls start yielding
+# there, well before the cell collapses, which is the right reading for a
+# linear check. Per gram, diamond is the stiffest and strongest of the
+# three and Schwarz P the weakest.
+SHEETS = {
+    "gyroid": {"C": 0.648, "n": 1.43, "A": 3.01, "m": 1.10},
+    "diamond": {"C": 0.671, "n": 1.35, "A": 2.62, "m": 1.22},
+    "schwarz-p": {"C": 0.669, "n": 1.68, "A": 3.82, "m": 1.04},
+}
+
+# Homogenized strut cells (struts.py), from `homogenize` the same way
+# (bench/strut_fits.py: periodic unit cell, 48 voxels a cell, relative
+# density 0.06-0.34). Struts are cubic but anisotropic, so these are the
+# conservative isotropic reading: the modulus is the lesser of the [100]
+# and [111] moduli, the stress factor the largest of a [100] pull, a [111]
+# pull and a shear. BCCz and FCCz are stiff along z and the octet along its
+# struts; the fits do not count on it. The thickness is the strut diameter.
+# sheet_modulus and sheet_stress_factor read STRUT_TABLES below instead,
+# which run to rho 0.92; these power laws are the summary over 0.06-0.34.
+STRUTS = {
+    "cubic": {"C": 0.739, "n": 2.38, "A": 3.09, "m": 1.84},
+    "bcc": {"C": 0.61, "n": 2.49, "A": 4.63, "m": 1.64},
+    "bccz": {"C": 0.488, "n": 2.5, "A": 4.12, "m": 2.3},
+    "fcc": {"C": 0.443, "n": 1.4, "A": 5.96, "m": 0.97},
+    "fccz": {"C": 0.435, "n": 1.44, "A": 5.26, "m": 1.19},
+    "octet": {"C": 0.363, "n": 1.36, "A": 7.22, "m": 0.91},
+    "kelvin": {"C": 0.937, "n": 2.07, "A": 3.28, "m": 1.62},
+    # one periodic draw of 8 relaxed seeds (struts._periodic_voronoi), the
+    # thickness over the seed spacing; a foam is near isotropic
+    "voronoi": {"C": 0.841, "n": 1.93, "A": 2.87, "m": 1.57},
+    "diamond-strut": {"C": 0.695, "n": 2.1, "A": 2.63, "m": 1.77},
+}
+
+
+# The power laws above were fitted over rho 0.06-0.34 and miss badly past
+# it: at rho 0.8 the octet fit reads E*/E 0.27 against a solved 0.56 and a
+# stress factor 8.8 against 4.3, so a dense strut core looked far weaker than
+# it is. The same unit-cell solves from rho 0.06 to 0.92 (bench/strut_fits.py,
+# n=48), tabulated as (rho, E*/E, stress factor), the conservative isotropic
+# reading as above. Between rows the readings are interpolated log-log, up to
+# the solid (1, 1, 1); under the first row the power law runs on with the
+# slope of the first two rows.
+STRUT_TABLES = {
+    "cubic": [
+        (0.061, 0.001, 525.18), (0.099, 0.003, 225.22), (0.159, 0.0092, 85.85), (0.237, 0.0237, 46.11), (0.343, 0.0605, 21.63),
+        (0.478, 0.1399, 10.45), (0.647, 0.3106, 5.63), (0.785, 0.5317, 3.59),
+    ],
+    "bcc": [
+        (0.058, 0.0005, 472.41), (0.093, 0.0016, 229.56), (0.158, 0.0058, 104.25), (0.232, 0.0158, 56.67), (0.327, 0.0404, 25.59),
+        (0.49, 0.1298, 10.7), (0.658, 0.3127, 5.89), (0.799, 0.551, 3.85), (0.921, 0.8148, 2.26),
+    ],
+    "bccz": [
+        (0.055, 0.0004, 3174.74), (0.104, 0.0017, 748.84), (0.158, 0.0046, 290.12), (0.235, 0.0125, 116.99), (0.348, 0.0373, 45.0),
+        (0.483, 0.0997, 18.63), (0.648, 0.258, 7.29), (0.799, 0.5184, 3.47), (0.921, 0.8014, 2.25),
+    ],
+    "fcc": [
+        (0.056, 0.0083, 94.57), (0.095, 0.0155, 58.45), (0.163, 0.0317, 35.92), (0.246, 0.0613, 24.25), (0.334, 0.1026, 16.2),
+        (0.487, 0.2017, 9.34), (0.655, 0.3516, 5.35), (0.798, 0.5517, 3.6), (0.919, 0.8046, 2.16),
+    ],
+    "fccz": [
+        (0.062, 0.0085, 134.39), (0.105, 0.0161, 79.55), (0.163, 0.0291, 47.25), (0.238, 0.0534, 30.62), (0.335, 0.0989, 17.6),
+        (0.481, 0.1808, 9.3), (0.644, 0.3172, 5.76), (0.805, 0.5462, 3.66), (0.92, 0.8037, 2.16),
+    ],
+    "octet": [
+        (0.073, 0.0108, 74.07), (0.107, 0.0173, 57.65), (0.178, 0.033, 36.12), (0.243, 0.0515, 27.9), (0.322, 0.0827, 18.73),
+        (0.48, 0.1702, 11.09), (0.652, 0.3379, 6.48), (0.79, 0.5612, 4.27), (0.922, 0.8359, 2.2),
+    ],
+    "kelvin": [
+        (0.056, 0.0023, 344.9), (0.094, 0.0071, 155.37), (0.16, 0.0213, 69.09), (0.239, 0.0482, 32.62), (0.331, 0.0945, 19.28),
+        (0.478, 0.207, 10.72), (0.646, 0.4007, 5.47), (0.803, 0.6402, 3.33), (0.922, 0.8481, 1.95),
+    ],
+    "diamond-strut": [
+        (0.058, 0.0018, 378.68), (0.093, 0.0047, 192.93), (0.157, 0.0144, 70.05), (0.232, 0.0321, 33.78), (0.34, 0.0721, 17.59),
+        (0.489, 0.1596, 9.47), (0.657, 0.3211, 5.96), (0.797, 0.5353, 4.3), (0.92, 0.8046, 2.91),
+    ],
+    "voronoi": [
+        (0.06, 0.0036, 236.04), (0.1, 0.0098, 106.78), (0.16, 0.0244, 52.1), (0.24, 0.0531, 26.99), (0.34, 0.104, 15.49),
+        (0.481, 0.2074, 8.75), (0.65, 0.3885, 5.01), (0.8, 0.6086, 3.21), (0.92, 0.8274, 2.16),
+    ],
+}
+
+
+def _table_reading(kind: str, rho, col: int):
+    """Log-log interpolation of a strut table column (1 = E*/E, 2 = stress
+    factor) at rho, None for a kind with no table."""
+    from .struts import canonical
+
+    k = kind if kind in SHEETS else canonical(kind)
+    rows = STRUT_TABLES.get(k)
+    if rows is None:
+        return None
+    t = np.array(rows + [(1.0, 1.0, 1.0)], float)
+    x, y = np.log(t[:, 0]), np.log(t[:, col])
+    lr = np.log(np.clip(np.asarray(rho, float), 1e-3, 1.0))
+    slope = (y[1] - y[0]) / (x[1] - x[0])
+    out = np.where(lr < x[0], y[0] + slope * (lr - x[0]), np.interp(lr, x, y))
+    return np.exp(out)
+
+
+def lattice_fit(kind: str) -> dict:
+    """The homogenized fit (C, n, A, m) of a sheet or strut cell."""
+    from .struts import canonical
+
+    if kind in SHEETS:
+        return SHEETS[kind]
+    k = canonical(kind)
+    if k in STRUTS:
+        return STRUTS[k]
+    raise ValueError(f"no homogenized fit for lattice {kind!r} (have {', '.join(list(SHEETS) + list(STRUTS))})")
+
+
+_SINGLE = [0]
+
+
+class single_precision:
+    """Inside this block (from any thread) gyroid and diamond take their
+    trig in single precision, on a phase reduced to one period in double:
+    numpy's float32 sin/cos are SIMD and ~30x faster than float64's, and
+    the value is still good to ~1e-7 of a cell near the surface (1e-6 mm
+    on a 7 mm cell). For sampling a grid for marching cubes (which keeps
+    float32 samples anyway); not for finite differences on a 1e-4 pitch
+    step, as the crease pass takes, where that noise is a 3% gradient."""
+
+    def __enter__(self):
+        _SINGLE[0] += 1
+        return self
+
+    def __exit__(self, *exc):
+        _SINGLE[0] -= 1
+
+
+def tpms(kind: str, pts: np.ndarray, cell: float) -> np.ndarray:
+    """Approximate signed distance (mm) to the TPMS mid-surface, `cell` mm per
+    period: the level-set value over its gradient's magnitude. Exact on the
+    surface, and good to a few percent out to a quarter cell, which is as far
+    as a sheet wall reaches."""
+    if kind not in TPMS:
+        raise ValueError(f"lattice type must be one of {sorted(TPMS)}, got {kind!r}")
+    if not _SINGLE[0] and np.ndim(cell) == 0:
+        from . import fieldops
+
+        if fieldops.available():
+            # double precision, one compiled pass (bit for bit the code below)
+            return fieldops.tpms(kind, pts, cell)
+    k = 2.0 * np.pi / cell
+    if kind == "schwarz-p":
+        x, y, z = (k * pts[:, i] for i in range(3))
+        f, grad = TPMS[kind]
+        g = np.stack(grad(x, y, z), axis=-1) * k
+        return f(x, y, z) / np.maximum(np.linalg.norm(g, axis=-1), 0.3 * k)
+    # gyroid and diamond from one set of sines and cosines (the separate
+    # value and gradient functions above take each three times)
+    if _SINGLE[0]:
+        two_pi = np.float32(2.0 * np.pi)
+        ph = []
+        for i in range(3):
+            u = pts[:, i] * (1.0 / cell)
+            u -= np.floor(u)
+            ph.append(u.astype(np.float32) * two_pi)
+        x, y, z = ph
+        k = np.float32(k)
+    else:
+        x, y, z = (k * pts[:, i] for i in range(3))
+    sx, cx, sy, cy, sz, cz = np.sin(x), np.cos(x), np.sin(y), np.cos(y), np.sin(z), np.cos(z)
+    if kind == "gyroid":
+        f = sx * cy + sy * cz + sz * cx
+        g = (cx * cy - sz * sx, cy * cz - sx * sy, cz * cx - sy * sz)
+    else:
+        f = sx * sy * sz + sx * cy * cz + cx * sy * cz + cx * cy * sz
+        g = (cx * sy * sz + cx * cy * cz - sx * sy * cz - sx * cy * sz,
+             sx * cy * sz - sx * sy * cz + cx * cy * cz - cx * sy * sz,
+             sx * sy * cz - sx * cy * sz - cx * sy * sz + cx * cy * cz)
+    gn = np.sqrt(g[0] * g[0] + g[1] * g[1] + g[2] * g[2]) * k
+    return np.asarray(f / np.maximum(gn, 0.3 * k), np.float64)
+
+
+@lru_cache(maxsize=None)
+def _density_table(kind: str):
+    """Relative density of a sheet |tpms| < wall/2 against wall/cell, sampled
+    on one cell (the distance approximation makes it a little sub-linear)."""
+    n = 96
+    c = (np.arange(n) + 0.5) / n
+    g = np.stack(np.meshgrid(c, c, c, indexing="ij"), -1).reshape(-1, 3)
+    d = np.sort(np.abs(tpms(kind, g, 1.0)))
+    t = np.linspace(0.0, 0.8, 161)
+    rho = np.searchsorted(d, 0.5 * t) / d.size
+    return t, rho
+
+
+def relative_density(kind: str, wall, cell: float, blend: float = 0.0):
+    """Volume fraction of a `wall` mm sheet (or strut diameter) in `cell` mm
+    cells; `blend` (mm) is a strut cell's node fillet."""
+    from .struts import is_strut, strut_relative_density
+
+    if is_strut(kind):
+        return strut_relative_density(kind, wall, cell, blend=float(blend) / float(np.mean(cell)))
+    t, rho = _density_table(kind)
+    return np.interp(np.asarray(wall, float) / cell, t, rho)
+
+
+def wall_for_density(kind: str, rho, cell: float):
+    """The sheet wall (mm) that gives relative density `rho`."""
+    t, r = _density_table(kind)
+    return np.interp(np.asarray(rho, float), r, t) * cell
+
+
+def sheet_modulus(kind: str, rho):
+    """E*/E of a sheet or strut cell at relative density rho."""
+    s = lattice_fit(kind)
+    rho = np.asarray(rho, float)
+    t = _table_reading(kind, rho, 1)
+    if t is not None:
+        return np.where(rho >= 1.0, 1.0, t)
+    return np.where(rho >= 1.0, 1.0, s["C"] * np.clip(rho, 1e-3, 1.0) ** s["n"])
+
+
+def sheet_stress_factor(kind: str, rho):
+    """Peak wall stress over the macro stress the lattice carries."""
+    s = lattice_fit(kind)
+    rho = np.asarray(rho, float)
+    t = _table_reading(kind, rho, 2)
+    if t is not None:
+        return np.where(rho >= 1.0, 1.0, t)
+    return np.where(rho >= 1.0, 1.0, s["A"] * np.clip(rho, 1e-3, 1.0) ** -s["m"])
+
+
+def homogenize(kind: str, wall_over_cell: float, n: int = 40, nu: float = 0.35, blend: float = 0.0) -> dict:
+    """Effective properties of a TPMS sheet by periodic homogenization of one
+    unit cell on an n^3 voxel grid (only the solid voxels; their nodes wrap
+    across the cell faces). Returns relative density, uniaxial modulus and
+    Poisson ratio, shear modulus (all over the solid's E), the Zener
+    anisotropy ratio, and the peak wall stress factor under a uniaxial and a
+    shear macro stress (99.5th percentile and max of nodal von Mises over
+    the macro von Mises). Strut cells too (struts.py): `wall_over_cell` is
+    then the strut diameter over the cell and `blend` the node fillet over
+    the cell; they are cubic but far from isotropic, so the modulus along
+    the cube diagonal [111] and the wall stress under a [111] pull come
+    too (E111, stressFactor111). Slow (tens of seconds at n = 40): the fits
+    in SHEETS and STRUTS come from it."""
+    import pyamg
+    import scipy.sparse as sp
+    from scipy.sparse.linalg import cg
+
+    from .fem import CORNERS, _b_matrix, elastic_c, hex8_b, hex8_ke, von_mises
+
+    h = 1.0 / n
+    c = (np.arange(n) + 0.5) * h
+    g = np.stack(np.meshgrid(c, c, c, indexing="ij"), -1).reshape(-1, 3)
+    from .struts import is_strut, unit_cell_distance
+
+    if is_strut(kind):
+        solid = unit_cell_distance(kind, g, blend) < 0.5 * wall_over_cell
+    else:
+        solid = np.abs(tpms(kind, g, 1.0)) < 0.5 * wall_over_cell
+    eijk = np.argwhere(solid.reshape(n, n, n))
+    ne = len(eijk)
+    corner = (eijk[:, None, :] + CORNERS[None]) % n
+    used, inv = np.unique((corner[..., 0] * n + corner[..., 1]) * n + corner[..., 2], return_inverse=True)
+    enode = inv.reshape(ne, 8)
+    nn = len(used)
+    edof = (3 * enode[:, :, None] + np.arange(3)).reshape(ne, 24)
+    ke = hex8_ke(nu) * h
+    k = sp.csr_matrix((np.tile(ke.ravel(), ne), (np.repeat(edof, 24, axis=1).ravel(),
+                                                 np.tile(edof, (1, 24)).ravel())), shape=(3 * nn, 3 * nn))
+    free = np.ones(3 * nn, bool)
+    free[:3] = False                     # one node holds the cell still
+    kf = k[free][:, free]
+    ml = pyamg.smoothed_aggregation_solver(kf, symmetry="hermitian", max_coarse=400, coarse_solver="splu")
+    xc = (eijk[:, None, :] + CORNERS[None]) * h
+    c0 = elastic_c(1.0, nu)
+    bc = _b_matrix(0, 0, 0) / h
+
+    def load(e):
+        # u = macro strain . x + periodic fluctuation
+        eps = np.array([[e[0], e[3] / 2, e[5] / 2], [e[3] / 2, e[1], e[4] / 2], [e[5] / 2, e[4] / 2, e[2]]])
+        u0 = (xc @ eps.T).reshape(ne, 24)
+        f = np.zeros(3 * nn)
+        np.add.at(f, edof, -(u0 @ ke.T))
+        uf, info = cg(kf, f[free], rtol=1e-8, maxiter=2000, M=ml.aspreconditioner())
+        if info != 0:
+            raise RuntimeError("unit cell solve did not converge")
+        u = np.zeros(3 * nn)
+        u[free] = uf
+        ue = u[edof] + u0
+        mean = ((ue @ bc.T) @ c0.T).sum(axis=0) / n ** 3
+        acc = np.zeros((nn, 6))
+        for kk, (a, b, cc) in enumerate(2.0 * CORNERS - 1.0):
+            np.add.at(acc, enode[:, kk], (ue @ (hex8_b(a, b, cc, nu) / h).T) @ c0.T)
+        vm = von_mises(acc / np.bincount(enode.ravel(), minlength=nn)[:, None])
+        return mean, vm
+
+    s1, _ = load([1, 0, 0, 0, 0, 0])
+    c11, c12 = s1[0], s1[1]
+    c44 = load([0, 0, 0, 1, 0, 0])[0][3]
+    e_uni = (c11 - c12) * (c11 + 2 * c12) / (c11 + c12)
+    nu_h = c12 / (c11 + c12)
+    _, vm_z = load([-nu_h / e_uni, -nu_h / e_uni, 1 / e_uni, 0, 0, 0])
+    _, vm_s = load([0, 0, 0, 1 / c44, 0, 0])
+    # [111]: macro stress n n^T (unit von Mises) through the cubic compliance
+    s11 = (c11 + c12) / ((c11 - c12) * (c11 + 2 * c12))
+    s12 = -c12 / ((c11 - c12) * (c11 + 2 * c12))
+    s44 = 1.0 / c44
+    e111 = 1.0 / (s11 - 2 * (s11 - s12 - 0.5 * s44) / 3.0)
+    sig = np.full(6, 1.0 / 3.0)
+    eps = np.array([s11 * sig[0] + s12 * (sig[1] + sig[2]), s11 * sig[1] + s12 * (sig[0] + sig[2]),
+                    s11 * sig[2] + s12 * (sig[0] + sig[1]), s44 * sig[3], s44 * sig[4], s44 * sig[5]])
+    _, vm_d = load(list(eps))
+    return {"rho": float(solid.mean()), "E": float(e_uni), "nu": float(nu_h), "G": float(c44),
+            "E111": float(e111), "stressFactor111": float(np.percentile(vm_d, 99.5)),
+            "zener": float(2 * c44 / (c11 - c12)),
+            "stressFactor": float(np.percentile(vm_z, 99.5)), "stressFactorMax": float(vm_z.max()),
+            "shearStressFactor": float(np.percentile(vm_s, 99.5) / np.sqrt(3.0))}
+
+
+@dataclass
+class LatticeOptions:
+    kind: str = "gyroid"
+    cell: float = 8.0               # mm per period
+    skin: float = 1.2               # mm of solid shell; 0 leaves the lattice open
+    wall_min: float = 0.8           # mm, where the part idles (>= the process's min feature)
+    wall_max: float = 2.0           # mm; a cell that needs more turns solid
+    solid_above: float = 0.5        # (solid-part grading) utilization above which material stays solid
+    safety_factor: float = 2.0      # (solid-part grading) the allowable is strength / this
+    target_sf: float | None = None  # homogenized sizing to this safety factor (every load case)
+    collar: float = 2.0             # mm of solid round preserved shapes, keep-outs, supports and loads
+    blend: float | None = None      # mm, smooth-union radius between solid and lattice (default wall_max)
+    drains: str = "auto"            # "auto" (powder and resin processes), "yes", "no"
+    drain_diameter: float | None = None   # mm (default the process's escape hole: SLS 4, MJF 5, resin 3.5)
+    fill_pockets: float | None = None     # mm^3: enclosed voids smaller than this are filled (default cell^3/8)
+    iterations: int = 12            # sizing passes
+    analysis_cells: int = 120_000   # homogenized FEA size
+    step: float | None = None       # field sampling, mm (default: wall_min / 2.5)
+    max_points: int = 12_000_000
+    exact_surface: bool = True      # mesh the TPMS itself (projected), not its grid samples
+    anisotropic: bool | None = None  # (homogenized sizing) full cell tensors (lattice_tensors); None: on
+                                     # where tables exist and LOADPATH_LATTICE_ANISO is not 0
+
+    @classmethod
+    def from_spec(cls, spec: dict, process=None, safety_factor: float | None = None) -> "LatticeOptions":
+        """Options from the JSON spec (schema.LATTICE_SCHEMA). `safety_factor`
+        is the study goal's, used when the spec names none."""
+        spec = dict(spec or {})
+        o = cls()
+        for key, attr in (("type", "kind"), ("cell", "cell"), ("skin", "skin"), ("minWall", "wall_min"),
+                          ("maxWall", "wall_max"), ("solidAbove", "solid_above"), ("collar", "collar"),
+                          ("blend", "blend"), ("drains", "drains"), ("drainDiameter", "drain_diameter"),
+                          ("fillPockets", "fill_pockets"), ("step", "step")):
+            if key in spec:
+                setattr(o, attr, spec[key] if attr in ("kind", "drains") else float(spec[key]))
+        sizing = spec.get("sizing", "homogenized")
+        if sizing not in ("homogenized", "solid-stress"):
+            raise ValueError("lattice sizing must be 'homogenized' or 'solid-stress'")
+        sf = float(spec.get("safetyFactor") or safety_factor or 2.0)
+        if sizing == "homogenized":
+            o.target_sf = sf
+        else:
+            o.safety_factor = sf
+        if process is not None and o.wall_min < process.min_feature:
+            o.wall_min = process.min_feature
+        if o.wall_max < o.wall_min:
+            raise ValueError("lattice maxWall must be at least minWall")
+        if o.cell < 4.0 * o.wall_max:
+            raise ValueError(f"lattice cell {o.cell:g}mm is too small for {o.wall_max:g}mm walls "
+                             "(at least 4 x maxWall, or the channels close)")
+        if o.drains not in ("auto", "yes", "no"):
+            raise ValueError("lattice drains must be 'auto', 'yes' or 'no'")
+        return o
+
+
+def envelope_mesh(study: Study):
+    """The whole envelope as a solid: design space and preserved shapes, less
+    the keep-outs. A lattice part that keeps its outer shape starts here."""
+    import manifold3d as m3d
+
+    from .shapes import trimesh_from_manifold
+
+    add = m3d.Manifold.batch_boolean([s.to_manifold() for s in study.design_space]
+                                     + [r.shape.to_manifold() for r in study.preserve], m3d.OpType.Add)
+    if study.keep_out:
+        add = add - m3d.Manifold.batch_boolean([r.shape.to_manifold() for r in study.keep_out], m3d.OpType.Add)
+    return trimesh_from_manifold(add)
+
+
+def _part_distance(mesh, step, lo, dims):
+    """Signed distance to the mesh surface on the grid (negative inside),
+    from an inside/outside voxelization and two distance transforms."""
+    from .verify import voxelize
+
+    hi = lo + np.asarray(dims) * step
+    solid, origin = voxelize(mesh, step, box=(lo, hi))
+    if solid.shape != tuple(dims):     # rounding at the last cell
+        out = np.zeros(dims, bool)
+        s = tuple(slice(0, min(a, b)) for a, b in zip(solid.shape, dims))
+        out[s] = solid[s]
+        solid = out
+    return _signed_distance(solid, step)
+
+
+def _signed_distance(solid, step):
+    d = (ndimage.distance_transform_edt(~solid) - ndimage.distance_transform_edt(solid)) * step
+    return d + np.where(solid, 0.5 * step, -0.5 * step)
+
+
+def _collar_distance(study: Study, pts, collar):
+    """Distance (negative inside) to the solid zones round everything the
+    user drew: preserved shapes, keep-outs (a bore's wall), and where loads
+    and supports attach. Nothing there should be lattice."""
+    shapes = [r.shape for r in study.preserve] + [r.shape for r in study.keep_out]
+    for s in study.supports:
+        shapes.append(s.shape if s.shape is not None else study.region_shape(s.region)[0])
+    for case in study.load_cases:
+        for ld in case.loads:
+            shapes.append(ld.shape if ld.shape is not None else study.region_shape(ld.region)[0])
+    d = np.full(len(pts), np.inf)
+    seen = set()
+    for s in shapes:
+        if id(s) in seen:
+            continue
+        seen.add(id(s))
+        d = np.minimum(d, s.sdf(pts) - collar)
+    return d
+
+
+def _block_mean(a, r):
+    nx, ny, nz = (n // r for n in a.shape)
+    return a[:nx * r, :ny * r, :nz * r].reshape(nx, r, ny, r, nz, r).mean(axis=(1, 3, 5))
+
+
+def _size(study: Study, o: LatticeOptions, lo, step, inside, solid_zone):
+    """Homogenized fully-stressed sizing on a grid r fine cells to the side.
+    Returns (rho per analysis cell, 1 = solid; the strain-equivalent stress
+    at full modulus, MPa; r; info)."""
+    from scipy.spatial import cKDTree
+
+    from .domain import boundary_conditions, gravity_force
+    from .fem import HexMesh, Solver, Stiffness, von_mises
+
+    mat = study.material
+    kind = o.kind
+    vol = inside.sum() * step ** 3
+    pitch = max(o.cell / 5.0, (vol / o.analysis_cells) ** (1.0 / 3.0))
+    r = max(1, int(round(pitch / step)))
+    pitch = r * step
+    f_in = _block_mean(inside.astype(np.float32), r)
+    f_solid = _block_mean((inside & solid_zone).astype(np.float32), r)
+    active = f_in >= 0.5
+    lbl, _ = ndimage.label(active)
+    ijk = np.argwhere(active)
+    hm = HexMesh(ijk, pitch, lo)
+    bc = boundary_conditions(study, hm, check_loads=False, tol_floor=0.5 * pitch)
+    sup = np.unique(lbl[tuple(ijk[bc.support_nodes[hm.enode].any(axis=1)].T)])
+    keep = np.isin(lbl[tuple(ijk.T)], sup)
+    if not keep.all():
+        ijk = ijk[keep]
+        hm = HexMesh(ijk, pitch, lo)
+        bc = boundary_conditions(study, hm, check_loads=False, tol_floor=0.5 * pitch)
+    fs = (f_solid[tuple(ijk.T)] / f_in[tuple(ijk.T)]).astype(float)
+    fc = 1.0 - fs
+    lattice_cell = fc > 0.05
+    rho_min = float(relative_density(kind, o.wall_min, o.cell))
+    rho_max = float(relative_density(kind, o.wall_max, o.cell))
+    rho = np.full(hm.n_elem, rho_min)
+    rho[~lattice_cell] = 1.0
+    stiff = Stiffness(hm, mat.nu, bc.fixed)
+    solver = Solver(hm, rtol=1e-6, maxiter=3000)
+    aniso = _use_tensors(o)
+    if aniso:
+        from .fem import elastic_c
+        from .homogenized import _center_strain, solve_anisotropic
+        from .lattice_tensors import stress_surface, tensors_at
+
+        c_solid = elastic_c(1.0, mat.nu)
+        # candidate densities a cell can be sized to, and their tensors
+        cand = np.geomspace(rho_min, rho_max, 28)
+        cand_t = tensors_at(kind, cand)
+    target = o.target_sf * 1.15             # verify's discretization allowance
+    allow = mat.strength / target
+    contact = bc.support_nodes.copy()
+    for ln in bc.case_load_nodes:
+        contact |= ln
+    band = 1.5 * pitch + o.collar
+    near = cKDTree(hm.node_xyz[contact]).query(hm.elem_centers(), k=1, distance_upper_bound=band)[0] < np.inf
+    # a stress concentration spreads over a cell before the lattice can
+    # follow it: grow each requirement over a quarter cell
+    grow = max(1, int(round(0.25 * o.cell / pitch)))
+    grid = np.zeros(active.shape)
+    history = []
+    analyzed = rho
+    for it in range(o.iterations):
+        e_cell = mat.E * (fs + fc * sheet_modulus(kind, rho))
+        fg = gravity_force(hm, np.ones(hm.n_elem), bc.gravity, bc.fixed) if bc.gravity is not None else 0.0
+        rhs = [bc.loads[ci] + fg for ci in range(len(study.load_cases))]
+        if aniso:
+            c_lat = tensors_at(kind, rho)[0]
+            c_cell = mat.E * (fs[:, None, None] * c_solid + fc[:, None, None] * c_lat)
+            us = solve_anisotropic(hm, mat.nu, c_cell, bc, mat.E, rhs, proxy=e_cell)
+            need, wall_u, se = _tensor_need(kind, us, hm, mat, rho, rho_max, cand, cand_t, allow,
+                                            _center_strain, stress_surface, c_solid)
+            need = np.where(lattice_cell, need, 0.0)
+            grid[:] = 0.0
+            grid[tuple(ijk.T)] = need
+            need = ndimage.maximum_filter(grid, size=2 * grow + 1)[tuple(ijk.T)]
+            new = np.clip(np.maximum(need, 0.5 * np.minimum(rho, rho_max)), rho_min, None)
+            stay = (rho >= 1.0) & (need > 0.8 * rho_max)
+            new = np.where((new > rho_max) | stay, 1.0, np.minimum(new, rho_max))
+            new[~lattice_cell] = 1.0
+            wall_u = np.where(lattice_cell & (rho < 1.0), wall_u, 0.0)
+            solid_u = np.where(~lattice_cell | (rho >= 1.0), se, 0.0)
+            peak = float(np.max(np.where(near, 0.0, np.maximum(wall_u, solid_u))))
+            frac = float((fs + fc * rho).mean())
+            history.append({"iteration": it, "predictedSF": mat.strength / (1.15 * peak) if peak > 0 else np.inf,
+                            "solidCells": float((rho >= 1).mean()), "fill": frac,
+                            "compliance": float(sum(f @ u for f, u in zip(rhs, us)))})
+            short = history[-1]["predictedSF"] / o.target_sf
+            if it >= 2:
+                allow *= float(np.clip(short, 0.85, 1.15)) ** 0.5
+            if np.allclose(new, rho, atol=0.01) and abs(short - 1.0) < 0.05:
+                break
+            analyzed, rho = rho, new
+            continue
+        k = stiff.assemble(e_cell)
+        if bc.springs is not None:
+            k = (k + mat.E * bc.springs).tocsr()
+        us = solver.solve_many(k, rhs)
+        # stress at the solid's modulus for each cell's strain: what the
+        # skin carries, and E*/E of it is the lattice's macro stress
+        se = np.max([von_mises(stiff.stress(u, mat.E)) for u in us], axis=0)
+        sm = se * sheet_modulus(kind, rho)
+        # a solid cell is judged as the densest lattice under the same
+        # strain: whether it could go back to lattice (with some hysteresis,
+        # or cells flicker), not what it needs as solid, which would spread
+        # solid outwards a ring per pass
+        s = SHEETS[kind]
+        sm_eval = se * sheet_modulus(kind, np.minimum(rho, rho_max))
+        need = np.where(lattice_cell, (s["A"] * sm_eval / allow) ** (1.0 / s["m"]), 0.0)
+        grid[:] = 0.0
+        grid[tuple(ijk.T)] = need
+        need = ndimage.maximum_filter(grid, size=2 * grow + 1)[tuple(ijk.T)]
+        new = np.clip(np.maximum(need, 0.5 * np.minimum(rho, rho_max)), rho_min, None)    # move limit
+        stay = (rho >= 1.0) & (need > 0.8 * rho_max)
+        new = np.where((new > rho_max) | stay, 1.0, np.minimum(new, rho_max))
+        new[~lattice_cell] = 1.0
+        wall_u = np.where(lattice_cell & (rho < 1.0), sheet_stress_factor(kind, rho) * sm, 0.0)
+        solid_u = np.where(~lattice_cell | (rho >= 1.0), se, 0.0)
+        peak = float(np.max(np.where(near, 0.0, np.maximum(wall_u, solid_u))))
+        frac = float((fs + fc * rho).mean())
+        history.append({"iteration": it, "predictedSF": mat.strength / (1.15 * peak) if peak > 0 else np.inf,
+                        "solidCells": float((rho >= 1).mean()), "fill": frac,
+                        "compliance": float(sum((bc.loads[ci] + fg) @ u for ci, u in enumerate(us)))})
+        # the sizing assumes each cell's macro stress stays put as it
+        # changes; when the analysis keeps reading under the target (the
+        # load moved onto what got stiffer), tighten the allowable to match
+        short = history[-1]["predictedSF"] / o.target_sf
+        if it >= 2:
+            allow *= float(np.clip(short, 0.85, 1.15)) ** 0.5
+        if np.allclose(new, rho, atol=0.01) and abs(short - 1.0) < 0.05:
+            break
+        analyzed, rho = rho, new
+    else:
+        rho = analyzed           # report the field that was analyzed
+    rho_grid = np.zeros(active.shape)
+    rho_grid[tuple(ijk.T)] = rho
+    se_grid = np.zeros(active.shape)
+    se_grid[tuple(ijk.T)] = se
+    mask = np.zeros(active.shape, bool)
+    mask[tuple(ijk.T)] = True
+    info = {"analysisPitch": pitch, "analysisCells": int(hm.n_elem), "history": history,
+            "predictedSF": history[-1]["predictedSF"],
+            "solidCellFraction": float((rho[lattice_cell] >= 1).mean()) if lattice_cell.any() else 0.0}
+    return rho_grid, se_grid, mask, r, info
+
+
+def _use_tensors(o) -> bool:
+    import os
+
+    from .lattice_tensors import has_tensors
+
+    on = o.anisotropic
+    if on is None:
+        on = os.environ.get("LOADPATH_LATTICE_ANISO", "1").strip() not in ("0", "false", "off")
+    return bool(on) and has_tensors(o.kind)
+
+
+def _tensor_need(kind, us, hm, mat, rho, rho_max, cand, cand_t, allow, center_strain, stress_surface, c_solid):
+    """Fully-stressed sizing on the cell tensors: each cell's macro stress
+    (its lattice tensor at the density it was analyzed at, a solid cell as
+    the densest lattice) held while the density changes, the least
+    candidate density whose wall stress surface stays under `allow` in every
+    load case (log-interpolated between candidates; above rho_max where none
+    does). Also the walls' stress at the analyzed density and the solid's
+    von Mises, both worst over the cases."""
+    from .fem import von_mises
+    from .lattice_tensors import tensors_at
+
+    r_eval = np.minimum(rho, rho_max)
+    c_now, p_now, q_now, f_now = tensors_at(kind, r_eval)
+    Ck, Pk, Qk, Fk = cand_t
+    worst = np.zeros((len(rho), len(cand)))
+    wall_now = np.zeros(len(rho))
+    se = np.zeros(len(rho))
+    for u in us:
+        eps = center_strain(hm, u)
+        se = np.maximum(se, von_mises(mat.E * eps @ c_solid.T))
+        sig = mat.E * np.einsum("eab,eb->ea", c_now, eps)
+        wall_now = np.maximum(wall_now, stress_surface(sig, p_now, q_now, f_now))
+        for j in range(len(cand)):
+            worst[:, j] = np.maximum(worst[:, j], stress_surface(sig, Pk[j], Qk[j], Fk[j]))
+    ok = worst <= allow
+    first = np.where(ok.any(axis=1), ok.argmax(axis=1), len(cand))
+    need = np.full(len(rho), 1.5 * rho_max)
+    at = first < len(cand)
+    need[at] = cand[first[at]]
+    mid = at & (first > 0)
+    j = first[mid]
+    lw0, lw1 = np.log(worst[mid, j - 1]), np.log(worst[mid, j])
+    t = np.clip((lw0 - np.log(allow)) / np.maximum(lw0 - lw1, 1e-12), 0.0, 1.0)
+    need[mid] = np.exp(np.log(cand[j - 1]) + t * (np.log(cand[j]) - np.log(cand[j - 1])))
+    return need, wall_now, se
+
+
+def _to_fine(coarse, mask, r, dims):
+    """Trilinear upsampling of a per-analysis-cell field to the fine grid,
+    the cells outside the analysis filled from their nearest neighbour."""
+    idx = ndimage.distance_transform_edt(~mask, return_distances=False, return_indices=True)
+    filled = coarse[tuple(idx)]
+    coords = [(np.arange(n) + 0.5) / r - 0.5 for n in dims]
+    out = np.empty(dims, np.float32)
+    gy, gz = np.meshgrid(coords[1], coords[2], indexing="ij")
+    for i, x in enumerate(coords[0]):    # a slab at a time keeps the coordinates small
+        out[i] = ndimage.map_coordinates(filled, [np.full_like(gy, x), gy, gz], order=1, mode="nearest")
+    return out
+
+
+def _capsule(pts, a, b, radius):
+    ab = b - a
+    t = np.clip(((pts - a) @ ab) / (ab @ ab), 0.0, 1.0)
+    return np.linalg.norm(pts - (a + t[:, None] * ab), axis=1) - radius
+
+
+def _local(lo, step, shape, a, b, reach):
+    """The grid block round segment a-b out to `reach`, and its points."""
+    box_lo = np.floor((np.minimum(a, b) - reach - lo) / step - 1).astype(int).clip(0)
+    box_hi = np.ceil((np.maximum(a, b) + reach - lo) / step + 1).astype(int).clip(None, np.array(shape))
+    bs = tuple(slice(x0, x1) for x0, x1 in zip(box_lo, box_hi))
+    ii = np.stack(np.meshgrid(*[np.arange(x0, x1) for x0, x1 in zip(box_lo, box_hi)], indexing="ij"), -1)
+    return bs, lo + (ii.reshape(-1, 3) + 0.5) * step, ii.shape[:3]
+
+
+def _drains(o, d, dp, d_collar, stress, lo, step, process):
+    """Pockets too small to drain (a mask, to fill solid), and drain holes
+    from every other enclosed void to the outside: (a, b, radius, report)
+    per hole, a running from inside the void out through the skin.
+
+    Holes go where the part is calmest, just under the skin on a flat face
+    clear of everything the user drew, two per void well apart so powder
+    can be blown and resin rinsed through. Each gets a solid boss."""
+    material = d < 0.0
+    lbl, n = ndimage.label(~material)
+    open_ids = set(np.unique(lbl[dp > 0.0]).tolist())
+    vox = step ** 3
+    sizes = ndimage.sum_labels(np.ones_like(lbl), lbl, index=np.arange(1, n + 1))
+    fill = o.fill_pockets if o.fill_pockets is not None else o.cell ** 3 / 8.0
+    trapped = [i for i in range(1, n + 1) if i not in open_ids]
+    small = [i for i in trapped if sizes[i - 1] * vox < fill]
+    pockets = np.isin(lbl, small) if small else None
+    big = [i for i in trapped if i not in small]
+    holes = []
+    if not big or o.drains == "no" or (o.drains == "auto" and (process is None or process.kind == "fdm")):
+        return pockets, holes
+    if o.drain_diameter is not None:
+        dia = o.drain_diameter
+    else:
+        from .processcheck import RULES
+
+        dia = getattr(process, "escape_hole", None) or \
+            (RULES[process.kind]["escapeHole"] if process.kind in RULES else 3.0 if process.kind == "volumetric" else 4.0)
+    rad = 0.5 * dia
+    axis, sign = process.build if process is not None and process.build is not None else (2, 1)
+    objs = ndimage.find_objects(lbl)
+    for i in big:
+        sl = objs[i - 1]
+        comp = lbl[sl] == i
+        depth = -dp[sl]
+        cand = comp & (depth < o.skin + 3.0 * step) & (d_collar[sl] > rad + o.collar + 1.0)
+        if not cand.any():
+            cand = comp & (depth <= depth[comp].min() + step)
+        idx = np.argwhere(cand)
+        sv = stress[sl][cand]
+        off = np.asarray([s_.start for s_ in sl])
+        # a hole is a stress raiser (about 3x in a plate): the calmest flat
+        # site first, then the calmest one well away from it, so air or
+        # rinse can flow through; on a tie, lower along the build drains
+        order = np.lexsort((idx[:, axis] * sign, np.round(sv, 1)))
+        reach = rad + max(o.collar, o.wall_max)
+        extent = float(np.linalg.norm((idx.max(axis=0) - idx.min(axis=0)) * step))
+        picks = []
+        for j in order[:2000]:
+            pt0 = lo + (off + idx[j] + 0.5) * step
+            if picks and np.linalg.norm(pt0 - picks[0][0]) < max(4.0 * dia, 0.5 * extent):
+                continue
+            site = _drain_site(dp, tuple(off + idx[j]), lo, step, reach)
+            if site is not None:
+                picks.append(site)
+                if len(picks) == 2:
+                    break
+        for pt, nrm, g in picks:
+            b = pt + nrm * (-dp[g] + 1.5)
+            holes.append((pt, b, rad, {"at": (pt + nrm * -dp[g]).tolist(), "normal": nrm.tolist(),
+                                      "diameter": dia, "stress": float(stress[g])}))
+    return pockets, holes
+
+
+def _drain_site(dp, g, lo, step, reach):
+    """The site's point and outward normal, if the surface over it is flat
+    out to `reach`: a hole on an edge or a corner loses half its boss to
+    the edge and is where the stress concentrates."""
+    nb = tuple(slice(max(c - 2, 0), c + 3) for c in g)
+    gr = np.array([np.gradient(dp[nb], step, axis=k).mean() for k in range(3)])
+    nrm = gr / max(np.linalg.norm(gr), 1e-9)
+    pt = lo + (np.asarray(g) + 0.5) * step
+    surf = pt + nrm * -dp[g]
+    u = np.cross(nrm, [1.0, 0.0, 0.0] if abs(nrm[0]) < 0.9 else [0.0, 1.0, 0.0])
+    u /= np.linalg.norm(u)
+    v = np.cross(nrm, u)
+    ang = np.linspace(0.0, 2.0 * np.pi, 12, endpoint=False)
+    ring = surf + reach * (np.cos(ang)[:, None] * u + np.sin(ang)[:, None] * v)
+    ijk = np.floor((ring - lo) / step).astype(int)
+    if (ijk < 0).any() or (ijk >= np.array(dp.shape)).any():
+        return None
+    if np.abs(dp[tuple(ijk.T)]).max() > 1.5 * step:
+        return None
+    return pt, nrm, g
+
+
+def _trapped(d, dp, step):
+    lbl, n = ndimage.label(d >= 0.0)
+    open_ids = np.unique(lbl[dp > 0.0])
+    tr = (lbl > 0) & ~np.isin(lbl, open_ids)
+    return float(tr.sum() * step ** 3), int(len(np.setdiff1d(np.arange(1, n + 1), open_ids)))
+
+
+def lattice_infill(study: Study, mesh, fields: dict | None = None, opts: LatticeOptions | None = None):
+    """Returns (trimesh.Trimesh, info). With `opts.target_sf` the wall is
+    sized by the homogenized analysis (see the module docstring); otherwise
+    `fields` is verify_part(..., fields=True)["fields"] for the solid part,
+    and without it the lattice is uniform at wall_min. `mesh` is the solid
+    to fill: a topology-optimized part, or `envelope_mesh(study)` to keep
+    the envelope's outer shape."""
+    import manifold3d as m3d
+    import trimesh
+    from skimage.measure import marching_cubes
+
+    from .reconstruct import _smooth_union
+    from .shapes import manifold_from_trimesh, trimesh_from_manifold
+
+    o = opts or LatticeOptions()
+    process = study.process
+    lo, hi = mesh.bounds
+    lo = lo - 2.0 * o.wall_max
+    hi = hi + 2.0 * o.wall_max
+    step = o.step or o.wall_min / 2.5
+    step = max(step, (float(np.prod(hi - lo)) / o.max_points) ** (1.0 / 3.0))
+    dims = tuple(np.maximum(np.ceil((hi - lo) / step).astype(int), 2))
+    d_part = _part_distance(mesh, step, lo, dims)
+    inside = d_part < 0
+
+    idx = np.stack(np.meshgrid(*[np.arange(n) for n in dims], indexing="ij"), -1).reshape(-1, 3)
+    pts = lo + (idx + 0.5) * step
+    del idx
+    flat_in = inside.ravel()
+    d_collar = np.full(len(pts), np.inf)
+    if o.collar > 0:
+        d_collar[flat_in] = _collar_distance(study, pts[flat_in], o.collar)
+    d_collar = d_collar.reshape(dims)
+    sizing = None
+    stress = np.zeros(dims, np.float32)
+    if o.target_sf:
+        zone = (d_part > -o.skin) | (d_collar < 0)
+        rho_c, se_c, mask, r, sizing = _size(study, o, lo, step, inside, zone)
+        rho = _to_fine(rho_c, mask, r, dims)
+        stress = _to_fine(se_c, mask, r, dims)
+        rho_max = float(relative_density(o.kind, o.wall_max, o.cell))
+        wall = np.clip(wall_for_density(o.kind, np.minimum(rho, rho_max), o.cell), o.wall_min, o.wall_max)
+        d_cells = _signed_distance(rho > 0.5 * (1.0 + rho_max), step)
+        util = None
+    else:
+        util = np.zeros(len(pts))
+        if fields is not None:
+            from scipy.spatial import cKDTree
+
+            vm = np.max([c["vonMises"] for c in fields["cases"]], axis=0)
+            allow = study.material.strength / o.safety_factor
+            tree = cKDTree(fields["nodes"])
+            dist, near = tree.query(pts[flat_in], k=4)
+            w = 1.0 / np.maximum(dist, 1e-6) ** 2
+            util[flat_in] = (w * vm[near]).sum(axis=1) / w.sum(axis=1) / allow
+        # wall from utilization, square-root graded so moderate stress already
+        # thickens it; solid above solid_above
+        u = np.clip(util / o.solid_above, 0.0, 1.0)
+        wall = (o.wall_min + (o.wall_max - o.wall_min) * np.sqrt(u)).reshape(dims)
+        d_cells = ((o.solid_above - util) * o.cell).reshape(dims)
+        stress = (util * study.material.strength / o.safety_factor).reshape(dims)
+    # marching cubes reads a 2.5-sample wall about 5% thin: a hair more
+    # keeps the thinnest wall at the process minimum
+    d_lat = (np.abs(tpms(o.kind, pts, o.cell)) - 0.5 * wall.ravel() - 0.15 * step).reshape(dims)
+    del pts
+    d_solid = np.minimum(d_cells, d_collar)
+    if o.skin > 0:
+        d_solid = np.minimum(d_solid, -d_part - o.skin)
+    blend = o.blend or o.wall_max
+    d = np.maximum(d_part, _smooth_union(d_lat, d_solid, blend))
+    # how much of d follows the lattice term (1 in the open lattice, fading
+    # through the blend, 0 in solid, skin, pockets and holes): the exact
+    # surface below corrects d by this much of the TPMS's own sampling error
+    sens = _lattice_share(d_lat, d_solid, d_part, blend) if o.exact_surface else None
+    del d_cells
+
+    # a boss can wall off a scrap of channel next to it: a second round
+    # fills or drains whatever the first left
+    filled = 0.0
+    all_holes = []
+    boss = max(o.collar, o.wall_max)
+    for _ in range(3):
+        pockets, holes = _drains(o, d, d_part, d_collar, stress, lo, step, process)
+        if pockets is not None:
+            d = np.where(pockets, -0.5 * step, d)
+            if sens is not None:
+                sens[pockets] = 0.0
+            filled += float(pockets.sum() * step ** 3)
+        if not holes:
+            break
+        for a, b, rad, _ in holes:
+            bs, hp, shp = _local(lo, step, d.shape, a, b, rad + boss + blend)
+            cap = _capsule(hp, a, b, rad).reshape(shp)
+            ds = np.minimum(d_solid[bs], cap - boss)
+            new = np.maximum(d_part[bs], _smooth_union(d_lat[bs], ds, blend))
+            if sens is not None:
+                sens[bs] = np.where(new < d[bs], _lattice_share(d_lat[bs], ds, d_part[bs], blend), sens[bs])
+            d[bs] = np.minimum(d[bs], new)
+            d_solid[bs] = ds
+        for a, b, rad, _ in all_holes + holes:
+            # through the boss's rounded end and on into the void
+            a = a - (b - a) / np.linalg.norm(b - a) * (boss + rad + blend)
+            bs, hp, shp = _local(lo, step, d.shape, a, b, rad)
+            cut = -_capsule(hp, a, b, rad).reshape(shp)
+            if sens is not None:
+                sens[bs] = np.where(cut > d[bs], 0.0, sens[bs])
+            d[bs] = np.maximum(d[bs], cut)
+        all_holes += holes
+    holes = all_holes
+    holes = [h[3] for h in holes]
+    del d_solid
+    trapped_vol, trapped_n = _trapped(d, d_part, step)
+
+    if o.exact_surface:
+        lat = _exact_mesh(o, d, d_lat, sens, wall, lo, step)
+    else:
+        verts, faces, _, _ = marching_cubes(d, 0.0, spacing=(step, step, step))
+        verts = verts + lo + 0.5 * step
+        lat = trimesh.Trimesh(verts, faces[:, ::-1], process=True)
+    del d_lat, sens
+    if lat.volume < 0:
+        lat.invert()
+    part = manifold_from_trimesh(lat)
+    solid_vol = float(manifold_from_trimesh(mesh).volume())
+    # the user's geometry stays exact: preserved shapes solid, keep-outs clear
+    if study.preserve:
+        part = part + m3d.Manifold.batch_boolean([r.shape.to_manifold() for r in study.preserve],
+                                                 m3d.OpType.Add)
+        part = part ^ manifold_from_trimesh(mesh)
+    if study.keep_out:
+        part = part - m3d.Manifold.batch_boolean([r.shape.to_manifold() for r in study.keep_out],
+                                                 m3d.OpType.Add)
+    # Drop lattice fragments the trim cut loose. (decompose() also returns
+    # each enclosed cavity, as a negative volume: those stay.)
+    pieces = part.decompose()
+    big = max(b.volume() for b in pieces)
+    loose = [b for b in pieces if 0 < b.volume() < 0.01 * big]
+    for b in loose:
+        part = part - b
+    out = trimesh_from_manifold(part)
+    vol = float(part.volume())
+    info = {"kind": o.kind, "cell": o.cell, "skin": o.skin, "wallMin": o.wall_min, "wallMax": o.wall_max,
+            "step": step, "volume": vol, "solidVolume": solid_vol, "volumeRatio": vol / solid_vol,
+            "mass": vol * study.material.density / 1000.0, "graded": fields is not None or bool(o.target_sf),
+            "sizing": sizing, "droppedBodies": len(loose),
+            "solidFraction": float((util[flat_in] >= o.solid_above).mean()) if util is not None and flat_in.any()
+            else (sizing or {}).get("solidCellFraction", 0.0)}
+    info["printability"] = _printability(out, d, d_part, lo, step, o, process, holes, filled, trapped_vol, trapped_n)
+    # what stays walled in, where powder or resin would be trapped
+    info["enclosedVoid"] = trapped_vol
+    return out, info
+
+
+def _lattice_share(d_lat, d_solid, d_part, blend, eps=1e-3):
+    """d(d) / d(d_lat) for d = max(d_part, smooth_union(d_lat, d_solid))."""
+    from .reconstruct import _smooth_union
+
+    su = _smooth_union(d_lat, d_solid, blend)
+    share = (_smooth_union(d_lat + eps, d_solid, blend) - su) / eps
+    return np.where(su >= d_part, share, 0.0).astype(np.float32)
+
+
+def _exact_mesh(o, d, d_lat, sens, wall, lo, step):
+    """The lattice part meshed from its field with the TPMS evaluated
+    exactly: the sampled field d, trilinear between samples, plus `sens`
+    times the TPMS term's own error there (exact sheet minus its trilinear
+    samples, which also drops the samples' 0.15 step allowance for
+    marching cubes reading walls thin). The slow parts (part distance,
+    collars, sizing, drains) stay on the grid; the sheet, which is what a
+    grid gets wrong (facets, walls ~0.03 mm off), comes out on its exact
+    surface, projected by fields.field_mesh."""
+    from .fields import field_mesh
+
+    wall = np.broadcast_to(np.asarray(wall, np.float32), d.shape)
+    grids = [np.asarray(g, np.float32) for g in (d, d_lat, sens, wall)]
+    lo = np.asarray(lo, float)
+
+    def f(P):
+        c = ((P - lo) / step - 0.5).T
+        di, li, si, wi = (ndimage.map_coordinates(g, c, order=1, mode="nearest") for g in grids)
+        le = np.abs(tpms(o.kind, P, o.cell)) - 0.5 * wi
+        return di + si * (le - li)
+
+    hi = lo + (np.array(d.shape) - 0.5) * step
+    return field_mesh(f, lo + 0.5 * step, hi, pitch=step)
+
+
+def _wall_thickness(d, step):
+    """(p1, p5) wall thickness, mm, from the field itself: twice the depth of
+    the medial ridge, interpolated by the field's own distance there. No ray
+    casts: on a lattice mesh of millions of faces, trimesh's ray fallback
+    (without embree) runs out of memory."""
+    depth = np.maximum(-d, 0.0)
+    ridge = (depth > 0) & (depth >= ndimage.maximum_filter(depth, size=3))
+    vals = 2.0 * depth[ridge] + 0.5 * step
+    if vals.size == 0:
+        return None, None
+    return float(np.percentile(vals, 1)), float(np.percentile(vals, 5))
+
+
+def _printability(mesh, d, dp, lo, step, o, process, holes, filled, trapped_vol, trapped_n):
+    p1, p5 = _wall_thickness(d, step)
+    min_feature = process.min_feature if process is not None else 0.8
+    rep = {"process": process.kind if process is not None else None, "minFeature": min_feature,
+           "wallP1": p1, "wallP5": p5, "wallOk": p1 is not None and p1 >= 0.9 * min_feature,
+           "drainHoles": holes, "filledPocketVolume": filled,
+           "trappedVolume": trapped_vol, "trappedVoids": trapped_n}
+    if process is None or process.kind != "fdm":
+        rep["drainOk"] = trapped_vol < 1.0
+    # the lattice's own ceilings and the skin's over it (inside the part): FDM
+    # bridges these, so report how much faces down past the 45 degree limit
+    if process is not None and process.build is not None:
+        axis, sign = process.build
+        up = np.zeros(3)
+        up[axis] = sign
+        c = mesh.triangles_center
+        ijk = np.clip(((c - lo) / step).astype(int), 0, np.array(dp.shape) - 1)
+        interior = dp[tuple(ijk.T)] < -(0.5 * o.skin + step)
+        down = -(mesh.face_normals @ up) > np.cos(np.radians(40.0))
+        a = mesh.area_faces
+        rep["internalOverhangFraction"] = float(a[interior & down].sum() / max(a[interior].sum(), 1e-9))
+    return rep