KAHIBARO Bookshelves
Discord Login Register

25.8. H. PyROOT Cheat Sheet

Basic Setup

Starting PyROOT

PyROOT lets you use ROOT from Python. It is usually available after installing ROOT with Python bindings enabled.

To test PyROOT, start Python and try:

python
import ROOT
print(ROOT.__version__)

If this runs without errors, PyROOT is available.

To use PyROOT in an interactive way:

bash
python          # or python3, ipython, jupyter notebook

Then in Python:

python
import ROOT

You can also enable automatic C++ / Python interoperability helpers:

python
import ROOT
ROOT.gROOT.SetBatch(False)   # show graphics windows

Basic Configuration

Set some useful global options:

python
import ROOT
ROOT.gROOT.SetBatch(False)      # allow canvases to pop up
ROOT.gStyle.SetOptStat(1110)    # show main stats on histograms

To use implicit multithreading in modern ROOT:

python
ROOT.ROOT.EnableImplicitMT()    # choose default number of threads
# or
ROOT.ROOT.EnableImplicitMT(4)   # explicitly 4 threads

To load a C++ macro:

python
ROOT.gROOT.ProcessLine('.L myMacro.C')     # interpreted
ROOT.gROOT.ProcessLine('.L myMacro.C+')    # compiled with ACLiC

ROOT Objects in Python

Creating Common Objects

Create a 1D histogram:

python
h = ROOT.TH1F("h", "Example;X;Entries", 100, 0.0, 10.0)

Create a 2D histogram:

python
h2 = ROOT.TH2F("h2", "2D;X;Y", 50, 0.0, 5.0, 40, -2.0, 2.0)

Create a function:

python
f = ROOT.TF1("f", "gaus", -5.0, 5.0)

Create a canvas:

python
c = ROOT.TCanvas("c", "Canvas", 800, 600)

Create an empty graph:

python
g = ROOT.TGraph()

Histograms in PyROOT

Creating and Filling

Simple creation:

python
h = ROOT.TH1F("h", "Gaussian;X;Entries", 100, -5.0, 5.0)

Fill with values in a loop:

python
for i in range(10000):
    x = ROOT.gRandom.Gaus(0.0, 1.0)
    h.Fill(x)

Fill with weights:

python
h.Fill(1.23, 0.5)   # value 1.23 with weight 0.5

Accessing Bin Information

Bin index from x:

python
ibin = h.FindBin(0.5)

Read bin contents and errors:

python
content = h.GetBinContent(ibin)
error   = h.GetBinError(ibin)

Set bin contents:

python
h.SetBinContent(ibin, 10.0)
h.SetBinError(ibin, 1.5)

Basic statistics:

python
entries = h.GetEntries()
mean    = h.GetMean()
rms     = h.GetRMS()

Enable proper error storage before filling:

python
h.Sumw2()

Always call h.Sumw2() before filling if you plan to use bin errors or perform arithmetic operations on histograms.

Drawing Histograms

Draw to the current canvas:

python
c = ROOT.TCanvas()
h.Draw()                   # default option
c.Update()

Draw with options:

python
h.Draw("E")                # draw with error bars
h.Draw("HIST")             # histogram as line
h.Draw("HIST same")        # overlay on existing plot

Save the canvas:

python
c.SaveAs("hist.png")
c.SaveAs("hist.pdf")

Graphs and Errors

TGraph

Create from Python lists or NumPy arrays:

python
x = [0.0, 1.0, 2.0, 3.0]
y = [0.0, 1.0, 4.0, 9.0]
g = ROOT.TGraph(len(x), array('d', x), array('d', y))

A more Pythonic way if ROOT is built with the experimental Pythonizations:

python
g = ROOT.TGraph(len(x))
for i, (xi, yi) in enumerate(zip(x, y)):
    g.SetPoint(i, xi, yi)

Set styles:

python
g.SetMarkerStyle(20)
g.SetMarkerColor(ROOT.kBlue)
g.SetLineColor(ROOT.kBlue)

Draw:

python
c = ROOT.TCanvas()
g.Draw("AP")   # axes + points
c.SaveAs("graph.pdf")

TGraphErrors

Create with symmetric errors:

python
x  = [0.5, 1.5, 2.5]
y  = [10.0, 20.0, 15.0]
ex = [0.1, 0.1, 0.1]
ey = [1.0, 1.0, 1.0]
gx = array('d', x)
gy = array('d', y)
gex = array('d', ex)
gey = array('d', ey)
ge = ROOT.TGraphErrors(len(x), gx, gy, gex, gey)
ge.SetMarkerStyle(21)
ge.Draw("AP")

TGraphAsymmErrors

Create with asymmetric errors:

python
gasy = ROOT.TGraphAsymmErrors()
for i, (xi, yi) in enumerate(zip(x, y)):
    gasy.SetPoint(i, xi, yi)
    gasy.SetPointError(i, ex_low, ex_high, ey_low, ey_high)

Files and TTrees

TFile in Python

Open or create a ROOT file:

python
f = ROOT.TFile("data.root", "RECREATE")  # or "READ"

Write objects:

python
h.Write()
f.Write()
f.Close()

Open and read:

python
f = ROOT.TFile.Open("data.root")
h = f.Get("h")      # histogram named "h"

List contents:

python
f.ls()

Creating a TTree

Create a tree and branches:

python
f = ROOT.TFile("tree.root", "RECREATE")
t = ROOT.TTree("T", "Example tree")
from array import array
x = array('f', [0.0])
y = array('i', [0])
t.Branch("x", x, "x/F")
t.Branch("y", y, "y/I")
for i in range(100):
    x[0] = i * 0.1
    y[0] = i
    t.Fill()
t.Write()
f.Close()

Reading a TTree

Open and access branches:

python
f = ROOT.TFile.Open("tree.root")
t = f.Get("T")

Simple loop:

python
for entry in t:
    xv = entry.x
    yv = entry.y
    # do something

Draw variables quickly:

python
t.Draw("x")                 # histogram of x
t.Draw("x:y")               # 2D plot y vs x
t.Draw("x", "y > 10")       # with selection

RDataFrame from Python

Creating an RDataFrame

Create from a TTree in a ROOT file:

python
df = ROOT.RDataFrame("T", "tree.root")

Create from multiple files:

python
files = ["file1.root", "file2.root"]
df = ROOT.RDataFrame("T", files)

Basic Operations

Count entries:

python
n = df.Count().GetValue()

Filter:

python
df1 = df.Filter("x > 1.0 && y < 10", "basic selection")

Define new column:

python
df2 = df1.Define("z", "x * y")

Create histogram:

python
h = df2.Histo1D(("hz", "z;z;Entries", 50, 0.0, 10.0), "z")
h.Draw()

Snapshot to a new ROOT file:

python
df2.Snapshot("Tsel", "selected.root", ["x", "y", "z"])

Enable multithreading:

python
ROOT.ROOT.EnableImplicitMT()
df = ROOT.RDataFrame("T", "tree.root")

Fitting in PyROOT

Fitting Histograms

Fit with a built in Gaussian:

python
h.Fit("gaus")    # default fit range entire histogram

Fit with range:

python
h.Fit("gaus", "", "", -1.0, 1.0)

Access fit function and parameters:

python
f = h.GetFunction("gaus")
p0 = f.GetParameter(0)    # amplitude
p1 = f.GetParameter(1)    # mean
p2 = f.GetParameter(2)    # sigma
e1 = f.GetParError(1)     # error on mean

Custom Fit Functions

Define a TF1 from an expression:

python
fexp = ROOT.TF1("fexp", "[0]*exp(-x/[1])", 0.0, 10.0)
fexp.SetParameters(1.0, 2.0)   # initial guesses
h.Fit(fexp, "R")

Or define a C++ function in line:

python
ROOT.gInterpreter.Declare("""
double myfunc(double *x, double *par) {
    double xx = x[0];
    return par[0] * xx + par[1];
}
""")
fline = ROOT.TF1("fline", "myfunc", 0.0, 10.0, 2)
h.Fit(fline, "R")

NumPy and PyROOT

Converting TTree Columns to NumPy

Using RDataFrame and AsNumpy (modern PyROOT):

python
import numpy as np
df = ROOT.RDataFrame("T", "tree.root")
arrays = df.AsNumpy(columns=["x", "y"])
x_np = arrays["x"]
y_np = arrays["y"]

x_np and y_np are NumPy arrays and can be used in standard NumPy or SciPy code.

Filling Histograms from NumPy Arrays

Given a NumPy array data:

python
h = ROOT.TH1F("h", "from numpy;X;Entries", 100, 0.0, 10.0)
for v in data:
    h.Fill(float(v))

Or use vectorized filling from RDataFrame by creating a temporary TTree, if performance matters.

Passing NumPy Arrays to TGraph

python
import numpy as np
from array import array
x = np.linspace(0, 10, 101)
y = np.sin(x)
gx = array('d', x)
gy = array('d', y)
g = ROOT.TGraph(len(x), gx, gy)

Canvases, Styles, and Saving

Basic Plot Workflow

Create canvas, draw, then save:

python
c = ROOT.TCanvas("c", "c", 800, 600)
h.Draw()
c.Update()
c.SaveAs("plot.pdf")

Use log axes:

python
c.SetLogy(True)
# or
c.SetLogx(True)
c.SetLogz(True)

Styling Examples

Set titles and labels:

python
h.SetTitle("Title;X axis;Y axis")
h.GetXaxis().SetTitleSize(0.05)
h.GetYaxis().SetTitleOffset(1.4)

Set line and marker style:

python
h.SetLineColor(ROOT.kRed)
h.SetLineWidth(2)
h.SetMarkerStyle(20)
h.SetMarkerSize(1.0)

Legend:

python
leg = ROOT.TLegend(0.6, 0.7, 0.9, 0.9)
leg.AddEntry(h, "Data", "l")
leg.Draw()

Calling C++ from Python

Using gInterpreter

Define C++ code inline:

python
ROOT.gInterpreter.Declare("""
double square(double x) {
    return x*x;
}
""")
print(ROOT.square(3.0))

Declare a C++ function operating on ROOT objects:

python
ROOT.gInterpreter.Declare("""
void scale_hist(TH1 *h, double factor) {
    h->Scale(factor);
}
""")
ROOT.scale_hist(h, 2.0)

Loading C++ Macros

Load an external macro:

python
ROOT.gROOT.ProcessLine('.L myCode.C+')
# use functions or classes defined in myCode.C
ROOT.MyClass().MyMethod()

Quick Reference Table

TaskPyROOT snippet
Import ROOTimport ROOT
Create 1D histogramh = ROOT.TH1F("h","t;x;y",100,0,10)
Fill histogramh.Fill(value)
Draw histogramh.Draw()
Save canvasc.SaveAs("fig.pdf")
Open ROOT filef = ROOT.TFile.Open("file.root")
Get object from fileh = f.Get("hname")
Create TTree from filet = f.Get("T")
Loop over TTree entriesfor e in t: print(e.x)
Quick plot from TTreet.Draw("x>>h(100,0,10)")
Create RDataFramedf = ROOT.RDataFrame("T","file.root")
Filter RDataFramedf1 = df.Filter("x>0")
Define new columndf2 = df1.Define("z","x*y")
Histogram from RDataFrameh = df2.Histo1D(("h","t;z;y",50,0,10),"z")
Snapshot RDataFramedf2.Snapshot("Tsel","out.root")
Enable multithreadingROOT.ROOT.EnableImplicitMT()
Fit histogram with Gaussianh.Fit("gaus")
Get fit parameterp1 = h.GetFunction("gaus").GetParameter(1)
ROOT to NumPy via RDataFramearr = df.AsNumpy(["x"])["x"]

This cheat sheet focuses on the most common PyROOT operations so you can move quickly between Python and standard ROOT analyses.

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

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