19.5. PyROOT and Matplotlib
Table of Contents
Combining ROOT analysis with Python plotting
Using PyROOT you can treat ROOT as a powerful data and I/O backend while relying on Matplotlib for flexible and familiar plotting. This is especially attractive if you already use the scientific Python stack and want ROOT’s file format, TTrees, and statistics, but prefer Python-style plots.
In this chapter the focus is on how to move data and results from ROOT objects into forms that Matplotlib understands, then build plots with Matplotlib. Concepts such as reading ROOT files, creating histograms, or using NumPy with PyROOT are covered elsewhere, so here they are only used as ingredients.
Getting ROOT data into NumPy
Matplotlib expects data in simple containers such as Python lists or, more commonly, NumPy arrays. The basic strategy is therefore:
- Use PyROOT to read or compute something.
- Convert the result into NumPy arrays.
- Pass those arrays to Matplotlib plotting functions.
Many ROOT classes support a direct or convenient conversion pathway.
For a TTree you can use the TTree.AsMatrix (older) or RDataFrame.AsNumpy interface. For example, if you have a TTree named t with branches x and y, you can write in Python:
import ROOT
import numpy as np
f = ROOT.TFile.Open("data.root")
t = f.Get("tree")
# Using RDataFrame for modern ROOT
df = ROOT.RDataFrame(t)
np_dict = df.AsNumpy(["x", "y"])
x = np_dict["x"]
y = np_dict["y"]
The variables x and y are now NumPy arrays suitable for any Matplotlib function. This approach is very convenient for 1D and 2D distributions, scatter plots, or correlation studies.
Histograms require a slightly different approach. A ROOT histogram stores bin contents and bin edges. Matplotlib’s most common plotting functions use arrays of bin centers or edges. You can extract both from a TH1 using something like:
h = f.Get("h_energy") # TH1F or TH1D
nbins = h.GetNbinsX()
edges = np.array([h.GetBinLowEdge(i) for i in range(1, nbins + 2)])
contents = np.array([h.GetBinContent(i) for i in range(1, nbins + 1)])
errors = np.array([h.GetBinError(i) for i in range(1, nbins + 1)])
Here edges has length nbins + 1, while contents and errors have length nbins. You can convert edges to bin centers if you prefer:
centers = 0.5 * (edges[:-1] + edges[1:])This pattern also works for 2D histograms, except that you need to loop separately over x and y bins, then reshape arrays. For more complex objects, such as graphs or profiles, you access the underlying arrays in a similar way through their getters.
When converting ROOT histograms to NumPy for Matplotlib, always be explicit about bin definitions. Use GetBinLowEdge, GetBinWidth, and consistent indexing so that the x range of your Matplotlib plot matches the original ROOT histogram range.
Plotting ROOT histograms with Matplotlib
Once you have the bin contents and edges, you can build Matplotlib plots that faithfully reproduce the ROOT histogram. For simple visual checks, it often suffices to draw bin contents as a step plot.
A typical 1D example looks like this:
import matplotlib.pyplot as plt
# centers, contents, and errors extracted as shown above
plt.figure()
plt.errorbar(
centers,
contents,
yerr=errors,
fmt="o",
markersize=3,
linestyle="none",
label="Data"
)
plt.step(edges[:-1], contents, where="post", color="C0", alpha=0.6)
plt.xlabel("Energy [MeV]")
plt.ylabel("Counts per bin")
plt.legend()
plt.tight_layout()
plt.show()
The combination of errorbar and step gives you both clear marker points with uncertainties and the underlying binned structure. If you want a purely binned look without markers, you can omit errorbar and use only step.
Sometimes you want to compare several ROOT histograms on the same axes, but still use Matplotlib. In that case, extract centers and contents for each histogram, then plot them together:
centers1, contents1 = ...
centers2, contents2 = ...
plt.figure()
plt.step(centers1, contents1, where="mid", label="Sample A", color="C0")
plt.step(centers2, contents2, where="mid", label="Sample B", color="C1")
plt.xlabel("Observable X")
plt.ylabel("Events")
plt.legend()
plt.tight_layout()
plt.show()
Using where="mid" with centers produces a clean overlay if the binning is identical. If the bins differ, use the original edges for each histogram to keep them accurate.
You can also reconstruct ROOT-style logarithmic axes by calling Matplotlib’s log methods:
plt.yscale("log")
plt.xscale("log") # if neededThese behave similarly to the log options you might use on ROOT canvases.
Plotting functions and fit results
ROOT functions and fit results are often central to an analysis, and Matplotlib can display them if you evaluate the fitted model on a NumPy grid. The typical workflow is:
- Fit a ROOT histogram or graph in PyROOT.
- Get the fitted TF1 (or define a TF1 yourself).
- Sample the function on a dense grid of x values.
- Plot both data and model in Matplotlib.
Suppose you fit a Gaussian to a ROOT histogram h using PyROOT:
f_gaus = ROOT.TF1("f_gaus", "gaus", 0, 10)
h.Fit(f_gaus, "Q") # quiet fitYou can then evaluate the fitted function in Python:
x_vals = np.linspace(0, 10, 400)
y_vals = np.array([f_gaus.Eval(x) for x in x_vals])Finally, plot everything:
plt.figure()
plt.errorbar(centers, contents, yerr=errors, fmt="o", markersize=3, label="Data")
plt.plot(x_vals, y_vals, "r-", label="Gaussian fit")
plt.xlabel("x")
plt.ylabel("Events")
plt.legend()
plt.tight_layout()
plt.show()If you have multiple fitted components, such as signal and background parts, you can define separate TF1 objects in ROOT and evaluate each one on the same x grid. You can then display them with different line styles in Matplotlib, which is convenient for publication-quality decomposition plots.
For TGraph or TGraphErrors, you can convert the graph directly into NumPy arrays and let Matplotlib take over:
g = f.Get("g_data") # TGraphErrors
n = g.GetN()
x = np.array([g.GetPointX(i) for i in range(n)])
y = np.array([g.GetPointY(i) for i in range(n)])
ex = np.array([g.GetErrorX(i) for i in range(n)])
ey = np.array([g.GetErrorY(i) for i in range(n)])
plt.figure()
plt.errorbar(x, y, xerr=ex, yerr=ey, fmt="o", markersize=3)
plt.xlabel("X")
plt.ylabel("Y")
plt.tight_layout()
plt.show()This preserves the original measurement uncertainties while giving you Matplotlib’s control over fonts, colors, and export formats.
Coordinating ROOT and Matplotlib in one analysis
To keep your analysis maintainable, it is helpful to separate responsibilities. ROOT is particularly strong at reading ROOT files, working with TTrees, and producing histograms and fits. Matplotlib excels at styling and exporting figures as part of a Python ecosystem. A clean structure is often:
- Use PyROOT and possibly ROOT’s RDataFrame to read data and compute histograms, profiles, and fit results.
- Extract results to NumPy or simple Python containers.
- Pass these containers to Matplotlib-only plotting functions.
You might implement this separation in code by placing the ROOT-specific logic in dedicated functions or modules, and the plotting logic in another. For example, you can have a function that takes no ROOT types as arguments, only plain arrays:
def plot_spectrum(centers, counts, errors, model_x=None, model_y=None):
import matplotlib.pyplot as plt
plt.figure()
plt.errorbar(centers, counts, yerr=errors, fmt="o", markersize=3, label="Data")
if model_x is not None:
plt.plot(model_x, model_y, "r-", label="Model")
plt.xlabel("Energy [MeV]")
plt.ylabel("Events")
plt.legend()
plt.tight_layout()
plt.show()The calling code can stay inside a PyROOT environment, but it only needs to pass NumPy arrays. This pattern makes it easier to test and reuse the plotting part independently from the ROOT analysis.
When you combine ROOT and Matplotlib, there are a few practical details to keep in mind. ROOT has its own GUI event loop, and Matplotlib also interacts with windowing backends. To avoid conflicts, it is often simplest to run PyROOT with graphics disabled or to avoid using ROOT canvases and Draw() in the same script where you use interactive Matplotlib windows. Alternatively, you can treat ROOT as a pure computational and I/O library, never calling TCanvas or Draw(), and let Matplotlib manage all graphics.
When using PyROOT and Matplotlib together, avoid mixing ROOT’s GUI event loop with Matplotlib’s interactive windows in the same script. Prefer a workflow where ROOT is used for data handling and computation, and Matplotlib is used exclusively for plotting. This reduces conflicts and makes your code more portable.
Finally, Matplotlib integrates very well with other Python tools such as Jupyter notebooks and LaTeX typesetting. By converting ROOT results to NumPy arrays and plotting with Matplotlib, you can place complex ROOT-based analyses into a wider Python workflow, while still keeping the strengths of ROOT for data handling and physics analysis.
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!