ACORN Particle Tracking Pipeline

• ACORN is a modular charged-particle reconstruction pipeline that uses graph construction, sparsification, and clustering to convert detector hits into accurate tracks.
• The pipeline employs metric learning for hit embedding, GNN refinement for edge scoring, and techniques like CCWalk or DBSCAN for final track reconstruction.
• ACORN emphasizes scalable, hardware-aware design and uncertainty quantification, enabling efficient high-throughput tracking in high-energy physics experiments.

Searching arXiv for the ACORN tracking pipeline papers and closely related references. Searching arXiv for ACORN tracking pipeline references and related tracking-system papers. The ACORN particle tracking pipeline is a modular charged-particle reconstruction workflow that appears in two closely related senses in the literature. In the most direct sense, ACORN denotes a geometric deep learning tracking pipeline developed within the Exa.TrkX program for high-energy physics, in which detector hits are converted into graphs, candidate relations are sparsified, and tracks are reconstructed through learned edge scoring or object-condensation-based clustering (Péron et al., 22 Aug 2025). In a broader systems sense, the term also usefully denotes a transferable pipeline design pattern for high-throughput tracking: partition the workload, separate bandwidth-dominated and compute-dominated stages, overlap communication with computation, and validate reconstructed objects at the constituent level rather than by bitwise identity, as exemplified by production TPC tracking in ALICE and by experiment-independent tracking toolkits such as Acts (Rohr et al., 2017, Ai, 2020).

1. Definition and scope

Within the ACORN literature, the core reconstruction problem is standard charged-particle tracking: starting from detector hits, infer which hits belong to the same trajectory and assemble them into reconstructed tracks (Péron et al., 22 Aug 2025). In the TrackML-based setting emphasized by recent ACORN-related work, the pipeline is organized as graph construction, edge scoring, and track construction, with a specific instantiation consisting of a Metric learning graph constructor, a Filter for graph sparsification, a GNN for refined edge classification/scoring, and CCWalk for final rule-based track candidate construction (Péron et al., 22 Aug 2025). A closely related branch replaces the usual final edge-rendering stage with object condensation (OC), so that tracks are reconstructed as clusters of hits in a learned latent space rather than only as connected components of a thresholded edge graph (Lieret et al., 2023).

This scope should be distinguished from detector-specific implementations that are not ACORN by name but are architecturally informative. The ALICE High-Level Trigger (HLT) TPC tracker is a production-grade online pipeline in which TPC raw data flow through cluster finder, sector tracker, track merger, and later detector updates such as ITS association, vertexing, and trigger logic; its central transferable contribution is the decomposition of tracking into phases matched to heterogeneous hardware (Rohr et al., 2017). Acts, by contrast, is presented as an experiment-independent tracking toolkit whose principal pipeline components are geometry/navigation, propagation, seeding, combinatorial Kalman track finding, fitting, and vertexing (Ai, 2020). Together, these references define ACORN as both a specific learned tracking stack and a broader pipeline architecture for scalable tracking.

A useful implication is that ACORN is best understood as a pipeline family rather than a single algorithm. The learned TrackML implementations stress graph construction, graph inference, and clustering (Péron et al., 22 Aug 2025, Lieret et al., 2023), while the systems references stress partitioning, streaming, and hardware-aware execution (Rohr et al., 2017, Ai, 2020).

2. Architectural lineage and stage decomposition

A recurring architectural pattern across the literature is staged reconstruction. In the ACORN geometric deep learning formulation, hits are first embedded into a latent space, then connected into a candidate graph, then sparsified or rescored, and only afterward rendered into tracks (Péron et al., 22 Aug 2025). The object-condensation branch makes this explicit by treating track formation as latent-space clustering: detector hits become graph nodes with engineered geometric and cluster-shape features; candidate edges are built geometrically; a lightweight edge filter removes most fake edges while preserving high-$p_T$ connectivity; an interaction-network GNN predicts per-hit condensation coordinates and $\beta$ scores; and a downstream clustering algorithm, specifically DBSCAN, renders reconstructed tracks (Lieret et al., 2023).

The same staged logic appears in classical high-throughput tracking, but with different primitives. ALICE sector tracking first identifies short, local, geometrically consistent track segments, then fits them, extrapolates and collects more clusters row by row, and finally resolves overlaps and selects final tracks (Rohr et al., 2017). Acts formalizes a more general detector-independent sequence in which measurements are transformed into space points, seeds are formed, tracks are followed by a combinatorial Kalman filter, fitted states are accumulated in a multitrajectory data model, and vertexing is applied downstream (Ai, 2020).

The consequence is a common separation between proposal, refinement, and rendering. In ACORN-like learned pipelines, proposal is graph construction; refinement is filtering or GNN message passing; rendering is CCWalk, connected components, or DBSCAN (Péron et al., 22 Aug 2025, Lieret et al., 2023). In ALICE, proposal is the cellular-automaton local linking, refinement is Kalman-based extension, and rendering is overlap resolution plus cross-sector prolongation (Rohr et al., 2017). This suggests that ACORN should not be reduced to one stage such as edge scoring; its defining property is the composition of these stages into a coherent reconstruction flow.

3. Learned graph construction, edge scoring, and track rendering

In the ACORN case study on TrackML, the pipeline begins from a point cloud of hits that is converted into a graph by Metric learning (Péron et al., 22 Aug 2025). The first stage uses an MLP to embed hits into a high-dimensional latent space, after which a fixed-radius nearest neighbor (FRNN) graph is constructed; the resulting graph is still dense, with approximately $O(10^5)$ edges per event on average (Péron et al., 22 Aug 2025). The dense graph is then sparsified by the Filter, implemented as an MLP acting on graph node/hit features to score candidate edges between 0 and 1, reducing graph size from roughly $O(10^5)$ to $O(10^4)$ edges before the GNN (Péron et al., 22 Aug 2025). The GNN refines these edge scores, and CCWalk finally turns them into track candidates by thresholding, taking connected edge sequences without branching as candidate tracks, and handling branching structures with stricter thresholds or score-based continuation choices (Péron et al., 22 Aug 2025).

The object-condensation branch modifies only the final logic, but the change is structural. In the modular OC pipeline for HL-LHC tracking, graph construction is geometric rather than purely learned: hits on different layers are connected if they satisfy cuts on $z_0$, $\phi_\text{slope}$, and $\Delta R$, producing a graph $\mathcal G=(X,R_a,I)$ with $X\in\mathbb{R}^{N\times 14}$, $\beta$0, and edge features $\beta$1 (Lieret et al., 2023). Geometric construction alone yields about $\beta$2 edges per event at only $\beta$3 purity, so the authors insert a lightweight fully connected edge classifier before the OC GNN; after filtering at $\beta$4, the graph purity rises to $\beta$5 with about $\beta$6 edges per event (Lieret et al., 2023). The OC GNN then predicts per-hit clustering coordinates $\beta$7 and condensation strengths $\beta$8, and track formation is performed by DBSCAN in condensation space with $\beta$9 and $O(10^5)$0 (Lieret et al., 2023).

A later OC study presents a streamlined high-pileup formulation with three stages: learned graph construction, object condensation, and post-processing (Lieret et al., 2023). There, graph construction embeds each hit from 14 raw features into an 8-dimensional space, builds a $O(10^5)$1 nearest-neighbor graph with maximum edge length 1, and achieves average graph size $O(10^5)$2, graph efficiency $O(10^5)$3, and graph purity $O(10^5)$4 (Lieret et al., 2023). The OC GNN outputs 24-dimensional clustering coordinates $O(10^5)$5 and condensation likelihoods $O(10^5)$6, and DBSCAN with $O(10^5)$7, $O(10^5)$8 is used to render final track candidates, discarding clusters with fewer than three hits (Lieret et al., 2023).

A concise stage comparison is therefore:

Pipeline family	Proposal stage	Rendering stage
ACORN edge-scoring	Metric learning + Filter + GNN	CCWalk
OC branch	Geometric or learned graph + OC GNN	DBSCAN
ALICE HLT TPC	Cellular automaton local linking	Selection, merge, prolongation

This suggests that the main distinction inside ACORN is not whether it is graph-based—the graph remains central—but whether the final track object is recovered from edges or from latent clusters.

4. Core algorithms and mathematical structure

ACORN-related work spans two algorithmic families: graph-neural pipelines and local-first combinatorial tracking. In the ACORN uncertainty study, the learned pipeline is explicitly three-stage: graph construction, edge scoring, and track construction (Péron et al., 22 Aug 2025). The graph constructor uses metric learning; the Filter and GNN score edges; and CCWalk deterministically assembles tracks from those scores (Péron et al., 22 Aug 2025). The paper frames uncertainty propagation in a chain of models by writing, for stage outputs $O(10^5)$9,

$O(10^5)$0

with

$O(10^5)$1

and then studies the ACORN case empirically rather than analytically (Péron et al., 22 Aug 2025).

The OC branch shifts supervision from pairwise connectivity to latent clustering. In the modular OC pipeline, the GNN predicts $O(10^5)$2 and $O(10^5)$3, with the decoder dimensions implying $O(10^5)$4, and training uses attractive and repulsive OC potentials together with a $O(10^5)$5-control term (Lieret et al., 2023). The reported OC hyperparameters are

$O(10^5)$6

while the streamlined high-pileup OC study reports

$O(10^5)$7

for its OC loss (Lieret et al., 2023, Lieret et al., 2023). In both cases, the purpose is the same: same-track hits should condense in latent space, while different-track hits should be separated.

The ALICE HLT tracker exemplifies a complementary local-first design. Its neighbors finder searches, for each cluster on row $O(10^5)$8, for the best neighboring clusters on rows $O(10^5)$9 and $O(10^4)$0 subject to approximate local collinearity, then retains only reciprocal links in the evolution step (Rohr et al., 2017). Chains of one-to-one reciprocal links define short local tracklets. After local seeding, a Kalman filter fits and extrapolates tracklets row by row, accepting new clusters if a $O(10^4)$1 condition is satisfied, and a final selection stage removes overlaps and clones (Rohr et al., 2017). One refinement is an explicit quality-weighted deterministic assignment rule for competing tracklets,

$O(10^4)$2

with $O(10^4)$3 the tracklet length and $O(10^4)$4 reported as the best tradeoff (Rohr et al., 2017). This idea is directly relevant to ACORN-like candidate competition because it combines support size and fit quality in a deterministic score.

Acts expresses a third viewpoint: a detector-independent track reconstruction stack in which state transport is formalized through global/free parameters

$O(10^4)$5

and local/bound parameters

$O(10^4)$6

with propagation, combinatorial Kalman track finding, and fitting organized around surfaces, layers, and tracking volumes (Ai, 2020). The significance for ACORN is not the exact formulas but the architectural lesson that state representation, geometry, and branching trajectory storage are first-class pipeline elements rather than afterthoughts.

5. Systems engineering, hardware mapping, and scaling

A defining feature of ACORN-like tracking is that performance depends as much on execution structure as on the tracker itself. The ALICE HLT paper makes this explicit: initialization and track output are mostly data reformatting and output formatting operations, touch most bytes only once, and are memory-bandwidth dominated, so they are kept on the CPU; the actual tracking stages—neighbor finding, cellular automaton evolution, tracklet construction, and selection—are ported to the GPU (Rohr et al., 2017). The sector-tracking pipeline is therefore split into CPU preprocessing, transfer to GPU, GPU tracking, transfer back, and CPU postprocessing, with sectors arranged so that GPU tracking, CPU preprocessing, and data transfer proceed in parallel (Rohr et al., 2017). After multithreaded CPU-side orchestration, the GPU is idle only at the boundaries of the stream, and the GPU tracker outperforms the CPU version by about a factor of three (Rohr et al., 2017).

The learned graph-tracking literature reveals a different systems bottleneck: graph construction and graph labeling often dominate latency more than the final GNN itself. In the accelerated Exa.TrkX inference pipeline, average wall-clock inference per event on TrackML falls from $O(10^4)$7 s on one CPU core to $O(10^4)$8 s on an Nvidia V100 GPU, with graph construction and filtering as the dominant stages (Lazar et al., 2022). Replacing a generic graph builder with Faiss reduces build-edge time from about 12 s to 0.54 s, and a custom CUDA-enabled FRNN reduces it further to 0.04 s; replacing DBSCAN-style labeling with GPU weakly connected components reduces labeling from about 2.2 s to 0.11 s, and the complete optimized pipeline reaches about 0.7 s/event (Lazar et al., 2022). The practical lesson for ACORN is that graph construction, sparsification, and labeling are part of the critical path and must be co-designed with the learning stages.

The broader Exa.TrkX performance paper supports the same conclusion at full-event scale. On full TrackML, the pipeline comprises preprocessing, embedding network, filter network, GNN edge classification, track building/partitioning, and postprocessing, and its GPU wall-clock inference is $O(10^4)$9 s per event versus $z_0$0 s on a single CPU core (Ju et al., 2021). Per-stage timings show that Build Edge and Filtering dominate both CPU and GPU inference, and the computational requirements scale close to linearly with the number of particles in the event (Ju et al., 2021).

Acts contributes a software-architecture counterpart to these hardware lessons. The project emphasizes const-correctness, stateless tools, explicit conditions/context passing, a branch-capable MultiTrajectory event data model, and accelerator-friendly kernels for seeding and propagation (Ai, 2020). The paper reports that Acts::Seedfinder is highly parallelizable, with about 14x speed-up on GPU at environments up to 100k hits with identical physics output, while track propagation also benefits from GPU and OpenMP execution (Ai, 2020). In ACORN terms, this reinforces the principle that the pipeline should isolate embarrassingly parallel kernels, avoid hidden mutable state, and separate algorithm kernels from experiment-owned conditions.

6. Validation, uncertainty, and performance

The ACORN uncertainty paper studies uncertainty quantification and propagation for the learned pipeline using Monte Carlo Dropout on the Filter and GNN stages (Péron et al., 22 Aug 2025). For each edge, with $z_0$1 stochastic forward passes, it defines a predictive mean $z_0$2, predictive variance $z_0$3, total uncertainty as Shannon entropy

$z_0$4

and epistemic uncertainty as mutual information

$z_0$5

The central empirical findings are that combined GNN uncertainty is roughly equally split between intrinsic GNN uncertainty and uncertainty propagated from the Filter, that the remaining uncertainty is largely aleatoric as training-set size grows, and that uncertainty propagated into final tracking efficiency is only about $z_0$6 (Péron et al., 22 Aug 2025). This indicates that ACORN uncertainty is primarily a pipeline property and that graph-topology changes induced by upstream filtering are a major mechanism of propagation.

The same paper also reports the baseline edge-scoring quality of the trained GNN: edgewise efficiency $z_0$7 and edgewise purity $z_0$8 (Péron et al., 22 Aug 2025). It further shows that, although raw edge scores are underconfident in a calibration sense, downstream tracking performance changes negligibly after explicit calibration: the reported efficiency moves from 0.944 to 0.945, while fake rate drops from 0.007 to 0.004 and duplication rate remains 0.039 (Péron et al., 22 Aug 2025). A plausible implication is that score miscalibration is less damaging to ACORN than topology or threshold placement.

The OC branch supplies complementary reconstruction metrics. The 2023 OC pipeline reports, with DBSCAN tuned to $z_0$9, $\phi_\text{slope}$0,

$\phi_\text{slope}$1

on the TrackML pixel detector (Lieret et al., 2023). The streamlined high-pileup OC paper reports improved values,

$\phi_\text{slope}$2

again on TrackML pixels at $\phi_\text{slope}$3 (Lieret et al., 2023). These numbers are notable because they approach the graph-construction upper bounds while using clustering in latent space instead of pure edge rendering.

For comparison, the full Exa.TrkX geometric deep learning pipeline on full TrackML reports physics efficiency $\phi_\text{slope}$4 and technical efficiency $\phi_\text{slope}$5 for particles with $\phi_\text{slope}$6 MeV, with purity $\phi_\text{slope}$7, and a TrackML score $\phi_\text{slope}$8, rising to $\phi_\text{slope}$9 when training includes noise hits (Ju et al., 2021). Acts reports about 99% CKF efficiency at central pseudorapidity with fake rate about $\Delta R$0 for $\Delta R$1, $\Delta R$2, and average fitting time about 0.2 ms per track on CPU (Ai, 2020). ALICE, in turn, reports a 99.99976\% agreement between CPU and GPU tracking under a track-matched, row-by-row cluster assignment criterion, with no tracking-efficiency difference from Monte Carlo (Rohr et al., 2017). Taken together, these results show that ACORN-like learned pipelines, classical Kalman stacks, and GPU-first local-first trackers can all achieve high-quality reconstruction, but they do so under different detector and metric conventions.

7. Limitations, detector specificity, and future directions

Several limitations are explicit in the literature and should not be overgeneralized. The ACORN uncertainty study does not quantify uncertainty for the metric-learning graph-construction stage and treats the aleatoric/epistemic decomposition from Monte Carlo Dropout as indicative rather than absolute (Péron et al., 22 Aug 2025). The OC papers are restricted to the TrackML pixel detector and note that lowering memory consumption is still necessary before applying the method to the full detector (Lieret et al., 2023, Lieret et al., 2023). The streamlined OC paper also remains a progress study rather than a final production system: it still depends on DBSCAN rather than a pure $\Delta R$3-center assignment decoder, and it does not provide a detector-wide benchmark table against a matched edge-classification baseline (Lieret et al., 2023).

Systems papers reveal complementary constraints. ALICE sector tracking alone misses very short within-sector segments of tracks crossing boundaries, so a prolongation step into neighboring sectors is required; the method depends on data locality and partitionability, and production operation exposed failure modes such as GPU memory exhaustion on noisy sectors (Rohr et al., 2017). Acts is a toolkit rather than a full end-to-end application and leaves raw-data decoding, detailed ambiguity resolution beyond CKF branching, and experiment-owned conditions implementations outside its scope (Ai, 2020). The Exa.TrkX acceleration paper shows that even inference nearly saturates 16 GB GPU memory, with peak memory usage about 15.7 GB on GPU and 11 GB on CPU, which implies that memory budgets are an intrinsic design constraint for ACORN-like graph pipelines (Lazar et al., 2022).

Future directions are already visible in the papers themselves. The ACORN uncertainty work suggests that, once training size is sufficient and aleatoric uncertainty dominates, further gains will likely come from better detector information, graph construction, or architectural inductive bias rather than simply more of the same data (Péron et al., 22 Aug 2025). The OC branch points toward more direct one-shot reconstruction, including future regression of track properties such as transverse momentum (Lieret et al., 2023), while the high-pileup OC status paper mentions ongoing work on sparse transformers with Exact Euclidean LSH and reports first experiments with up to 100x inference speedup relative to the OC pipeline described there (Lieret et al., 2023). A plausible synthesis is that ACORN is moving toward a family of tracking pipelines in which graph construction remains essential, but the final rendering stage becomes progressively less dependent on explicit edge completeness and more dependent on learned object-level structure.

In that sense, the ACORN particle tracking pipeline is neither merely a GNN nor merely a track builder. It is a layered reconstruction architecture in which graph construction, sparsification, message passing, object rendering, uncertainty propagation, and hardware-aware execution are all coequal components of the tracking problem (Péron et al., 22 Aug 2025, Rohr et al., 2017).