loadpath 0.1.1__py3-none-any.whl

loadpath/sizing.py

@@ -0,0 +1,312 @@
+"""
+Size a two-fluid TPMS heat exchanger for a duty: the core's dimensions
+inside an envelope, the cell, the wall, the split of the void between the
+fluids and each fluid's ports, under a pressure-drop budget per fluid and
+the print process's limits. Seconds: it sweeps the epsilon-NTU rating
+(heatx_thermal.rate), corrected for what the whole-exchanger simulation
+and the LBM showed the rating misses, and the best few can then be
+designed and simulated whole (`verify`).
+
+What the rating misses, and how it is put back:
+
+- Edge bands. Outside its own zones each fluid is sealed within `cap` of
+  the core's surface, and partial channels next to that seal carry
+  almost nothing (porous.py, fitted to LBM of the 30 mm crossflow cube).
+  So each sealed face loses a band about `cap + cell / 4` deep from the
+  core that actually works. On a core a few cells across that is a third
+  of it; it is why small cells (more cells across) win more than the
+  rating alone says.
+- Ports. A port that jets into its plenum loses more than the rating's
+  1.5 velocity heads, and on the cube a 6 mm port at 1 L/min lost more
+  at the core's face than the porous medium can show. Each port is sized
+  so its velocity heads stay under a share of the fluid's budget
+  (`port_share`), as large as its face allows.
+- Plenums. The port turns into its plenum through a ring pi d around and
+  `header` deep; a velocity head of that speed in and out is added. On
+  Connor's intercooler duty (0.143 kg/s charge air) a 6 mm plenum behind
+  a 47 mm port cost more than the core, so the header depth is swept too
+  (6-20 mm) and pays for itself out of the envelope.
+
+Checked whole (porous.simulate_box, 3 mm voxels) on intercooler-sized
+cores 200 x 70-100 x 62 mm: effectiveness within 5% (the sim reads
+higher), core pressure drop within 10%.
+
+The envelope is the part's bounding box. Each face with a zone gives up
+header + shell + port length to its plenum and port; the other faces a
+shell.
+
+Process limits (walls that hold pressure and stay leak-tight, channels
+that drain powder or resin): `PROCESS_LIMITS`.
+"""
+from __future__ import annotations
+
+import itertools
+
+import numpy as np
+
+from .heatx_thermal import WALL_DENSITY, _flow, _fluid, rate, tpms_geometry
+
+__all__ = ["PROCESS_LIMITS", "size_exchanger", "verify"]
+
+# per process: thinnest leak-tight wall (mm), narrowest channel (hydraulic diameter, mm,
+# to clear powder or drain resin), and the heatx process that builds it
+PROCESS_LIMITS = {
+    "fdm": {"minWall": 0.8, "minChannel": 1.5, "heatx": "fdm"},
+    "lpbf": {"minWall": 0.5, "minChannel": 2.0, "heatx": "lpbf"},
+    "sls": {"minWall": 0.8, "minChannel": 2.5, "heatx": "lpbf"},
+    "mjf": {"minWall": 0.8, "minChannel": 2.5, "heatx": "lpbf"},
+    "sla": {"minWall": 0.6, "minChannel": 1.5, "heatx": "lpbf"},
+    "dlp": {"minWall": 0.6, "minChannel": 1.5, "heatx": "lpbf"},
+}
+
+from .porous import _BAND_CELLS  # noqa: E402  (the dead band under a sealed face, in cells, beyond the seal)
+
+
+# port speed to aim for (m/s) when the face has room: whole-exchanger sims put 3-5
+# velocity heads in the headers, so a port sized only to the budget leaves a
+# liquid side over it (intercooler coolant: 11.5 mm port, 18 kPa of headers; 22 mm, 1.8)
+_PORT_SPEED = {"liquid": 1.0, "gas": 25.0}
+
+
+def _port(m, fl, dp_budget, share, d_max, d_min=4.0):
+    """The port (mm, 0.5 mm steps): wide enough that its 1.5 velocity heads
+    stay under `share` of the budget and its speed under _PORT_SPEED, as the
+    face allows. Returns (d, whether the face capped it below the budget's)."""
+    v_aim = _PORT_SPEED["liquid" if fl.rho > 100 else "gas"]
+    if dp_budget is None or not np.isfinite(dp_budget):
+        v = v_aim
+    else:
+        v = np.sqrt(share * dp_budget / (0.75 * fl.rho))
+    d_need = 2e3 * np.sqrt(m / (fl.rho * np.pi * v))
+    d = max(d_need, min(2e3 * np.sqrt(m / (fl.rho * np.pi * v_aim)), d_max))
+    d = max(d_min, np.ceil(d * 2.0) / 2.0)
+    return float(min(d, d_max)), d_need > d_max
+
+
+def size_exchanger(duty: dict, envelope, *, process: str = "fdm", max_pressure_drop: dict | None = None,
+                   layout: str = "auto", kind: str = "gyroid", cells=None, walls=None, splits=(0.4, 0.5, 0.6, 0.66),
+                   min_effectiveness: float | None = None, target_duty: float | None = None,
+                   objective: str = "mass", header: float | None = None, shell: float | None = None,
+                   port_length: float = 8.0, cap: float | None = None, port_share: float = 0.25,
+                   fractions=(0.4, 0.55, 0.7, 0.85, 1.0), keep: int = 8, min_wall: float | None = None,
+                   axes: str | None = None, max_points: int | None = None) -> dict:
+    """Sweep the core's dimensions (fractions of what the envelope leaves),
+    cell, wall, split and layout for `duty` ({"A": {"fluid", "kgPerS" |
+    "lPerMin", "tIn"}, "B": {...}, "wall": material}). `envelope` (mm) is
+    the part's [x, y, z] extent; one fluid runs along x and the other
+    along y (cross), or back along the first with side ports on the other
+    (counter), both ways round; z carries no ports. Keeps designs within
+    `max_pressure_drop` ({fluid: Pa}) and, if given, `min_effectiveness`
+    or `target_duty` (W). `objective`: "mass" (lightest that meets them),
+    "effectiveness" (best), or "pressure" (least of the worst fluid's
+    share of its budget; "metal" is "mass"). Returns the best few, each
+    with a heatx spec ready to design ("spec"): its core centred in the
+    envelope's frame (the box from [0, 0, 0] to `envelope`), so ports and
+    plenums land inside it.
+
+    `min_wall` (mm) floors the walls swept (the default walls start at the
+    process's minimum);
+    `axes` ("xy" or "yx") pins which way fluid A runs (A along axes[0]);
+    without it both are tried. Only candidates the design step can mesh
+    within `max_points` grid points (heatx's cap, default 16M: a grid of at
+    most wall / 2) are returned; "unmeshable" counts those dropped.
+    "solidVolume" and "coreMass" are the core's sheet only: the shell,
+    plenums and ports add to it (the design's report.mass is the part)."""
+    from .heatx import HeatExchangerSpec, grid_plan, heat_exchanger_from_spec
+
+    if process not in PROCESS_LIMITS:
+        raise ValueError(f"process is one of {sorted(PROCESS_LIMITS)}")
+    objective = "mass" if objective == "metal" else objective
+    if objective not in ("mass", "effectiveness", "pressure"):
+        raise ValueError('objective is "mass", "effectiveness" or "pressure"')
+    if axes is not None and axes not in ("xy", "yx"):
+        raise ValueError(f"sizing puts the ports on the envelope's x and y faces (z, the build axis, carries "
+                         f"none): axes is \"xy\" (the first fluid along x) or \"yx\", got {axes!r}; turn the "
+                         "envelope so the ports face x and y")
+    max_points = int(max_points or HeatExchangerSpec.max_points)
+    lim = PROCESS_LIMITS[process]
+    names = [n for n in duty if n != "wall"]
+    if len(names) != 2:
+        raise ValueError("duty names two fluids")
+    fls = [_fluid(duty[n].get("fluid", "water")) for n in names]
+    ms = [_flow(duty[n], f) for n, f in zip(names, fls)]
+    t_in = [duty[n].get("tIn") for n in names]
+    caps = [m * f.cp for m, f in zip(ms, fls)]
+    if target_duty is not None:
+        if None in t_in:
+            raise ValueError("target_duty needs each fluid's tIn")
+        min_effectiveness = max(min_effectiveness or 0.0, target_duty / (min(caps) * abs(t_in[0] - t_in[1])))
+    budget = max_pressure_drop or {}
+    wall_mat = duty.get("wall", "petg")
+    density = WALL_DENSITY.get(wall_mat) if isinstance(wall_mat, str) else None
+    shell = shell if shell is not None else max(1.6, 2 * lim["minWall"])
+    env = np.asarray(envelope, float)
+    headers = [float(header)] if header is not None else [6.0, 9.0, 12.0, 16.0, 20.0]
+    # the process's minimum floors the default walls; min_wall floors any
+    floor = max(lim["minWall"] if walls is None else 0.0, float(min_wall or 0.0))
+    walls = [w for w in (walls if walls is not None else (0.5, 0.6, 0.8, 1.0, 1.2, 1.5)) if w >= floor - 1e-9]
+    if not walls:
+        raise ValueError(f"no wall to sweep at or over {floor:g} mm")
+    cells = cells if cells is not None else [4.0, 5.0, 6.0, 7.0, 8.0, 10.0, 12.0, 14.0]
+    layouts = ["cross", "counter"] if layout == "auto" else [layout]
+    rows, rejected = [], 0
+    axes_tried = (axes,) if axes else ("xy", "yx")
+    for hd, lay, axes in itertools.product(headers, layouts, axes_tried):
+        allow = hd + shell + port_length
+        # what the envelope leaves the core: A's zones on its axis, B's on the other (both
+        # layouts); `room` is in A's frame (A along its first entry)
+        e = env if axes == "xy" else env[[1, 0, 2]]
+        room = np.array([e[0] - 2 * allow, e[1] - 2 * allow, e[2] - 2 * shell])
+        if (room <= 0).any():
+            continue
+        for fx, fy, fz in itertools.product(fractions, repeat=3):
+            dims = room * np.array([fx, fy, fz])
+            for a, t, sp in itertools.product(cells, walls, splits):
+                if a < 3 * t or min(dims) < a:
+                    continue
+                cp_ = cap if cap is not None else t + 1.0
+                try:
+                    geo = tpms_geometry(kind, a, t, sp)
+                except ValueError:
+                    continue
+                if min(g["dh"] for g in geo["sides"]) < lim["minChannel"]:
+                    continue
+                # the band each sealed face loses, and the core that works
+                band = cp_ + _BAND_CELLS * a
+                eff_dims = dims - 2 * band
+                if (eff_dims <= 0.25 * dims).any():
+                    continue
+                v_eff = float(np.prod(eff_dims))
+                if lay == "cross":
+                    lengths = [dims[0], dims[1]]
+                    frontal = [eff_dims[1] * eff_dims[2], eff_dims[0] * eff_dims[2]]
+                    faces = [(dims[1], dims[2]), (dims[0], dims[2])]
+                else:
+                    lengths = [dims[0], dims[0]]
+                    frontal = [eff_dims[1] * eff_dims[2], eff_dims[1] * eff_dims[2]]
+                    faces = [(dims[1], dims[2]), (0.4 * dims[0], dims[2])]
+                ports, too_big = [], False
+                for i, n in enumerate(names):
+                    d_max = min(faces[i]) - 2 * cp_ - 2.0
+                    d, over = _port(ms[i], fls[i], budget.get(n, np.inf), port_share, d_max)
+                    ports.append(d)
+                    too_big |= over
+                # the port turns into the plenum through a ring pi d deep `header`: a
+                # velocity head of that speed (whole-exchanger sims put most of the
+                # header loss there; a shallow plenum on a big air port dominates)
+                if min(ports) < 3.0:
+                    continue
+                # rate the working core: its volume, each fluid's frontal area through
+                # its full length (so the dead bands still cost pressure)
+                r = rate(kind, a, t, v_eff, [v_eff / f for f in frontal],
+                         {**{n: duty[n] for n in names}, "wall": wall_mat},
+                         "counter" if lay == "counter" else "cross", tuple(ports), split=sp)
+                dp, plen = {}, {}
+                for i, n in enumerate(names):
+                    s = r["fluids"][n]
+                    v_ring = ms[i] / (fls[i].rho * np.pi * ports[i] * 1e-3 * hd * 1e-3)
+                    plen[n] = 2 * 0.5 * fls[i].rho * v_ring ** 2  # in and out
+                    dp[n] = s["pressureDropCore"] * lengths[i] / (v_eff / frontal[i]) + \
+                        s["pressureDropPorts"] + s["pressureDropMouths"] + plen[n]
+                solid = float(np.prod(dims)) * (1.0 - geo["phiSheet"])
+                world = dims if axes == "xy" else dims[[1, 0, 2]]
+                row = {"layout": lay, "axes": axes, "fluidAxes": dict(zip(names, axes)),
+                       "core": np.round(world, 1).tolist(), "cell": float(a), "wall": float(t),
+                       "split": float(sp), "cap": cp_, "header": hd,
+                       "pressureDropPlenums": plen, "ports": dict(zip(names, ports)),
+                       "effectiveness": r["effectiveness"], "effectivenessRange": r["effectivenessRange"],
+                       "duty": r.get("duty"), "tOut": r.get("tOut"), "pressureDrop": dp,
+                       "workingCore": round(v_eff / float(np.prod(dims)), 3),
+                       "solidVolume": solid, "coreMass": solid * density / 1000.0 if density else None,
+                       "portLimited": bool(too_big)}
+                ok = all(dp[n] <= budget.get(n, np.inf) for n in names) and \
+                    (min_effectiveness is None or r["effectiveness"] >= min_effectiveness)
+                if ok:
+                    rows.append(row)
+                else:
+                    rejected += 1
+    if objective == "mass":
+        rows.sort(key=lambda x: (x["solidVolume"], -x["effectiveness"]))
+    elif objective == "effectiveness":
+        rows.sort(key=lambda x: -x["effectiveness"])
+    else:
+        rows.sort(key=lambda x: max(x["pressureDrop"][n] / budget.get(n, 1.0) for n in names))
+    best, unmeshable, nearest = [], 0, None
+    for x in rows:
+        # skip near-duplicates (same cell, wall and layout) so the list shows real options
+        if any(b["cell"] == x["cell"] and b["wall"] == x["wall"] and b["layout"] == x["layout"]
+               and b["axes"] == x["axes"] for b in best):
+            continue
+        spec = _spec(x, names, kind, x["header"], shell, port_length, lim["heatx"], duty, env)
+        # only what the design step can mesh within its point cap
+        hx = heat_exchanger_from_spec({k: v for k, v in spec.items() if k not in ("name", "duty")})
+        hx.max_points = max_points
+        plan = grid_plan(hx)
+        if not plan["fits"]:
+            unmeshable += 1
+            nearest = plan if nearest is None or plan["maxPointsNeeded"] < nearest["maxPointsNeeded"] else nearest
+            continue
+        x["spec"] = spec
+        x["grid"] = {k: plan[k] for k in ("step", "points", "peakMemoryGB")}
+        best.append(x)
+        if len(best) >= keep:
+            break
+    out = {"best": best[0] if best else None, "candidates": best, "objective": objective,
+           "considered": len(rows) + rejected, "feasible": len(rows), "process": process,
+           "minEffectiveness": min_effectiveness, "unmeshable": unmeshable, "maxPoints": max_points,
+           "envelopeFrame": {"min": [0.0, 0.0, 0.0], "max": env.tolist()}}
+    if unmeshable:
+        out["note"] = (f"{unmeshable} candidate(s) were dropped: the design step could not mesh them "
+                       f"within {max_points / 1e6:g}M grid points (it needs a grid of at most wall / 2). The "
+                       f"nearest needs {nearest['maxPointsNeeded'] / 1e6:.0f}M points, about "
+                       f"{nearest['memoryNeededGB']:.1f} GB: raise the cap with "
+                       "--max-points if the machine has that, or take a thicker wall")
+    return out
+
+
+def _spec(row, names, kind, header, shell, port_length, heatx_process, duty, envelope=None):
+    c = np.asarray(row["core"], float)
+    # centred in the envelope's frame ([0, 0, 0] to envelope): ports and plenums inside it
+    lo = 0.5 * (np.asarray(envelope, float) - c) if envelope is not None else np.zeros(3)
+    return {"name": f"sized-{row['layout']}-{row['cell']:g}-{row['wall']:g}",
+            "core": {"type": "box", "min": np.round(lo, 2).tolist(), "max": np.round(lo + c, 2).tolist()},
+            "type": kind, "layout": row["layout"],
+            "axes": row["axes"], "fluids": list(names), "cell": row["cell"], "wall": row["wall"],
+            "split": row["split"], "cap": row["cap"], "header": header, "shell": shell,
+            "portLength": port_length, "portDiameter": row["ports"], "process": heatx_process,
+            "duty": duty}
+
+
+def verify(candidate: dict, voxel=None, closures="design", progress=None, max_points=None, method="auto"):
+    """Simulate a sized candidate whole (porous.py): returns the
+    simulation's effectiveness, pressure drops and flow sharing next to the
+    sizing's own. `method` "design" designs it first (heatx, wall-resolving:
+    small cores); "box" builds the porous grid straight from the spec
+    (porous.box_domain, cross layout, any size); "auto" takes "box" for a
+    cross core over 1e5 mm3. The box sim's header losses read 3-5 port
+    velocity heads at 3 mm voxels where cell-resolved LBM of the tuned cube
+    measured ~1.4: take its header dp as an upper bound."""
+    from .heatx import heat_exchanger_from_spec
+    from .porous import simulate_box, simulate_exchanger
+
+    spec = dict(candidate["spec"])
+    duty = spec.pop("duty")
+    hx = heat_exchanger_from_spec(spec)
+    if max_points:
+        hx.max_points = int(max_points)
+    if method == "auto":
+        method = "box" if spec.get("layout") == "cross" and float(np.prod(candidate["core"])) > 1e5 else "design"
+    if method == "box":
+        sim = simulate_box(hx, duty, voxel=voxel, closures=closures, progress=progress)
+        rep = {}
+    else:
+        _, rep, sim = simulate_exchanger(hx, duty, voxel=voxel, closures=closures, progress=progress)
+    return {"sized": {k: candidate[k] for k in ("effectiveness", "pressureDrop", "tOut")},
+            "simulated": {"effectiveness": sim.get("effectiveness"),
+                          "pressureDrop": {n: f["pressureDrop"] for n, f in sim["fluids"].items()},
+                          "tOut": {n: f.get("tOut") for n, f in sim["fluids"].items()},
+                          "midplaneCv": {n: f["midplane"]["cv"] for n, f in sim["fluids"].items()}},
+            "design": {"isolated": rep.get("isolated"), "connected": rep.get("connected"),
+                       "minWallBetweenFluids": rep.get("minWallBetweenFluids"), "solidVolume": rep.get("solidVolume"),
+                       "warnings": rep.get("warnings")},
+            "method": method, "seconds": sim.get("seconds")}

loadpath/slicer.py

@@ -0,0 +1,321 @@
+"""
+A real slicer in the FDM loop: print time, filament and support material
+measured by slicing the delivered part, not modelled.
+
+For an FDM user the cost of a part is mostly hours on the printer, and grams
+are only a proxy for that: two designs of the same mass can print in very
+different times once one of them needs a forest of support. So every FDM
+outcome is sliced headless (PrusaSlicer's command line, or a fork that keeps
+it: SuperSlicer) standing the way it was designed to print, and the G-code
+is read back for
+
+- printTime (s), the slicer's own estimate under its machine limits;
+- filament (mm, cm^3, g), and how much of it is support;
+- the extruded volume of each feature type (perimeters, infill, support...).
+
+`goal.minimize: "printTime"` then picks the fastest passing outcome instead
+of the lightest, and `slicer.grade` (infill.py) turns the verified stress
+into per-region infill and wall counts the slicer prints as modifiers.
+
+The part is verified solid, so the default slice is solid too (100% infill):
+what was analysed is what gets printed. Sparse infill is only safe where the
+stress allows it, which is what grading works out.
+
+The built-in profile is a generic 0.4 mm nozzle, 0.2 mm layer bed slinger at
+moderate speeds (Prusa MK3S class); a CoreXY printer runs two to three times
+faster. Pass your own PrusaSlicer config (`slicer.profile`, an .ini exported
+from File > Export > Export Config) for absolute times; for comparing
+outcomes against each other the generic one is enough.
+
+Orca Slicer and Bambu Studio open the 3MF this writes (PrusaSlicer's
+modifier metadata), but their command lines differ and are not driven here.
+"""
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+import time
+from dataclasses import dataclass, field
+
+import numpy as np
+
+__all__ = ["SlicerOptions", "find_slicer", "slice_mesh", "read_gcode", "DEFAULT_PROFILE"]
+
+# PrusaSlicer config keys. Bed 256 x 256 to match threemf's plate centre.
+DEFAULT_PROFILE = {
+    "printer_technology": "FFF",
+    "gcode_flavor": "marlin2",
+    "bed_shape": "0x0,256x0,256x256,0x256",
+    "max_print_height": "256",
+    "nozzle_diameter": "0.4",
+    "filament_diameter": "1.75",
+    "layer_height": "0.2",
+    "first_layer_height": "0.2",
+    "extrusion_width": "0.45",
+    "perimeter_extrusion_width": "0.45",
+    "external_perimeter_extrusion_width": "0.45",
+    "infill_extrusion_width": "0.45",
+    "solid_infill_extrusion_width": "0.45",
+    "top_infill_extrusion_width": "0.4",
+    "support_material_extrusion_width": "0.35",
+    "perimeters": "3",
+    "top_solid_layers": "5",
+    "bottom_solid_layers": "4",
+    "top_solid_min_thickness": "0.7",
+    "bottom_solid_min_thickness": "0.5",
+    "fill_density": "100%",
+    "fill_pattern": "gyroid",
+    "infill_anchor": "2.5",
+    "perimeter_speed": "45",
+    "small_perimeter_speed": "25",
+    "external_perimeter_speed": "25",
+    "infill_speed": "80",
+    "solid_infill_speed": "80",
+    "top_solid_infill_speed": "40",
+    "support_material_speed": "50",
+    "support_material_interface_speed": "80%",
+    "bridge_speed": "30",
+    "gap_fill_speed": "40",
+    "travel_speed": "180",
+    "first_layer_speed": "20",
+    "max_volumetric_speed": "11.5",
+    "perimeter_acceleration": "800",
+    "infill_acceleration": "1000",
+    "bridge_acceleration": "1000",
+    "first_layer_acceleration": "800",
+    "default_acceleration": "1000",
+    "machine_limits_usage": "time_estimate_only",
+    "machine_max_acceleration_extruding": "1250",
+    "machine_max_acceleration_travel": "1250",
+    "machine_max_acceleration_x": "1000",
+    "machine_max_acceleration_y": "1000",
+    "machine_max_feedrate_x": "200",
+    "machine_max_feedrate_y": "200",
+    "support_material": "1",
+    "support_material_auto": "1",
+    # overhangs flatter than 45 degrees from horizontal get support: the
+    # angle loadpath's overhang control designs to, less printcheck's
+    # 5 degree tolerance
+    "support_material_threshold": "40",
+    "support_material_contact_distance": "0.2",
+    "support_material_spacing": "2",
+    "support_material_style": "grid",
+    "skirts": "1",
+    "brim_width": "0",
+    "use_relative_e_distances": "1",
+    "layer_gcode": "G92 E0",
+    "gcode_comments": "0",
+}
+
+# PrusaSlicer's ";TYPE:" feature names, by what they are
+_SUPPORT_TYPES = ("Support material", "Support material interface")
+_PART_TYPES = ("Perimeter", "External perimeter", "Overhang perimeter", "Internal infill", "Solid infill",
+               "Top solid infill", "Bridge infill", "Gap fill")
+
+_NAMES = ("prusa-slicer", "PrusaSlicer", "prusaslicer", "superslicer", "SuperSlicer")
+
+
+def find_slicer(path: str | None = None) -> str | None:
+    """The slicer executable: `path`, $LOADPATH_SLICER, or PrusaSlicer (or
+    SuperSlicer) on PATH or in its usual macOS place. None if there is none."""
+    for cand in (path, os.environ.get("LOADPATH_SLICER")):
+        if cand:
+            return cand if (os.path.isfile(cand) or shutil.which(cand)) else None
+    for n in _NAMES:
+        p = shutil.which(n)
+        if p:
+            return p
+    for p in ("/Applications/PrusaSlicer.app/Contents/MacOS/PrusaSlicer",
+              "/Applications/Original Prusa Drivers/PrusaSlicer.app/Contents/MacOS/PrusaSlicer"):
+        if os.path.isfile(p):
+            return p
+    return None
+
+
+@dataclass
+class SlicerOptions:
+    enabled: object = "auto"          # "auto": when FDM and a slicer is installed; True: warn if none
+    executable: str | None = None
+    profile: str | None = None        # PrusaSlicer .ini, applied before `settings`
+    settings: dict = field(default_factory=dict)
+    supports: object = "auto"         # "auto"/True: slicer's own auto supports; False: none
+    infill: float = 100.0             # percent infill of the ungraded slice (100 = as verified)
+    timeout: float = 600.0
+    grade: dict | None = None         # infill.GradeOptions spec, or None
+
+    @classmethod
+    def from_spec(cls, spec, base_dir: str | None = None) -> "SlicerOptions":
+        if spec is None:
+            return cls()
+        if isinstance(spec, bool):
+            return cls(enabled=spec)
+        if not isinstance(spec, dict):
+            raise ValueError("slicer is true/false or an object")
+        enabled = spec.get("enabled", "auto")
+        if enabled not in (True, False, "auto"):
+            raise ValueError("slicer.enabled is true, false or \"auto\"")
+        prof = spec.get("profile")
+        if prof is not None and base_dir and not os.path.isabs(prof):
+            prof = os.path.join(base_dir, prof)
+        infill = float(spec.get("infill", 100.0))
+        if not 0.0 <= infill <= 100.0:
+            raise ValueError("slicer.infill is a percentage, 0..100")
+        sup = spec.get("supports", "auto")
+        if sup not in (True, False, "auto"):
+            raise ValueError("slicer.supports is true, false or \"auto\"")
+        settings = spec.get("settings") or {}
+        if not isinstance(settings, dict):
+            raise ValueError("slicer.settings is an object of PrusaSlicer config keys")
+        grade = spec.get("grade")
+        if grade is True:
+            grade = {}
+        elif grade is False:
+            grade = None
+        elif grade is not None and not isinstance(grade, dict):
+            raise ValueError("slicer.grade is true or an object")
+        return cls(enabled=enabled, executable=spec.get("executable"), profile=prof,
+                   settings={str(k): _fmt_setting(v) for k, v in settings.items()}, supports=sup,
+                   infill=infill, timeout=float(spec.get("timeout", 600.0)), grade=grade)
+
+    def config(self) -> dict:
+        """The config keys the slice is run with (the profile file aside)."""
+        cfg = {} if self.profile else dict(DEFAULT_PROFILE)
+        cfg["fill_density"] = f"{self.infill:g}%"
+        if self.infill >= 100.0:
+            cfg["fill_pattern"] = "rectilinear"   # PrusaSlicer refuses gyroid at 100%
+        cfg["support_material"] = "0" if self.supports is False else "1"
+        cfg["use_relative_e_distances"] = "1"     # read_gcode sums E per feature
+        cfg.setdefault("layer_gcode", "G92 E0")    # which PrusaSlicer requires with it
+        cfg.update(self.settings)
+        return cfg
+
+
+def _fmt_setting(v) -> str:
+    if isinstance(v, bool):
+        return "1" if v else "0"
+    if isinstance(v, (list, tuple)):
+        return ",".join(str(x) for x in v)
+    return str(v)
+
+
+def _version(exe: str) -> str:
+    try:
+        out = subprocess.run([exe, "--help"], capture_output=True, text=True, timeout=30).stdout
+    except (OSError, subprocess.SubprocessError):
+        return "unknown"
+    first = out.strip().splitlines()[0] if out.strip() else ""
+    return first.split(" based on")[0].strip() or "unknown"
+
+
+_TIME_RE = re.compile(r"(\d+)\s*([dhms])")
+
+
+def _seconds(text: str) -> float:
+    unit = {"d": 86400, "h": 3600, "m": 60, "s": 1}
+    return float(sum(int(n) * unit[u] for n, u in _TIME_RE.findall(text)))
+
+
+def read_gcode(path: str, density: float | None = None) -> dict:
+    """Print time, filament and per-feature extruded volume from a
+    PrusaSlicer G-code (relative E). `density` g/cm^3 gives grams."""
+    feat: dict[str, float] = {}
+    cur = "Other"
+    meta: dict[str, str] = {}
+    dia = 1.75
+    relative = None
+    with open(path, "r", errors="replace") as fh:
+        for line in fh:
+            if line.startswith(";TYPE:"):
+                cur = line[6:].strip()
+                continue
+            if line.startswith("; ") and " = " in line:
+                k, v = line[2:].split(" = ", 1)
+                meta[k.strip()] = v.strip()
+                continue
+            if line.startswith("M83"):
+                relative = True
+            elif line.startswith("M82"):
+                relative = False
+            if line.startswith("G1 ") or line.startswith("G2 ") or line.startswith("G3 "):
+                i = line.find(" E")
+                if i >= 0:
+                    j = i + 2
+                    k = j
+                    while k < len(line) and (line[k].isdigit() or line[k] in ".-"):
+                        k += 1
+                    try:
+                        e = float(line[j:k])
+                    except ValueError:
+                        continue
+                    if e > 0:
+                        feat[cur] = feat.get(cur, 0.0) + e
+    if "filament_diameter" in meta:
+        dia = float(meta["filament_diameter"].split(",")[0])
+    if relative is False:
+        raise ValueError("read_gcode needs relative extrusion (use_relative_e_distances = 1)")
+    area = np.pi * (0.5 * dia) ** 2 / 1000.0          # cm^3 per mm of filament
+    vol = {k: v * area for k, v in feat.items()}
+    support = sum(vol.get(k, 0.0) for k in _SUPPORT_TYPES)
+    total_mm = float(meta.get("filament used [mm]", sum(feat.values())))
+    total_cm3 = float(meta.get("filament used [cm3]", total_mm * area))
+    t = meta.get("estimated printing time (normal mode)")
+    out = {
+        "printTime": _seconds(t) if t else None,
+        "printTimeText": t,
+        "filamentLength": total_mm,
+        "filamentVolume": total_cm3,
+        "supportVolume": float(support),
+        "supportShare": float(support / total_cm3) if total_cm3 > 0 else 0.0,
+        "features": {k: round(v, 4) for k, v in sorted(vol.items(), key=lambda kv: -kv[1])},
+        "layerHeight": float(meta["layer_height"]) if "layer_height" in meta else None,
+    }
+    if density is not None:
+        out["filamentMass"] = total_cm3 * density
+        out["supportMass"] = float(support) * density
+    return out
+
+
+def slice_mesh(mesh, build=None, material=None, opts: SlicerOptions | None = None, *, name: str = "part",
+               object_settings: dict | None = None, modifiers: list | None = None,
+               keep: str | None = None) -> dict:
+    """Slice `mesh` (trimesh, mm) standing along `build` (as threemf takes
+    it) with `opts`; `object_settings` and `modifiers` (dicts with "mesh",
+    "settings", "name") are the per-region config graded infill prints
+    with. Returns read_gcode's report plus the slicer's name and version and
+    the slicing time. `keep` copies the G-code there."""
+    from .threemf import write_3mf
+
+    opts = opts or SlicerOptions()
+    exe = find_slicer(opts.executable)
+    if exe is None:
+        raise FileNotFoundError("no slicer found: install PrusaSlicer (or set LOADPATH_SLICER to its executable)")
+    t0 = time.time()
+    with tempfile.TemporaryDirectory(prefix="loadpath-slice-") as tmp:
+        tmf = os.path.join(tmp, "part.3mf")
+        write_3mf(tmf, mesh, build, name=name, material=material, object_settings=object_settings,
+                  modifiers=modifiers)
+        ini = os.path.join(tmp, "loadpath.ini")
+        with open(ini, "w") as fh:
+            fh.write("".join(f"{k} = {v}\n" for k, v in opts.config().items()))
+        gcode = os.path.join(tmp, "part.gcode")
+        cmd = [exe]
+        if opts.profile:
+            cmd += ["--load", opts.profile]
+        cmd += ["--load", ini, "--export-gcode", "--output", gcode, tmf]
+        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=opts.timeout)
+        if proc.returncode != 0 or not os.path.isfile(gcode):
+            msg = (proc.stderr or proc.stdout or "").strip().splitlines()[-3:]
+            raise RuntimeError(f"slicer failed ({proc.returncode}): {' / '.join(msg)}")
+        density = getattr(material, "density", None)
+        rep = read_gcode(gcode, density)
+        if keep:
+            shutil.copyfile(gcode, keep)
+            rep["gcode"] = keep
+    rep["slicer"] = _version(exe)
+    rep["profile"] = opts.profile or "loadpath generic (0.4 mm nozzle, 0.2 mm layers, MK3S-class speeds)"
+    rep["infill"] = opts.infill
+    rep["seconds"] = time.time() - t0
+    return rep