CLAUDE.md
Context for continuing work on this dataset. Captures the design decisions, conventions, and operational details worked out so far. Read this before touching the ETL or schema.
What this dataset is
Inova-Mk1-Telemetry is the tick-anchored printer-state dataset: one row per 10 Hz recorder tick, with the full sensor snapshot (~64 columns: temperatures, position, power, lights) on every row, the nearest camera frame bytes embedded inline when one fell in the prior 100 ms window, and 1 kHz position_hf events from that window collected as a per-tick list.
It is the third leaf in the Inova Mk1 dataset ecosystem alongside Inova-Mk1-Database (canonical printer entities) and Inova-Mk1-ASTM (mechanical-test specimens).
Unlike the other two, this dataset has no local source/ directory — its raw inputs are the flat exports written by the recorder repo (Agentic-Additive-Manufacturing-Process-Optimization), which contains this dataset as a submodule at datasets/Inova-Mk1-Telemetry. The ETL here reshapes those flat exports into one parquet file per build.
Data lineage — printer to row
End-to-end, before this dataset's ETL touches anything:
┌────────────────────────────┐
│ Inova Mk1 SLS printer │ firmware events: position, temp, power, lights;
│ (SLS4All.Compact) │ camera frames (chamber, galvo, thermal);
│ on 192.168.1.146 │ high-rate position events (~1 kHz, native).
└──────────────┬─────────────┘
│ HTTP (port 5001) + WebSocket
▼
┌────────────────────────────┐
│ Inova-API-Plugin │ C# plugin running inside the printer firmware.
│ (sls4all/Inova-API-Plugin)│ Authoritative source for sensor semantics:
│ │ • InovaApiPlugin.cs → defines /state/snapshot
│ │ • exposes /movement/position/stream (~1 kHz WS)
│ │ • exposes /temperature/bedmatrix/stream (~2 Hz WS)
│ │ • exposes /plotter/commands/stream (per slicer cmd)
└──────────────┬─────────────┘
│ REST polling + WS streams
▼
┌────────────────────────────┐
│ Recorder repo │ TypeScript/Fastify server runs as a long-lived
│ (Agentic-Additive-…-Opt) │ background process; writes to Postgres + image
│ │ files on disk.
│ │ server/src/recorder/telemetry.ts
│ │ • polls /state/snapshot @ 10 Hz
│ │ • expand() explodes each frame into the
│ │ deterministic ~64 (sensor_id, kind) rows
│ │ of the `telemetry` table
│ │ server/src/recorder/positionStream.ts
│ │ • subscribes WS /movement/position/stream
│ │ • writes `position_hf` rows on motion events
│ │ server/src/recorder/camera.ts
│ │ • polls firmware HTTP frame endpoints
│ │ • writes JPG/PNG/GIF to data/frames/{build}/
│ │ • writes one row per file in `frames` table
└──────────────┬─────────────┘
│ scripts/export.py (in the recorder repo)
▼
┌────────────────────────────┐
│ Flat exports │ Idempotent dumps of the live Postgres + frame
│ data/exports/ │ files. Contract surface between the recorder
│ in the recorder repo │ repo and this dataset.
│ │ builds.jsonl — 30 builds
│ │ events.jsonl — sparse
│ │ frames.jsonl — ~1.27 M
│ │ plotter_commands.jsonl — 0 rows
│ │ telemetry/{build_id}.parquet — ~10 files
│ │ position_hf/{build_id}.parquet — sparse
│ │ build_to_inova_session.csv — sidecar
│ │ sensors.csv — sidecar
└──────────────┬─────────────┘
│ scripts/ticks/01_extract.py (here)
▼
┌────────────────────────────┐
│ This dataset │ Per-build wide parquet, one row per 10 Hz tick.
│ data/ticks/{NNN}.parquet │ Embedded image bytes, denormalized build
│ │ context, ~79 columns including position burst.
└────────────────────────────┘
The two sidecar CSVs at the recorder layer (build_to_inova_session.csv, sensors.csv) are hand-annotated by a human, not generated. They're checked into the recorder repo and read by this dataset's ETL via the containing-repo path.
How the data is captured
The repos
Two GitHub repos own the upstream data path. Both belong to the same user; neither is a fork.
| Repo | URL | What it is |
|---|---|---|
| Recorder | https://github.com/ppak10/Agentic-Additive-Manufacturing-Process-Optimization | TypeScript/Fastify server + dockerized Postgres + Python tooling. Owns the live DB, the image files, and scripts/export.py. This dataset's ETL depends on its data/exports/ tree. |
| Inova plugin | https://github.com/ppak10/Inova-API-Plugin | C# plugin loaded by the SLS4All firmware on the printer. Exposes the REST + WebSocket endpoints the recorder polls. Authoritative source for sensor semantics (InovaApiPlugin.cs). |
The recorder also pins sls4all/SLS4All.Compact as a submodule at tag public/1.195.0 — that's the SLS4All firmware itself, kept as a read-only vendor reference. Don't touch it; it's there so the plugin can build against a known firmware ABI.
Submodule layout inside the recorder repo:
sls4all/
Inova-API-Plugin/ # the C# plugin (our code; editable)
SLS4All.Compact/ # firmware (vendor; pinned)
Inova-Defect-Detection-Model/# layer-wise defect detection model
datasets/
Inova-Mk1-Telemetry/ # THIS repo (update=none — never blanket --recurse-submodules; 566 GB)
Inova-Mk1-Database/ # canonical printer entities (update=none)
Inova-Mk1-ASTM/ # mechanical-test specimens (update=none)
Inova-Mk1-Conversations/ # agent transcripts (update=none)
How the recorder runs
The recorder is a single Fastify Node process plus a Postgres container. server/src/index.ts starts the HTTP API and five in-process recorder workers in parallel:
| Worker | File | What it does |
|---|---|---|
startTelemetryRecorder |
server/src/recorder/telemetry.ts |
Subscribes to plugin WS /state/stream at TELEMETRY_HZ. Calls expand() on each frame, batches ~100 rows / 200 ms, writes into telemetry table. Source of truth for ~64 sensor columns per tick. |
startCameraRecorder |
server/src/recorder/camera.ts |
Polls firmware HTTP endpoints at CAMERA_HZ for chamber and galvo frames. Writes JPG/PNG bytes to data/frames/{build_id}/{ts_ms}_{kind}.{ext} and a row to the frames table. |
startBedMatrixRecorder |
server/src/recorder/bedmatrix.ts |
Polls thermal IR matrix at THERMAL_HZ. Writes GIFs (often animated) to disk and frame rows. |
startPositionStreamRecorder |
server/src/recorder/positionStream.ts |
Subscribes to plugin WS /movement/position/stream (~1 kHz native, event-driven). Writes to position_hf only on motion. Sparse during heating, bursts during raster. |
startPlotterStreamRecorder |
server/src/recorder/plotterStream.ts |
Subscribes to plugin WS /plotter/commands/stream. Writes one row per CodeCommand to plotter_commands. Newer than the historical builds — 0 rows currently. |
startJobDetector |
server/src/recorder/job.ts |
Watches firmware state to open/close builds rows (sets started_at, phase, ended_at). One build is created per print run. |
All workers also write structured rows into events on state transitions.
Runtime configuration
The recorder reads .env at startup (.env.example in the repo shows the keys, redacted). Key settings:
INOVA_API_BASE_URL=http://192.168.1.146:5001 # plugin REST/WS port
INOVA_FIRMWARE_BASE_URL=http://192.168.1.146 # firmware HTTP port 80
DATABASE_URL=postgres://inova:inova@localhost:5432/inova
TELEMETRY_HZ=10
CAMERA_HZ=5
THERMAL_HZ=2
FRAMES_DIR=../data/frames
The INOVA_API_BASE_URL is the on-network address of the physical printer running the firmware + plugin. If you're working remotely, the recorder can't talk to it; rely on the already-exported flat files in data/exports/ instead. The Postgres container (agentic-sls-postgres) runs locally on the same host as the Fastify server, persisted to data/postgres/ (root-owned, accessible only inside the container).
How to bring it up from scratch
Only needed if you're rebuilding the recorder side — this dataset's ETL doesn't require any of it once data/exports/ exists.
# In the recorder repo:
# Don't use blanket --recurse-submodules: this dataset (566 GB) is itself a
# submodule at datasets/Inova-Mk1-Telemetry (guarded by update=none). Init
# the submodules you need explicitly instead.
git clone git@github.com:ppak10/Agentic-Additive-Manufacturing-Process-Optimization.git
git submodule update --init sls4all/Inova-API-Plugin sls4all/SLS4All.Compact
cp .env.example .env # then fill in printer IP
docker compose up -d # brings up Postgres
cd server && npm install # then run the Fastify server in dev/prod mode
The recorder writes continuously while a build is live. When you want flat files, run python scripts/export.py in the recorder repo — that produces the JSONL/parquet/CSV tree under data/exports/ that this dataset's ETL consumes.
Ecosystem (concrete paths)
Assuming you're working on this machine (/mnt/storage2):
| Repo | Filesystem path | Role |
|---|---|---|
| This dataset | /mnt/storage2/GitHub/Agentic-Additive-Manufacturing-Process-Optimization/datasets/Inova-Mk1-Telemetry/ |
Where you are now. A submodule of the recorder repo. ETL reads the containing repo's exports; writes data/ticks/. |
| Recorder repo | /mnt/storage2/GitHub/Agentic-Additive-Manufacturing-Process-Optimization/ |
Owns the live DB + export script and contains this dataset as a submodule. The only repo this dataset depends on. This ETL reads data/exports/. |
| Database dataset | /mnt/storage2/GitHub/Agentic-Additive-Manufacturing-Process-Optimization/datasets/Inova-Mk1-Database/ |
Fellow submodule. Informational only — not a dependency. Consumers can join print_profile_name against source/PrintProfiles/*.json themselves to recover the UUID; see "Joining back to Inova-Mk1-Database" in the README. |
| ASTM dataset | /mnt/storage2/GitHub/Agentic-Additive-Manufacturing-Process-Optimization/datasets/Inova-Mk1-ASTM/ |
Fellow submodule. Independent leaf; no direct dependency. |
scripts/_lib.py resolves the recorder path relative to its own location: ROOT is the repo root (_lib.py → two .parents up), and then:
- Recorder (
AGENTIC_ROOT):ROOT.parent.parent— two climbs fromROOT(datasets/Inova-Mk1-Telemetry→datasets→ recorder root).
If you move the repo out of the recorder's datasets/ folder, that climb needs updating.
Authoritative references for sensor semantics in the recorder repo:
sls4all/Inova-API-Plugin/InovaApiPlugin.cs—/state/snapshotreturns{ position, lights, power, temperature }. Lines 85–213 are the endpoint definitions; lines 495–507 are theCaptureSnapshotshape.server/src/recorder/telemetry.tslines 25–50 —expand()is the only place that defines which(sensor_id, kind)rows get written. Every row in thetelemetrytable is one entry from this function. Read this file before assuming what a column means.server/src/db/schema.sql— canonical DDL for all 6 Postgres tables.
Running the ETL
Prerequisites
- Sibling recorder repo at the expected path with a populated
data/exports/directory. If it doesn't exist or is stale, runscripts/export.pythere first. The recorder DB has to be reachable (Docker containeragentic-sls-postgres) for the exporter to work. - uv installed;
pyproject.tomldeps (pyarrow,polars) will be installed viauv syncor auto-resolved byuv run.
This dataset has no other repo dependencies at ETL time. In particular, Inova-Mk1-Database is not required — print_profile_name is preserved as a string and consumers can resolve the UUID themselves if they want.
Commands
# All builds with telemetry (full rebuild — ~2 hours, ~30 GB output)
uv run scripts/ticks/01_extract.py
# One or more specific builds (smoke test or incremental)
uv run scripts/ticks/01_extract.py 13 # ~2 min for build 13
uv run scripts/ticks/01_extract.py 13 26 28 # build 26 is ~30 min on its own
The script always overwrites existing data/ticks/{build_id:03d}.parquet files — there's no skip-if-exists check. If you want incremental behavior, pass only the build IDs you want to refresh.
Expected wall-time and output sizes
From the last full run (10 builds, 1.01 M ticks total, completed 2026-06-24):
| build_id | ticks | size | notes |
|---|---|---|---|
| 1 | 102,805 | 2.9 GB | "Hex Coasters" Init/BedPrep phase |
| 2 | 68 | 2.4 MB | partial — recorder joined mid-run |
| 12 | 201,660 | 4.6 GB | "Hex Coasters" Layers phase |
| 13 | 13,811 | 527 MB | "D790 + D638 + Benchy" Heating |
| 14 | 2 | 48 KB | failed heating attempt |
| 16 | 14 | 788 KB | failed heating attempt |
| 17 | 2 | 32 KB | failed heating attempt |
| 25 | 24 | 1.2 MB | failed heating attempt |
| 26 | 355,580 | 11 GB | longest run (9h54m) |
| 28 | 340,162 | 11 GB | 2026-06-07 print, 9h28m |
| total | 1.01 M | 30 GB | wall time: 2h 7m |
Wall time is dominated by IO — each non-null frame_* column triggers a disk read from data/frames/{build_id}/{ts_ms}_{kind}.{ext} in the recorder repo. CPU/RAM are unremarkable.
Verifying output
# Schema sanity
uv run python -c "
import pyarrow.parquet as pq
pf = pq.ParquetFile('data/ticks/026.parquet')
print(f'rows: {pf.metadata.num_rows:,}, row_groups: {pf.metadata.num_row_groups}')
for f in pf.schema_arrow:
if f.name.startswith('frame_'):
print(f' {f.name}: {f.type}')
"
# Expected: struct<bytes: binary, path: string> on all three frame_* columns.
# Decode one embedded image to confirm bytes are valid
uv run --with pillow python -c "
import polars as pl, io
from PIL import Image
df = pl.read_parquet('data/ticks/026.parquet', columns=['frame_chamber'])
row = df.filter(pl.col('frame_chamber').is_not_null()).head(1).row(0, named=True)
img = Image.open(io.BytesIO(row['frame_chamber']['bytes']))
print(img.format, img.size)
"
# Expected: JPEG (600, 650) or similar.
# Frame-attached rates per build
uv run python -c "
import polars as pl
df = pl.read_parquet('data/ticks/026.parquet',
columns=['frame_chamber','frame_galvo','frame_thermal'])
for c in df.columns:
print(f'{c}: {df[c].is_not_null().sum():,} / {df.height:,}')
"
# Expected: chamber ~36%, galvo ~37%, thermal ~16%.
Where humans must intervene
Two pieces of context can't be derived; they live in the recorder repo and someone has to edit them by hand:
Agentic-…-Optimization/data/exports/build_to_inova_session.csv— mapsbuild_id→inova_session_id UUID. Until filled in,inova_session_idis null in every row here and consumers fall back to name-based joining viaprint_profile_name. Recommended cadence: edit when you add a new build that maps to a knownPrintSession.Agentic-…-Optimization/data/exports/sensors.csv—(sensor_id, kind, unit, description). Theunitanddescriptioncolumns are blank by default. This dataset's card cites those values when describing column meanings. Until filled in, we hardcode firmware conventions (temps °C, power W, position microns) in this CLAUDE.md and in the README.
Neither blocks the ETL. They improve dataset metadata.
Architectural decisions
- One config, not four. Early iteration had separate
builds,telemetry,position_hf, andframesconfigs. Replaced with a singleticksconfig because ML consumers almost always want the joined view: state + frame + position at one moment in time. The four-silo version pushed the join cost onto every downstream user. - Anchor on the 10 Hz telemetry tick, not strict outer join. The recorder's
/state/snapshotpoll fires at 10 Hz andexpand()emits a deterministic ~64-row burst into thetelemetrytable — so a tick already represents a full state snapshot. Anchoring on ticks gives every row densely populated columns; frames andposition_hfattach to the tick they're closest to. A strict outer join across all stream timestamps gave ~3M mostly-sparse rows for less ML value. - Wide format, dotted column names matching upstream. Sensor columns are named exactly
{sensor_id}.{kind}— e.g.powderBed.temp.current,laser.power,positions.position.x. This matches the upstreamsensors.csvglossary 1:1 so unit annotations land where consumers will look. ~64 sensor columns + build context + frame paths + bedmatrix + position burst = 79 columns total. - Frames attach by nearest-before-tick within a 100 ms window and the image bytes are embedded inline. Frame timestamps don't align with telemetry ticks (chamber 5 Hz, thermal 2 Hz, galvo varies). For each tick we look back 100 ms and grab the most recent frame of each kind; nulls when nothing landed. Each
frame_*column is a struct of{bytes: binary, path: string}matching HF'sImagefeature wire format — declared asdtype: imagein the README sodatasetsdecodes toPIL.Imageon access. Thepathfield inside the struct is the original relative filename ("26/1780265532038_chamber.jpg") preserved for traceability back to the recorder repo. - Null is preserved when no frame attaches — we explicitly did not forward-fill the latest captured frame. Reason: shuffled training with forward-fill would pair the same image with widely varying telemetry rows (e.g. one chamber jpg stamped onto thousands of consecutive ticks during a 30-min heating phase), teaching the model spurious associations. Filtering null-frame rows at consume time is a one-liner; recovering "this image is stale" from a forward-filled column is impossible.
bedmatrixis the IR temperature matrix as raw numbers, not a rendered image. It attaches nearest-before-tick within the same 100 ms window as frames, but embeds as a numeric struct{width: int32, height: int32, values: list<float32> (row-major °C), path: string}— a 32×24 = 768-cell bed-surface temperature grid, null when nothing landed. History: through 2026-07-12 the same sensor was captured as a pre-rendered GIF heatmap under frame kindthermal(the source offrame_thermal, HTTP-polled from/api/bedmatrix/image/). Recorder commit8d98e0cdropped that poll; the dedicatedbedmatrix.tsWS recorder (/temperature/bedmatrix/stream) now streams the raw matrix as JSON under kindbedmatrix. That JSON stream has actually run since build 13, sobedmatrixbackfills across the whole dataset and is strictly richer than the old heatmap. Consequence:frame_thermalis null for builds captured after 2026-07-12 (044 is the last with it; 046 has none) — usebedmatrixfor thermal from there on. To recover a heatmap image, colormapvaluesreshaped toheight × width.position_hfpreserved as per-tick bursts. The firmware emitsPositionChangedHighFrequencyevent-driven, not at fixed 1 kHz — so it bursts during motion and is empty during heating. We keep the full burst inside each tick's window asposition_hf_burst: list<struct<ts_offset_ms, x, y, z1, z2, r, has_homed>>. Empty list when no motion. Lossless within the 100 ms window; the rawposition_hf/{build_id}.parquetupstream is the fallback if you need motion data between ticks.- Build context denormalized into every row.
build_id,job_name,started_at,ended_at,phase,print_profile_name,inova_session_idrepeat on every row. Parquet dictionary encoding makes this essentially free (~1 byte per row regardless of value). print_profile_nameonly, noprint_profile_id. The recorder'sevents.jsonlcarries the name a build started with; the UUID lives inInova-Mk1-Database/source/PrintProfiles/*.json. Earlier versions of the ETL cached the name→UUID lookup into aprint_profile_idcolumn, but doing that turnedInova-Mk1-Databaseinto an ETL-time dependency for a one-line consumer join. We dropped the column so this dataset stands on its own with only the recorder repo. Consumers who want the UUID can join externally — see the README section "Joining back to Inova-Mk1-Database."- One parquet file per build.
data/ticks/{build_id:03d}.parquet(zero-padded to 3 digits so a lexicallssorts numerically and the layout caps cleanly at 999 builds). HF globsdata/ticks/*.parquetto load the full dataset. Builds without telemetry produce no file; consumers should expect missing build IDs. - Polars for the pivot + asof joins. ~22 M telemetry rows (build 26) pivot to ~355 K ticks in seconds. Polars'
pivotandjoin_asof(tolerance=100ms)do the heavy lifting; the position_hf burst is a manual sorted-merge. - Streaming chunked write for the embed step. With image bytes inlined, build 26 alone is
11 GB on disk. The writer is a500 MB even for thermal-heavy builds). Polars handles the upstream pivot/join; pyarrow handles the streaming output.pyarrow.parquet.ParquetWriterfedCHUNK_ROWS=2000-row slices; each slice does its own image-bytes read, so peak working set per chunk is bounded (
Directory layout
.python-version # 3.13
pyproject.toml # pyarrow, polars, imageio[ffmpeg], pillow, numpy
.gitattributes # *.parquet, *.mp4, *.gif → LFS
scripts/
_lib.py # recorder-repo paths + JSONL streaming
ticks/
00_recover_spool41.py # one-off: recover build 41 from NVMe spool (DB was wiped)
00_export_new_db.py # one-off: export DB builds with ID remap (old_id:new_id; identity N:N since 2026-07-13)
01_extract.py # the single ETL — wide-pivot + asof + burst + embed
previews/
01_render.py # per-build MP4 previews from data/ticks/
02_timelapse.py # per-build timelapse GIFs, one frame per print layer
data/
ticks/{build_id:03d}.parquet # LFS; e.g. 001.parquet, 026.parquet
previews/
{build_id:03d}/
chamber.mp4 # LFS; optical, forward-filled, 10 fps real-time
thermal.mp4 # LFS; IR matrix
galvo.mp4 # LFS; scan-mirror trace
composite.mp4 # LFS; 1×3 panel: chamber | thermal | galvo
timelapse_chamber.gif # LFS; layer-by-layer GIF, 25 fps, ≤ 12 s
timelapse_thermal.gif # LFS
timelapse_galvo.gif # LFS
timelapse_composite.gif # LFS; 1×3 panel GIF
There is no source/ (raw data lives in the containing recorder repo's data/exports/).
scripts/ticks/01_extract.py is organized as:
load_builds_index()/load_frames_for_build()— load upstream JSONLpivot_telemetry()— long-to-wide on(sensor_id, kind)attach_frames()— threejoin_asof(strategy='backward', tolerance=100ms)callsattach_bedmatrix()— one morejoin_asoffor the IR matrix JSON pathattach_position_hf()— manual sorted-merge to build the burst listsdenormalize_build()—pl.lit()columns for build context_embed_frame_column()/_embed_bedmatrix_column()/_embed_chunk()/process_build()— chunked write with pyarrowParquetWritermain()— iterate target build IDs, callprocess_build()per build
Row shape
# per row, ~79 columns:
{
# Build context (denormalized; same on every row of a given file)
"build_id": 26,
"ts": datetime(2026, 6, 2, 21, 16, 53, 936, tzinfo=UTC),
"job_name": "D790 and D638 and Benchy 2026_06_02",
"started_at": "...", "ended_at": "...",
"phase": "Heating",
"print_profile_name": "2026_05_30 20mJ/mm Formlabs PA12 GF",
"inova_session_id": None, # filled when upstream CSV is curated
# Position (microns, firmware native) — always present
"positions.position.x": ..., "positions.position.y": ...,
"positions.position.z1": ..., "positions.position.z2": ...,
"positions.position.r": ...,
# Lights
"lights.lights.enabled": 0.0,
"lights.lights.count": 4.0,
# Power (W) — ~9 columns
"laser.power": 1140.0, "fanGalvo.power": ..., "buzzer.power": ...,
"powerman.power.current": 1140.0, "powerman.power.required": 1540.0,
"powerman.power.max": 1300.0,
...
# Temperature (°C) — ~51 columns
"powderBed.temp.current": 97.32, "powderBed.temp.average": 97.11,
"powderBed.temp.target": 100.0,
"printBed.temp.current": ..., "printChamber1.temp.current": ...,
"quadrant1.temp.current": ..., "surfaceAvg.temp.average": ...,
...
# Frames — embedded HF Image structs (PIL.Image on load) or None
"frame_chamber": {"bytes": b"\xff\xd8...", "path": "26/1780265532038_chamber.jpg"},
"frame_galvo": {"bytes": b"\x89PNG...", "path": "26/1780265532040_galvo.png"},
"frame_thermal": None, # legacy GIF heatmap; null for builds after 2026-07-12
# IR temperature matrix (raw numbers, replaces frame_thermal) — struct or None
"bedmatrix": {"width": 32, "height": 24,
"values": [97.3, 97.1, ...], # 768 floats, row-major °C
"path": "26/1780433796515_bedmatrix.json"},
# 1 kHz position-stream burst within (tick_ts - 100ms, tick_ts]
"position_hf_burst": [
{"ts_offset_ms": -84.2, "x": 0.123, "y": 0.045, "z1": ..., "has_homed": True},
{"ts_offset_ms": -32.7, "x": 0.131, "y": 0.046, ...},
],
}
Sensor groups (from expand() in the recorder)
The ~64 sensor columns break down by group. All four come from a single /state/snapshot GET, so they share the tick timestamp exactly:
| Group | Columns | Source |
|---|---|---|
| Position (10 Hz) | positions.position.{x,y,z1,z2,r} — 5 cols |
s.position[k] for k in (x,y,z1,z2,r). Microns, firmware native. |
| Lights | lights.lights.{enabled,count} — 2 cols |
s.lights.{isEnabled,lightCount}. enabled is 0/1. |
| Power (W) | {e.id}.power for each s.power.entries — typically {laser,fanGalvo,buzzer,laserSafety,io-en,wd-en,wd-in} — 7 cols, plus powerman.power.{current,required,max} — 3 cols |
s.power.entries[].id is the per-device draw; powerman.* is the manager state. |
| Temperature (°C) | {e.id}.temp.{current,average,target} for each s.temperature.entries — typically {powderBed, printBed, powderChamber1..4, printChamber1..4, quadrant1..4, surface, surfaceAvg, surfaceMin, surfaceMax, testTemp1} — ~51 cols total |
e.targetTemperature is omitted when null, so temp.target columns can be null even when current/average are populated. |
If expand() in the recorder ever changes, all of those column names change with it — no normalization here.
Important gotchas
frame_*bytes are embedded;pathinside the struct is recorder-relative. Each non-null frame column carries the actual image bytes plus the original relative path ("26/1780265532038_chamber.jpg", meaningAgentic-Additive-Manufacturing-Process-Optimization/data/frames/...). The path is for traceability only — consumers don't need the recorder repo to access the image. The unattached frames (~half of the 1.27 M captured) still live only in the recorder repo; this dataset only carries the per-tick attached subset.frame_thermalis legacy and null for builds captured after 2026-07-12; usebedmatrixinstead. The recorder stopped polling the pre-rendered IR heatmap GIF (commit8d98e0c) and now streams the raw 32×24 temperature matrix as JSON under kindbedmatrix. Build 044 is the last withframe_thermal; 046 onward has none.bedmatrixis a numeric struct ({width, height, values: list<float32> row-major °C, path}), backfilled across the whole dataset (the JSON stream has run since build 13), and strictly richer — colormapvaluesreshaped toheight × widthto recover a heatmap. The preview renderers now do exactly this:previews/*/thermal.mp4,composite.mp4,timelapse_thermal.gif, andtimelapse_composite.gifrender the thermal panel frombedmatrix(inferno colormap over a fixed 20–200 °C range; seescripts/previews/_thermal.py), falling back toframe_thermalonly for the three earliest builds (001/002/012) that predate the stream. So thermal previews exist for all builds, including post-2026-07-12 ones.positions.position.*columns are 10 Hz, not 1 kHz. They come from the snapshot'spositionfield. For 1 kHz fidelity during motion, readposition_hf_burst.inova_session_idis always null until someone curatesbuild_to_inova_session.csvin the recorder repo. Consumers who need an entity-graph link can fall back to joining onprint_profile_nameagainstInova-Mk1-Databasemeanwhile.build_idis a Postgres BIGSERIAL, not a UUID. One DatabasePrintSessionmay have manybuild_ids (one per recorder restart / attempt). That's why session-id mapping must be hand-authored.- Sensor units are firmware-convention, not labeled in this dataset.
*.temp.*are °C,*.power*are W,positions.position.*are microns (firmware native; divide by 1000 for mm). Authoritative annotations live in the upstreamsensors.csvglossary; when it's filled in, the dataset card will be updated. - Builds without
telemetry/{build_id}.parquetproduce no file here.data/ticks/will have gaps for failed-heating runs (typically 12–38 s with zero recorded telemetry). - The 100 ms window is the recorder's tick interval. Frame attachment is "the most recent frame within the prior tick interval"; this is a design choice (could be wider or interpolated). If a frame is more than 100 ms stale at tick time, it's null even if it's the closest existing frame. Consider widening the window if frame_kind null rates feel too high.
- The ETL always overwrites. No skip-if-exists. If you only want incremental refresh, pass specific build IDs on the command line.
eventsandplotter_commandsupstream tables are not exposed here.events(78 rows) is sparse;plotter_commands(0 rows) postdates the historical builds. Both stay upstream-only for v1.- The recorder repo is a moving target. It's actively developed; new sensors, new build records, schema changes can appear. Diff
server/src/db/schema.sqlandserver/src/recorder/telemetry.tsagainst your last known state before relying on column names.
Current state
ticksconfig: 26 parquet files across builds 001–046 (with gaps; 045 is an empty/aborted build with no telemetry, so no file). Build 041 was recovered from the NVMe spool after the Postgres DB was wiped. Builds 042–043 were added under the old offset scheme; builds 044 and 046 were added 2026-07-13 via identity mapping now that the DB realigned to 1:1 — see "Build ID mapping" below.print_profile_nameis preserved on every row; theprint_profile_idUUID is not materialized here (see the architectural decision above).eventsandplotter_commandsnot surfaced as configs.peregrineconfig (added 2026-07-19): sparse, defect-labeled counterpart toticks, shaped like the ORNL Peregrine dataset — one row per labeled layer,data/peregrine/{build:03d}.parquet, built byscripts/peregrine/01_extract.pyfromsource/labels/+data/frames_index/+source/telemetry/. Images are raw JPEG/PNGbinary(post-recoat chamber =image_after_powder, post-scan chamber =image_after_melt, galvo =part_mask), labels are bbox-levellist<{class,bbox,polarity}>+has_<class>bools + a few process scalars. Only re-runs the changed build (no full rewrite). Post-recoat vs post-scan stills are split by the z2 step preceding each label (z2 ramps monotonically to ~29 mm — it does NOT cycle to 0 per recoat; don't reuse the return-to-0 heuristic). Prereqs per build:sls-export+sls-export-labels+sls-deliver-framesmust have run.- Forward-fill semantics deferred. Current attach is "fresh frame within 100 ms of tick or null." Carrying the latest captured frame forward to fill null rows is left to consumers (one-line groupby + ffill); baking it into the dataset would destroy the fresh-vs-stale signal that's the whole point of keeping nulls.
previews/MP4s and timelapse GIFs: rendered through 046. Timelapse GIFs re-rendered 2026-07-13 withCHAMBER_BRIGHTNESS_RATIOraised 0.25 → 0.5 to drop dim-frame flashes.
Build ID mapping
History. The recorder's Postgres DB was wiped between build 040 and the next print (2026-07-09). The new DB briefly restarted its builds_id_seq at 1, so builds 042–043 were added under an offset (DB id 1→042, 2→043) to avoid colliding with the existing dataset files.
Current state (verified 2026-07-13). The DB has since realigned: it now holds builds 1–46 carrying the original job names, and build_id matches the dataset id 1:1 — no offset needed. Builds carrying telemetry: 42, 43, 44, 46. Build 45 is empty (aborted: no ended_at, 0 telemetry rows, None job name) and produces no dataset file. The exact mechanism of the realignment (restore from backup vs. re-import) is unconfirmed; treat the DB as a moving target and re-verify IDs before each import.
To add a new build, use 00_export_new_db.py with an identity mapping (N:N) — it scopes the export to one build and appends only that build's rows to the shared JSONL files (safer than re-running the recorder's export.py):
uv run --with psycopg2-binary scripts/ticks/00_export_new_db.py 46:46
uv run scripts/ticks/01_extract.py 46
uv run scripts/previews/01_render.py 46
uv run scripts/previews/02_timelapse.py 46
Before running, query the DB to confirm the target build has ended_at set and non-zero telemetry, and that its id doesn't already have a data/ticks/{id:03d}.parquet. Don't run two 00_export_new_db.py invocations concurrently — they all append to the same builds.jsonl/frames.jsonl/events.jsonl, so parallel appends interleave and corrupt them. Run builds one at a time.
Frame files live in data/frames/{build_id}/ and the paths stored in frames.jsonl reference those same ids, so the ETL reads them without renaming.
Adding a build — recipe
If the recorder DB is healthy (sequence hasn't reset):
- New build runs in the recorder, produces telemetry / frames / position_hf in Postgres + on disk.
- Run
scripts/export.pyin the recorder repo to refreshdata/exports/. Pass--builds Nto scope to one build if you don't want to re-export everything. - (Optional) edit
Agentic-…-Optimization/data/exports/build_to_inova_session.csvfor theinova_session_idUUID. uv run scripts/ticks/01_extract.py N→data/ticks/NNN.parquetuv run scripts/previews/01_render.py N→ four MP4s underpreviews/NNN/uv run scripts/previews/02_timelapse.py N→ four timelapse GIFs underpreviews/NNN/git add data/ticks/NNN.parquet previews/NNN/(LFS) and commit.
If the DB IDs don't line up with the recorder's export.py expectations (e.g. after a reset/realignment): use 00_export_new_db.py with an old_id:new_id mapping instead of step 2 — currently an identity mapping (N:N). See "Build ID mapping" above.
Regenerate everything
rm -f data/ticks/*.parquet
uv run scripts/ticks/01_extract.py
Takes ~2 hours, produces ~30 GB. The IO is the bottleneck; the Polars pivot and asof joins are fast.
Preview videos and timelapse GIFs
MP4 previews (01_render.py)
scripts/previews/01_render.py walks data/ticks/*.parquet and emits four MP4s per build under previews/{build_id:03d}/:
chamber.mp4— optical, fromframe_chamberthermal.mp4— IR matrix, fromframe_thermalgalvo.mp4— scan-mirror trace, fromframe_galvocomposite.mp4— 1×3 panel (chamber | thermal | galvo)
Design choices:
- Real-time playback at 10 fps — output duration matches build wall-clock. Null cells are forward-filled (viewing convenience only; not training data).
- Letterbox-fit into a canvas locked by the first non-null frame (handles thermal dim drift).
- Streamed row-group iteration (
BATCH_ROWS=1000) — necessary for 11+ GB parquets. - NVENC encode (
h264_nvenc, K620 GPUs) with libx264 fallback (RENDER_CPU=1).
uv run scripts/previews/01_render.py # all builds
uv run scripts/previews/01_render.py 13 26 # specific builds
uv run scripts/previews/01_render.py 26 --kinds chamber,composite
Timelapse GIFs (02_timelapse.py)
scripts/previews/02_timelapse.py emits four animated GIFs per build:
timelapse_chamber.gif,timelapse_thermal.gif,timelapse_galvo.giftimelapse_composite.gif— 1×3 panel
Layer detection: positions.position.z2 is quantized in 100 µm buckets. Only z2 > 0 rows are used — z2 stays at 0 during pre-print heating, so this naturally excludes non-printing ticks. The last non-null frame in each z2 bucket is the representative (most-recent view of the layer just before recoating).
Playback: 25 fps, capped at 300 frames (max 12 s GIF). Builds with fewer than 300 detected layers are not padded. Null-frame levels are forward-filled within the GIF. Canvas height 240 px (half the MP4 height) to keep file sizes web-friendly.
Composite pass: does a single parquet stream reading all three frame columns at once (not three separate passes).
uv run scripts/previews/02_timelapse.py # all builds
uv run scripts/previews/02_timelapse.py 26 28 # specific builds
uv run scripts/previews/02_timelapse.py 26 --kinds chamber,composite
Always overwrites. For incremental work, name the build IDs.