added GPR

2026-03-19 19:29:08 +03:00
parent bdefe3f581
commit 9581730e41
39 changed files with 3830 additions and 201 deletions
@@ -39,39 +39,79 @@ def serialize_trace_collection(collection: SweepCollection, magic: int) -> bytes

 def serialize_result_collection(collection: ResultCollection) -> bytes:
    """Serialize one processed collection with result blocks/payloads."""
+
+    def serialize_payload(buffer: bytearray, payload) -> None:
+        """Append one payload in ring-compatible result format."""
+        name_bytes = payload.processing_name.encode("utf-8")
+        if len(name_bytes) > 0xFFFF:
+            raise ValueError("processing_name is too long")
+
+        buffer.extend(struct.pack("<BH", payload.kind, len(name_bytes)))
+        buffer.extend(name_bytes)
+
+        if payload.kind == 1:
+            freq = np.asarray(payload.frequency_hz, dtype=np.float32)
+            trace = np.asarray(payload.trace, dtype=np.complex64)
+            if freq.size != trace.size:
+                raise ValueError("Result trace frequency and values sizes must match")
+
+            buffer.extend(struct.pack("<I", int(freq.size)))
+            buffer.extend(freq.astype("<f4", copy=False).tobytes())
+
+            interleaved = np.empty(freq.size * 2, dtype="<f4")
+            interleaved[0::2] = trace.real.astype("<f4", copy=False)
+            interleaved[1::2] = trace.imag.astype("<f4", copy=False)
+            buffer.extend(interleaved.tobytes())
+            return
+
+        if payload.kind == 2:
+            buffer.extend(struct.pack("<f", float(payload.scalar_value)))
+            return
+
+        if payload.kind == 3:
+            image_x_axis = np.asarray(payload.image_x_axis, dtype=np.float32)
+            image_y_axis = np.asarray(payload.image_y_axis, dtype=np.float32)
+            image = np.asarray(payload.image, dtype=np.float32)
+            if image.ndim != 2:
+                raise ValueError("Result image payload must be a 2D matrix")
+            if image.shape != (image_y_axis.size, image_x_axis.size):
+                raise ValueError("Result image axis sizes must match image matrix shape")
+            buffer.extend(struct.pack("<II", int(image_x_axis.size), int(image_y_axis.size)))
+            buffer.extend(image_x_axis.astype("<f4", copy=False).tobytes())
+            buffer.extend(image_y_axis.astype("<f4", copy=False).tobytes())
+            buffer.extend(image.astype("<f4", copy=False).ravel(order="C").tobytes())
+            return
+
+        if payload.kind == 4:
+            table = np.asarray(payload.table, dtype=np.float32)
+            if table.ndim != 2:
+                raise ValueError("Result table payload must be a 2D matrix")
+            buffer.extend(struct.pack("<II", int(table.shape[1]), int(table.shape[0])))
+            buffer.extend(table.astype("<f4", copy=False).ravel(order="C").tobytes())
+            return
+
+        raise ValueError(f"Unsupported payload kind: {payload.kind}")
+
    buffer = bytearray()
    buffer.extend(
-        struct.pack("<IQQI", RESULT_MAGIC, collection.collection_id, collection.monotonic_ns, len(collection.blocks))
+        struct.pack(
+            "<IQQII",
+            RESULT_MAGIC,
+            collection.collection_id,
+            collection.monotonic_ns,
+            len(collection.collection_payloads),
+            len(collection.blocks),
+        )
    )

+    for payload in collection.collection_payloads:
+        serialize_payload(buffer, payload)
+
    for block in collection.blocks:
        buffer.extend(struct.pack("<II", block.combo.input_pos, block.combo.output_pos))
        buffer.extend(struct.pack("<I", len(block.payloads)))

        for payload in block.payloads:
-            name_bytes = payload.processing_name.encode("utf-8")
-            if len(name_bytes) > 0xFFFF:
-                raise ValueError("processing_name is too long")
-
-            buffer.extend(struct.pack("<BH", payload.kind, len(name_bytes)))
-            buffer.extend(name_bytes)
-
-            if payload.kind == 1:
-                freq = np.asarray(payload.frequency_hz, dtype=np.float32)
-                trace = np.asarray(payload.trace, dtype=np.complex64)
-                if freq.size != trace.size:
-                    raise ValueError("Result trace frequency and values sizes must match")
-
-                buffer.extend(struct.pack("<I", int(freq.size)))
-                buffer.extend(freq.astype("<f4", copy=False).tobytes())
-
-                interleaved = np.empty(freq.size * 2, dtype="<f4")
-                interleaved[0::2] = trace.real.astype("<f4", copy=False)
-                interleaved[1::2] = trace.imag.astype("<f4", copy=False)
-                buffer.extend(interleaved.tobytes())
-            elif payload.kind == 2:
-                buffer.extend(struct.pack("<f", float(payload.scalar_value)))
-            else:
-                raise ValueError(f"Unsupported payload kind: {payload.kind}")
+            serialize_payload(buffer, payload)

    return bytes(buffer)
@@ -137,6 +137,7 @@ def save_result_history_binary(stage_dir: Path, history: list[ResultCollection])
                {
                    "collection_id": collection.collection_id,
                    "monotonic_ns": collection.monotonic_ns,
+                    "collection_payload_count": len(collection.collection_payloads),
                    "block_count": len(collection.blocks),
                },
                indent=2,
@@ -190,6 +191,66 @@ def save_result_history_numpy(stage_dir: Path, history: list[ResultCollection])
        collection_dir = stage_dir / collection_dir_name(index, collection.collection_id, collection.monotonic_ns)
        collection_dir.mkdir(parents=True, exist_ok=False)

+        collection_payload_meta: list[dict[str, int | str | float]] = []
+        for payload_index, payload in enumerate(collection.collection_payloads):
+            safe_name = sanitize_path_component(payload.processing_name or "processor")
+            base_name = f"collection_{payload_index:03d}_{safe_name}_kind{payload.kind}"
+            if payload.kind == 1:
+                freq = np.asarray(payload.frequency_hz, dtype=np.float32)
+                trace = np.asarray(payload.trace, dtype=np.complex64)
+                np.save(collection_dir / f"{base_name}_freq.npy", freq)
+                np.save(collection_dir / f"{base_name}_trace.npy", trace)
+                collection_payload_meta.append(
+                    {
+                        "kind": int(payload.kind),
+                        "name": payload.processing_name,
+                        "points": int(freq.size),
+                        "freq_file": f"{base_name}_freq.npy",
+                        "trace_file": f"{base_name}_trace.npy",
+                    }
+                )
+            elif payload.kind == 2:
+                scalar = np.asarray([float(payload.scalar_value)], dtype=np.float32)
+                np.save(collection_dir / f"{base_name}_scalar.npy", scalar)
+                collection_payload_meta.append(
+                    {
+                        "kind": int(payload.kind),
+                        "name": payload.processing_name,
+                        "scalar_file": f"{base_name}_scalar.npy",
+                        "scalar_value": float(payload.scalar_value),
+                    }
+                )
+            elif payload.kind == 3:
+                image_x_axis = np.asarray(payload.image_x_axis, dtype=np.float32)
+                image_y_axis = np.asarray(payload.image_y_axis, dtype=np.float32)
+                image = np.asarray(payload.image, dtype=np.float32)
+                np.save(collection_dir / f"{base_name}_x_axis.npy", image_x_axis)
+                np.save(collection_dir / f"{base_name}_y_axis.npy", image_y_axis)
+                np.save(collection_dir / f"{base_name}_image.npy", image)
+                collection_payload_meta.append(
+                    {
+                        "kind": int(payload.kind),
+                        "name": payload.processing_name,
+                        "x_points": int(image_x_axis.size),
+                        "y_points": int(image_y_axis.size),
+                        "x_axis_file": f"{base_name}_x_axis.npy",
+                        "y_axis_file": f"{base_name}_y_axis.npy",
+                        "image_file": f"{base_name}_image.npy",
+                    }
+                )
+            elif payload.kind == 4:
+                table = np.asarray(payload.table, dtype=np.float32)
+                np.save(collection_dir / f"{base_name}_table.npy", table)
+                collection_payload_meta.append(
+                    {
+                        "kind": int(payload.kind),
+                        "name": payload.processing_name,
+                        "rows": int(table.shape[0]) if table.ndim == 2 else 0,
+                        "columns": int(table.shape[1]) if table.ndim == 2 else 0,
+                        "table_file": f"{base_name}_table.npy",
+                    }
+                )
+
        blocks_meta: list[dict[str, int | str | list[dict[str, int | str | float]]]] = []
        for block_index, block in enumerate(collection.blocks):
            block_dir = collection_dir / f"block_{block_index:03d}_i{block.combo.input_pos}_o{block.combo.output_pos}"
@@ -224,6 +285,36 @@ def save_result_history_numpy(stage_dir: Path, history: list[ResultCollection])
                            "scalar_value": float(payload.scalar_value),
                        }
                    )
+                elif payload.kind == 3:
+                    image_x_axis = np.asarray(payload.image_x_axis, dtype=np.float32)
+                    image_y_axis = np.asarray(payload.image_y_axis, dtype=np.float32)
+                    image = np.asarray(payload.image, dtype=np.float32)
+                    np.save(block_dir / f"{base_name}_x_axis.npy", image_x_axis)
+                    np.save(block_dir / f"{base_name}_y_axis.npy", image_y_axis)
+                    np.save(block_dir / f"{base_name}_image.npy", image)
+                    payload_meta.append(
+                        {
+                            "kind": int(payload.kind),
+                            "name": payload.processing_name,
+                            "x_points": int(image_x_axis.size),
+                            "y_points": int(image_y_axis.size),
+                            "x_axis_file": f"{base_name}_x_axis.npy",
+                            "y_axis_file": f"{base_name}_y_axis.npy",
+                            "image_file": f"{base_name}_image.npy",
+                        }
+                    )
+                elif payload.kind == 4:
+                    table = np.asarray(payload.table, dtype=np.float32)
+                    np.save(block_dir / f"{base_name}_table.npy", table)
+                    payload_meta.append(
+                        {
+                            "kind": int(payload.kind),
+                            "name": payload.processing_name,
+                            "rows": int(table.shape[0]) if table.ndim == 2 else 0,
+                            "columns": int(table.shape[1]) if table.ndim == 2 else 0,
+                            "table_file": f"{base_name}_table.npy",
+                        }
+                    )

            blocks_meta.append(
                {
@@ -240,6 +331,8 @@ def save_result_history_numpy(stage_dir: Path, history: list[ResultCollection])
                {
                    "collection_id": int(collection.collection_id),
                    "monotonic_ns": int(collection.monotonic_ns),
+                    "collection_payload_count": len(collection.collection_payloads),
+                    "collection_payloads": collection_payload_meta,
                    "block_count": len(collection.blocks),
                    "blocks": blocks_meta,
                },