12.4. Reading ROOT Files
Table of Contents
Opening files
To use data or objects saved in a .root file, you first need to open that file with the TFile class. Conceptually, TFile behaves like a C++ stream combined with a directory of objects: it gives you both access to the file itself and a way to look up what is inside.
The most common way to open a ROOT file is through its constructor. In the ROOT prompt you can write
TFile *f = new TFile("results.root");
ROOT will try to open results.root in read mode. If the file does not exist, the pointer will still be created, but the file will be marked as a zombie, which means it is invalid for normal use. You should always check that the file was opened successfully before using it.
A simple safety pattern is
TFile *f = TFile::Open("results.root", "READ");
if (!f || f->IsZombie()) {
std::cout << "Error opening file results.root" << std::endl;
return;
}
Here TFile::Open is a convenient static method that returns a pointer, and the second argument "READ" selects read only mode. Other modes, such as "RECREATE" or "UPDATE", are covered elsewhere in the ROOT Files chapter, so here you only need to remember that when you are reading files, "READ" is the appropriate choice.
You can also open ROOT files directly from the command line when starting ROOT. For example
root results.root
will start ROOT and automatically open results.root as the current file. In the interactive session, the file is accessible through the global pointer gFile. You can inspect which file is currently associated with gFile by printing
gFile->GetName();or by calling
gFile->ls();to list its contents.
When you have finished reading from a file, close it explicitly, especially in macros and longer analyses.
f->Close();
delete f;Closing ensures that any internal buffers are flushed and that the file is properly detached from memory.
Always check if (!f || f->IsZombie()) after opening a ROOT file for reading. Using an invalid TFile pointer is a frequent source of crashes and confusing errors.
If you expect to open files inside functions or loops, it is good practice to keep the pointer scope as small as possible. Open the file, retrieve what you need, then close and delete the TFile before leaving the scope, so you do not accumulate open files or rely on global state.
Retrieving objects
Once a ROOT file is open, the next step is to access the objects that were written to it, such as histograms, graphs, TTrees, or directories. In most simple cases, the objects are stored at the top level of the file and can be accessed by their names. When objects were written, each had an internal key that matches its object name. To retrieve an object, you use TFile::Get.
Suppose a one dimensional histogram named "hEnergy" was saved to the file. You can read it back with
TH1F *hEnergy = (TH1F*) f->Get("hEnergy");
The Get method returns a generic TObject*, so you must cast it to the correct class. This cast is your responsibility, because ROOT cannot know at compile time which concrete type is stored under a given name. If you cast to the wrong type, you may see undefined behavior. You can protect yourself by checking the returned pointer:
TH1F *hEnergy = (TH1F*) f->Get("hEnergy");
if (!hEnergy) {
std::cout << "Histogram hEnergy not found in file" << std::endl;
}
For trees, the procedure is similar. If a TTree was saved with the name "Events", retrieve it with
TTree *tree = (TTree*) f->Get("Events");
if (!tree) {
std::cout << "TTree Events not found" << std::endl;
}
After that, you can use all the usual TTree methods, such as Print, Draw, or manual loops.
Often, you are not entirely sure which objects are present, or what their exact names are. Before retrieving, list the file contents with
f->ls();This command prints a hierarchical view of objects and directories inside the file, together with their class types. For example, you might see lines like
TH1F hEnergy;1 Energy spectrum
TTree Events;1 Event data
The left entry is the class, the first word after that is the key name, which you pass to Get.
If objects are stored inside subdirectories in the file, you must include the directory path in the name. For example, if hEnergy is in a directory named "spectra", you retrieve it with
TH1F *hEnergy = (TH1F*) f->Get("spectra/hEnergy");Alternatively, you can navigate into the directory first:
f->cd("spectra");
TH1F *hEnergy = (TH1F*) gDirectory->Get("hEnergy");
Here gDirectory represents the current directory inside the file. If you use this style, you need to pay attention to which directory is active, especially in larger macros.
In interactive work, you can use the ROOT browser to explore files and pick objects. Start the browser with
TBrowser b;
then click on the file, directories, and objects. Double clicking a histogram or a graph will draw it automatically. The browser shows you the object names, which you can then reuse in your code when calling Get.
Sometimes you only know the class but not the exact object names. In that case, you can iterate over the list of keys. A simple pattern is
TIter nextkey(f->GetListOfKeys());
TKey *key;
while ((key = (TKey*) nextkey())) {
std::cout << key->GetName() << " " << key->GetClassName() << std::endl;
}This technique is useful for files that contain many similar objects, for example a histogram per detector channel.
ROOT tracks object ownership, so it is important to understand who owns objects you retrieve. In most common use cases, when you call Get, the object is owned by the file or by the current directory. That means you should not delete the retrieved object yourself if you intend to keep the file open. If you close the file while still using the object, you might access invalid memory. A safe pattern is to finish using the objects, then close the file at the end of your analysis.
Make sure the type you cast from Get matches the class that was written. Always check that the pointer returned by Get is not null before using it, and keep the TFile open as long as you are using objects that the file owns.
If you need to keep a copy of an object after closing the file, you can clone it:
TH1F *hEnergy = (TH1F*) f->Get("hEnergy");
TH1F *hCopy = (TH1F*) hEnergy->Clone("hEnergy_copy");
f->Close(); // hCopy is still valid, because it is now independent of the fileThe cloned object is stored in memory and is no longer tied to the file's lifetime. This is a common pattern when you want to process or modify histograms from an input file while keeping your analysis code independent from the original storage.
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!