data/data_dictionary.md

# Data dictionary and format spec -- LEVEL Running Dataset

This document has two parts:

1. **The LEVEL session format** -- the files of a LEVEL Collector recording that this dataset
   contains: their columns, units and clocks.
2. **This dataset** -- how the recordings are organized here, what was added (the session context, a
   coordinate-free GPS profile, the watch data, the session table), and how they were de-identified.

Conventions used throughout: times are **integer microseconds since the Unix epoch (UTC)** unless stated
otherwise; CSV files are comma-separated with one header row; device ids (`0000`, `1111`, ...) are
**per-participant pseudonyms** for the sensors and the chest strap, consistent within a participant
(2.6). In a recording straight from LEVEL Collector the id is the last 4 hex digits of the device address.

---

## Part 1 -- The LEVEL session format

### 1.1 A session folder

One folder per recording. Every file in it shares **one host clock** (the phone's), so streams align
by their time column without any offset.

| File | Present | Contents |
|---|---|---|
| `imu-<placement>-<id>.csv` | always, one per LEVEL sensor | accelerometer + gyroscope samples |
| `meta-summary.json` | always | app, session timing, sensors, transports, settings, file list |
| `barometer.csv`, `steps.csv` | when the phone sensor is enabled | phone streams |
| `polar_<id>_{hr,ecg,acc}.csv` | when a Polar H10 is paired | chest-strap add-on streams |

### 1.2 LEVEL sensor -- `imu-<placement>-<id>.csv`

One row per sample. `placement` is the label given in the app, lower-cased with spaces as underscores
(`left_foot`, `right_foot`, `back`, `left_wrist`, `arm`, ...); `id` is the sensor's short id. Long
recordings rotate into numbered files (`imu-<...>.csv`, `imu-<...>.001.csv`, ...): concatenate them in
numeric order.

| Column | Unit | Notes |
|---|---|---|
| `time` | us | **the column to use**: when the sample was taken, on the host timeline (1.2.1); in this dataset it counts from 0 at the session's first published sample (2.6) |
| `accel_x`, `accel_y`, `accel_z` | m/s^2 | sensor frame; range +/-16 g |
| `gyro_x`, `gyro_y`, `gyro_z` | rad/s | sensor frame |
| `frame_sensor` | count | sample counter stamped by the sensor, wraps 0-255; a jump of more than 1 means lost samples (whole packets) |
| `time_sensor` | ms | the sensor's own clock, 16-bit (wraps every 65.5 s); absent in the earliest app build |
| `time_host` | ms | host clock when the packet arrived (bursty; recordings from 2026-09 on) |

The sampling rate is in `meta-summary.json` (`settings`). Samples per packet is there too for
`schema_version` 1; for `schema_version` 2 it is the `samples_per_packet` column of
`context/session_context.csv`. Recordings made
before LEVEL Collector's 2026-09 rename call `frame_sensor` / `time_sensor` `frame_number` /
`raw_counter`; this dataset publishes them under the current names.

#### 1.2.1 The three clocks

- **`time_sensor`** is stamped by the sensor on every sample: even spacing, no radio jitter, 1 ms
  resolution. It is the best clock for anything *within* the LEVEL sensors. With time sync on, all
  sensors share one counter; without it, each counts from its own start.
- **`time_host`** is stamped by the host (phone or PC) when the packet arrives: always later than the
  sample by a variable transport delay, and bursty (many samples share one value).
- **`time`** is the sensor clock placed on the host timeline: `time_sensor` (unwrapped) plus one
  offset to the host clock. It is the column shared with every other stream -- phone GPS, barometer,
  steps, the Polar strap -- so use it to line LEVEL data up with anything else. How the offset was
  estimated is stated per run (`context/session_context.csv` `time_method`): `first_sample_anchor` = the host arrival
  of the session's first sample (one shared anchor when time sync is on, one per sensor when off), so
  that packet's transport delay (typically tens of ms) and slow sensor-crystal drift (~30 ppm) remain
  in `time`.

`time_sensor` and `time_host` are kept so the alignment can be checked or redone offline.
`lvl_running.unwrap_time_sensor` turns `time_sensor` into a continuous count.

### 1.3 `meta-summary.json` (schema_version 1 or 2)

| Key | Meaning |
|---|---|
| `app.versionName` | the recording app's version |
| `session.startedAtIso`, `session.startedAtMs`, `session.endedAtMs`, `session.durationMs` | session timing (ms since epoch) |
| `session.activityCode`, `session.sensorType` | what kind of recording this is (`BTIMU_RAW`, `BT_IMU`) |
| `session.endReason` | schema 2: `clean`, `terminated` (the app was closed mid-recording; data ends early) or `manual_stop_recovered` |
| `sensors[]` | per sensor: `shortMac` (id), `sensorLabel` (placement; as typed in the app in schema 1, normalized like the file name in schema 2, e.g. `left_foot`), `transport`, `firmwareVersion` |
| `transports[]` | per radio path: `type` (`DONGLE` = LEVEL USB dongle, or phone Bluetooth), `firmwareVersion`; schema 2 adds `shortMac` (the dongle's id, when reported) |
| `settings.sampling_rate_hz`, `settings.sensor_count` | stream settings (`settings.samples_per_packet` too in schema 1) |
| `settings.time_sync` | whether sensor time sync was requested (app builds from 2026-09-16) |
| `files[]` | per file: `name`, `modality` (e.g. `ACCEL_GYRO`), `shortMac`, `rotationCount`, `units` |
| `notes`, `uncleanShutdown` | free text; schema 1's flag for a session the app was closed during (schema 2: `session.endReason`) |

### 1.4 Phone streams

| File | Columns |
|---|---|
| `barometer.csv` | `timestamp` (us), `pressure_hPa`, `altitude_m` (barometric), ~1 Hz |
| `steps.csv` | `timestamp` (us), `step_count` -- one row per step detected by the phone, counting from 1 |

### 1.5 Polar H10 chest strap -- `polar_<id>_{hr,ecg,acc}.csv`

| File | Columns |
|---|---|
| `polar_<id>_hr.csv` | `RECEIVED_TIMESTAMP` (us), `HEART_RATE` (bpm), `RR_INTERVAL` (ms; blank when none in that notification) |
| `polar_<id>_ecg.csv` | `RECEIVED_TIMESTAMP` (us), `DEVICE_TIMESTAMP` (ns, strap clock, integer), `ECG` (uV) -- 130 Hz |
| `polar_<id>_acc.csv` | `RECEIVED_TIMESTAMP` (us), `DEVICE_TIMESTAMP` (ns, strap clock, integer), `ACCEL_X/Y/Z` (mG) -- 200 Hz |

The strap sends samples in batches, so one `RECEIVED_TIMESTAMP` (the host clock at arrival, shared
with the rest of the session) repeats across a batch. `DEVICE_TIMESTAMP` is the strap's own clock: use
its differences for sample spacing, and `RECEIVED_TIMESTAMP` to align with the other streams.

### 1.6 Time and units

Every timestamp on the session clock is an integer in **microseconds**, so any two files align
directly. Clocks that belong to a device keep that device's native unit.

| Column | File(s) | Clock | Unit |
|---|---|---|---|
| `time` | `imu-*.csv` | session (host) clock | us |
| `time_sensor` | `imu-*.csv` | the LEVEL sensor's own clock | ms |
| `time_host` | `imu-*.csv` | the host clock at packet arrival | ms |
| `timestamp` | `barometer.csv`, `steps.csv` | session clock | us |
| `time_us` | `pace_profile.csv` | session clock | us |
| `RECEIVED_TIMESTAMP` | `polar_*.csv` | session clock, at arrival | us |
| `DEVICE_TIMESTAMP` | `polar_*_ecg.csv`, `polar_*_acc.csv` | the strap's own clock | ns |
| `time`, `start_time` | `fit3/*.csv` | session clock | us |
| keys ending in `Ms` | `meta-summary.json` | as named (epoch or session-relative) | ms |

---

## Part 2 -- This dataset

### 2.1 Layout

```
data/
  S01/R01/                    one folder per session, numbered in date order; anonymous on its own
    level/                    the run as LEVEL Collector recorded it: a LEVEL session folder (Part 1) + pace_profile.csv
    fit3/                     Samsung Galaxy Fit3 watch data for the run
  context/                    everything the recordings cannot carry -- the only non-anonymous folder
    session_context.csv              one row per session: date, setting, surface, event, location, policy (2.2)
    participants.csv          one row per participant (2.7)
  data_dictionary.md          this file
sessions.csv                  one row per session (2.5)
figures/                      the same layout as data/; overview.png first in every session folder
```

Calibration recordings are not released; sensor-to-body calibration may be added later.

### 2.2 `context/session_context.csv`

One row per session: the facts a recording cannot carry itself. Nothing in a session folder repeats
them, so the folders are anonymous on their own and this file sets the release's level of context.

| Column | Values |
|---|---|
| `subject`, `session` | the session folder, `data/<subject>/<session>/` |
| `date` | the session's calendar date (no file or folder name carries it) |
| `setting` | `indoor`, `outdoor` |
| `surface` | `pavement`, `track`, `trail`, `grass`, `treadmill` |
| `event` | type of organized event: `parkrun` or `race`; `null` for a training run |
| `location` | the named place, only where the participant chose to publish it (e.g. a public parkrun); otherwise `null` |
| `other_bluetooth_reported` | other Bluetooth devices on the phone as the participant remembers them (`none`, `headphones`, `watch`, `other`; `;`-separated), for sessions recorded before the app logged them; otherwise `null` |
| `sensor_firmware_reported`, `dongle_firmware_reported` | firmware versions for sessions whose app build did not record them (`x.y.z`); otherwise `null`. `sessions.csv` uses the recorded value where there is one |
| `phone_carry` | where the recording phone was: `pack` (waist pack) or `hand` |
| `calibration` | which calibration recording the metrics used: `pre` (before the run) or `post` (after it; when the pre-run one was unusable). Calibration recordings are not released |
| `terminated_early` | `true` when the recording did not cover the whole run or event |
| `unreliable_sensors` | `;`-list of placements whose data should not be used in that session (e.g. a sensor that came loose); `null` when all are usable |
| `clock` | `synthetic` or `real` (see 2.6) |
| `gps` | `profile`: the phone GPS track is released only as the coordinate-free `pace_profile.csv` (2.3) |
| `time_method` | how `time` was placed on the host clock (1.2.1): `first_sample_anchor` |
| `time_sync_mode`, `time_sync_verdict` | the sensor time-sync mode -- `BEACON_TIMESYNC` (sync on: the sensors share one clock) or `RECEIVER_TIMESTAMP` (sync off: each sample is stamped when it reaches the receiver) -- and its result: `ALIGNED` when every sensor's clock agreed with the reference sensor's within 50 ms at the end of the session, else `MISALIGNED`. `MISALIGNED` means timing *between* sensors (e.g. left vs right foot) is unreliable in that session; each sensor's own signal is unaffected. `null` when that app build did not record it |
| `samples_per_packet` | samples per radio packet, for recordings whose `meta-summary.json` (schema 2) does not carry it |
| `phone_model` | the recording phone (manufacturer and model; for sessions before 2026-09-28, as reported by the participant) |
| `bluetooth_devices` | other Bluetooth devices connected to the phone during the session, as recorded by the app: `;`-list of `headphones` / `watch` / `other`, or `none`; `null` for app builds before 2026-09-21 |
| `phone_battery_start_pct`, `phone_battery_end_pct`, `phone_temp_start_c`, `phone_temp_end_c` | the recording phone's battery level and temperature at the start and end |
| `sensor_voltage_start_v`, `sensor_voltage_end_v` | the LEVEL sensors' battery voltage at the start and end of the session: the lowest across the sensors (V) |
| `sensor_temp_start_c`, `sensor_temp_end_c` | the LEVEL sensors' temperature at the start and end: the highest across the sensors (°C) |
| `notes` | the session's journal: what a user must know before trusting it (a sensor that came loose, a capture cut short, clocks that did not align, a GPS distance that disagreed with a known course); `null` when nothing was unusual. Sensor ids are the session's public ids |

### 2.3 `level/pace_profile.csv` -- GPS without coordinates

Derived from the phone GPS track with latitude and longitude removed.

| Column | Unit | Notes |
|---|---|---|
| `time_us` | us | the session clock -- align on this |
| `cum_km` | km | distance along the route from the first fix |
| `speed_mps` | m/s | phone-reported speed |
| `pace_min_km` | min/km | from speed; blank when nearly stopped |
| `gps_alt_rel_m`, `baro_alt_rel_m` | m | relative elevation from GPS and from the barometer |

Distance covered = last `cum_km` minus first `cum_km`. Indoors there is no GPS fix: ignore distance
and pace there.

### 2.4 `fit3/` -- Samsung Galaxy Fit3 watch

Re-written from the watch's export into our own schema; nothing ships in Samsung's format.

- `fit3_live.csv` -- 10 s samples: `time` (us, same clock as the session), `heart_rate` (bpm), `cadence`
  (steps/min), `speed` (m/s).
- `fit3_summary.csv` -- the watch's summary of the run, one row: `start_time` (us), `duration_s`,
  `distance_m`, `hr_mean` / `hr_max` / `hr_min`, `cadence_mean` / `cadence_max`, `speed_mean_mps` /
  `speed_max_mps`, `calorie_kcal`, `vo2_max`, `altitude_gain_m` / `altitude_loss_m`.

The watch's own GPS route and its distance field are not released (the phone's `pace_profile.csv` is
the distance source).

### 2.5 `sessions.csv`

One row per session; columns in groups, read left to right.

| Group | Column | Meaning |
|---|---|---|
| Session | `subject`, `date`, `session` | pseudonym, calendar date, session folder |
| Conditions | `setting`, `surface`, `event`, `location` | from `context/session_context.csv` |
| Setup | `sensor_count`, `placements` | LEVEL sensors worn and where |
| | `channels` | sensor channels recorded (e.g. `accel+gyro`) |
| | `sampling_rate_hz`, `samples_per_packet` | stream settings |
| | `transport`, `dongle_firmware`, `sensor_firmware`, `app_version` | how the data travelled, and versions |
| | `phone_model`, `bluetooth_devices` | host phone, and the other Bluetooth devices sharing its radio as a `;`-list of `none` / `headphones` / `watch` / `other` (from the app's record; for sessions before 2026-09-21, from the participant's report); blank = unknown |
| | `time_sync` | time-sync mode, `BEACON_TIMESYNC` or `RECEIVER_TIMESTAMP` (blank = not recorded by that app build) |
| | `phone_carry`, `calibration` | from `context/session_context.csv` |
| Data available | `gps`, `barometer`, `steps` | `true` when the session has that phone file (`gps` = the coordinate-free `pace_profile.csv`) |
| | `h10_hr`, `h10_ecg`, `h10_acc` | `true` when the session has that Polar H10 file |
| | `watch` | `true` when the session has the Fit3 files (`fit3/`) |
| Run | `duration_min`, `run_duration_min`, `run_duration_source`, `distance_km`, `distance_source`, `pace_min_km` | `duration_min` = how long the LEVEL recording ran. `run_duration_min` and `distance_km` describe the run itself, from the first source that has them: `reported` (set by hand, e.g. a parkrun is 5.00 km), `phone_gps` (outdoors only), `fit3` (the watch; its clock is not synced to the app, so a few minutes' difference is expected), then for duration the `recording` itself unless the notes say it stopped before the run ended. `pace_min_km` = run duration / distance |
| | `hr_mean_bpm`, `hr_max_bpm`, `hr_source` | from the chest strap if it covered >= 80 % of the run, else the watch |
| | `cadence_mean_spm`, `cadence_source` | from the watch (`fit3`) if worn, else the phone step counter (`phone_steps`) |
| Capture analysis | `loss_pct` | samples lost in transit: gaps in `frame_sensor` between each sensor's first and last sample (gaps over 2 s sized from `time`), averaged over the session's sensors. A sensor that stops for good shows as a short run, not as loss |
| | `effective_rate_hz` | samples received / recording span, averaged over sensors; below nominal by the loss plus ~0.1 % sensor-crystal offset |
| | `max_gap_s` | the longest interval between two consecutive samples of any sensor, in seconds: with `loss_pct` it says whether the loss came as one dropout or as scattered packets |
| | `long_gaps_per_hour` | gaps longer than 150 ms (3 or more lost packets) per hour of recording, worst sensor: separates a clean link from a bursty one when `loss_pct` is similar |
| | `data_ends_early_s` | seconds between the end of the session and the last sample of the sensor that stopped first; ~0-10 s is normal, more means a sensor or the link stopped before the recording did |
| | `terminated_early` | from `context/session_context.csv` |
| | `time_sync_verdict` | `ALIGNED` / `MISALIGNED`, from `context/session_context.csv` (2.2) |
| | `unreliable_sensors` | from `context/session_context.csv` |
| | `phone_battery_start_pct`, `phone_battery_end_pct`, `phone_temp_start_c`, `phone_temp_end_c` | host phone, from `context/session_context.csv` |
| | `sensor_voltage_start_v`, `sensor_voltage_end_v`, `sensor_temp_start_c`, `sensor_temp_end_c` | LEVEL sensors: lowest voltage and highest temperature across the sensors, from `context/session_context.csv` |
| | `n_files`, `size_mb` | files and size of the `level/` folder |
| | `notes` | the session's journal (2.2): caveats and data-quality issues, blank when there were none |

### 2.6 De-identification

**The data files are anonymous; the context lives in the catalog.** Nothing inside a recording says
when or where it happened: clocks count from 0, altitude and pressure are relative, the route is
coordinate-free, participants and devices are pseudonyms, and free text carries no names or places.
The date, the event type and (where a participant chose to publish it) the named location appear in
exactly two places that are one source: `context/session_context.csv`, and the root `sessions.csv` that is
built from it. Session folders are just `R01`, `R02`, ... in date order, and nothing inside them repeats
the context. The analysis reports may name public events in prose.

- **Participants** are pseudonyms (`S01`, ...); `context/participants.csv` (2.7) is the whole public profile.
  Each participant chose which streams are released: the LEVEL sensors and phone streams are the core
  every participant shares; chest strap, raw ECG and watch data are present only where that participant
  had the device and agreed. A stream that is absent for a participant is absent by choice, not lost.
- **Children** appear with an age group only (no age, body mass or HR max), never with raw ECG, free-text
  notes, or an event type or location.
- **Clock.** Every run's whole session is shifted by one offset so that the published clock counts
  from **0 at the earliest sample of any published stream** (sensors, phone, strap, watch, or the
  session-start stamp). Epoch 0 is 1970-01-01, so the clock is obviously synthetic: time of day and
  time zone are gone, the calendar date lives in `context/session_context.csv`, and durations and
  the alignment between every stream are exact. Nothing is negative; the run's own start is a few
  seconds to minutes after 0 when another stream (typically the watch) began first. `time_host` is
  shifted with `time`. (`context/session_context.csv` `clock` = `synthetic`; the format also allows `real`, unused
  here.)
- **Location.** Every run's GPS route is released only as `pace_profile.csv` (no coordinates,
  heading or place names; distance and elevation relative to the first fix), and `barometer.csv` is
  relative to its first sample -- no absolute altitude or air pressure.
- **Devices.** Sensor and strap ids are pseudonyms assigned per participant (`0000`, `1111`, ... in
  order of first use), so the same physical unit carries a different id under each participant and
  shared equipment never links two people. Within a participant an id always means the same unit. The
  host's USB device path is removed.
- **Time sync.** Only the result is published (mode and verdict); how the sensor clocks are
  synchronized is not.
- **Heart.** Every participant with a chest strap has heart rate and RR intervals (HRV is derivable);
  the raw ECG waveform is included only where the participant agreed to its release (S01: yes).
- **Other Bluetooth devices.** Only their type is published (`headphones`, `watch`, `other`); names
  (often personal) and addresses are not.
- **Watch.** Re-written into our schema (2.4): no account ids, other workouts, free text or route.
- **Named locations.** A run's place is published only where the participant chose to (`location` in
  `context/session_context.csv`); the route itself is still coordinate-free and the clock still synthetic.
- **Notes.** The only free text released is the session's `notes` (2.2) and the operator's `notes` in
  `meta-summary.json`; neither carries names, initials, place names (a published location is simply
  omitted there) or, on synthetic-clock runs, clock times.
- **Not released:** calibration recordings, any participant who did not agree to release, the raw GPS
  route (phone and watch), the Samsung export files, raw ECG for participants who did not opt in, the
  collection-day notes, and the app's diagnostic files (its values that matter are in
  `context/session_context.csv`).

### 2.7 `context/participants.csv`

One row per released participant.

| Column | Meaning |
|---|---|
| `subject` | pseudonym, matches the `data/<subject>/` folder and `sessions.csv` |
| `age_group` | `adult` or `child` |
| `sex` | as reported |
| `age_years` | age at the participant's first session (adults only) |
| `weight_kg` | body mass, self-reported (adults only) |
| `hr_max_bpm`, `hr_max_source` | maximum heart rate used in the reports and where it came from (adults only) |