CELEBI: Design and Realization of a Reproducible Physics Analysis Framework

In the vast, high-stakes world of particle physics, scientists do not simply look through a microscope to find answers. Instead, they build massive machines that smash particles together, creating a chaotic shower of signals that must be translated into knowledge. This translation is not a single moment of discovery but a long, winding journey of computation. Detectors capture raw data, which is then processed through centralized systems to create cleaner datasets. Only then do individual researchers begin their own work: writing code to select specific events, adjusting mathematical parameters, and running complex statistical tests to see if a new particle has been found or if a theory holds up. This entire process is a chain of decisions, where the final result depends on a specific combination of software, settings, and data inputs.

The challenge for the scientific community is that this chain is constantly moving. As researchers refine their methods, they change the code, tweak the numbers, and swap out data sets. A result published today might rely on a version of a program that was altered tomorrow. If a scientist from five years ago wants to check a result, or if a new team wants to build upon an old finding, they face a difficult puzzle: how to reconstruct the exact state of the work when it was done. It is not enough to save the final numbers or the source code alone; one must preserve the entire context of how those numbers were made. Without this, the history of scientific discovery becomes a collection of disconnected snapshots, where the path from a question to an answer is lost.

To solve this, a framework called Celebi was developed by Mingrui Zhao at Peking University. This system is designed to manage the life of a physics analysis, treating it not as a static file but as a living, evolving collection of materials. The researcher realized that the way scientists currently organize their work often mixes the instructions for a calculation with the massive amounts of data those calculations produce. This makes it hard to track exactly which version of a program led to which result, especially when the work changes over time. Celebi separates these two worlds. It keeps the lightweight instructions—the code, the settings, and the logic—in one place, while the heavy, generated data lives in another. This separation allows the instructions to be preserved in a clear, organized way without being bogged down by the terabytes of data they produce.

The core of Celebi is a new way of thinking about how an analysis is built. The researcher introduced a concept they call a "materialized workflow." In traditional computing, a workflow is often just a list of steps telling a computer what to do next. In Celebi, the workflow is built from actual, tangible objects that represent the parts of the analysis. The system distinguishes between an "algorithm," which is the general recipe for a calculation, and a "task," which is the specific application of that recipe to a particular set of data with specific settings. Imagine a chef who has a master recipe for a soup (the algorithm) but makes different batches for different customers, adding varying amounts of salt or using different vegetables (the tasks). In this system, the master recipe stays the same, but each specific batch is recorded as a unique task that links back to the recipe and the specific ingredients used. This structure allows the same piece of code to be reused in many different parts of an analysis without having to copy and paste the code, reducing errors and making the history of the work much clearer.

To make this structure easy for humans to read and understand, the researcher organized the digital files in a way that mirrors the logical structure of the analysis. Instead of hiding everything in complex, hidden folders, the system uses a clear hierarchy of projects, directories, algorithms, and tasks. Each of these objects carries its own notes and descriptions, so that anyone looking at the file system can immediately understand what a piece of code does and how it connects to the rest of the work. This organization ensures that the analysis remains self-describing; the context is built right into the files themselves. Furthermore, the system handles data inputs differently depending on where they come from. If data is generated by a previous step in the analysis, the system tracks the link between the tasks. If data comes from outside, the system creates a specific object to mark where that external data enters the workflow. This creates a consistent map of where every piece of information originated, regardless of its source.

The most critical innovation in Celebi is a mechanism called "impressions." Since the working analysis is always changing, the researcher needed a way to freeze a specific moment in time without stopping the work. An impression is like a snapshot of the entire analysis at a particular moment, capturing the exact state of the code, the parameters, and the dependencies. Once an impression is made, it is immutable; it cannot be changed. If the scientist later alters the code or the settings, they create a new working state, but the old impression remains exactly as it was. This allows them to keep a permanent record of the conditions under which a specific result was produced. If a result is generated, it is tied directly to the impression that created it. This means that even years later, a scientist can look at a result and know precisely which version of the code and which specific settings were used to create it, because that result is permanently linked to that unchangeable snapshot.

The system also separates the act of preserving the analysis from the act of running it. The preserved instructions are stored in a repository, but when it is time to do the actual calculation, a separate system called a "Production Factory" takes over. A middleware layer, named Yuki, acts as the bridge between the two. When a preserved state needs to be run, Yuki translates the stored instructions into a format that a computer can execute and sends it to a workflow runner. This design means that the way the analysis is stored does not depend on the specific computer or software used to run it. The researcher can change the computing environment or the execution tools without having to rewrite the analysis itself. This flexibility ensures that the analysis can be preserved for the long term, even as the technology used to run it evolves.

By combining these elements, Celebi provides a complete framework for managing the lifecycle of a physics analysis. It offers a way to keep the instructions for a calculation separate from the massive data it produces, organizes those instructions in a human-readable structure, and creates permanent, unchangeable records of specific states. This approach addresses a fundamental problem in modern science: the difficulty of reproducing results when the underlying work is constantly shifting. The researcher demonstrates that by treating an analysis as a collection of structured, interconnected objects and by using impressions to lock in specific states, it is possible to maintain a clear and unbroken line of evidence from the original question to the final answer. This work lays the foundation for a future where scientific results are not just published, but are fully preserved, traceable, and ready to be revisited and verified by anyone, anywhere, at any time.