13.5. Reading a TTree
Table of Contents
Accessing branches
When you read data from a TTree you almost never work with the TTree alone. You ask for one or more of its branches and tell ROOT where in memory it should put the values it reads for each entry. For beginners it is enough to understand the following sequence: open the file, get the tree, set up access to branches, then iterate over entries.
A typical session starts by opening a ROOT file and retrieving the TTree object:
TFile *f = TFile::Open("data.root");
TTree *t = (TTree*)f->Get("myTree");At this point you probably want to know what branches the tree contains. The simplest inspection commands are:
t->Print(); // detailed structure, branches, types, leaves
t->Scan(); // quick table-like view of branch contents
The names printed by Print() are exactly the names you will use when you read data.
There are two common, beginner friendly ways to access branches: direct drawing expressions using TTree::Draw() and explicit branch access using addresses. The first way is covered in another chapter, so here the focus is on setting up reading through branch addresses, which gives you full control inside C++ code.
To read a branch you create a C++ variable of the appropriate type and ask the tree to fill it whenever you move to a new entry. This is usually done with SetBranchAddress() on the tree object:
int eventID;
float energy;
double time;
// Associate tree branches with C++ variables
t->SetBranchAddress("eventID", &eventID);
t->SetBranchAddress("energy", &energy);
t->SetBranchAddress("time", &time);
You must pass the address of your variable, so you use &variableName. When ROOT reads an entry it will write the branch value directly into that variable. The type of the variable must match the branch type. If the branch was written as Int_t you should use int. If it was Float_t use float, and for Double_t use double. If you are not sure, Print() will tell you the exact leaf type.
The C++ variable type must be compatible with the branch type, and you must pass its address to SetBranchAddress(). A wrong type, or forgetting the &, is a common source of crashes.
Strings and small fixed arrays appear very often in real data. A C-style character array branch can be read like this:
char detectorName[16]; // large enough buffer
t->SetBranchAddress("detName", detectorName);
Here you do not use &detectorName because an array already behaves like a pointer to its first element. For simple numeric fixed-size arrays, you typically declare a C array and pass it in the same way:
float hitEnergy[64];
t->SetBranchAddress("hitEnergy", hitEnergy);
Branches that hold std::vector<type> objects are common in modern ROOT files. They allow a different number of elements per event. Reading them uses a pointer:
std::vector<float> *hitE = nullptr;
t->SetBranchAddress("hitEnergyVec", &hitE);
ROOT will allocate and manage the std::vector objects as you call GetEntry(). Once the address is set you can use hitE in your event loop like any other pointer to a vector.
Sometimes you do not want to read all branches. Turning off unused branches is an important performance technique covered in a later chapter, but the basic mechanism is simple:
t->SetBranchStatus("*", 0); // disable all branches
t->SetBranchStatus("energy", 1); // enable only "energy"
t->SetBranchStatus("time", 1); // and "time"
With this configuration calls to GetEntry() will only read enabled branches into the variables you connected with SetBranchAddress(). This is especially useful for large TTrees and big files.
Looping over entries
Once your branches are connected to variables the central operation is an event loop. You go over all entries in the tree or a selected subset and for each entry you read the branch values and perform calculations or fill histograms.
The total number of entries can be obtained with GetEntries():
Long64_t nEntries = t->GetEntries();
The index of an entry runs from 0 to nEntries - 1. To read the contents of a specific entry you call GetEntry(entryIndex):
t->GetEntry(iEntry);
This call triggers ROOT to read the requested entry from disk and fill all the active branches into the variables you connected with SetBranchAddress(). After GetEntry() returns, your variables hold the values for that event and you can use them.
A minimal, complete event loop that reads all entries and prints something looks like this:
Long64_t nEntries = t->GetEntries();
for (Long64_t i = 0; i < nEntries; ++i) {
t->GetEntry(i); // load entry i into eventID, energy, time
std::cout << "Entry " << i
<< " eventID = " << eventID
<< " energy = " << energy
<< " time = " << time << std::endl;
}You usually replace printing with analysis operations such as filling histograms, computing derived quantities, or applying selection cuts. A typical pattern combines selection and histogram filling:
TH1F *hEnergy = new TH1F("hEnergy", "Energy;E [MeV];Events", 100, 0.0, 1000.0);
Long64_t nEntries = t->GetEntries();
for (Long64_t i = 0; i < nEntries; ++i) {
t->GetEntry(i);
// Example event selection
if (energy > 10.0 && time > 0.0) {
hEnergy->Fill(energy);
}
}Here the TTree provides input values, the event loop applies simple physics cuts, and the histogram collects the resulting distribution.
You are not forced to process every entry. You may want to inspect only the first few events or skip some entries. This is just standard C++ control over the loop:
for (Long64_t i = 0; i < nEntries; i += 2) { // process every second entry
t->GetEntry(i);
// analysis for this subset
}Or to limit processing to a maximum number of entries:
Long64_t maxEntries = std::min(nEntries, (Long64_t)10000);
for (Long64_t i = 0; i < maxEntries; ++i) {
t->GetEntry(i);
// quick test analysis on first 10k entries
}
When reading branches that hold std::vector objects the pattern inside the loop is slightly different, because each event can contain a different number of elements. After GetEntry() you query the size of the vector and loop over its entries:
Long64_t nEntries = t->GetEntries();
for (Long64_t i = 0; i < nEntries; ++i) {
t->GetEntry(i);
// hitE is a pointer to std::vector<float>
for (size_t j = 0; j < hitE->size(); ++j) {
float e = hitE->at(j);
// work with individual hit energy e
}
}This style is central in real analyses where each event may have a variable number of tracks, clusters, or detector hits.
It is often useful to check return values from GetEntry(), especially when you operate near the end of a tree or on corrupted data. GetEntry() returns the number of bytes read. If it returns zero or a negative value something is wrong or you are past the last valid entry:
if (t->GetEntry(i) <= 0) {
std::cerr << "Problem reading entry " << i << std::endl;
break;
}
A correct event loop always calls GetEntry() for each entry index you want to process. Using branch variables without a preceding GetEntry() means you are working with stale values from an old entry.
By combining careful branch access and a well structured loop over entries you gain full programmatic control of TTree contents. This is the foundation for all later topics, such as drawing directly from TTrees, applying selection cuts, or using higher level interfaces like RDataFrame.
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!