[Paper Review] LHCO_reader: A new code for reading and analyzing detector-level events stored in LHCO format

Andrew Fowlie|arXiv (Cornell University)|Oct 25, 2015

Particle physics theoretical and experimental studies1 references3 citations

TL;DR

LHCO_reader is a Python module that simplifies reading and analyzing detector-level events in LHCO format from simulations like Delphes and PGS. It enables intuitive, object-oriented event manipulation, kinematic variable computation (e.g., $\alpha_T$, $m_{T2}$), and cut-based analysis via a user-friendly, Python-native interface, with performance adequate for up to ~100k events on standard hardware.

ABSTRACT

We present a new Python module - LHCO_reader - for reading detector-level events in LHCO format generated from detector-simulators such as PGS and Delphes. Emphasis is placed upon ease of use. The module is installed via pip. Once installed, one can read and scrutinize events, with helpful functions and classes for cutting, plotting and inspecting events, and manipulating four-momenta by e.g. boosting. Implementing complicated analyses should be straight-forward by coding any cuts into Python. Furthermore, common kinematic variables, including $α_T$ and razor are included out of the box, and $m_{T2}$ and $m_{T2}^W$ are provided by interfaces with external libraries.

Motivation & Objective

• To provide a user-friendly, Python-based tool for reading and analyzing detector-level events in LHCO format.
• To simplify the implementation of complex event selections and kinematic cuts in high-energy physics analyses.
• To support both LHCO-formatted files and ROOT files from Delphes via automatic conversion.
• To offer built-in functions for common analyses, including $\alpha_T$, razor, $m_{T2}$, and $m_{T2}^{W}$.
• To enable interactive, high-level analysis with intuitive object-oriented access to event data.

Proposed method

• The module reads LHCO-formatted event files using a custom parser that maps columns to event object properties such as $p_T$, $\eta$, $\phi$, and invariant mass.
• It provides a class-based event structure where particles are accessed by type (e.g., 'electron', 'jet'), with methods for sorting, cutting, and retrieving four-vectors.
• Kinematic variables like $H_T$, $\not{H}_T$, $\alpha_T$, and razor are computed directly from event objects using built-in functions.
• The module supports $m_{T2}$ and $m_{T2}^{W}$ via interfaces to external libraries, enabling advanced missing energy analyses.
• It includes utilities for plotting, counting particle types, calculating angular separations, and applying cuts using lambda functions.
• Performance is optimized through profiling and code-level improvements, achieving ~351 ms per 10,000 events for loading and ~0.3 s per 10,000 events for basic cuts.

Experimental results

Research questions

• RQ1 How can detector-level event analysis in LHCO format be made more accessible and interactive for researchers using high-level programming?
• RQ2 What is the performance trade-off of using Python for event analysis compared to compiled languages like C++?
• RQ3 Can a Python-based tool efficiently handle realistic event samples of up to 100,000 events for analysis prototyping?
• RQ4 How effectively can common LHC analysis variables like $\alpha_T$, $m_{T2}$, and razor be integrated into a modular, reusable framework?
• RQ5 To what extent can a single tool support both native LHCO files and converted Delphes ROOT files?

Key findings

• LHCO_reader loads 10,000 events in approximately 351 ms on a standard computer, with performance sufficient for interactive analysis of samples up to ~100,000 events.
• Basic event cuts, such as on tau-lepton count, take about 0.3 s per 10,000 events, demonstrating efficient filtering capabilities.
• The combined acceptance of a multi-variable analysis (including $\eta$, $p_T$, and invariant mass cuts) was measured at 2%, with a 68% confidence interval of [0.01658, 0.01932].
• The module successfully supports both direct LHCO input and automatic conversion of Delphes ROOT files into LHCO format for analysis.
• Common variables like $\alpha_T$, razor, $m_{T2}$, and $m_{T2}^{W}$ are available out of the box or via external library integration.
• The object-oriented design allows users to implement any analysis in pure Python by defining custom cuts using lambda functions or named functions.