19.4. PyROOT and NumPy
Table of Contents
Converting ROOT data
When you use ROOT from Python through PyROOT, NumPy is usually the most convenient way to handle numerical data. The typical workflow is: read data from ROOT objects, convert the numbers to NumPy arrays, then use Python tools such as NumPy, SciPy, or pandas for further analysis.
The details of reading ROOT files and TTrees are explained elsewhere in this course. Here, the focus is on how to convert the data you already have in ROOT objects into NumPy arrays.
The exact tools you use depend on the kind of ROOT object and on the ROOT version you have.
Histograms to NumPy
ROOT histograms store bin contents and bin edges internally. In PyROOT you can access this information and construct NumPy arrays that represent the same histogram.
For 1D histograms, there are two useful views: bin contents and bin edges. Bin contents are usually what you want for numerical processing. Bin edges are useful if you plan to re-bin, integrate, or plot with Matplotlib.
A simple way to extract bin contents into a NumPy array is to loop over bins and fill a Python list, then convert the list to a NumPy array. You also need to remember that ROOT bin numbering starts at 1, with bin 0 as the underflow and bin $N\!+\!1$ as the overflow for a histogram with $N$ bins.
Important rule: For a TH1 histogram with $N$ bins, the valid "normal" bins are $1, \dots, N$. Bin 0 is underflow and bin $N+1$ is overflow. Never assume that bin 0 or bin $N+1$ is part of the main histogram range.
You can also obtain the bin edges. For a histogram with $N$ bins there are $N+1$ edges. Once you convert both contents and edges, you can use them with NumPy or Matplotlib. The exact code style can vary, but the pattern is always: loop over ROOT bins, read values, store to NumPy.
TTrees to NumPy
Converting a TTree branch to a NumPy array is very common. Conceptually, each branch is a column of data and each entry in the TTree is a row. When all entries of a single branch are converted to a NumPy array, you obtain a one dimensional array of length equal to the number of entries.
There are several approaches. A straightforward method is to loop over entries in PyROOT, read the branch value, and append it to a Python list, then convert to a NumPy array. This always works, regardless of ROOT version, but it is not the fastest option.
More efficient methods use modern interfaces such as RDataFrame with PyROOT or specific helpers available in your ROOT version. These can fill a NumPy array directly from a branch without an explicit Python loop. The details of RDataFrame are covered in another chapter. From the NumPy point of view, the important idea is that you end with arrays that contain the branch values, one element per entry.
If a TTree branch stores C++ vectors, the conversion is slightly different. Instead of a simple 1D array, you obtain an array of variable length arrays or lists. In such cases you usually have a Python list of per event arrays, or you flatten the data if it makes sense for your analysis.
When you convert several branches at once you can think of your result as a table of NumPy arrays, one array for each column. This is a convenient starting point for numerical analysis, plotting, or exporting data to other Python packages.
Graphs and other objects
You can also convert other ROOT objects to NumPy, such as TGraph or TGraphErrors. There, you usually extract separate arrays for the x coordinates, the y coordinates, and possibly the uncertainties. The pattern is the same: loop or use built in methods to access the ROOT data, then create NumPy arrays.
Once the data is in NumPy, you stop thinking in terms of ROOT objects and instead use Python and NumPy operations to process the arrays.
Working with NumPy arrays
Once your data is in NumPy arrays, you can use NumPy and the rest of the Python ecosystem as you would in any other scientific Python project. The ROOT part only provides the input, and NumPy handles the computation.
Basic array operations
A NumPy array is an efficient container for numbers. Arrays can be one dimensional, such as a list of measured energies, or multidimensional, such as a table of variables per event. Common operations include sums, means, standard deviations, and elementwise arithmetic.
Suppose you have an array $x$ of measured values. NumPy provides functions like $x.\text{mean}()$ and $x.\text{std}()$ for the mean and standard deviation. When you calculate simple statistics from ROOT data, it is often more convenient to convert to NumPy and use these functions.
Important rule: NumPy operations typically act on the entire array at once. You do not need explicit Python loops to add, multiply, or compare elements. Use vectorized operations such as $x + y$ or $x[x > 0]$ instead of manual loops.
You can combine several arrays, for instance, to compute a derived quantity from ROOT branches. If $E$ is an array of energies and $p$ is an array of momenta, you can compute a quotient element by element with a single operation.
Logical selections and masks
NumPy is particularly powerful for applying selection cuts. From ROOT, you may be used to expressions in TTree::Draw. The equivalent in NumPy uses boolean masks.
If you have a NumPy array representing some variable and you want to select only entries that satisfy a condition, you build a boolean array where each element is True or False according to the condition. You then index the original array with this boolean array to select only the desired elements.
For example, if $x$ contains a variable and you want values inside a given range, you create a mask like $(x > x_{\min}) \land (x < x_{\max})$ and use it to filter. You can create more complex combinations using logical operators. This technique parallels selection cuts in ROOT but happens entirely inside NumPy.
These boolean masks can be built from several arrays at once, which makes multi variable cuts straightforward. The logic is close to the "simple cuts" discussed in the TTree chapters, but expressed with NumPy syntax.
Histograms and statistics with NumPy
For quick checks, you can compute histograms directly from NumPy arrays, for instance with functions that return bin counts and edges. This can be useful if you want to compare ROOT histogram binning with a pure NumPy or Matplotlib version.
You can also compute statistics and uncertainties from NumPy directly, then compare them with the values stored by ROOT histograms, such as the mean and RMS. This offers an independent check of your ROOT based analysis.
Keep in mind that ROOT and NumPy may use slightly different definitions or default options for some operations. For example, there may be differences in how normalization is handled or in the definition of standard deviation for small samples. When comparing results, confirm that both sides use the same conventions.
Interoperability with other Python tools
Once your ROOT data is in NumPy arrays, it is easy to pass it to other libraries. You can use SciPy for advanced statistics or fitting, Matplotlib for plotting, pandas for table like analysis, or machine learning libraries such as scikit learn or TensorFlow.
From the perspective of NumPy, ROOT is simply one more data source. You read the data with PyROOT, convert to NumPy arrays, then hand those arrays to any Python tool you like.
This is particularly effective if you keep a clear boundary between I/O and computation. One practical pattern is to use PyROOT only in a small part of your script to read TTrees and produce NumPy arrays, then do the rest of the analysis in standard Python. This simplifies the code and makes it easier to reuse in non ROOT contexts.
Going back from NumPy to ROOT
Sometimes you want to convert NumPy arrays back into ROOT histograms or TTrees. For instance, after manipulating or filtering the data in NumPy, you might want to store the result as a ROOT file or plot it with ROOT plotting features.
The typical pattern is to create a ROOT histogram with some number of bins and range, then loop over the NumPy array and call Fill for each element. For TTrees, you can create branches that hold simple types or vector types and fill them entry by entry from your arrays.
Although this conversion is more mechanical than conceptually difficult, it emphasizes an important idea: PyROOT and NumPy together let you move data freely between the ROOT world and the Python scientific stack.
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!