simcon-toolkit 0.1.0__py3-none-any.whl

simcon_toolkit/_kit/packages/cadmould_results/loader.py

@@ -0,0 +1,288 @@
+"""Read and slice the AI-Solver injection-molding prediction (HDF5).
+
+The prediction file is a 2.5D filling simulation produced by the Simcon AI
+solver.  Everything lives in a single ``.h5`` file with this layout::
+
+    /                              root attrs: geometry, material, model_id, ...
+    /TimeStep_0001 ... _0053       one group per time step
+        Time, dt, filling_level    (group attrs)
+        Degree_of_filling  (N,)    per-node fill fraction (NaN = not filled yet)
+        Pressure           (N,)    per-node cavity pressure  [bar]
+        Temperature        (N, L)  per-node, per-layer melt temperature  [K]
+        Log(1 + Shear_rate)(N, L)  per-node, per-layer  log1p of shear rate
+    /geometry3DF/Coordinates (N, 3)   midplane mesh node coordinates  [mm]
+    /supporting_points/NodePoints (N, L, 3)  through-thickness point cloud [mm]
+    /flowrate0  (53,)              global injection curve (time, flowrate, p, switch)
+    /input                         process settings + gate location(s)
+    /material_data                 PP material model (pvt / viscosity / thermal)
+
+Here ``N`` = number of mesh nodes (6201) and ``L`` = number of layers across
+the wall thickness (41).  ``Pressure`` and ``Degree_of_filling`` are stored per
+node only; ``Temperature`` and the shear field additionally resolve the wall
+thickness, so layer 0 is one surface, layer ``L-1`` the other, and the middle
+index is the core.
+
+The class below is the one object you work with.  It opens the file lazily and
+hands you NumPy arrays via small, well-named slicing methods ("chunks") so the
+template scripts never touch h5py directly.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import h5py
+import numpy as np
+
+# --- canonical field names as stored in each TimeStep group -----------------
+DEGREE_OF_FILLING = "Degree_of_filling"
+PRESSURE = "Pressure"
+TEMPERATURE = "Temperature"
+SHEAR_LOG = "Log(1 + Shear_rate)"  # legacy: log-encoded shear (de-log with expm1)
+SHEAR_RATE = "Shear_rate"  # current: straight shear rate [1/s]
+
+#: fields stored as (N,)            -> one value per node
+NODE_FIELDS = (DEGREE_OF_FILLING, PRESSURE)
+#: fields stored as (N, L)          -> one value per node and wall layer (both shear
+#: spellings listed so membership tests work whichever the file carries)
+LAYERED_FIELDS = (TEMPERATURE, SHEAR_LOG, SHEAR_RATE)
+ALL_FIELDS = NODE_FIELDS + LAYERED_FIELDS
+
+
+@dataclass(frozen=True)
+class ProcessInputs:
+    """Process settings the prediction was run with (from /input attrs)."""
+
+    filling_time_s: float
+    flowrate: float
+    melt_temperature_c: float
+    wall_temperature_c: float
+    gate_xyz: np.ndarray  # (G, 3) gate location(s) in mm
+
+
+class PredictionResult:
+    """A read-only view over one AI-Solver prediction file.
+
+    Use it as a context manager so the underlying HDF5 handle is closed::
+
+        with PredictionResult("part_prediction.h5") as res:
+            snap = res.snapshot(step=29)          # all fields at one time step
+            p_gate = res.node_history(PRESSURE, node=res.gate_node)
+    """
+
+    def __init__(self, path: str | Path) -> None:
+        """Open a prediction file and read its time axis.
+
+        Args:
+            path: The prediction ``.h5`` to open. It stays open until ``close``.
+        """
+        self.path = Path(path)
+        self._f = h5py.File(self.path, "r")
+
+        # Ordered list of TimeStep group names (the file is already sorted, but
+        # never rely on dict order in HDF5 -- sort explicitly).
+        self.timestep_names: list[str] = sorted(k for k in self._f if k.startswith("TimeStep_"))
+
+        # The geometry group name has a trailing space in the source file; find
+        # it robustly instead of hard-coding the quirk.
+        self._geom_key = next(k for k in self._f if k.strip() == "geometry3DF")
+
+        # Time axis (seconds), one entry per time step.
+        self.times: np.ndarray = np.array(
+            [float(self._f[name].attrs["Time"]) for name in self.timestep_names],
+            dtype=np.float64,
+        )
+
+    # -- lifecycle -----------------------------------------------------------
+    def close(self) -> None:
+        """Close the underlying HDF5 file."""
+        self._f.close()
+
+    def __enter__(self) -> PredictionResult:
+        """Enter a ``with`` block; the file is already open."""
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        """Leave a ``with`` block, closing the file. Exceptions propagate."""
+        self.close()
+
+    # -- basic dimensions / metadata ----------------------------------------
+    @property
+    def meta(self) -> dict:
+        """Root attributes: geometry name, material, solver/model id, ..."""
+        return {k: _decode(v) for k, v in self._f.attrs.items()}
+
+    @property
+    def n_timesteps(self) -> int:
+        """How many time steps the file recorded."""
+        return len(self.timestep_names)
+
+    @property
+    def n_nodes(self) -> int:
+        """How many midplane mesh nodes the geometry has."""
+        return self._f[self._geom_key]["Coordinates"].shape[0]
+
+    @property
+    def n_layers(self) -> int:
+        """How many through-thickness layers each layered field carries."""
+        return self._f[self.timestep_names[0]][TEMPERATURE].shape[1]
+
+    @property
+    def coordinates(self) -> np.ndarray:
+        """Midplane mesh node coordinates, shape (N, 3), in mm."""
+        return np.asarray(self._f[self._geom_key]["Coordinates"][()], dtype=np.float32)
+
+    @property
+    def node_points(self) -> np.ndarray:
+        """Through-thickness point cloud, shape (N, L, 3), in mm."""
+        return np.asarray(self._f["supporting_points"]["NodePoints"][()], dtype=np.float32)
+
+    @property
+    def has_inputs(self) -> bool:
+        """Whether the file carries an `/input` group (process settings + gate location).
+
+        Cloud results omit it unless augmented — see the run-one-simulation template.
+        """
+        return "input" in self._f
+
+    @property
+    def inputs(self) -> ProcessInputs:
+        """The process settings and gate location the run was submitted with.
+
+        Raises:
+            KeyError: If the file carries no ``/input`` group; check ``has_inputs``.
+        """
+        g = self._f["input"]
+        gates = np.asarray(g["gate_locations"][()])
+        gate_xyz = np.column_stack([gates["x"], gates["y"], gates["z"]]).astype(np.float32)
+        return ProcessInputs(
+            filling_time_s=float(g.attrs["filling_time"]),
+            flowrate=float(g.attrs["flowrate"]),
+            melt_temperature_c=float(g.attrs["melt_temperature"]),
+            wall_temperature_c=float(g.attrs["wall_temperature"]),
+            gate_xyz=gate_xyz,
+        )
+
+    @property
+    def gate_node(self) -> int:
+        """Index of the mesh node closest to the (first) gate location."""
+        gate = self.inputs.gate_xyz[0]
+        d = np.linalg.norm(self.coordinates - gate, axis=1)
+        return int(np.argmin(d))
+
+    @property
+    def flowrate_curve(self) -> np.ndarray:
+        """Global injection curve, as a structured array.
+
+        Its fields are ``time``, ``flowrate_calculated``, ``pressure`` and ``switch``.
+        """
+        return np.asarray(self._f["flowrate0"][()])
+
+    def field_unit(self, field: str) -> str:
+        """Unit string stored on a field (e.g. 'bar', 'Pa', 'K', '1/s', 'relative')."""
+        ds = self._f[self.timestep_names[0]][field]
+        return _decode(ds.attrs.get("unit", ""))
+
+    def has_field(self, field: str) -> bool:
+        """True if ``field`` exists in the time-step groups (the result format varies)."""
+        return field in self._f[self.timestep_names[0]]
+
+    def shear_name(self) -> str | None:
+        """Name of the shear field this file carries, or None if it carries neither.
+
+        Either ``Shear_rate`` (current, straight 1/s) or ``Log(1 + Shear_rate)`` (legacy,
+        log-encoded).
+        """
+        for n in (SHEAR_RATE, SHEAR_LOG):
+            if self.has_field(n):
+                return n
+        return None
+
+    def pressure_series_bar(self) -> np.ndarray:
+        """Pressure over all steps in **bar**, regardless of stored unit (Pa or bar)."""
+        s = self.field_series(PRESSURE)
+        return s / 1.0e5 if self.field_unit(PRESSURE).strip().lower() == "pa" else s
+
+    # -- time indexing -------------------------------------------------------
+    def step_at_time(self, t_seconds: float) -> int:
+        """Return the time-step index whose Time is closest to ``t_seconds``."""
+        return int(np.argmin(np.abs(self.times - t_seconds)))
+
+    def _group(self, step: int) -> h5py.Group:
+        return self._f[self.timestep_names[step]]
+
+    # -- CHUNK 1: a single time step (a "snapshot") --------------------------
+    def field_at(self, field: str, step: int) -> np.ndarray:
+        """One field at one time step.
+
+        Shape is (N,) for node fields and (N, L) for layered fields.
+        Unfilled nodes are NaN.  float16 storage is promoted to float32.
+        """
+        return np.asarray(self._group(step)[field][()], dtype=np.float32)
+
+    def snapshot(self, step: int) -> dict:
+        """All fields at one time step, plus that step's time/fill metadata."""
+        g = self._group(step)
+        data = {f: self.field_at(f, step) for f in ALL_FIELDS if self.has_field(f)}
+        data["time"] = float(g.attrs["Time"])
+        data["filled_fraction"] = float(np.isfinite(data[DEGREE_OF_FILLING]).mean())
+        return data
+
+    # -- CHUNK 2: a field across the whole simulation ------------------------
+    def field_series(self, field: str) -> np.ndarray:
+        """Stack one field over every time step.
+
+        Shape is (T, N) for node fields and (T, N, L) for layered fields.
+        """
+        return np.stack([self.field_at(field, s) for s in range(self.n_timesteps)])
+
+    # -- CHUNK 3: the time history at a single node (a virtual sensor) -------
+    def node_history(self, field: str, node: int, layer: int | None = None) -> np.ndarray:
+        """Time history of ``field`` at one mesh node, shape (T,).
+
+        For layered fields pass ``layer`` (defaults to the core, L//2).
+        """
+        if field in LAYERED_FIELDS:
+            if layer is None:
+                layer = self.n_layers // 2
+            return np.array([self.field_at(field, s)[node, layer] for s in range(self.n_timesteps)])
+        return np.array([self.field_at(field, s)[node] for s in range(self.n_timesteps)])
+
+    # -- CHUNK 4: one through-thickness layer over time ----------------------
+    def layer_series(self, field: str, layer: int) -> np.ndarray:
+        """A single wall layer of a layered field over time, shape (T, N)."""
+        if field not in LAYERED_FIELDS:
+            raise ValueError(f"{field!r} has no layers; it is stored per node only.")
+        return np.stack([self.field_at(field, s)[:, layer] for s in range(self.n_timesteps)])
+
+    # -- derived helpers -----------------------------------------------------
+    def fill_progress(self) -> np.ndarray:
+        """Fraction of nodes reached by the flow front at each step, shape (T,)."""
+        return np.array([np.isfinite(self.field_at(DEGREE_OF_FILLING, s)).mean() for s in range(self.n_timesteps)])
+
+    def shear_rate(self, step: int) -> np.ndarray:
+        """Shear rate at a step, regardless of how the file stores it.
+
+        Current files carry a straight ``Shear_rate`` field [1/s] -> returned as-is.
+        Legacy files carry ``Log(1 + Shear_rate)`` -> de-logged with ``expm1`` (the
+        legacy unit label is '100s', i.e. units of 100 1/s).
+        """
+        name = self.shear_name()
+        if name is None:
+            raise KeyError("no shear field (Shear_rate / Log(1 + Shear_rate)) in this file")
+        s = self.field_at(name, step)
+        return np.expm1(s) if name == SHEAR_LOG else s
+
+
+def _decode(v: object) -> object:
+    """Turn HDF5 bytes/0-d arrays into plain Python values for printing.
+
+    The input is an arbitrary HDF5 attribute value, so the body narrows by type rather
+    than assuming one.
+    """
+    if isinstance(v, bytes):
+        return v.decode("utf-8", "replace")
+    if isinstance(v, np.ndarray) and v.shape == ():
+        return v.item()
+    return v

simcon_toolkit/_kit/packages/cadmould_scoring/__init__.py

@@ -0,0 +1,7 @@
+"""Score a filling result: pressure, fill evenness and weld-line detection.
+
+    from cadmould_scoring import metrics
+
+Nothing is imported here on purpose, so a file that wants one module pays for one
+module. See ``cadmould_scoring.metrics`` for the documented measures.
+"""