14.2. Event Loops
Table of Contents
Reading events
In event based analysis you almost always start from a TTree that stores one entry per event. Each entry typically represents a detector trigger, a collision, or one simulated event. An event loop means iterating over all entries in a TTree, reading their contents, and performing calculations or selections.
The essential pattern for reading events manually is always the same. You open the ROOT file, get the TTree, connect C++ variables to the branches, then loop over all entries and call GetEntry in each iteration.
A minimal structure looks like this:
void loop_example() {
TFile *f = TFile::Open("data.root");
TTree *t = (TTree*)f->Get("Events");
// Variables to hold branch data
float energy;
int nHits;
// Connect branches to variables
t->SetBranchAddress("energy", &energy);
t->SetBranchAddress("nHits", &nHits);
Long64_t nEntries = t->GetEntries();
for (Long64_t i = 0; i < nEntries; ++i) {
t->GetEntry(i); // Read event i into energy and nHits
// Work with this event here
}
f->Close();
}
The call SetBranchAddress tells the TTree where to store the data when you call GetEntry. Each call to GetEntry(i) fills all connected variables with the content of entry i. Inside the loop the variables behave like regular C++ variables. You can read them, combine them, and use them to decide which events to keep or reject.
You should treat the event index as opaque. In most analyses you loop from 0 to nEntries-1 in order. For more advanced workflows you can also restrict the loop to a subset of entries or process entries in blocks, but the basic idea is always entry by entry access via GetEntry.
Although ROOT offers high level interfaces like TTree::Draw and RDataFrame, learning to write a manual event loop is important. It shows clearly when data are read, when calculations happen, and how often histograms are filled. This control is essential once you build more complex analyses.
In every manual event loop you must:
- Connect all needed branches using
SetBranchAddress. - Call
GetEntry(i)once per event inside the loop. - Use the filled variables only after
GetEntryhas been called.
Applying calculations
Once you can read each event, the next step is to compute quantities derived from the raw branches. These derived quantities can be simple arithmetic combinations or more involved physics observables.
For each event you typically proceed as follows. First, call GetEntry(i) to load the event. Next, apply basic checks such as discarding obviously invalid or incomplete events. Then compute the quantities you care about and finally decide whether the event should contribute to a given histogram or result.
Here is a simple pattern that computes a derived variable from branches:
void loop_with_calculations() {
TFile *f = TFile::Open("data.root");
TTree *t = (TTree*)f->Get("Events");
float energy1, energy2;
float time1, time2;
t->SetBranchAddress("energy1", &energy1);
t->SetBranchAddress("energy2", &energy2);
t->SetBranchAddress("time1", &time1);
t->SetBranchAddress("time2", &time2);
Long64_t nEntries = t->GetEntries();
for (Long64_t i = 0; i < nEntries; ++i) {
t->GetEntry(i);
// Derived quantities
float totalEnergy = energy1 + energy2;
float deltaT = time2 - time1;
// Simple quality checks
if (totalEnergy <= 0) continue;
if (fabs(deltaT) > 100.0) continue;
// Use totalEnergy and deltaT for further analysis or histogramming
}
f->Close();
}
The calculations themselves can use ordinary C++ arithmetic and functions from <cmath> and ROOT helper classes. For vector like quantities you may use ROOT classes such as TLorentzVector or TVector3. For example, constructing a four vector per event and then asking for invariant mass fits naturally into this per event pattern, but the detailed physics belongs to later chapters.
It is important to keep calculations inside the event loop independent between events. Each iteration must rely only on the data loaded for that specific event. Do not accidentally carry values over from a previous iteration unless you explicitly want cumulative sums or counters.
Another practical point is to separate calculations that are constant from those that depend on the event. Calibration constants, scale factors, or geometry parameters should be defined outside the loop. Inside the loop you reuse these constants for each event. This keeps the loop code simpler and avoids unnecessary repeated computations.
Within an event loop:
- Call
GetEntry(i)before any calculations for eventi. - Use only the current event data to compute derived quantities.
- Place constant parameters and calibration factors outside the loop.
Filling histograms
The ultimate goal of most event loops is to summarize event by event information into histograms or similar objects. The pattern is straightforward. You create and configure histograms once before the loop, then fill them for each selected event inside the loop, and finally inspect or save them after the loop has finished.
A minimal example ties everything together:
void loop_fill_histograms() {
TFile *f = TFile::Open("data.root");
TTree *t = (TTree*)f->Get("Events");
float energy;
t->SetBranchAddress("energy", &energy);
// Create histograms before the loop
TH1F *hEnergy = new TH1F("hEnergy", "Energy;E [MeV];Events", 100, 0, 1000);
TH1F *hEnergyHigh = new TH1F("hEnergyHigh", "High energy;E [MeV];Events", 100, 500, 1500);
Long64_t nEntries = t->GetEntries();
for (Long64_t i = 0; i < nEntries; ++i) {
t->GetEntry(i);
// Basic selection
if (energy <= 0) continue;
// Fill general spectrum
hEnergy->Fill(energy);
// Fill second histogram only for high energy events
if (energy > 600) {
hEnergyHigh->Fill(energy);
}
}
// After the loop, you can draw or save the histograms
TCanvas *c1 = new TCanvas("c1", "Energy spectra", 800, 600);
hEnergy->Draw();
c1->SaveAs("energy_spectrum.png");
f->Close();
}
You can also fill histograms with weights. In that case Fill(x, w) increments the bin corresponding to x by the weight w instead of 1. This can be useful for efficiency corrections, luminosity scaling, or when input events already carry weights.
When you use weighted fills and you care about proper statistical uncertainties, you should tell the histogram to store the sum of squared weights. This is done once, before filling, with Sumw2().
TH1F *hWeighted = new TH1F("hWeighted", "Weighted distribution;X;Weighted events", 50, 0, 1);
hWeighted->Sumw2(); // enable proper error handling
for (Long64_t i = 0; i < nEntries; ++i) {
t->GetEntry(i);
double x = /* some derived quantity */;
double weight = /* event weight */;
hWeighted->Fill(x, weight);
}
This event loop pattern extends naturally to multiple histograms and multiple TTrees. You can create several histograms before the loop, fill each one under its specific conditions inside the same loop, and at the end you can write all of them to a ROOT file. The key is always to keep histogram creation outside the loop and to call Fill only after you have computed and validated the quantities for a given event.
For histogramming inside event loops:
- Create and configure histograms before the event loop.
- Fill histograms only after selection and calculations for each event.
- Call
Sumw2()before the loop if you will use weighted fills and want correct bin errors.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to ROOT
- ☰ 1.1. What Is ROOT?
- ☰ 1.2. Installing ROOT
- ☰ 1.3. Starting ROOT
- ☰ 1.4. Your First ROOT Session
-
- ☰ 2. C++ Basics for ROOT
- ☰ 2.1. Why ROOT Uses C++
- ☰ 2.2. Variables and Data Types
- ☰ 2.3. Operators
- ☰ 2.4. Conditional Statements
- ☰ 2.5. Loops
- ☰ 2.6. Functions
- ☰ 2.7. Arrays and Vectors
-
- ☰ 3. ROOT Macros
- ☰ 3.1. What Is a ROOT Macro?
- ☰ 3.2. Running ROOT Macros
- ☰ 3.3. Functions Inside ROOT Macros
- ☰ 3.4. Compiling ROOT Macros
- ☰ 3.5. Organizing a ROOT Project
-
- ☰ 4. ROOT Objects and the ROOT Object Model
- ☰ 4.1. Introduction to ROOT Classes
- ☰ 4.2. Object Names and Titles
- ☰ 4.3. ROOT Collections
- ☰ 4.4. Inspecting ROOT Objects
-
- ☰ 5. Histograms
- ☰ 5.1. Introduction to Histograms
- ☰ 5.2. Creating a 1D Histogram
- ☰ 5.3. Filling Histograms
- ☰ 5.4. Drawing Histograms
- ☰ 5.5. Histogram Properties
- ☰ 5.6. Accessing Histogram Bins
- ☰ 5.7. Histogram Errors
- ☰ 5.8. Normalizing Histograms
- ☰ 5.9. Combining Histograms
-
- ☰ 6. Two-Dimensional Histograms
- ☰ 6.1. Creating 2D Histograms
- ☰ 6.2. Filling 2D Histograms
- ☰ 6.3. Drawing 2D Histograms
- ☰ 6.4. Projections
- ☰ 6.5. Profiles
-
- ☰ 7. Graphs
- ☰ 7.1. Introduction to TGraph
- ☰ 7.2. Creating a TGraph
- ☰ 7.3. Graph Styling
- ☰ 7.4. TGraphErrors
- ☰ 7.5. TGraphAsymmErrors
- ☰ 7.6. MultiGraph
-
- ☰ 8. Canvases and Plotting
- ☰ 8.1. TCanvas
- ☰ 8.2. Dividing a Canvas
- ☰ 8.3. Drawing Multiple Objects
- ☰ 8.4. Legends
- ☰ 8.5. Text and Annotations
- ☰ 8.6. Logarithmic Axes
- ☰ 8.7. Saving Plots
-
- ☰ 9. Styling ROOT Plots
- ☰ 9.1. ROOT Plot Styles
- ☰ 9.2. Axis Configuration
- ☰ 9.3. Line Styles
- ☰ 9.4. Marker Styles
- ☰ 9.5. Publication-Quality Figures
-
- ☰ 10. Mathematical Functions
- ☰ 10.1. Introduction to TF1
- ☰ 10.2. Built-in Functions
- ☰ 10.3. Custom Functions
- ☰ 10.4. Evaluating Functions
- ☰ 10.5. Function Integrals
-
- ☰ 11. Curve Fitting
- ☰ 11.1. Introduction to Fitting
- ☰ 11.2. Gaussian Fits
- ☰ 11.3. Polynomial Fits
- ☰ 11.4. Custom Fit Functions
- ☰ 11.5. Fit Parameters
- ☰ 11.6. Goodness of Fit
- ☰ 11.7. Fit Residuals
- ☰ 11.8. Fitting Graphs
-
- ☰ 12. ROOT Files
- ☰ 12.1. Introduction to ROOT Files
- ☰ 12.2. Creating ROOT Files
- ☰ 12.3. Writing Objects
- ☰ 12.4. Reading ROOT Files
- ☰ 12.5. Exploring ROOT Files
- ☰ 12.6. Directories Inside ROOT Files
-
- ☰ 13. TTrees
- ☰ 13.1. Introduction to TTrees
- ☰ 13.2. Creating a TTree
- ☰ 13.3. Filling a TTree
- ☰ 13.4. Writing a TTree to a File
- ☰ 13.5. Reading a TTree
- ☰ 13.6. Inspecting TTrees
- ☰ 13.7. Drawing Data from TTrees
- ☰ 13.8. Applying Selection Cuts
- ☰ 13.9. Branch Addresses
-
- ☰ 14. Event-Based Data Analysis
- ☰ 14.1. Understanding Event Data
- ☰ 14.2. Event Loops
- ☰ 14.3. Event Selection
- ☰ 14.4. Derived Quantities
- ☰ 14.5. Analysis Workflow
-
- ☰ 15. Working with Real Experimental Data
- ☰ 15.1. Importing Text Data
- ☰ 15.2. Converting Data to ROOT
- ☰ 15.3. Data Cleaning
- ☰ 15.4. Data Calibration
- ☰ 15.5. Signal and Background
-
- ☰ 16. Random Numbers and Simulations
- ☰ 16.1. Random Number Generation
- ☰ 16.2. Common Distributions
- ☰ 16.3. Simple Monte Carlo Simulation
- ☰ 16.4. Detector Resolution Simulation
- ☰ 16.5. Efficiency Simulation
-
- ☰ 17. Statistical Analysis with ROOT
- ☰ 17.1. Basic Statistics
- ☰ 17.2. Probability Distributions
- ☰ 17.3. Statistical Uncertainties
- ☰ 17.4. Chi-Square Tests
- ☰ 17.5. Confidence Intervals
-
- ☰ 18. Modern ROOT with RDataFrame
- ☰ 18.1. Introduction to RDataFrame
- ☰ 18.2. Loading Data
- ☰ 18.3. Filtering Data
- ☰ 18.4. Defining New Columns
- ☰ 18.5. Creating Histograms
- ☰ 18.6. Statistical Operations
- ☰ 18.7. Saving Results
- ☰ 18.8. Multithreading
-
- ☰ 19. ROOT and Python
- ☰ 19.1. Introduction to PyROOT
- ☰ 19.2. ROOT Objects in Python
- ☰ 19.3. Reading ROOT Files with Python
- ☰ 19.4. PyROOT and NumPy
- ☰ 19.5. PyROOT and Matplotlib
- ☰ 19.6. Choosing Between C++ and Python
-
- ☰ 20. Advanced TTree Techniques
- ☰ 20.1. Trees with Multiple Branches
- ☰ 20.2. Storing std::vector Objects
- ☰ 20.3. TChain
- ☰ 20.4. Friends
- ☰ 20.5. Efficient TTree Analysis
-
- ☰ 21. ROOT for Particle and Nuclear Physics
- ☰ 21.1. Four-Vectors
- ☰ 21.2. Particle Kinematics
- ☰ 21.3. Invariant Mass
- ☰ 21.4. Angular Distributions
- ☰ 21.5. Detector Spectra
-
- ☰ 22. Debugging and Common ROOT Problems
- ☰ 22.1. ROOT Object Ownership
- ☰ 22.2. Null Pointers
- ☰ 22.3. Segmentation Faults
- ☰ 22.4. Missing Histograms
- ☰ 22.5. ROOT File Problems
- ☰ 22.6. TTree Branch Problems
- ☰ 22.7. Histogram Range Problems
- ☰ 22.8. Fit Failures
- ☰ 22.9. Debugging ROOT Macros
-
- ☰ 23. Writing Better ROOT Analysis Code
- ☰ 23.1. Separating Analysis and Plotting
- ☰ 23.2. Using Functions
- ☰ 23.3. Using Header Files
- ☰ 23.4. Naming Conventions
- ☰ 23.5. Avoiding Hard-Coded Values
- ☰ 23.6. Configuration Parameters
- ☰ 23.7. Reproducible Analysis
- ☰ 23.8. Version Control with Git
-
- ☰ 24. Final Project
- ☰ 24.1. Project Overview
- ☰ 24.2. Analyze a complete scientific dataset using ROOT.
- ☰ 24.3. Import the Data
- ☰ 24.4. Explore the Dataset
- ☰ 24.5. Apply Data Selection
- ☰ 24.6. Create Histograms
- ☰ 24.7. Fit the Data
- ☰ 24.8. Calculate Physical Quantities
- ☰ 24.9. Estimate Statistical Uncertainties
- ☰ 24.10. Create Publication-Quality Figures
- ☰ 24.11. Save the Analysis Results
- ☰ 24.12. Write a Short Analysis Report
-
- ☰ 25. Appendices
- ☰ 25.1. A. ROOT Command Cheat Sheet
- ☰ 25.2. B. ROOT Histogram Classes
- ☰ 25.3. C. ROOT Graph Classes
- ☰ 25.4. D. Common TTree Commands
- ☰ 25.5. E. Common Drawing Options
- ☰ 25.6. F. Common Fit Functions
- ☰ 25.7. G. ROOT C++ Cheat Sheet
- ☰ 25.8. H. PyROOT Cheat Sheet
- ☰ 25.9. I. Common ROOT Errors and Solutions
- ☰ 25.10. J. Recommended ROOT Analysis Workflow
-
Comments
Please login to add a comment.
Don't have an account? Register now!