4.3. ROOT Collections
Table of Contents
Lists
ROOT provides several container classes to hold groups of objects in memory. These are called ROOT collections. The most common general purpose container is TList. You will often meet TList indirectly, because many ROOT classes use it internally to manage their own children, for example the list of primitives drawn on a canvas, or the list of keys in a file directory.
A TList is conceptually similar to a list in other languages. It stores pointers to TObject instances, keeps them in a defined order, and lets you add, remove, and iterate over them. A TList does not care about the specific derived class, so you can store histograms, graphs, functions, or other ROOT objects together. Since it stores TObject*, you access the real type by casting when you retrieve elements.
You typically create a list with the default constructor:
TList *myList = new TList();
To add objects, you use Add:
TH1F *h1 = new TH1F("h1", "Histogram 1", 100, 0, 10);
TH1F *h2 = new TH1F("h2", "Histogram 2", 100, 0, 10);
myList->Add(h1);
myList->Add(h2);
Lists can optionally take ownership of their elements. If a TList owns an object, it will delete it when the list is deleted or when the object is removed from the list. This is controlled with SetOwner:
myList->SetOwner(kTRUE);With ownership enabled, you must not delete the objects manually, because the list will handle that. Without ownership, the list only stores pointers and you are responsible for deleting the contained objects yourself. Object ownership in collections is a frequent source of confusion, and it connects directly to the more general topic of ROOT object ownership that is discussed elsewhere in this course.
A TList can also be searched by object name using FindObject:
TH1F *hFound = (TH1F*) myList->FindObject("h2");This is one of the reasons why meaningful and unique object names are important in ROOT.
Another closely related class is TObjArray, which also stores TObject* but has an array like structure. TObjArray is introduced in more detail in the next section, together with other array like containers.
The following table summarizes some common TList methods you will encounter:
| Method | Purpose |
|---|---|
Add(TObject *obj) | Append an object to the list |
Remove(TObject *obj) | Remove a specific object |
FindObject(name) | Find by name or pointer |
SetOwner(Bool_t) | Enable or disable ownership of elements |
GetSize() | Number of objects stored |
At(Int_t i) | Access object by index (via TObjArray) |
The indexing related methods come from the fact that TList internally uses a TObjArray like structure. In practice, you will usually iterate with an iterator instead of indexed access.
Arrays
ROOT provides several collection classes that behave like arrays, that is, they are index based rather than purely list based. The most important ones for general use are TObjArray and the numerical arrays TArrayF, TArrayD, TArrayI, and similar.
TObjArray is an array of pointers to TObject, very similar in spirit to TList, but with stronger emphasis on indexed access. You create it and add elements like this:
TObjArray *arr = new TObjArray();
TH1F *h1 = new TH1F("h1", "Histogram 1", 100, 0, 10);
TH1F *h2 = new TH1F("h2", "Histogram 2", 100, 0, 10);
arr->Add(h1); // placed at first free slot
arr->AddAt(h2, 5); // explicitly placed at index 5
You access elements by index with At:
TH1F *h = (TH1F*) arr->At(5);
As with TList, there is an ownership mechanism. You can call arr->SetOwner(kTRUE) to let the array manage the lifetime of its contents. Again, combining this with manual delete calls leads to double deletion, so be consistent.
The TArray* classes store raw values rather than pointers to TObject. For example, TArrayD is an array of Double_t values, and TArrayF is an array of Float_t. These classes are useful when you need a simple numerical container that integrates smoothly with ROOT I/O, for example to store vectors of numbers inside a TTree or a persistent class.
You create and use a TArrayD as follows:
TArrayD arrD(5); // array of 5 doubles
arrD[0] = 1.0;
arrD[1] = 2.5;
arrD[2] = 3.3;
arrD[3] = 4.7;
arrD[4] = 5.9;
double x = arrD[2];
TArrayD and its relatives provide basic operations such as resizing and setting all elements to a given value. They do not store TObject instances and they do not participate in ROOT ownership rules in the same way as TList or TObjArray.
The table below contrasts the most common ROOT collection types that behave like lists or arrays:
| Class | Stores | Access style | Typical use case |
|---|---|---|---|
TList | TObject* | Iteration, search | Heterogeneous collections, order matters |
TObjArray | TObject* | Indexed, iteration | Fixed or sparse index based collections |
TArrayD | Double_t values | Indexed | Numerical arrays that must be ROOT serializable |
TArrayF | Float_t values | Indexed | Like TArrayD but single precision |
Important rule: TList and TObjArray store pointers, not copies. If you delete an object that is still stored in the collection, the collection will contain a dangling pointer. If the collection owns its elements, do not delete them manually.
Iterating over ROOT objects
ROOT collections provide several ways to loop over their contents. You will often need to iterate over a TList, for example to perform the same style change on all histograms, or to draw every object stored in a file.
For TList and TObjArray, the classic ROOT pattern uses an explicit iterator:
TList *myList = new TList();
myList->Add(new TH1F("h1", "h1", 100, 0, 10));
myList->Add(new TH1F("h2", "h2", 100, 0, 10));
TIter next(myList);
TObject *obj = nullptr;
while ((obj = next())) {
obj->Print();
}
TIter is a helper that knows how to step through a TCollection. Inside the loop, you usually cast the TObject* to the specific type you expect:
while ((obj = next())) {
TH1 *h = dynamic_cast<TH1*>(obj);
if (!h) continue;
h->SetLineColor(kRed);
}
The use of dynamic_cast is a safe way to handle lists that may contain different derived classes. If you are certain that all elements are of the same type, a static cast is possible, but it is less safe if the list content ever changes.
Many ROOT collections also support indexed access, which you can combine with a traditional for loop. This is more common with TObjArray:
TObjArray *arr = new TObjArray();
arr->Add(new TH1F("h1", "h1", 100, 0, 10));
arr->Add(new TH1F("h2", "h2", 100, 0, 10));
Int_t n = arr->GetEntriesFast();
for (Int_t i = 0; i < n; ++i) {
TObject *obj = arr->At(i);
if (!obj) continue;
TH1 *h = (TH1*) obj;
h->SetLineWidth(2);
}
GetEntriesFast returns the number of entries without some of the overhead of GetEntries. For simple loops over arrays that are already filled, this is usually what you want.
In modern C++ with ROOT, you can also sometimes use range based for loops, but this is not consistently available for all ROOT collections and depends on the ROOT version and headers. For a beginner friendly and portable style inside ROOT macros, the iterator based pattern shown above is safer.
You will also meet iteration over special collections provided by other ROOT classes. For example, a TFile or TDirectory has a GetListOfKeys method that returns a TList of keys stored in the file, and you can iterate over that list to load all objects:
TFile f("myfile.root");
TList *keys = f.GetListOfKeys();
TIter nextKey(keys);
TObject *keyObj = nullptr;
while ((keyObj = nextKey())) {
TKey *key = (TKey*) keyObj;
TObject *obj = key->ReadObj();
obj->Print();
}
This pattern, a TList or TObjArray obtained from some other object, a TIter, and a loop that processes each contained TObject, appears throughout ROOT based analysis code. Mastering it gives you a flexible way to work with collections of histograms, graphs, and many other ROOT objects.
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!