getframes 2.4.0__tar.gz → 2.6.0__tar.gz

{getframes-2.4.0 → getframes-2.6.0}/CHANGELOG.md

@@ -6,6 +6,112 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [2.6.0] - 2026-10-10
+
+### Added
+
+- **`Calibration`: ADU to input-referred electrons and incident photons**
+  (`gf.Calibration`, `Camera.calibration`). `Calibration.from_camera(cam,
+  exposure, n_darks=64, seed=...)` averages exposure-matched dark frames into a
+  mean master dark on the camera's device and precision; `to_electrons` applies
+  `L^-1[(ADU - dark) * gain_e_per_adu / em_gain] / flat`, inverting the
+  configured nonlinearity (closed form or Newton) by default; `to_photons`
+  divides by the scalar QE `expose` applies, a `quantum_efficiency`, the
+  `qe_curve` at `wavelength_nm`, or its effective value over a `bandpass`;
+  `saturated` flags pixels whose charge reached the input well, the output
+  register or the ADC ceiling. It works on NumPy and CuPy frames, takes an
+  optional unit-mean flat, and handles binned frames. Tests check that the mean
+  calibrated flux matches the incident photons to 0.5% for EMCCD, qCMOS, sCMOS,
+  eAPD, CCD and CMOS presets (issue #10).
+- **`Camera.effective_read_noise_e(binning=..., binning_mode=...)`**: the
+  per-frame read noise referred to the input (electrons collected in the
+  pixel): output read noise (the quadrature mean of a per-pixel map), kTC/reset
+  noise and avalanche-scaled noise, divided by the EM/avalanche gain. The
+  docstring and the new guide give the excess-noise-factor SNR.
+- **Guide: [A WFS camera in a closed loop](docs/guides/wfs-closed-loop.md)**:
+  exposure vs. frame period, ADU calibration and its accuracy, input-referred
+  noise and the excess noise factor, recommended EMCCD/qCMOS/sCMOS/eAPD/CCD
+  presets, and keeping small frames cheap.
+- `benchmarks/bench_small_frames.py`: seeded 256x256 WFS frames for one preset
+  per detector class, with before/after comparison and a SHA-256 digest of
+  seeded output for bit-identity checks; results in
+  `benchmarks/small-frame-results.md`.
+
+### Performance
+
+- **Photon-starved EMCCD and eAPD frames are faster on the CPU, with
+  bit-identical seeded output.** NumPy returns `Gamma(shape=0)` as exactly zero
+  without consuming a draw, but still visits every such pixel; the gain stage
+  now samples only the pixels that hold charge when they are a minority (a
+  wavefront sensor's dark background), and skips the `* 1` shape scaling at
+  `F = sqrt(2)`. Same draws, same order, same generator state afterwards;
+  seeded frames of every preset, in both precisions, are bit-identical to 2.5.0.
+  On one Neoverse-N1 core (256x256 Shack-Hartmann spots, 1 ms, in-process A/B):
+  the Gamma draw 1.43 → 0.78 ms; whole frames `andor_ocam2k` 6.57 → 5.95 ms
+  (1.10x), `leonardo_saphira` 4.79 → 4.29 ms (1.12x), `first_light_imaging_cred_one`
+  7.16 → 6.63 ms (1.08x); presets without a gain stage are unchanged. The CPU
+  chain is otherwise at its sampler floor (about 85% of a frame is NumPy's
+  Poisson, Gamma and Gaussian draws). An exact vectorised replica of NumPy's
+  small-rate Poisson for the CIC draw was tried and measured no faster, so it
+  was not kept. See `benchmarks/small-frame-results.md`.
+
+### Documented
+
+- The 1--2% calibrated-flux deficit seen in the dithered Shack-Hartmann
+  prototype is not a deterministic offset of the signal chain: averaged over
+  300 frames the prototype recovers 1.002 (OCAM2K), 0.999 (ORCA-Quest 2) and
+  1.001 (generic sCMOS) of the incident flux, while a single 288x288 frame
+  scatters by 1.2%, 1.0% and 3.3%. The guide lists the deterministic offsets a
+  pipeline can introduce (median master dark, scalar vs. spectral QE,
+  nonlinearity, saturation, unflattened fixed patterns) and their remedies.
+- The Nüvü HNü 240 / 128 presets cap the *amplified* charge at their 500 / 800
+  e- `full_well_e` (no `output_full_well_e`), so at EM gain 1000 a pixel holding
+  one electron saturates; the guide warns about it (#11).
+
+## [2.5.0] - 2026-10-07
+
+### Added
+
+- **Arm benchmark data point** (`benchmarks/device-results-neoverse-n1.*`): the
+  device table on an Ampere Neoverse-N1 host (16 pinned cores) with an RTX
+  4060 and an RTX A400.
+
+### Performance
+
+- **Small GPU frames run up to 2.6x faster, with bit-identical seeded output.**
+  WFS-sized frames were launch-bound: the host spent longer issuing about twenty
+  small CuPy kernels per frame than the GPU spent running them. The GPU path now
+  computes the photo and total expectations in one fused kernel and the whole
+  readout (full-well clip, defects, reset/avalanche/read noise, gain, bias
+  pedestal and structure, common mode, rounding, ADC saturation, `uint32`
+  conversion) in another; keeps scalar inputs (`background`, `extra_electrons`,
+  the EM-gain scale, the CIC rate) on the host instead of uploading them every
+  frame; samples Poisson counts directly in the working precision; and reuses
+  the chain's `photo + dark + extra` sum as `FrameTruth.mean_electrons`. The
+  noise is drawn by the same calls in the same order and the fused kernels
+  repeat the same floating-point operations (FMA contraction off), so every
+  seeded GPU frame and truth array is unchanged; a new GPU test compares them
+  bit for bit against the separate operations. `bench_devices.py` on an Ampere
+  Neoverse-N1 host (12 pinned cores), frames/s, 2.4.0 → now, median of three
+  interleaved runs: RTX 4060 — Pyramid 80x80 2,422 → 6,418 (2.65x),
+  Shack-Hartmann 160x160 2,424 → 6,340 (2.62x), OCAM2K 240x240 1,650 → 2,733
+  (1.66x), SAPHIRA 256x320 1,809 → 2,072 (1.15x), 1024x1024 240 → 247 (1.03x);
+  RTX A400 — Pyramid 2,403 → 6,315 (2.63x), the larger frames 1.02–1.06x.
+  Larger frames are bound by CuPy's double-precision Poisson and Gamma
+  samplers. See the [GPU guide](docs/guides/gpu.md#small-frames-fused-kernels).
+- The NumPy path skips whole-frame identity arithmetic (adding a zero offset,
+  dividing by a unit gain, multiplying by a unit avalanche-gain map) and reuses
+  the expectation sum as the truth: 1–5% faster (1024x1024: 13.4 → 14.1 frames/s
+  on the same host), with identical seeded output. It remains bound by NumPy's
+  Poisson sampler (about 80% of a 1024x1024 frame), whose single sequential
+  stream cannot be threaded without changing seeded frames.
+
+### Fixed
+
+- `benchmarks/bench_devices.py` reported the CPU of Arm hosts as `aarch64`;
+  it now reads the model from `lscpu` (e.g. `Neoverse-N1`) when
+  `/proc/cpuinfo` has no model name.
+
 ## [2.4.0] - 2026-10-07
 
 ### Added
@@ -646,7 +752,8 @@ together in 1.0.
 - Documentation, runnable examples, and CI (lint, type-check, test matrix, PyPI
   release via Trusted Publishing).
 
-[Unreleased]: https://github.com/jacotay7/getframes/compare/2.4.0...HEAD
+[Unreleased]: https://github.com/jacotay7/getframes/compare/2.5.0...HEAD
+[2.5.0]: https://github.com/jacotay7/getframes/compare/2.4.0...2.5.0
 [2.4.0]: https://github.com/jacotay7/getframes/compare/2.3.0...2.4.0
 [2.3.0]: https://github.com/jacotay7/getframes/compare/2.2.0...2.3.0
 [2.2.0]: https://github.com/jacotay7/getframes/compare/2.1.1...2.2.0

{getframes-2.4.0 → getframes-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: getframes
-Version: 2.4.0
+Version: 2.6.0
 Summary: Generate physically realistic synthetic camera frames (CCD/CMOS/EMCCD/eAPD/sCMOS) — dark, bias, flat, and rendered star fields — with auditable noise physics for scientific imaging pipelines.
 Project-URL: Homepage, https://github.com/jacotay7/getframes
 Project-URL: Documentation, https://jacotay7.github.io/getframes/
@@ -174,6 +174,10 @@ for the methodology.
 - **Calibration & ground truth** — master bias/dark/flat builders and a
   `calibrate` reduction that closes the
   **[raw → reduced → truth loop](https://jacotay7.github.io/getframes/guides/calibration/)**.
+- **Wavefront-sensor cameras** — `Calibration` turns ADU back into
+  input-referred electrons and photons, `Camera.effective_read_noise_e` gives
+  the input-referred noise, and a guide covers
+  **[a WFS camera in a closed loop](https://jacotay7.github.io/getframes/guides/wfs-closed-loop/)**.
 - **Observations** — `Observation` drives time series with jitter, drift, dither
   and persistence, carrying per-frame
   **[truth](https://jacotay7.github.io/getframes/guides/time-series/)**.

{getframes-2.4.0 → getframes-2.6.0}/README.md

@@ -127,6 +127,10 @@ for the methodology.
 - **Calibration & ground truth** — master bias/dark/flat builders and a
   `calibrate` reduction that closes the
   **[raw → reduced → truth loop](https://jacotay7.github.io/getframes/guides/calibration/)**.
+- **Wavefront-sensor cameras** — `Calibration` turns ADU back into
+  input-referred electrons and photons, `Camera.effective_read_noise_e` gives
+  the input-referred noise, and a guide covers
+  **[a WFS camera in a closed loop](https://jacotay7.github.io/getframes/guides/wfs-closed-loop/)**.
 - **Observations** — `Observation` drives time series with jitter, drift, dither
   and persistence, carrying per-frame
   **[truth](https://jacotay7.github.io/getframes/guides/time-series/)**.

{getframes-2.4.0 → getframes-2.6.0}/benchmarks/bench_devices.py

@@ -112,6 +112,15 @@ def _cpu_model() -> str:
                 return line.split(":", 1)[1].strip()
     except OSError:
         pass
+    # Arm /proc/cpuinfo has no "model name"; lscpu decodes the part number
+    # (e.g. "Neoverse-N1").
+    try:
+        output = subprocess.run(["lscpu"], check=True, capture_output=True, text=True).stdout
+    except (OSError, subprocess.CalledProcessError):
+        output = ""
+    for line in output.splitlines():
+        if line.startswith("Model name:"):
+            return line.split(":", 1)[1].strip()
     return platform.processor() or "unknown CPU"
 
 

getframes-2.6.0/benchmarks/bench_small_frames.py

@@ -0,0 +1,192 @@
+# SPDX-License-Identifier: MIT
+"""Benchmark small, frequent wavefront-sensor frames on the CPU.
+
+A closed-loop wavefront-sensor study calls :meth:`getframes.Camera.expose` once
+per loop step on a small frame, so per-frame latency, not throughput on large
+detectors, is what limits it. This script times seeded ``expose`` calls on a
+256x256 Shack-Hartmann-like spot pattern (16x16 subapertures of 16x16 pixels,
+one Gaussian spot each) for one preset of each WFS detector class, at a
+photon-starved and a bright flux, in two call styles:
+
+* ``default``: ``expose(rate, t, seed=s, include_truth=False)``;
+* ``workspace``: the same with a reused :class:`getframes.DetectorWorkspace` and
+  a caller-owned ``out`` frame.
+
+It also records a SHA-256 digest of a few seeded frames per configuration, so two
+revisions can be compared for bit-identical output (``--compare``). Timings are
+process CPU time per frame over interleaved, warmed blocks (the chain is
+single-threaded); they are machine dependent and are not part of the test gate.
+Each case reports the median and the best (minimum) block; on a shared host,
+compare the best blocks, which other load can only inflate.
+
+Run from the repository root::
+
+    python benchmarks/bench_small_frames.py --output small-frame-results.json
+    python benchmarks/bench_small_frames.py --compare before.json after.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import platform
+import statistics
+import time
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+import getframes as gf
+
+SHAPE = (256, 256)
+SUBAPERTURE_PX = 16
+EXPOSURE_S = 1e-3
+#: One preset per detector class a WFS is built from.
+PRESETS = (
+    ("EMCCD", "andor_ocam2k"),
+    ("EMCCD", "andor_ixon_ultra_888"),
+    ("qCMOS", "hamamatsu_orca_quest_2"),
+    ("sCMOS", "generic_scmos"),
+    ("eAPD", "first_light_imaging_cred_one"),
+)
+#: Photons per subaperture per frame: photon-starved and bright.
+FLUXES = (100.0, 2000.0)
+DIGEST_SEEDS = (0, 1, 2)
+
+
+def spot_pattern(photons_per_subaperture: float) -> np.ndarray[Any, np.dtype[np.float64]]:
+    """A 256x256 photon map of one Gaussian spot (sigma 1.5 px) per subaperture."""
+    coordinates = np.arange(SUBAPERTURE_PX) - (SUBAPERTURE_PX - 1) / 2
+    spot = np.exp(-(coordinates[:, None] ** 2 + coordinates[None, :] ** 2) / (2 * 1.5**2))
+    spot *= photons_per_subaperture / spot.sum()
+    reps = (SHAPE[0] // SUBAPERTURE_PX, SHAPE[1] // SUBAPERTURE_PX)
+    return np.tile(spot, reps)
+
+
+def make_camera(preset: str) -> gf.Camera:
+    return gf.Camera.from_preset(preset).with_config(resolution=SHAPE, roi=None)
+
+
+def _block_ms(function: Any, calls: int) -> float:
+    # Process CPU time, not wall time: the chain is single-threaded, and CPU time
+    # is far less sensitive to other load on a shared host.
+    start = time.process_time_ns()
+    for index in range(calls):
+        function(index)
+    return (time.process_time_ns() - start) / calls / 1e6
+
+
+def bench_case(preset: str, flux: float, calls: int, repetitions: int) -> dict[str, Any]:
+    camera = make_camera(preset)
+    rate = spot_pattern(flux) / EXPOSURE_S
+    workspace = gf.DetectorWorkspace()
+    out = np.empty(SHAPE, dtype=np.uint32)
+
+    def default(seed: int) -> None:
+        camera.expose(rate, EXPOSURE_S, seed=seed, include_truth=False)
+
+    def reused(seed: int) -> None:
+        camera.expose(
+            rate, EXPOSURE_S, seed=seed, include_truth=False, workspace=workspace, out=out
+        )
+
+    for seed in range(10):
+        default(seed)
+        reused(seed)
+    samples: dict[str, list[float]] = {"default": [], "workspace": []}
+    variants = [("default", default), ("workspace", reused)]
+    for repetition in range(repetitions):
+        for name, function in variants if repetition % 2 == 0 else variants[::-1]:
+            samples[name].append(_block_ms(function, calls))
+
+    digest = hashlib.sha256()
+    for seed in DIGEST_SEEDS:
+        frame = camera.expose(rate, EXPOSURE_S, seed=seed)
+        digest.update(np.ascontiguousarray(frame.data).tobytes())
+        assert frame.truth is not None
+        digest.update(np.ascontiguousarray(frame.truth.mean_electrons).tobytes())
+    return {
+        "preset": preset,
+        "photons_per_subaperture": flux,
+        "default_ms": statistics.median(samples["default"]),
+        "workspace_ms": statistics.median(samples["workspace"]),
+        "default_best_ms": min(samples["default"]),
+        "workspace_best_ms": min(samples["workspace"]),
+        "default_samples_ms": samples["default"],
+        "workspace_samples_ms": samples["workspace"],
+        "seeded_digest": digest.hexdigest(),
+    }
+
+
+def run(calls: int, repetitions: int) -> dict[str, Any]:
+    results = []
+    for sensor, preset in PRESETS:
+        for flux in FLUXES:
+            case = bench_case(preset, flux, calls, repetitions)
+            case["class"] = sensor
+            results.append(case)
+            print(
+                f"{sensor:6s} {preset:30s} {flux:7.0f} ph/subap  "
+                f"default {case['default_ms']:6.2f} ms  workspace {case['workspace_ms']:6.2f} ms",
+                flush=True,
+            )
+    return {
+        "schema_version": 1,
+        "getframes": gf.__version__,
+        "numpy": np.__version__,
+        "platform": platform.platform(),
+        "processor": platform.processor() or platform.machine(),
+        "shape": list(SHAPE),
+        "exposure_s": EXPOSURE_S,
+        "calls_per_block": calls,
+        "repetitions": repetitions,
+        "results": results,
+    }
+
+
+def compare(before_path: Path, after_path: Path) -> str:
+    """A Markdown table of before/after best blocks and whether seeded output matches."""
+    before = json.loads(before_path.read_text(encoding="utf-8"))
+    after = json.loads(after_path.read_text(encoding="utf-8"))
+    lines = [
+        f"Before: getframes {before['getframes']}; after: getframes {after['getframes']} "
+        f"({after['processor']}, NumPy {after['numpy']}, {after['shape'][0]}x{after['shape'][1]}).",
+        "",
+        "| Class | Preset | Photons/subap | Before (ms, best) | After (ms, best) | Speed-up | "
+        "After, workspace+out (ms, best) | Seeded output |",
+        "| --- | --- | ---: | ---: | ---: | ---: | ---: | --- |",
+    ]
+    old = {(r["preset"], r["photons_per_subaperture"]): r for r in before["results"]}
+    for row in after["results"]:
+        ref = old.get((row["preset"], row["photons_per_subaperture"]))
+        if ref is None:
+            continue
+        same = "identical" if ref["seeded_digest"] == row["seeded_digest"] else "CHANGED"
+        lines.append(
+            f"| {row['class']} | {row['preset']} | {row['photons_per_subaperture']:.0f} | "
+            f"{ref['default_best_ms']:.2f} | {row['default_best_ms']:.2f} | "
+            f"{ref['default_best_ms'] / row['default_best_ms']:.2f}x | "
+            f"{row['workspace_best_ms']:.2f} | {same} |"
+        )
+    return "\n".join(lines) + "\n"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--calls", type=int, default=40)
+    parser.add_argument("--repetitions", type=int, default=7)
+    parser.add_argument("--output", type=Path)
+    parser.add_argument("--compare", nargs=2, type=Path, metavar=("BEFORE", "AFTER"))
+    arguments = parser.parse_args()
+    if arguments.compare:
+        print(compare(*arguments.compare), end="")
+        return
+    payload = run(arguments.calls, arguments.repetitions)
+    if arguments.output is not None:
+        arguments.output.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

getframes-2.6.0/benchmarks/device-results-neoverse-n1-rtx4060.json

@@ -0,0 +1,221 @@
+{
+  "schema_version": 1,
+  "generated_at_utc": "2026-10-07T07:14:14.461693+00:00",
+  "command": "/home/jtaylor/miniforge3/envs/aosim-bench/bin/python benchmarks/bench_devices.py --seconds 2 --warmup 10 --device both --output /home/jtaylor/aosim-bench-logs/artifacts/getframes-device-rtx4060.json",
+  "revision": "7b01daf765d432ab141176548f2b11cf0e7fc11c",
+  "source_dirty": true,
+  "python": "3.13.15 | packaged by conda-forge | (main, Sep  2 2026, 22:02:03) [GCC 15.3.0]",
+  "platform": "Linux-6.17.9-76061709-generic-aarch64-with-glibc2.39",
+  "processor": "aarch64",
+  "cpu": "Neoverse-N1",
+  "gpu": "NVIDIA GeForce RTX 4060",
+  "dependencies": {
+    "getframes": "2.4.0",
+    "numpy": "2.5.3",
+    "scipy": "1.18.1",
+    "cupy": "14.2.0"
+  },
+  "methodology": {
+    "seconds_per_cell": 2.0,
+    "warmup_frames": 10,
+    "persistent_camera": true,
+    "device_resident_rate_and_output": true,
+    "include_truth": true,
+    "rng": "one generator seeded at camera construction and advanced per frame",
+    "cuda_synchronization": "before and after each timed region",
+    "construction_included": false,
+    "host_transfers_included": false
+  },
+  "results": [
+    {
+      "workflow": "pyramid_cmos_80",
+      "label": "Pyramid WFS CMOS",
+      "preset": "generic_cmos",
+      "sensor": "CMOS",
+      "shape": [
+        80,
+        80
+      ],
+      "precision": "float32",
+      "exposure_s": 0.001,
+      "photon_rate_per_s": 2000000.0,
+      "device": "cpu",
+      "frames": 4295,
+      "elapsed_s": 2.0004646239976864,
+      "frame_s": 0.000465765919440672,
+      "frames_per_s": 2147.001225853703,
+      "megapixels_per_s": 13.740807845463701
+    },
+    {
+      "workflow": "pyramid_cmos_80",
+      "label": "Pyramid WFS CMOS",
+      "preset": "generic_cmos",
+      "sensor": "CMOS",
+      "shape": [
+        80,
+        80
+      ],
+      "precision": "float32",
+      "exposure_s": 0.001,
+      "photon_rate_per_s": 2000000.0,
+      "device": "gpu",
+      "frames": 5011,
+      "elapsed_s": 2.0001363799965475,
+      "frame_s": 0.0003991491478739867,
+      "frames_per_s": 2505.329161608795,
+      "megapixels_per_s": 16.034106634296286
+    },
+    {
+      "workflow": "shack_hartmann_cmos_160",
+      "label": "Shack-Hartmann WFS CMOS",
+      "preset": "generic_cmos",
+      "sensor": "CMOS",
+      "shape": [
+        160,
+        160
+      ],
+      "precision": "float32",
+      "exposure_s": 0.001,
+      "photon_rate_per_s": 2000000.0,
+      "device": "cpu",
+      "frames": 1149,
+      "elapsed_s": 2.001656759006437,
+      "frame_s": 0.001742085952137891,
+      "frames_per_s": 574.0244898782395,
+      "megapixels_per_s": 14.69502694088293
+    },
+    {
+      "workflow": "shack_hartmann_cmos_160",
+      "label": "Shack-Hartmann WFS CMOS",
+      "preset": "generic_cmos",
+      "sensor": "CMOS",
+      "shape": [
+        160,
+        160
+      ],
+      "precision": "float32",
+      "exposure_s": 0.001,
+      "photon_rate_per_s": 2000000.0,
+      "device": "gpu",
+      "frames": 5026,
+      "elapsed_s": 2.000239181012148,
+      "frame_s": 0.0003979783487887282,
+      "frames_per_s": 2512.699504994586,
+      "megapixels_per_s": 64.3251073278614
+    },
+    {
+      "workflow": "ocam2k_emccd_240",
+      "label": "OCAM2K EMCCD",
+      "preset": "andor_ocam2k",
+      "sensor": "EMCCD",
+      "shape": [
+        240,
+        240
+      ],
+      "precision": "float32",
+      "exposure_s": 0.001,
+      "photon_rate_per_s": 2000000.0,
+      "device": "cpu",
+      "frames": 288,
+      "elapsed_s": 2.003861945006065,
+      "frame_s": 0.006957853975715504,
+      "frames_per_s": 143.72247585106385,
+      "megapixels_per_s": 8.278414609021278
+    },
+    {
+      "workflow": "ocam2k_emccd_240",
+      "label": "OCAM2K EMCCD",
+      "preset": "andor_ocam2k",
+      "sensor": "EMCCD",
+      "shape": [
+        240,
+        240
+      ],
+      "precision": "float32",
+      "exposure_s": 0.001,
+      "photon_rate_per_s": 2000000.0,
+      "device": "gpu",
+      "frames": 3420,
+      "elapsed_s": 2.0004429029941093,
+      "frame_s": 0.000584924825436874,
+      "frames_per_s": 1709.621401781179,
+      "megapixels_per_s": 98.47419274259589
+    },
+    {
+      "workflow": "saphira_eapd_256x320",
+      "label": "SAPHIRA eAPD",
+      "preset": "leonardo_saphira",
+      "sensor": "EAPD",
+      "shape": [
+        256,
+        320
+      ],
+      "precision": "float32",
+      "exposure_s": 0.001,
+      "photon_rate_per_s": 2000000.0,
+      "device": "cpu",
+      "frames": 228,
+      "elapsed_s": 2.0011549520131666,
+      "frame_s": 0.00877699540356652,
+      "frames_per_s": 113.93420572986187,
+      "megapixels_per_s": 9.333490133390285
+    },
+    {
+      "workflow": "saphira_eapd_256x320",
+      "label": "SAPHIRA eAPD",
+      "preset": "leonardo_saphira",
+      "sensor": "EAPD",
+      "shape": [
+        256,
+        320
+      ],
+      "precision": "float32",
+      "exposure_s": 0.001,
+      "photon_rate_per_s": 2000000.0,
+      "device": "gpu",
+      "frames": 3786,
+      "elapsed_s": 2.000311462994432,
+      "frame_s": 0.000528344284995888,
+      "frames_per_s": 1892.7052461782241,
+      "megapixels_per_s": 155.05041376692012
+    },
+    {
+      "workflow": "science_cmos_1024",
+      "label": "Large science CMOS",
+      "preset": "generic_cmos",
+      "sensor": "CMOS",
+      "shape": [
+        1024,
+        1024
+      ],
+      "precision": "float32",
+      "exposure_s": 5.0,
+      "photon_rate_per_s": 200.0,
+      "device": "cpu",
+      "frames": 27,
+      "elapsed_s": 2.000652825983707,
+      "frame_s": 0.07409825281421137,
+      "frames_per_s": 13.495594862504088,
+      "megapixels_per_s": 14.151156878545088
+    },
+    {
+      "workflow": "science_cmos_1024",
+      "label": "Large science CMOS",
+      "preset": "generic_cmos",
+      "sensor": "CMOS",
+      "shape": [
+        1024,
+        1024
+      ],
+      "precision": "float32",
+      "exposure_s": 5.0,
+      "photon_rate_per_s": 200.0,
+      "device": "gpu",
+      "frames": 525,
+      "elapsed_s": 2.2030622210004367,
+      "frame_s": 0.0041963089923817845,
+      "frames_per_s": 238.30466293484497,
+      "megapixels_per_s": 249.880550241568
+    }
+  ]
+}