19.3. Reading ROOT Files with Python
Table of Contents
TFile
In PyROOT you open ROOT files using the TFile class, exactly as in C++, but through the ROOT module. The basic pattern is to import ROOT, open a file by name, check that it is valid, and then access objects inside it.
A minimal example looks like this:
import ROOT
f = ROOT.TFile.Open("data.root") # or ROOT.TFile("data.root", "READ")
if not f or f.IsZombie():
print("Error: could not open file")
else:
f.ls() # list contents of the file
TFile.Open() is usually preferred in Python, because it either returns a valid pointer or None when the open fails. The second argument controls the mode. For reading existing files you normally use "READ" or leave it empty, which also means read only. For this chapter we focus on reading, not writing.
Once the file is open, you can retrieve objects by name using Get:
h = f.Get("h_energy") # histogram
g = f.Get("g_calibration") # graph
t = f.Get("Events") # TTreeThe return value is a PyROOT proxy for the underlying C++ object. You should always verify that the object exists before using it:
t = f.Get("Events")
if not t:
raise RuntimeError("TTree 'Events' not found in file")In Python the file object will be closed automatically when it is garbage collected, but for analysis scripts it is good practice to close it explicitly when you are finished:
f.Close()
You can also use a with context manager to ensure the file closes even if an exception occurs. PyROOT does not provide a built-in context manager for TFile, so a simple helper can be useful:
import contextlib
import ROOT
@contextlib.contextmanager
def open_root(filename, mode="READ"):
f = ROOT.TFile.Open(filename, mode)
if not f or f.IsZombie():
raise IOError(f"Cannot open ROOT file '{filename}'")
try:
yield f
finally:
f.Close()
with open_root("data.root") as f:
f.ls()
t = f.Get("Events")
Within the with block, the file is open and you can freely access histograms, graphs, and trees. When the block ends, f.Close() is called automatically.
When you work with multiple input files in the same script, it is important to avoid reusing the same variable name if you still need the previous file open. Each TFile has its own internal directory structure, so the same object name can exist in different files. You must always know from which file you obtained a given object.
Always check that TFile.Open() and Get() actually return valid objects before using them. Trying to use a null or zombie object often leads to confusing errors later in your Python script.
TTrees
In PyROOT TTrees behave like C++ TTrees, but Python gives you a few extra ways to loop over entries and inspect data. Typical workflows read an existing tree from a file and then either inspect it directly, use TTree::Draw, or convert data to NumPy arrays or to RDataFrame for further analysis.
To obtain a TTree from a file, you use Get with the tree name:
import ROOT
f = ROOT.TFile.Open("data.root")
tree = f.Get("Events")
if not tree:
raise RuntimeError("Could not find TTree 'Events'")You can quickly inspect the structure of the tree from Python using familiar ROOT methods:
tree.Print() # full branch structure
tree.Show(0) # show first entry
tree.Scan("energy") # print values of a given branch
If you want to loop over events directly in Python, the simplest approach uses a for loop. PyROOT lets you iterate over a TTree and gives you an object where branch names become attributes:
for entry in tree:
e = entry.energy # access branch "energy"
t = entry.time # access branch "time"
if e > 1.0:
# perform some analysis
pass
This pattern is convenient for quick scripts. It avoids manual calls to GetEntry and manual branch address setup. It is suitable for small and medium size datasets or for prototyping.
For a more explicit C++ style loop you can still use GetEntry:
n_entries = tree.GetEntries()
for i in range(n_entries):
tree.GetEntry(i)
e = tree.energy
# do something with e
From Python the attribute access tree.energy automatically refers to the branch called "energy". Both loop styles are compatible with branches that hold simple numeric types. For more complex structures such as std::vector<double> you can still access the branch as an attribute and then use it like a Python sequence:
for entry in tree:
hits = entry.hit_energy # std::vector<float> on C++ side
n_hits = len(hits)
if n_hits > 0:
first = hits[0]
When you already use NumPy in your Python analysis, it is common to convert TTree data to NumPy arrays. PyROOT provides helpers in ROOT.RDataFrame and in ROOT.AsMatrix from the TMVA utilities in some ROOT versions, but these belong in the chapters on RDataFrame and PyROOT with NumPy. In this chapter it is enough to know that you can read the data once with a TTree loop in Python and then fill your own NumPy arrays or lists.
Another common pattern is to use TTree::Draw from Python, which lets ROOT handle the loop internally. For instance, to make a quick histogram from a branch:
c = ROOT.TCanvas()
tree.Draw("energy") # creates a TH1F in memory
hist = ROOT.gPad.GetPrimitive("htemp") # grab the automatically created histogramYou can pass selection cuts as a string and additional drawing options:
tree.Draw("energy >> h_sel(100,0,10)", "time > 50", "E")
h_sel = ROOT.gDirectory.Get("h_sel")This interface is identical to C++, but in Python it is very fast to prototype different selections and variables.
When reading TTrees from Python you must keep the parent TFile alive as long as you use the tree. If you close the file too early, the TTree and its branches may point to invalid memory. A safe pattern is to keep the TFile object in a variable that remains in scope for the lifetime of your analysis, or to nest all TTree usage inside a with block that manages the file, as shown before.
Never use a TTree or branch after its parent TFile has been closed. Keep the file object alive and in scope for as long as you access the tree from Python.
For high level analysis you will very often combine TTrees in Python with RDataFrame or with conversion to NumPy arrays. This keeps your loops concise, uses ROOT’s optimized back end, and takes advantage of Python’s ecosystem for further processing.
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!