⚛️ phenomenology

LHEReader: Simplified Conversion from Les Houches Event Files to ROOT Format

This paper presents LHEReader, a program that simplifies the conversion of Les Houches Event files into ROOT format, demonstrating its performance and utility through various particle physics simulations and analyses.

Original authors: Aman Desai

Published 2026-03-03

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Aman Desai

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a detective trying to solve a mystery about how the universe works. To do this, you need to look at the "crime scene" of particle collisions—like the ones happening at the massive Large Hadron Collider (LHC).

However, there's a problem: the raw data from these collisions comes in a very specific, rigid format called an LHE file (Les Houches Event file). Think of this file like a handwritten ledger written in a secret code. It contains every single detail about the particles created in a crash: their speed, their mass, who their parents were, and their energy. But, most modern detective tools (specifically a powerful software called ROOT) can't read this handwritten ledger directly. They need the data in a digital, organized database format.

This is where LHEReader comes in.

The Translator (LHEReader)

The paper introduces a tool called LHEReader. You can think of it as a universal translator or a smart scanner.

The Input: It takes the "handwritten ledger" (the LHE file).
The Process: It reads every line, understands the secret code, and rewrites the information into a modern, digital database format (a ROOT file).
The Output: Now, instead of a confusing text file, you have a structured database that scientists can easily search, sort, and analyze using standard tools.

The author, Aman Desai, built this tool because existing translators were either too complicated or didn't fit the specific needs of modern physics research. He made it free and open-source, so anyone can download it from GitHub.

How Fast is it? (The Performance Test)

The author didn't just build the tool; he tested it to see how fast it works. He ran two different "simulations":

The Simple Crash: Simulating two particles smashing into each other to create jets of particles (like two cars crashing and scattering debris).
The Complex Crash: Simulating an electron and a positron colliding to create a Z boson and a Higgs boson (like two billiard balls hitting to create two new, heavier balls).

The Result: The translator is incredibly fast. It takes about 0.04 to 0.2 milliseconds to convert a single event. To put that in perspective, if you had a million events, the tool could process them all in a matter of minutes. It's like having a librarian who can instantly scan a million books and organize them on a digital shelf without breaking a sweat.

The Detective Work (The EventLoop)

Once the data is converted into the ROOT format, the paper shows how to actually use it. The author provides a "recipe" (called an EventLoop) for scientists to follow.

Imagine you have a giant box of mixed-up LEGO bricks (the converted data). The EventLoop is a set of instructions that tells you:

Pick out the red bricks: "Find all the electrons and muons (leptons)."
Pick out the blue bricks: "Find all the bottom quarks (b-jets)."
Check the rules: "Only keep the bricks that are moving fast enough (high energy) and are close enough to each other."
Build the model: "Combine these specific bricks to see if they form a Higgs boson."

The paper demonstrates this by simulating a specific scenario: Protons colliding to create a Z boson and a Higgs boson.

The Z boson decays into two leptons (like two glowing sparks).
The Higgs boson decays into two bottom quarks (like two heavy, invisible bricks).

Using the LHEReader and the EventLoop, the author successfully filtered through millions of simulated collisions to find the ones that matched this pattern. He then plotted graphs showing the "transverse momentum" (how hard the particles are flying sideways) and the "invariant mass" (how heavy the reconstructed particles are).

Why Does This Matter?

In the world of particle physics, data is king. But raw data is useless if you can't read it.

Before LHEReader: Scientists might struggle to get their data into a format they can analyze, wasting time on complex coding.
With LHEReader: They can quickly convert their "secret code" files into a usable database, run their analysis scripts, and immediately start looking for new physics.

The author also notes that this tool isn't just for experts; it's a great educational tool for students learning how to handle real physics data. It's a lightweight, efficient bridge between the raw output of simulation software (like MadGraph) and the powerful analysis tools used by the world's top physicists.

In a Nutshell

LHEReader is a simple, fast, and free tool that acts as a bridge. It takes the raw, unorganized "receipts" of particle collisions and turns them into a neat, searchable database. This allows scientists to quickly sift through the noise of millions of collisions to find the tiny, precious signals of new particles, helping us understand the fundamental building blocks of our universe.

1. Problem Statement

High-energy physics (HEP) simulations typically generate event records at the parton level using Monte Carlo (MC) event generators like MadGraph5_aMC@NLO. These generators output data in the Les Houches Event (LHE) file format, a standard text-based format containing particle identities, status codes, four-momenta, spin, color information, and event weights.

While the LHE format is standard for generation, subsequent analysis stages (such as parton showering, hadronization via Pythia8, or detector simulation via MadAnalysis5) often require data to be in a more efficient, binary, and object-oriented format suitable for high-performance statistical analysis. The ROOT framework (developed by CERN) is the industry standard for this analysis. However, converting LHE files to ROOT files often requires complex, custom scripting or reliance on external libraries that may not be optimized for specific workflows. There was a need for a lightweight, accessible, and efficient tool to bridge this gap, allowing researchers to directly convert LHE files into ROOT TTree structures for immediate analysis.

2. Methodology

The paper introduces LHEReader, a Python-based program designed to parse LHE files and convert them into ROOT format.

Software Architecture:
- Language: Python (tested with version 3.10).
- Dependencies: Requires CERN ROOT and PyROOT.
- Input: Supports both uncompressed .lhe and compressed .lhe.gz files.
- Output: Generates a .root file containing a TTree object named events.
Data Structure Conversion:
The program maps the XML-like structure of the LHE file into a structured TTree with specific branches:
- Event-level branches: numParticles, eventweight, scale, alpha_qed, alpha_qcd.
- Particle-level branches (Vectors): pid (Particle ID), status, mother1/2, color1/2, px/py/pz (momentum), energy, mass, tau, and spin.
Analysis Workflow (EventLoop):
The author provides a C++ EventLoop template to demonstrate how to process the resulting ROOT file. This loop:
1. Iterates through events in the TTree.
2. Iterates through particles within each event.
3. Filters particles based on Status Codes (e.g., status == 1 for final state particles).
4. Identifies particles using PDG IDs (e.g., abs(pid) == 5 for b-quarks, 11/13 for leptons).
5. Calculates kinematic variables, including Missing Transverse Energy (MET) based on neutrino identification.

3. Key Contributions

LHEReader Tool: A publicly available, open-source utility (GitHub) that simplifies the LHE-to-ROOT conversion process, removing the need for complex custom parsers.
Performance Benchmarking: The paper provides empirical data on conversion speeds for two distinct physics processes:
- $pp \to jj$ (QCD dijet production).
- $e^+e^- \to ZH$ (Electron-positron Higgs production).
End-to-End Physics Demonstration: The paper does not just show file conversion; it demonstrates a full analysis chain:
1. Generation of $pp \to Z(\to \ell^+\ell^-)H(\to b\bar{b})$ events using MadGraph5_aMC@NLO.
2. Showering/Hadronization via Pythia8.
3. Jet clustering via FastJet (within MadAnalysis5).
4. Conversion to ROOT via LHEReader.
5. Analysis of kinematic distributions using the provided EventLoop.
Educational Resource: The inclusion of code snippets for both the conversion script and the C++ analysis loop serves as a tutorial for students and researchers on how to handle MC event data in ROOT.

4. Results

Conversion Performance:
The study evaluated the time required to convert events to ROOT format across varying sample sizes ( $10^4$ to $10^6$ events).
- $pp \to jj$ : Average conversion time per event decreased from 0.27 ms (at $10^4$ events) to 0.18 ms (at $10^6$ events).
- $e^+e^- \to ZH$ : Average conversion time per event decreased from 0.14 ms (at $10^4$ events) to 0.03 ms (at $10^6$ events).
- Observation: The tool scales efficiently, with larger batches showing improved per-event processing times, likely due to I/O overhead amortization.
Physics Analysis Validation:
The program was applied to simulate the $pp \to ZH$ process at $\sqrt{s} = 13.6$ TeV (LHC Run 3 conditions).
- Selection Cuts: Events were filtered for two opposite-sign, same-flavor isolated leptons ( $p_T > 25$ GeV, $|\eta| < 2.5$ ) with an invariant mass in the Z-boson window [80, 100] GeV.
- Reconstruction: b-jets were identified (truth-level for parton analysis, PID-based for reconstructed analysis) and used to reconstruct the Higgs candidate.
- Distributions: The paper presents normalized distributions for:
  - Transverse momenta ( $p_T$ ) of muons, electrons, and b-jets.
  - Invariant mass of dielectron and dimuon pairs (peaking at the Z mass).
  - Invariant mass of the b-jet pair (peaking at the Higgs mass).
- The results confirmed that the converted ROOT files accurately preserved the kinematic properties of the original LHE events, with reconstructed distributions showing expected broadening due to jet clustering and detector simulation effects.

5. Significance

Workflow Efficiency: LHEReader significantly lowers the barrier to entry for analyzing MC event data. By automating the conversion to ROOT, it allows physicists to leverage the full power of the ROOT analysis framework (histogramming, fitting, statistical tools) without writing low-level XML parsers.
Versatility: The tool supports both standard LHE files and compressed versions, and is compatible with outputs from various generators (MadGraph, MadAnalysis5), making it a versatile utility for diverse HEP research projects (including LHC and future FCCee studies).
Reproducibility: By providing the source code and specific analysis scripts (EventLoop), the paper promotes reproducibility in HEP analyses, allowing other researchers to quickly test kinematic distributions or validate new physics models against standard model backgrounds.
Educational Value: The paper serves as a practical guide for transitioning from event generation to data analysis, a critical skill for graduate students and early-career researchers in particle physics.