simcon-toolkit 0.1.0__py3-none-any.whl

simcon_toolkit/_kit/packages/cadmould_cloud/client.py

@@ -0,0 +1,235 @@
+"""Thin live REST client for the Cloud Solver Service (Simulation Platform).
+
+Mirrors the endpoints exercised by the canonical runner
+``cloud-solver/scripts/run_ai_filling.py`` and adds the **project / group**
+endpoints the one-click demo needs. Every call goes over the wire to a real
+deployed (or local) platform; there is no dummy mode here -- ``ai_demo.py`` is a
+*live* end-to-end demo.
+
+Endpoints (all under the ``/api/v1`` prefix, which the caller bakes into
+``base_url``):
+
+    GET  /projects                              -> list (dedupe "AI DEMO" by name)
+    POST /projects                              -> create project
+    POST /projects/{id}/groups                  -> create group
+    GET  /projects/{id}/runs                    -> runs linked to the project
+    POST /projects/{id}/events                  -> append a note to the decision log
+    POST /geometries/upload-url                 -> {geometry_id, presigned_put_url}
+    PUT  <presigned S3 url>                     -> upload the .cfex bytes
+    GET  /materials?q=...                       -> material catalogue search
+    GET  /material-versions/{version_id}        -> temps + process recommendations
+    POST /simulations/filling                   -> AI filling (SYNCHRONOUS; carries project_id/group_id)
+    GET  /simulations/filling/{id}/download-url -> fresh presigned result download
+    GET  <presigned S3 url>                     -> the result HDF5 bytes
+
+Auth: an Auth0 Bearer JWT (see ``cloud_auth.get_access_token``) attached to every
+platform call. Presigned S3 PUT/GET URLs are absolute and need no bearer; the PUT
+must send ``Content-Type: application/octet-stream`` exactly or S3 rejects it.
+
+Units follow the API: temperatures Kelvin, pressure Pascals, spatial mm, flow cm3/s.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+# Filling is synchronous server-side: warm ~2-3 s, cold start can take longer.
+# Give each POST generous headroom (the API gateway caps it earlier anyway).
+FILLING_TIMEOUT_S = 120.0
+DEFAULT_TIMEOUT_S = 60.0
+
+
+@dataclass
+class PlatformAPI:
+    """REST client for the cloud platform, holding one connection and one bearer token."""
+
+    base_url: str  # includes the /api/v1 prefix
+    token: str
+    logger: Callable[[str], None] = print
+
+    def __post_init__(self) -> None:
+        """Open the connection the rest of this object reuses."""
+        self._client = httpx.Client(
+            base_url=self.base_url.rstrip("/"),
+            headers={"Authorization": f"Bearer {self.token}"},
+            timeout=DEFAULT_TIMEOUT_S,
+        )
+
+    # -- plumbing ------------------------------------------------------------
+    def _req(self, method: str, path: str, *, timeout: float | None = None, **kw: object) -> dict:
+        self.logger(f"    -> {method} {path}")
+        resp = self._client.request(method, path, timeout=timeout or DEFAULT_TIMEOUT_S, **kw)
+        self.logger(f"    <- {resp.status_code} {resp.reason_phrase}")
+        resp.raise_for_status()
+        return resp.json() if resp.content else {}
+
+    def close(self) -> None:
+        """Close the underlying connection."""
+        self._client.close()
+
+    def __enter__(self) -> PlatformAPI:
+        """Enter a ``with`` block; the client is already open."""
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        """Leave a ``with`` block, closing the connection. Exceptions propagate."""
+        self.close()
+
+    # -- projects / groups ---------------------------------------------------
+    def list_projects(self) -> list[dict]:
+        """Every project this token can see."""
+        return self._req("GET", "/projects").get("projects", [])
+
+    def get_or_create_project(self, name: str, *, customer: str | None = None, notes: str | None = None) -> dict:
+        """Reuse an existing project with this exact name, else create one.
+
+        Keeps re-runs of the demo from piling up duplicate "AI DEMO" projects.
+        """
+        for p in self.list_projects():
+            if p.get("name") == name:
+                self.logger(f"  reusing existing project '{name}' (id={p['id']})")
+                return p
+        body: dict[str, Any] = {"name": name}
+        if customer:
+            body["customer"] = customer
+        if notes:
+            body["notes"] = notes
+        proj = self._req("POST", "/projects", json=body)
+        self.logger(f"  created project '{name}' (id={proj['id']})")
+        return proj
+
+    def create_group(self, project_id: str, name: str, *, description: str | None = None) -> dict:
+        """Create a run group inside a project, so a study's phases stay separable."""
+        body: dict[str, Any] = {"name": name}
+        if description:
+            body["description"] = description
+        grp = self._req("POST", f"/projects/{project_id}/groups", json=body)
+        self.logger(f"  created group '{name}' (id={grp['id']})")
+        return grp
+
+    def list_project_runs(self, project_id: str) -> dict:
+        """Every run recorded against a project."""
+        return self._req("GET", f"/projects/{project_id}/runs")
+
+    def add_note(self, project_id: str, message: str, *, title: str | None = None) -> dict | None:
+        """Record a decision as a project note, which the web UI shows on the project page.
+
+        The platform's request model is a single required field, ``note``. Extra keys are
+        ignored rather than refused, so a body that omits ``note`` is a 422 no matter what
+        else it carries - which is why a title is prefixed into the text rather than sent
+        beside it, where it would be silently dropped. Never let a refused note abort the
+        run that produced it: the decision is worth less than the result.
+        """
+        note = f"{title}: {message}" if title else message
+        try:
+            return self._req("POST", f"/projects/{project_id}/events", json={"note": note})
+        # Deliberately broad: one dead run must not kill the batch.
+        except Exception as exc:
+            self.logger(f"    (project note not recorded: {type(exc).__name__}: {exc})")
+            return None
+
+    # -- geometry ------------------------------------------------------------
+    def request_geometry_upload(self, filename: str, description: str | None = None) -> dict:
+        """Register a geometry and get the presigned URL to upload its ``.cfex`` to."""
+        body: dict[str, Any] = {"filename": filename}
+        if description:
+            body["description"] = description
+        return self._req("POST", "/geometries/upload-url", json=body)
+
+    def put_cfex(self, presigned_put_url: str, cfex_path: str | Path) -> None:
+        """Upload a ``.cfex`` to the presigned URL from ``request_geometry_upload``."""
+        data = Path(cfex_path).read_bytes()
+        self.logger(f"    -> PUT (presigned S3)  {len(data)} bytes")
+        # The geometry service presigns Content-Type: application/octet-stream;
+        # the PUT must send that exact header or S3 returns 403 SignatureDoesNotMatch.
+        r = httpx.put(
+            presigned_put_url, content=data, headers={"Content-Type": "application/octet-stream"}, timeout=300
+        )
+        self.logger(f"    <- {r.status_code} (uploaded)")
+        r.raise_for_status()
+
+    # -- materials -----------------------------------------------------------
+    def search_materials(self, query: str, *, limit: int = 20) -> list[dict]:
+        """Catalogue materials matching a free-text query."""
+        return self._req("GET", "/materials", params={"q": query, "limit": limit}).get("materials", [])
+
+    def find_material(self, trade_name: str) -> dict:
+        """Find a catalogue material by trade name (exact, case-insensitive; else partial)."""
+        candidates = self.search_materials(trade_name)
+        exact = [m for m in candidates if m.get("trade_name", "").lower() == trade_name.lower()]
+        match = exact or [m for m in candidates if trade_name.lower() in m.get("trade_name", "").lower()] or candidates
+        if not match:
+            raise RuntimeError(f"No material matching '{trade_name}' in the catalogue.")
+        return match[0]
+
+    def get_material_version(self, version_id: str) -> dict:
+        """One catalogue material version, by id."""
+        return self._req("GET", f"/material-versions/{version_id}")
+
+    # -- filling simulation --------------------------------------------------
+    def run_filling(
+        self,
+        *,
+        geometry_id: str,
+        material_id: str,
+        gate_positions_mm: list[list[float]],
+        melt_temperature_K: float,
+        wall_temperature_K: float,
+        flow_rate_cm3_s: float,
+        estimated_filling_time_s: float,
+        model_version: str,
+        num_timesteps: int = 50,
+        htc_W_m2K: float = 1000.0,
+        label: str | None = None,
+        project_id: str | None = None,
+        group_id: str | None = None,
+        solver_type: str = "ai",
+    ) -> dict:
+        """POST /simulations/filling -- AI path is synchronous, returns the full result.
+
+        Setting ``project_id`` / ``group_id`` links the run to the project + group at
+        submit time (no separate /runs/link call needed).  ``solver_type`` defaults to
+        the synchronous "ai" path; "numerical" requests the physics solver (which may
+        run async / be unavailable on this endpoint).
+        """
+        body: dict[str, Any] = {
+            "solver_type": solver_type,
+            "model_version": model_version,
+            "geometry_id": geometry_id,
+            "material_id": material_id,
+            "process_params": {
+                "melt_temperature_K": melt_temperature_K,
+                "wall_temperature_K": wall_temperature_K,
+                "flow_rate_cm3_s": flow_rate_cm3_s,
+            },
+            "gate_positions_mm": gate_positions_mm,
+            "estimated_filling_time_s": estimated_filling_time_s,
+            "num_timesteps": num_timesteps,
+            "htc_W_m2K": htc_W_m2K,
+            "label": label,
+            "project_id": project_id,
+            "group_id": group_id,
+        }
+        return self._req("POST", "/simulations/filling", json=body, timeout=FILLING_TIMEOUT_S)
+
+    def refresh_download_url(self, simulation_id: str) -> dict:
+        """A fresh presigned GET for the result (the URL from the POST may have expired)."""
+        return self._req("GET", f"/simulations/filling/{simulation_id}/download-url")
+
+    def download_to(self, url: str, dest: str | Path) -> Path:
+        """Stream a presigned URL to a local file, creating parent directories."""
+        dest = Path(dest)
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        self.logger(f"    -> GET (presigned S3)  {dest.name}")
+        with httpx.stream("GET", url, timeout=300) as r:
+            r.raise_for_status()
+            with open(dest, "wb") as fh:
+                for chunk in r.iter_bytes(1 << 20):
+                    fh.write(chunk)
+        self.logger(f"    <- 200 saved {dest.name} [{dest.stat().st_size} bytes]")
+        return dest

simcon_toolkit/_kit/packages/cadmould_geometry/__init__.py

@@ -0,0 +1,5 @@
+"""Geometry reading shared by every template.
+
+Deliberately empty of imports: a file that wants one module should pay for one
+module, not for every module in the package and their dependencies.
+"""

simcon_toolkit/_kit/packages/cadmould_geometry/mesh.py

@@ -0,0 +1,210 @@
+"""Mesh an STL into a ``.cfex`` and place gates on real mesh nodes.
+
+The AI filling solver requires every gate to sit on an actual mesh node, never an
+interpolated point, and the SDK's mesh objects expose no coordinate getter — so the
+written ``.cfex`` is the only place the node positions can be read back from.
+
+``cadmould`` is imported inside the functions that need it, so the pure-geometry
+helpers here stay usable on a machine with no licence and no wheel.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+
+from cadmould_geometry import stl
+
+__all__ = ["Geometry", "gate_line", "parse_cfex_nodes", "prepare_geometry", "snap"]
+
+
+def _sdk_classes() -> dict:
+    """Resolve the SDK entry points this module uses, across wheel layouts.
+
+    rc2 grouped meshing under ``cadmould.mesh`` (``mesh.Mesh``, ``mesh.Mesher``,
+    ``mesh.io.CfexWriter``); rc3 moved them to ``cadmould.domain`` / ``cadmould.tools``
+    / ``cadmould.io``. Same constructors and call chains, just relocated.
+
+    This is the module's only import of the licensed wheel, so it is also where a
+    machine without it is told so.
+
+    Returns:
+        The five SDK entry points this module uses, keyed by name.
+
+    Raises:
+        ModuleNotFoundError: If the licensed wheel is not installed.
+    """
+    try:
+        # Imported here, not at module level: the licensed wheel is absent on offline
+        # machines, and everything else in this module must still work without it.
+        import cadmould
+    except ImportError as exc:
+        raise ModuleNotFoundError(
+            "meshing needs the licensed cadmould wheel, which is not installed. "
+            "See docs/SETUP.md. Reading an STL and placing gates on an existing mesh "
+            "need no licence; only writing a .cfex does."
+        ) from exc
+
+    mesh_mod = getattr(cadmould, "mesh", None)
+    io_mod = getattr(mesh_mod, "io", None) if mesh_mod else None
+    return {
+        "Mesh": getattr(mesh_mod, "Mesh", None) or cadmould.domain.Mesh,
+        "Mesher": getattr(mesh_mod, "Mesher", None) or cadmould.tools.Mesher,
+        "CfexWriter": getattr(io_mod, "CfexWriter", None) or cadmould.io.CfexWriter,
+        "suggest_gates": cadmould.tools.suggest_gates,
+        "Session": cadmould.Session,
+    }
+
+
+def parse_cfex_nodes(cfex_path: str | Path) -> np.ndarray:
+    """Read the node coordinates from the ``#NODDAT`` block of a ``.cfex``.
+
+    Args:
+        cfex_path: The ``.cfex`` file to read.
+
+    Returns:
+        An ``(N, 3)`` array of node coordinates in millimetres.
+    """
+    coords: list[tuple[float, float, float]] = []
+    n_expected = None
+    with open(cfex_path) as fh:
+        it = iter(fh)
+        for line in it:
+            if line.startswith("#NODDAT"):
+                n_expected = int(line.strip().split(",")[1])
+                break
+        for line in it:
+            if line.startswith("#"):
+                break
+            parts = line.split(",")
+            if len(parts) < 4:
+                break
+            coords.append((float(parts[1]), float(parts[2]), float(parts[3])))
+            if n_expected and len(coords) >= n_expected:
+                break
+    return np.asarray(coords, dtype=np.float64)
+
+
+@dataclass
+class Geometry:
+    """A meshed part: where its nodes are, how big it is, and which way it runs."""
+
+    cfex_path: Path
+    node_coords: np.ndarray
+    suggested_gate: list[float]
+    volume_cm3: float
+    long_axis: int
+
+    @property
+    def bounds(self) -> np.ndarray:
+        """The axis-aligned bounding box as a ``(3, 2)`` min/max array."""
+        c = self.node_coords
+        return np.array([c.min(0), c.max(0)]).T
+
+
+def prepare_geometry(
+    stl_path: str | Path,
+    cfex_out: str | Path,
+    scale: float = 1.0,
+    logger: Callable[[str], None] = print,
+) -> Geometry:
+    """Mesh an STL, write the ``.cfex``, and read its node coordinates back.
+
+    Args:
+        stl_path: The surface mesh to start from.
+        cfex_out: Where to write the meshed ``.cfex``.
+        scale: Multiplier applied to the STL coordinates, for files not in millimetres.
+        logger: Called with one progress line.
+
+    Returns:
+        The meshed geometry, including the SDK's own suggested gate.
+    """
+    stl_path, cfex_out = Path(stl_path), Path(cfex_out)
+    # Resolved before the STL is parsed, so an unlicensed machine is told immediately
+    # rather than after the read.
+    cm = _sdk_classes()
+
+    raw_pts, faces = stl.read_stl(stl_path)
+    pts = raw_pts * scale
+    volume_cm3 = stl.volume_mm3(raw_pts, faces) / 1000.0 * (scale**3)
+
+    with cm["Session"].user_based():
+        logger("  cadmould licence session opened (user_based); a failed sign-in prints above")
+        raw = cm["Mesh"](pts.ravel(), faces.ravel())
+        meshed = cm["Mesher"](raw).with_surface_triangulation().with_thickness_and_w2w().build()
+        gates = cm["suggest_gates"](meshed)
+        suggested = [[float(p.x), float(p.y), float(p.z)] for p in gates.points][0]
+        cfex_out.parent.mkdir(parents=True, exist_ok=True)
+        cm["CfexWriter"]().save(meshed, str(cfex_out))
+
+    node_coords = parse_cfex_nodes(cfex_out)
+    dims = node_coords.max(0) - node_coords.min(0)
+    long_axis = int(np.argmax(dims))
+    logger(
+        f"  meshed {meshed.node_count()} nodes / {meshed.element_count()} elems; "
+        f"cfex has {len(node_coords)} nodes; volume {volume_cm3:.1f} cm^3; "
+        f"long axis = {'xyz'[long_axis]} ({dims[long_axis]:.0f} mm)"
+    )
+    return Geometry(cfex_out, node_coords, suggested, volume_cm3, long_axis)
+
+
+def snap(targets: np.ndarray, node_coords: np.ndarray) -> list[list[float]]:
+    """Move each target point onto the nearest real mesh node, dropping duplicates.
+
+    Args:
+        targets: The points to snap, as an ``(M, 3)`` array or a single point.
+        node_coords: The mesh nodes to snap onto.
+
+    Returns:
+        One position per distinct node, in the order their targets were given. Two targets
+        whose nearest node is the same node yield one position, because two gates cannot
+        share a node.
+    """
+    out: list[list[float]] = []
+    seen: set[int] = set()
+    for t in np.atleast_2d(targets):
+        j = int(np.argmin(np.linalg.norm(node_coords - t, axis=1)))
+        # Keyed on the node index. Keying on the rounded position merges two nodes that
+        # agree to a micrometre, which silently returns fewer gates than were asked for.
+        if j not in seen:
+            seen.add(j)
+            out.append([float(v) for v in node_coords[j]])
+    return out
+
+
+def gate_line(
+    geo: Geometry,
+    fractions: Sequence[float],
+    ref_xz: tuple[float, float] | None = None,
+) -> list[list[float]]:
+    """Place gates along the part's long axis at the given fractional stations.
+
+    The off-axis coordinates default to the SDK-suggested gate's, so every gate sits on
+    the same feed face and width centre line and only its length station varies.
+
+    Args:
+        geo: The meshed part.
+        fractions: Positions along the long axis, 0.0 at one end and 1.0 at the other.
+        ref_xz: Fixed off-axis coordinates, overriding the suggested gate's.
+
+    Returns:
+        One position per fraction, each snapped to a real mesh node.
+    """
+    axis = geo.long_axis
+    lo, hi = geo.node_coords[:, axis].min(), geo.node_coords[:, axis].max()
+    others = [i for i in range(3) if i != axis]
+    if ref_xz is None:
+        ref = {others[0]: geo.suggested_gate[others[0]], others[1]: geo.suggested_gate[others[1]]}
+    else:
+        ref = {others[0]: ref_xz[0], others[1]: ref_xz[1]}
+    targets = []
+    for fr in fractions:
+        t = [0.0, 0.0, 0.0]
+        t[axis] = lo + fr * (hi - lo)
+        t[others[0]] = ref[others[0]]
+        t[others[1]] = ref[others[1]]
+        targets.append(t)
+    return snap(np.array(targets), geo.node_coords)

simcon_toolkit/_kit/packages/cadmould_geometry/stl.py

@@ -0,0 +1,168 @@
+"""Read an STL into the vertex and face arrays the meshing pipeline expects.
+
+This replaces a three-line idiom that appeared in every template::
+
+    surf  = pv.read(str(STL)).triangulate()
+    pts   = np.asarray(surf.points, np.float64)
+    faces = surf.faces.reshape(-1, 4)[:, 1:].astype(np.int32)
+
+PyVista pulls in VTK, which is roughly 600 MB installed. Nothing here draws
+anything, so the templates were paying a graphics stack to parse a header
+followed by a flat list of triangles.
+
+**The output is byte-identical to what PyVista returned**, which is a hard
+requirement rather than a nicety: a gate is stored as an index into the vertex
+array, so a reader that returns the same points in a different order silently
+moves every gate in the kit. `tests/test_stl_reader.py` pins this against
+values recorded from PyVista's own output.
+
+Three things make that identity work, and all three are easy to get wrong:
+
+* **Duplicate corners are folded.** An STL repeats a shared corner once per
+  triangle, and VTK merges them on exact float equality, numbering points in
+  the order they are first met while scanning triangles.
+* **Degenerate triangles are dropped** after folding — VTK discards a triangle
+  whose corners are not three distinct points, so a reader that keeps them
+  returns a longer face array.
+* **A binary file may open with the word "solid"**, so the text-versus-binary
+  decision is made on the file's length against its triangle count, never on
+  that prefix.
+
+`trimesh` is used for the parsing alone — the file-format detection and its
+overflow guard — and costs 3 MB with numpy as its only dependency. The folding
+and the degenerate-face rule are done here, because trimesh's own versions of
+both differ from what the kit assumed; :func:`read_stl` says how.
+
+The derived quantities below are plain numpy over the arrays, so they need no
+reader at all and can be tested without one.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import trimesh
+
+__all__ = [
+    "body_count",
+    "open_edge_count",
+    "read_stl",
+    "surface_area_mm2",
+    "volume_mm3",
+]
+
+
+def read_stl(path: str | Path) -> tuple[np.ndarray, np.ndarray]:
+    """Read a binary or ASCII STL.
+
+    trimesh parses the file and nothing else. Its own cleanup is switched off with
+    ``process=False``, because it does not match what the templates read before:
+
+    * it merges corners that fall in the same **tolerance bucket** (``1e-8``)
+      rather than corners that are exactly equal, so two distinct points closer
+      than that become one and every later index shifts. Coordinates smaller than
+      about 0.08 are where this bites, because float32 spacing is finer than the
+      tolerance there — which is to say, anywhere a part crosses the origin.
+    * it keeps a face whose corners collapse to fewer than three distinct points
+      once folding has happened.
+
+    Folding on exact equality in first-encounter order, then dropping collapsed
+    faces, is what the graphics stack did and what the rest of the kit assumes.
+
+    Args:
+        path: The ``.stl`` file to read.
+
+    Returns:
+        ``(vertices, faces)`` — an ``(N, 3)`` float64 array of point positions in
+        the file's own units, and an ``(M, 3)`` int32 array of indices into it.
+    """
+    soup = trimesh.load_mesh(str(path), file_type="stl", process=False)
+    corners = np.asarray(soup.vertices, dtype=np.float32)[np.asarray(soup.faces, dtype=np.int64)]
+    return _fold(corners.reshape(-1, 3))
+
+
+def _fold(corners: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """Fold a flat corner list into unique points plus the faces indexing them.
+
+    Uniqueness is decided on the float32 bit patterns, so it is exact equality and
+    carries no tolerance. Points are numbered in the order they are first met.
+    """
+    view = np.ascontiguousarray(corners).view([("x", "<f4"), ("y", "<f4"), ("z", "<f4")]).ravel()
+    _, first_seen, inverse = np.unique(view, return_index=True, return_inverse=True)
+
+    order = np.argsort(first_seen)
+    renumber = np.empty(len(order), dtype=np.int64)
+    renumber[order] = np.arange(len(order))
+
+    vertices = corners[first_seen[order]].astype(np.float64)
+    faces = renumber[inverse].reshape(-1, 3)
+    distinct = (faces[:, 0] != faces[:, 1]) & (faces[:, 0] != faces[:, 2]) & (faces[:, 1] != faces[:, 2])
+    return vertices, faces[distinct].astype(np.int32)
+
+
+def volume_mm3(vertices: np.ndarray, faces: np.ndarray) -> float:
+    """Enclosed volume, by the divergence theorem over the triangles.
+
+    Absolute, matching what the templates read before: a mesh whose normals all
+    point inward would otherwise return a negative number where every caller
+    expects a positive one. Meaningless on a surface that is not closed — check
+    :func:`open_edge_count` first if that is in doubt.
+    """
+    a, b, c = _corners(vertices, faces)
+    return float(abs(np.einsum("ij,ij->i", a, np.cross(b, c)).sum() / 6.0))
+
+
+def surface_area_mm2(vertices: np.ndarray, faces: np.ndarray) -> float:
+    """Total area of the triangles."""
+    a, b, c = _corners(vertices, faces)
+    return float(np.linalg.norm(np.cross(b - a, c - a), axis=1).sum() / 2.0)
+
+
+def open_edge_count(vertices: np.ndarray, faces: np.ndarray) -> int:
+    """Edges that leave the surface open, so ``0`` means watertight.
+
+    Counts both boundary edges, used by one triangle, and non-manifold edges,
+    used by three or more. Both are defects and the graphics stack counted both;
+    counting only the first under-reports a mesh where three faces meet along one
+    edge, which is a shape that reads as closed and is not.
+    """
+    _, counts = np.unique(_edges(faces), axis=0, return_counts=True)
+    return int(((counts == 1) | (counts >= 3)).sum())
+
+
+def body_count(vertices: np.ndarray, faces: np.ndarray) -> int:
+    """How many separate connected bodies the mesh describes.
+
+    Reported because a part file holding one body has been described as holding
+    several, and the claim travelled a long way before anyone checked it.
+
+    Union-find rather than a graph library: the obvious call needs SciPy, and
+    pulling in SciPy for this would cost more than the graphics stack this module
+    exists to remove.
+    """
+    parent = np.arange(len(vertices))
+
+    def find(node: int) -> int:
+        while parent[node] != node:
+            parent[node] = parent[parent[node]]
+            node = parent[node]
+        return int(node)
+
+    for left, right in _edges(faces):
+        root_left, root_right = find(left), find(right)
+        if root_left != root_right:
+            parent[root_left] = root_right
+    return len({find(node) for node in range(len(vertices))})
+
+
+def _corners(vertices: np.ndarray, faces: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """The three corner positions of every triangle, as three parallel arrays."""
+    indices = np.asarray(faces, dtype=np.int64)
+    return vertices[indices[:, 0]], vertices[indices[:, 1]], vertices[indices[:, 2]]
+
+
+def _edges(faces: np.ndarray) -> np.ndarray:
+    """Every triangle edge as a sorted index pair, so the two directions agree."""
+    indices = np.asarray(faces, dtype=np.int64)
+    return np.sort(np.vstack([indices[:, [0, 1]], indices[:, [1, 2]], indices[:, [2, 0]]]), axis=1)

simcon_toolkit/_kit/packages/cadmould_results/__init__.py

@@ -0,0 +1,30 @@
+"""Tiny toolkit for working with Simcon AI-Solver prediction files.
+
+    from cadmould_results import PredictionResult, PRESSURE, TEMPERATURE
+
+See ``cadmould_results.loader`` for the data-model documentation.
+"""
+
+from .loader import (
+    ALL_FIELDS,
+    DEGREE_OF_FILLING,
+    LAYERED_FIELDS,
+    NODE_FIELDS,
+    PRESSURE,
+    SHEAR_LOG,
+    TEMPERATURE,
+    PredictionResult,
+    ProcessInputs,
+)
+
+__all__ = [
+    "PredictionResult",
+    "ProcessInputs",
+    "ALL_FIELDS",
+    "NODE_FIELDS",
+    "LAYERED_FIELDS",
+    "DEGREE_OF_FILLING",
+    "PRESSURE",
+    "TEMPERATURE",
+    "SHEAR_LOG",
+]