FLARE: FCCee b2Luigi Automated Reconstruction And Event processing

This paper introduces FLARE, an open-source, b2luigi-powered workflow orchestration tool designed to automate and manage the full data processing and Monte Carlo generation lifecycle for FCCee analyses within the Key4HEP stack.

The Gist

Here is an explanation of the paper, translated into simple language with some creative analogies.

The Big Picture: Building a "Future Collider" in a Computer

Imagine scientists are planning to build the ultimate particle accelerator, the Future Circular Collider (FCC). It's like a giant racetrack for subatomic particles, planned to open in the 2040s. Before they can build the real thing, they need to run millions of "test drives" inside computers to see how the detectors will work and what kind of physics they might discover.

To do this, they use two massive, complex software toolkits:

1. Key4HEP: The "Factory." It builds the raw materials (simulating particle collisions).
2. FCCAnalyses: The "Lab." It takes those raw materials and measures them to find interesting patterns.

The Problem: These two toolkits are like two different languages. They are both excellent, but they don't speak to each other easily. Getting them to work together usually requires a human to act as a translator, manually moving files from the Factory to the Lab, checking settings, and making sure the right tools are used. It's slow, prone to human error, and boring.

The Solution: Enter FLARE.

---

What is FLARE? The "Conductor" of the Orchestra

Think of FLARE as a super-smart orchestra conductor or a personal project manager for your computer.

Its job is to take the messy, complicated instructions for building a particle simulation and the instructions for analyzing it, and then automate the whole process. You tell FLARE what you want (e.g., "Simulate a Higgs boson collision and measure its mass"), and FLARE handles the rest.

It uses a tool called b2luigi (which is like a robot foreman) to organize the work. Instead of you running one script, then waiting, then running another, FLARE builds a "Directed Acyclic Graph" (DAG).

• The Analogy: Imagine a flowchart on a whiteboard. FLARE looks at the chart, sees that Step B depends on Step A, and automatically starts Step A. As soon as Step A finishes, it instantly starts Step B. It can even send different parts of the work to different computers in a "batch system" (like a cloud server) to make it go faster.

How FLARE Works (The "Magic" Features)

1. The "Lego" Approach (Extensibility)

FLARE is built like a set of Lego bricks. The authors designed it so that if scientists invent a new tool in the future, they can just snap it onto FLARE without breaking the whole system.

• Analogy: If you buy a new type of Lego piece, you don't have to rebuild your whole castle. You just click it onto the existing structure. FLARE is designed to accept new "pieces" (software tools) easily.

2. The "Recipe Book" (Configuration)

To tell FLARE what to do, you don't need to write complex code. You just write a simple YAML file (which is like a digital recipe card).

• The Recipe: "I want to use the Whizard generator (the chef), cook 1,000 meals (events), and serve them in the IDEA detector style (the plate)."
• The Magic: FLARE reads this recipe and automatically finds the right ingredients, mixes them, and serves the dish. If you want to try a different plate style (a different detector design), you just change one line in the recipe, and FLARE re-runs the whole thing with the new settings.

3. The "Command Line" (The Remote Control)

FLARE has a simple command-line interface (CLI). Think of it as a remote control for your physics simulation.

• Old Way: You have to type 20 different commands to set up the environment, run the generator, run the analysis, and plot the graphs.
• FLARE Way: You type one simple command: flare run analysis. The remote control does all the heavy lifting behind the scenes.

Real-World Examples from the Paper

The paper shows off FLARE with four specific "test drives":

1. The "Higgs Mass" Test: They took a famous, existing physics experiment and recreated it using FLARE.

   • Result: It worked perfectly, proving FLARE can handle standard, complex tasks without breaking a sweat.

2. The "Speed Run" (Time Comparison): They asked FLARE to generate 10,000 particle collisions.

   • Result: FLARE was incredibly fast and efficient. It showed that you can run many simulations at the same time (parallel processing) without getting confused. It's like having 10 chefs cooking 10 different meals simultaneously, all following the same master recipe.

3. The "Custom Chef" (Cross-Section Calculation): They built a custom workflow to calculate a specific physics value (cross-section) by combining FLARE's internal tools with their own custom math.

   • Result: They proved you can mix and match FLARE's tools with your own ideas. It's like using a pre-made pizza crust (FLARE) but adding your own unique toppings (custom code).

4. The "Detector Switch" (Multi-Detector Study): This was the big flex. They wanted to see how the same particle collision would look if the detector was built slightly differently (e.g., lighter walls, different sensors).

   • Result: They told FLARE to run the same simulation 5 times, each with a different "detector card." FLARE automatically generated 5 different sets of data files and analyzed them all side-by-side.
   • Analogy: Imagine taking a photo of a sunset. FLARE lets you instantly take that same photo through 5 different colored filters (Red, Blue, Green, etc.) and compare the results automatically, without you having to change the camera settings manually 5 times.

Why Should We Care?

Before FLARE, doing this kind of work was like trying to build a house by manually mixing every brick of cement yourself. It was slow and tedious.

FLARE is the construction crane and the automated brick-layer. It allows physicists to focus on the science (answering questions about the universe) rather than the plumbing (moving files and fixing software errors).

It is open source, meaning anyone can use it, improve it, or add their own tools to it. The authors are essentially saying: "We built this toolbox to help everyone in the physics community build the future of particle physics faster and easier."

Summary in One Sentence

FLARE is an open-source automation tool that acts as a smart project manager, connecting complex particle physics software to automatically generate, simulate, and analyze data, allowing scientists to focus on discovery rather than computer maintenance.

Technical Summary

Here is a detailed technical summary of the paper "FLARE: FCCee b2Luigi Automated Reconstruction And Event processing" (ADP-25-23/T1285).

1. Problem Statement

The Future Circular Collider (FCC), specifically the $e^+e^-$ collider phase, requires sophisticated software stacks to simulate particle interactions (Monte Carlo or MC) and analyze the resulting data. The current ecosystem relies on two primary components:

• Key4HEP: A software stack containing MC generators (e.g., Whizard, MadGraph5, Pythia8, Delphes) and detector simulation tools.
• FCCAnalyses: A software package designed to perform physics analyses on the data produced by Key4HEP.

The Core Challenge: While both packages are powerful individually, there is no seamless, harmonized method to synchronize them. Researchers currently face difficulties in orchestrating the complex workflow that involves:

1. Generating MC samples with specific generators.
2. Simulating detector effects.
3. Running multi-stage reconstruction and analysis (Stage 1, Stage 2, Final, Plots).
4. Managing dependencies across different batch systems (e.g., HTCondor, Slurm, LSF).

This lack of integration leads to manual, error-prone workflow management, particularly when scaling up to large-scale MC production or comparing different detector configurations.

2. Methodology

The authors introduce FLARE (FCC Analysis b2Luigi Automated Reconstruction And Event processing), an open-source data workflow orchestration tool designed to bridge Key4HEP and FCCAnalyses.

• Core Engine: FLARE is built upon b2luigi, a workflow orchestration tool originally developed by the Belle II collaboration (an extension of Spotify's Luigi). b2luigi uses Directed Acyclic Graphs (DAGs) to manage task dependencies and supports various batch systems (LSF, HTCondor, Slurm, Gbasf2, Apptainer).
• Architecture:
  • Abstraction Layer: FLARE creates an abstraction layer over Key4HEP and FCCAnalyses, synchronizing the two packages automatically while providing a user-friendly interface.
  • Task Packaging: It encapsulates specific stages of the analysis (e.g., fccanalysis run, fccanalysis final, fccanalysis plots) and MC generation steps into discrete b2luigi tasks.
  • Configuration via YAML: Users define workflows using YAML configuration files. These files specify generators, data types, detector cards, and batch environments.
  • Bracket Mappings: A unique symbolic placeholder system (e.g., ++, <>, ()) allows FLARE to dynamically map configuration parameters to file names and paths during runtime, ensuring flexibility in file naming conventions.
• Workflow Types:
  • FCC Analysis Workflow: Automates the standard FCC analysis stages (Stage 1, Stage 2, Final, Plots).
  • MC Production Workflow: Automates the generation of MC samples using generators like Whizard, MadGraph5, Pythia6/8, and Delphes.
  • Custom Workflows: Users can write custom Python scripts importing FLARE's Task classes to build entirely new workflows or inject dependencies into existing ones.

3. Key Contributions

• Unified Orchestration: FLARE is the first tool to seamlessly coordinate the Key4HEP MC generation stack with the FCCAnalyses analysis stack, handling the entire pipeline from event generation to final histograms.
• Extensibility: The framework is designed to be modular. New generators or analysis tools can be added as "FLARE Workflows" defined by a single YAML file without modifying the core code.
• Multi-Detector & Multi-Generator Support:
  • Supports running the same physics process against multiple detector configurations (e.g., different "cards" for the IDEA detector) in parallel.
  • Supports mixing different generators (e.g., Whizard and Pythia8) within a single workflow execution.
• Command Line Interface (CLI): Provides a user-friendly CLI (flare run) with sub-commands for analysis and mcproduction, allowing users to launch complex workflows with minimal arguments.
• Open Source & Community Driven: The package is open-source, with examples and documentation hosted on GitHub, encouraging community contribution.

4. Results and Validation

The paper validates FLARE through four distinct use cases:

1. Higgs Mass Reconstruction:

   • Replicated the "Fast Simulation Higgs Mass" example from the official FCCAnalyses repository.
   • Successfully reconstructed the Higgs mass ($m_H$) and recoil mass for signal ($e^+e^- \to ZH \to \mu^+\mu^-b\bar{b}$) and background events, producing results consistent with expected physics observables.

2. Large-Scale MC Production Timing:

   • Conducted timed experiments generating 1,000 and 10,000 events using the Whizard generator.
   • Efficiency: The system demonstrated linear scalability. Generating 10,000 events took 16 minutes (964.6s), which is only ~4x the time required for 1,000 events (4 minutes), proving efficient resource utilization in batch environments.

3. Cross-Section Calculation (Custom Workflow):

   • Built a custom workflow to calculate the total cross-section ($\sigma_{total}$) for specific decay chains by combining Whizard output with PDG branching fractions.
   • Accuracy: The calculated cross-sections for four different decay modes were compared against centrally produced FCC Collaboration MC samples. All results were within statistical uncertainties of the reference values (e.g., $0.02686 \pm 0.00035$pb vs. reference$0.0269$ pb).

4. Multi-Detector Sensitivity Study:

   • Generated MC samples for a single signal process ($e^+e^- \to ZH$) using five different detector cards (varying vertex detector thickness and magnetic fields).
   • Analyzed the impact of these hardware variations on reconstructed variables (jet mass and recoil mass), demonstrating FLARE's ability to manage complex, multi-configuration studies automatically.

5. Significance

• Accelerating FCC Physics: FLARE significantly reduces the barrier to entry for FCC physics studies. By automating the complex synchronization between simulation and analysis, it allows physicists to focus on physics results rather than software engineering.
• Scalability: The tool is specifically designed to handle the massive data volumes expected from the FCC (starting operations in the 2040s), leveraging batch systems to distribute workloads efficiently.
• Flexibility for Detector Optimization: The ability to easily swap detector configurations in a single workflow is crucial for the "Detector Design" phase of the FCC, allowing rapid comparison of different hardware proposals.
• Community Standard: By being open-source and built on established tools (b2luigi), FLARE aims to become a standard orchestration layer for the FCC community, fostering collaboration and reproducibility.

In conclusion, FLARE v0.1.4 represents a critical step forward in the software infrastructure for the Future Circular Collider, providing a robust, extensible, and user-friendly solution for end-to-end high-energy physics data workflows.