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 (e.g. HARDWARE_TS_TB) 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 (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, distance_km, pace_min_km	from the session and phone GPS (outdoors only)
	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)