CERN/ColliderML-drifting-beamspot

ColliderML: Drifting Beamspot (smeared digitisation)

This dataset contains single-muon events simulated in the Open Data Detector (ODD), with the primary vertex distributed uniformly over a region much wider than the nominal beamspot. It is the dataset used for training and evaluation in Renusch et al., Fast and Precise Learned Charged-Particle Trajectory Regression at the Large Hadron Collider, and is provided to allow the results of that work to be reproduced.

The detector response is simulated with Gaussian smearing digitisation: measured hit positions are the simulated positions smeared with a fixed per-layer resolution, and cluster formation is not simulated. The ColliderML benchmark datasets use geometric digitisation. This dataset therefore corresponds to the configuration of the publication above and is distinct from the geometric-digitisation version of these samples.

The dataset is part of the ColliderML series, together with CERN/ColliderML-Release-1.

Samples

Each event contains one muon. Positive and negative muons are generated in equal proportion (each within 0.3% of 50% in every sample), uniformly in azimuth and in pseudorapidity over |η| < 3. The production vertex is uniform in x and y within ±5 mm, in z within ±200 mm, and in time within ±0.32 ns.

Sample	Transverse momentum	Events	Files per object
single_muon_uniform	uniform in pT, 1 to 110 GeV	201,600,000	202
single_muon_loguniform	uniform in log pT, 0.9 to 110 GeV	200,000,000	200
single_muon_2GeV	fixed, 2 GeV	100,000	1
single_muon_10GeV	fixed, 10 GeV	100,000	1
single_muon_50GeV	fixed, 50 GeV	100,000	1
single_muon_100GeV	fixed, 100 GeV	100,000	1

In Renusch et al., the training set is drawn from single_muon_uniform and single_muon_loguniform, and the evaluation uses the 2, 10 and 50 GeV samples together with a held-out subset of single_muon_uniform. The 100 GeV sample is not used in that work.

Each sample is provided as five object tables, giving 30 subsets named <sample>_pu0_<object>. The pu0 label denotes the absence of pileup and follows the naming convention of the colliderml library.

Usage

ColliderML library

pip install colliderml

import colliderml

frames = colliderml.load(
    "single_muon_10GeV_pu0",
    dataset_id="CERN/ColliderML-drifting-beamspot",
    tables=["particles", "tracker_hits", "truth_tracks"],
    max_events=1000,
)
frames["truth_tracks"]  # polars DataFrame, one row per event

The tables argument is required, since the library default includes calo_hits, which is not part of this dataset.

Hugging Face datasets

from datasets import load_dataset

ds = load_dataset(
    "CERN/ColliderML-drifting-beamspot",
    "single_muon_uniform_pu0_tracker_hits",
    split="train",
    streaming=True,
)
event = next(iter(ds))

Without streaming=True, load_dataset downloads all files of the subset. Each of the two large samples is approximately 270 GB.

Dataset structure

Each row corresponds to one event, and per-object quantities (particles, hits, tracks) are stored as Parquet list columns. event_id is unique within a sample and identifies the rows of the different tables that belong to the same event. Rows are not ordered by event_id, and the row order differs between tables of the same sample, so tables must be joined on event_id rather than on row position.

Within an event, references between tables are list positions. particle_id, parent_id, majority_particle_id and the hit-level particle_id and particle_ids refer to positions in the particles lists of that event. simhit_ids refers to positions in tracker_simhits, and hit_ids to positions in tracker_hits. Lengths are given in mm, times in ns, and energies and momenta in GeV.

particles (truth)

The generated muon and the secondary particles produced in the detector simulation, with on average 1.9 particles per event.

Field	Type	Description
event_id	uint32	Event identifier
particle_id	list<uint64>	Position of the particle in the event's lists (0, 1, 2, ...)
pdg_id	list<int64>	PDG code
mass, energy, charge	list<float32>	Mass (GeV), energy (GeV), charge (e)
px, py, pz	list<float32>	Momentum at production (GeV)
vx, vy, vz, time	list<float32>	Production vertex (mm) and time (ns)
perigee_d0, perigee_z0	list<float32>	Not populated in this release (NaN)
vertex_primary	list<uint16>	Primary vertex index
parent_id	list<int64>	Position of the parent particle (-1 for the generated muon)
primary	list<bool>	Primary-particle flag

tracker_hits (digitised measurements)

Field	Type	Description
event_id	uint32	Event identifier
loc0, loc1	list<float32>	Measured local coordinates on the sensor (mm)
var_loc0, var_loc1	list<float32>	Variances of the local coordinates (mm²)
time, var_time	list<float32>	Measured time (ns) and its variance (ns²), filled for pixel hits and zero for strip hits
subspace	list<uint8>	Bitmask of the measured components (bit 0: loc0, bit 1: loc1, bit 2: time); 7 for pixel hits, 3 for short-strip hits, 1 for long-strip hits
x, y, z	list<float32>	Global position of the measurement (mm)
detector, volume_id, layer_id, surface_id	list	Detector subsystem, volume, layer and sensor identifiers
particle_ids	list<list<uint64>>	Positions in particles of the particles contributing to the hit
simhit_ids	list<list<uint32>>	Positions in tracker_simhits of the contributing simulated hits
size_loc0, size_loc1, n_channels, sum_activation, local_eta, local_phi, global_eta, global_phi, eta_angle, phi_angle	list	Cluster-shape quantities, zero in this release since smearing digitisation does not form clusters

tracker_simhits (Geant4 truth hits)

Field	Type	Description
event_id	uint32	Event identifier
true_x, true_y, true_z, true_time	list<float32>	True hit position (mm) and time (ns)
tpx, tpy, tpz, tE	list<float32>	Particle four-momentum before the interaction in the sensor (GeV)
dE	list<float32>	Energy deposited in the sensor (GeV)
particle_id	list<uint64>	Position in particles of the particle producing the hit
hit_index	list<uint16>	Order of the hit along the particle trajectory, starting at 0
detector, volume_id, layer_id, surface_id	list	Detector identifiers

tracks and truth_tracks (reconstruction)

The two tables share the same fields. tracks are reconstructed with the ACTS combinatorial Kalman filter (CKF). For truth_tracks, simulation truth is used only to assign hits to particles. The initial track parameters are estimated from a helix through three of the assigned hits, and the fit is an ACTS Kalman filter without further truth information.

Field	Type	Description
event_id	uint32	Event identifier
track_id	list<uint16>	Track identifier within the event
d0, z0	list<float32>	Transverse and longitudinal impact parameters at the perigee (mm)
phi, theta	list<float32>	Azimuthal and polar angles (rad)
qop	list<float32>	Charge over momentum (e/GeV)
t	list<float32>	Track time at the perigee (ns)
majority_particle_id	list<uint64>	Position in particles of the particle contributing the most hits; 2^64 - 1 if no particle is matched
hit_ids	list<list<uint32>>	Positions in tracker_hits of the hits on the track
hit_outlier	list<list<bool>>	Outlier flag of each hit in the fit

Track covariance matrices are not included in this release.

Remarks

1. The digitisation is Gaussian smearing with a fixed per-layer resolution. Cluster shapes are not simulated.
2. The CKF seeding requires a transverse impact parameter below 3 mm, whereas the vertex spread extends to ±5 mm in x and y. As a result, 72% of events in the 2 GeV sample contain a CKF track. The truth-assisted reconstruction has no such requirement, and nearly all events contain one entry in truth_tracks.
3. The particle perigee parameters perigee_d0 and perigee_z0 are not populated.

Production

The events are simulated with DD4hep and Geant4 in the Open Data Detector geometry, and digitised and reconstructed with ACTS, using the container ghcr.io/opendatadetector/sw:pr-8. The file layout follows ColliderML Release 1. Each file contains a contiguous range of event_id values: 1,000,000 events per file for single_muon_uniform and single_muon_loguniform (600,000 in the last single_muon_uniform file), and 100,000 events for each fixed-momentum sample. The event_id values of each sample are contiguous.

Citation

Please cite the publication for which this dataset was produced, and the ColliderML release paper:

@misc{renusch2026learnedfit,
  title         = {Fast and Precise Learned Charged-Particle Trajectory Regression at the Large Hadron Collider},
  author        = {Renusch, Jonathan and Huth, Benjamin and Murnane, Daniel and Xochelli, Eleni and Elitez, Do{\u{g}}a and Gessinger-Befurt, Paul and Stefl, Andreas and Couthures, Jeremy and Salzburger, Andreas and Heinrich, Lukas and Kagan, Michael and Elsing, Markus},
  year          = {2026},
  eprint        = {2609.32479},
  archivePrefix = {arXiv}
}

@article{colliderml2025,
  title   = {ColliderML: The first release of an OpenDataDetector high-luminosity physics benchmark dataset},
  author  = {Elitez, Do{\u{g}}a and Gessinger, Paul and Murnane, Daniel and Raaholt, Marcus Selchou and Salzburger, Andreas and Skov, Stine Kofoed and Stefl, Andreas and Zaborowska, Anna},
  journal = {arXiv preprint arXiv:2512.15230},
  year    = {2025}
}

License

CC-BY-4.0