⚛️ high-energy experiments

Parnassus: A GPU-enabled, Python-based Package for Fast Particle Detector Simulation and Reconstruction

The paper introduces Parnassus, a public, GPU-enabled Python/PyTorch framework that offers fast, interchangeable detector simulation and reconstruction models for various particle physics experiments, providing a ROOT-free alternative to traditional tools like Geant4 and Delphes.

Original authors: Abdelrahman Elabd, Eilam Gross, Dmitrii Kobylianskii, Benjamin Nachman

Published 2026-06-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Abdelrahman Elabd, Eilam Gross, Dmitrii Kobylianskii, Benjamin Nachman

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 trying to predict exactly how a complex machine, like a particle detector in a giant physics lab, will react when a subatomic particle smashes into it.

In the real world, scientists use a super-detailed, super-slow computer program called Geant4 to simulate this. Think of Geant4 as a high-definition, 4K movie camera that records every single drop of rain, every gust of wind, and every leaf falling during a storm. It is incredibly accurate, but it takes so long to render that simulating just one "storm" (a particle collision) can take hours. If you want to study millions of storms, you'd need a supercomputer farm running for years.

Parnassus is a new tool that acts like a smart, instant weather forecast. Instead of filming every single raindrop, it uses a "shortcut" to predict the final result of the storm almost instantly.

Here is how the paper explains this tool in simple terms:

1. The "Magic Translator" (The Core Idea)

Parnassus is a software package that translates "Truth" (what the particles should be doing in a perfect vacuum) directly into "Reality" (what the detector actually sees after the mess of the collision).

The Old Way: You build a full-scale model of the detector, simulate the particle hitting it, track every bounce, and then measure the result. (Slow, like building a real house to see how it looks in the rain).
The Parnassus Way: You feed it the "blueprint" of the particle, and it instantly spits out the "finished house" with all the rain damage already calculated. (Fast, like using an AI to generate a photo of the house in the rain).

2. Two Different "Shortcuts"

The paper says Parnassus offers two different types of shortcuts (called "backends") to do this translation:

The "AI Artist" (Neural Models): This uses a type of artificial intelligence called "Flow Matching." Imagine an artist who has studied millions of photos of how particles look after hitting a detector. When you show them a new particle, they instantly paint a picture of what the detector would see. This is incredibly fast and runs on powerful graphics cards (GPUs), which are the same chips used for gaming.
The "Mathematical Calculator" (TorchDelphes): This is a re-written version of an older tool called Delphes, but built entirely in Python (a popular coding language) so it can also run on those fast graphics cards. It uses math formulas to estimate the damage, similar to how a weatherman uses equations to predict a storm.

3. The "Universal Adapter"

One of the coolest features of Parnassus is that it doesn't care which detector you are simulating.

Think of the detector settings as "Cards" (like a deck of playing cards).
If you want to simulate the CMS detector (used at CERN), you pick the "CMS Card."
If you want to simulate the ATLAS or ALEPH detectors, you just swap the card.
The Magic: You don't have to retrain the AI or rewrite the code. You just swap the card, and the same tool works for the new detector. It's like having a universal remote control that works on your TV, your stereo, and your air conditioner just by pressing a different button.

4. Why This Matters (The "Speed Boost")

The paper highlights that Parnassus is GPU-enabled.

Old Tools: Ran on standard computer processors (CPUs), which are like a single chef cooking a meal. They are good, but slow.
Parnassus: Runs on Graphics Processing Units (GPUs), which are like a kitchen with 10,000 chefs working at once.
The Result: The paper shows that Parnassus can process events (simulations) much faster than the old methods, especially when using the AI model. It can handle thousands of simulations in the time it used to take to do a few.

5. What It Actually Does (and Doesn't Do)

The paper is very specific about what this tool is for:

It does: Simulate how a detector sees particles, group them into "jets" (clusters of particles), and calculate things like energy and direction. It outputs files that scientists can use immediately.
It does not: It does not replace the need for the real, slow simulations entirely. The AI models were trained on data from the real, slow simulations to learn how to mimic them.
It does not: It is not a medical tool or a tool for predicting the weather on Earth. It is strictly for high-energy physics (studying the smallest building blocks of the universe).

Summary Analogy

Imagine you are a film director.

Geant4 is like hiring 10,000 extras, building a real city, and filming a scene in real-time. It's perfect, but it takes a month.
Parnassus is like using a powerful AI to generate that same scene in 5 seconds. It looks 99% the same, but you can make 1,000 different versions of the scene in the time it used to take to make one.

The paper presents Parnassus as a free, open-source tool that lets physicists run these "instant simulations" on their own computers without needing to install complex, old-school software, making the study of the universe much faster and more accessible.

Technical Summary of Parnassus

Problem Statement
Full detector simulation and reconstruction in particle and nuclear physics, typically based on Geant4, is computationally expensive. This process often dominates the computing budgets of large-scale experiments and can be prohibitive for individual researchers or large-scale exploratory studies. There is a critical need for a fast, accurate surrogate that maps truth-level (generator-level) particles directly to detector-level reconstructed particles. Such a tool must preserve the fidelity of the full simulation chain while offering orders-of-magnitude speed improvements, ideally without requiring the installation of legacy C++ frameworks like ROOT or Delphes.

Methodology
Parnassus is a Python/PyTorch-based, GPU-compatible framework designed to address these challenges. It provides a unified, process-agnostic, and detector-agnostic API where users select a "detector card" (analogous to Delphes cards) to target specific experiments. The framework routes truth-level events through one of two interchangeable backends, both producing particle-flow (PFlow) objects for downstream physics-based post-processing (e.g., jet clustering via FastJet, lepton isolation).

The two primary backend types are:

Neural Backends: These utilize conditional flow matching architectures trained on full simulation and reconstruction data. The models are conditioned on truth-level particle properties, allowing them to learn the detector response without being tied to a specific physics process. This enables process-level generalization, including out-of-distribution scenarios, without retraining. The current release includes flow-matching models for the CMS (2011) and ALEPH detectors.
Parametric Backend (TorchDelphes): This is a pure PyTorch re-implementation of the Delphes fast-simulation chain, running natively on GPU. It models particle propagation, tracking efficiency, momentum smearing, calorimeter response, and energy-flow merging using parameters loaded from detector cards. This release includes TorchDelphes cards for CMS, ATLAS, and ALEPH, validated against C++ Delphes 3.5.1.

The framework handles input from HepMC files or Pythia8 steering cards. It supports optional pile-up merging (using a Delphes-compatible merger for the parametric backend) and includes post-processing pipelines for particle filtering, jet clustering (supporting $k_T$ , anti- $k_T$ , and Cambridge/Aachen algorithms), and lepton isolation. Output is written to ROOT format via the uproot library, eliminating the need for a native ROOT installation.

Key Contributions

Public Software Release: The paper presents the initial public release of Parnassus, providing a user-friendly interface for fast simulation and reconstruction.
Hybrid Backend Architecture: The framework unifies generative neural models and parametric re-implementations under a single API, allowing users to switch between high-fidelity learned models and fast parametric approximations without altering the analysis workflow.
GPU-Native Implementation: Unlike traditional C++/ROOT tools, Parnassus leverages PyTorch to enable GPU acceleration, significantly speeding up event processing.
Dependency Reduction: The software removes dependencies on building C++ Delphes, ROOT, Pythia8, or FastJet manually; these are installed as Python package dependencies.
Expanded Detector Support: The release includes validated models for the CMS and ALEPH detectors (neural) and parametric cards for CMS, ATLAS, and ALEPH, extending the framework to the $e^+e^-$ LEP environment.

Results

Performance Benchmarks: In benchmarks using $H \to ZZ \to 4\ell$ events, the TorchDelphes backend achieved a throughput of 86.9 events/s on an NVIDIA RTX A6000 GPU, compared to 80.6 events/s for C++ Delphes 3.5.1 on a CPU. The neural flow model achieved 17.5 events/s on the same GPU. The authors note that the neural backend was not optimized for speed in this release and that the current rates are unlikely to be the limiting factor for most applications.
Validation: The TorchDelphes backend was validated against C++ Delphes 3.5.1 for CMS and ATLAS cards. The neural models' validation and process-generalization capabilities were established in previous works (Refs. [2, 11]), which demonstrated that the approach reproduces full CMS simulation across a wide range of Standard Model processes.
Demonstration: The paper demonstrates the framework's capability on both Standard Model ( $H \to ZZ \to 4\ell$ ) and Beyond Standard Model ( $H \to aa \to gg\mu\mu$ ) processes. The results show that the same workflow can handle qualitatively different final states, correctly reconstructing visible topologies and resonance structures (e.g., distinguishing hadronic activity from lepton-like objects in BSM scenarios).

Significance
The paper positions Parnassus as a modern alternative to traditional fast simulation tools, specifically addressing the computational bottlenecks of Geant4 and the legacy constraints of C++/ROOT-based workflows. By providing a GPU-capable, Python-native interface, it enables seamless integration into modern analysis pipelines. The authors emphasize that the framework allows researchers to apply the same detector models to new physics processes without retraining, provided the inputs fall within the validated phase space. The release aims to enable the broader community to adopt neural fast simulation and reconstruction, with future releases planned to expand the library of detector cards and validated configurations.