KAHIBARO Bookshelves
Discord Login Register

25.1. A. ROOT Command Cheat Sheet

Interactive Session Basics

In a typical terminal, you start ROOT with:
root

To start without the splash screen and banner, use:
root -l

To execute a macro at startup:
root -l mymacro.C

To exit ROOT:
.q
or
gApplication->Terminate();

To execute a single command from the shell without entering the interactive prompt:
root -l -q 'mymacro.C'
or
root -l -q 'mymacro.C("arg1", 5)'

Use the command history with the up and down arrow keys. You can also save the session command log with:
.logon and .logoff for automatic scripts, or:
.x to rerun macros.

The most useful meta commands at the ROOT prompt are:

CommandPurpose
.x file.CRun a macro interpreted
.L file.CLoad a macro, keep definitions in memory
.L file.C+Compile macro with ACLiC
.L file.C++Force recompilation
.qQuit ROOT
.helpHelp on ROOT meta commands
.filesList open ROOT files
.pwdPrint current working directory

Use gROOT and gApplication as global pointers to the ROOT environment and application, and gDirectory for the current directory (often a file or memory).

Always use .q to exit ROOT so that open files are properly closed and buffered data is written.

Getting Help

ROOT provides several built in ways to get help during a session.

To list available classes and global objects in the current session:
.class
gROOT->GetListOfClasses()->Print();

To inspect a class dictionary from the prompt:
TH1::Class()->Dump();
or simply:
TH1::Class();

To see methods of a class interactively:
TH1::Class()->GetListOfMethods()->Print();

To browse help and documentation in a web browser, use:
help (from a system shell, not ROOT) to locate manual pages, or visit the ROOT reference guide online.

Inside ROOT, to load the object browser:
new TBrowser;

This opens a graphical browser to inspect files, histograms, trees, and canvases.

Files and Directories

Below is a compact list of the most commonly used commands for handling ROOT files and directories.

Typical file operations:

Command / CodeDescription
TFile *f = TFile::Open("a.root");Open an existing ROOT file
TFile *f = new TFile("a.root","RECREATE");Create / overwrite file
f->Write();Write all objects in memory to file
f->Close();Close file
f->ls();List contents of current file
gDirectory->pwd();Print current directory path
gDirectory->ls();List contents of current directory
TDirectory *d = f->mkdir("subdir");Create new subdirectory
f->cd("subdir");Change to directory inside file
TH1 h = (TH1)f->Get("hname");Retrieve object from file

When using TFile::Open, always check the pointer:
if (!f || f->IsZombie()) { / handle error / }

Always close a TFile with f->Close(); or by deleting the pointer to ensure all objects are written correctly.

Histograms

Useful commands to create, fill, draw, and inspect histograms.

Creation, filling, and drawing:

Command / CodeDescription
TH1F *h = new TH1F("h","Title",100,0,10);1D float histogram
TH1D *h = new TH1D("h","Title",100,0,10);1D double histogram
h->Fill(x);Fill one entry at value x
h->Fill(x, w);Fill with weight w
h->Draw();Draw histogram on current canvas
h->Draw("E");Draw with error bars
h->Sumw2();Store proper bin error sums

Basic properties and bin access:

Command / CodeDescription
h->GetEntries();Number of entries
h->GetMean();Mean of distribution
h->GetRMS();RMS of distribution
int bin = h->FindBin(x);Get bin number for value x
h->GetBinContent(bin);Read content of bin
h->SetBinContent(bin, value);Set content of bin
h->GetBinError(bin);Bin error
h->SetBinError(bin, err);Set bin error manually

Combining and scaling histograms:

Command / CodeDescription
h->Scale(factor);Multiply all bins by factor
h->Integral();Integral over all bins
h1->Add(h2);h1 += h2 bin by bin
h1->Add(h2, w);h1 += w * h2
h1->Divide(h2);Bin by bin division

Call h->Sumw2(); before filling if you plan to scale or add histograms and need correct bin errors.

Graphs

Basic commands to create and plot graphs.

Creating and filling graphs:

Command / CodeDescription
TGraph *g = new TGraph();Empty X Y graph
g->SetPoint(i, x, y);Set point index i to (x, y)
TGraph *g = new TGraph(n, xarr, yarr);From arrays
g->Draw("AP");Axes plus points
g->Draw("ALP");Axes, line, points

Graphs with errors:

Command / CodeDescription
TGraphErrors *ge = new TGraphErrors(n, x, y, ex, ey);Symmetric errors
TGraphAsymmErrors *gae = new TGraphAsymmErrors(n,x,y,exl,exh,eyl,eyh);Asymmetric errors
ge->Draw("AP");Draw with error bars

Combining graphs:

Command / CodeDescription
TMultiGraph *mg = new TMultiGraph();Multiple graphs container
mg->Add(g1, "LP");Add graph with draw option
mg->Add(g2, "P");Add second graph
mg->Draw("A");Draw axes and all graphs

Canvases and Drawing

Use TCanvas to create and manage plotting surfaces.

Basic canvas operations:

Command / CodeDescription
TCanvas *c = new TCanvas("c","Title",800,600);New canvas
c->cd();Make canvas current
c->Update();Force redraw
c->Clear();Clear canvas
c->Divide(nx, ny);Divide into pads
c->cd(pad_number);Select pad

Drawing multiple objects:

Command / CodeDescription
h1->Draw();Draw first object
h2->Draw("SAME");Draw on top of existing plot
h2->Draw("HIST SAME");Histogram as line on same pad

Logarithmic axes:

Command / CodeDescription
gPad->SetLogx();Logarithmic X axis
gPad->SetLogy();Logarithmic Y axis
gPad->SetLogz();Logarithmic Z axis for color

Saving plots:

Command / CodeDescription
c->SaveAs("plot.png");Save as PNG
c->SaveAs("plot.pdf");Save as PDF
c->SaveAs("plot.svg");Save as SVG
c->SaveAs("plot.root");Save canvas in ROOT format

Basic Styling

Quick commands to adjust appearance without going into full styling chapters.

Axis titles and ranges:

Command / CodeDescription
h->GetXaxis()->SetTitle("x [units]");Set X axis title
h->GetYaxis()->SetTitle("Counts");Set Y axis title
h->GetXaxis()->SetRangeUser(xmin, xmax);Restrict X axis range
h->SetTitle("Histogram title;X;Y");Title and axis labels in one string

Line and marker styles:

Command / CodeDescription
h->SetLineColor(kRed);Change line color
h->SetLineWidth(2);Thicker line
h->SetMarkerStyle(20);Set marker type
h->SetMarkerSize(1.2);Larger markers
h->SetMarkerColor(kBlue);Marker color

Legends and text:

Command / CodeDescription
TLegend *leg = new TLegend(0.6,0.7,0.9,0.9);New legend box
leg->AddEntry(h1, "Data", "lep");Add entry, line error point style
leg->Draw();Draw legend
TLatex latex; latex.DrawLatex(x, y, "Label");Draw LaTeX style text in NDC or user coords

When mixing histogram and graph drawing, always draw the object that should define axes first. Others must use "SAME" to overlay.

Functions and Fitting

Quick reference for TF1 creation and using the fit machinery.

Creating functions:

Command / CodeDescription
TF1 *f = new TF1("f","gaus", xmin, xmax);Built in Gaussian
TF1 *f = new TF1("f","pol1", xmin, xmax);Linear polynomial
TF1 f = new TF1("f","[0]exp(-x/[1])", xmin, xmax);Custom expression with parameters
f->SetParameters(p0, p1, ...);Set initial parameter values
f->SetParNames("A","tau");Parameter names
f->Eval(x);Evaluate function at x
f->Draw();Draw function

Fitting histograms and graphs:

Command / CodeDescription
h->Fit("gaus");Fit with built in Gaussian
h->Fit("f");Fit with user defined TF1 *f
h->Fit("f","R");Fit only in function range
g->Fit("pol1");Fit graph with straight line
TF1 *fit = h->GetFunction("gaus");Access last fit function

Reading fit results:

Command / CodeDescription
fit->GetParameter(i);Parameter i
fit->GetParError(i);Uncertainty on parameter
fit->GetChisquare();Chi square
fit->GetNDF();Degrees of freedom

Always check fit status by examining the return value of h->Fit(...) and by inspecting GetChisquare() and GetNDF() before trusting the results.

TTrees and Event Data

Essential TTree commands for basic event based analysis.

Creating and filling a tree:

Command / CodeDescription
TTree *t = new TTree("t","Tree title");New tree
Double_t x; t->Branch("x", &x, "x/D");Scalar branch
for (...) { x = value; t->Fill(); }Fill entries in a loop
t->Write();Write tree to current file

Reading an existing tree from a file:

Command / CodeDescription
TFile *f = TFile::Open("data.root");Open file
TTree t = (TTree)f->Get("t");Get tree
t->Print();Print structure
t->Scan();Text dump of entries

Setting branch addresses and looping:

Command / CodeDescription
Double_t x; t->SetBranchAddress("x", &x);Connect variable to branch
Long64_t n = t->GetEntries();Number of entries
for (Long64_t i=0; i<n; ++i) { t->GetEntry(i); ... }Event loop

Quick plotting from a tree:

Command / CodeDescription
t->Draw("x");Histogram of x
t->Draw("y:x");2D scatter plot y vs x
t->Draw("x", "x>0");Histogram of x with selection cut
t->Draw("y>>h(100,0,10)", "x>0");Fill named histogram with selection

When using SetBranchAddress, the variable that receives the data must stay in scope for the entire loop. Never use a local variable that goes out of scope while the tree is still being read.

Random Numbers and Simple Simulation

Quick access commands for random number generation.

Random engines:

Command / CodeDescription
TRandom *r = gRandom;Default global random generator
gRandom->SetSeed(0);Seed with a time dependent seed
gRandom->SetSeed(12345);Fixed seed for reproducibility
TRandom3 r3(0);Mersenne Twister engine

Common distributions:

Command / CodeDescription
gRandom->Uniform();Uniform in (0, 1)
gRandom->Uniform(a, b);Uniform in (a, b)
gRandom->Gaus(mean, sigma);Gaussian
gRandom->Poisson(mean);Poisson
gRandom->Exp(tau);Exponential with mean tau

Typical simulation loop:

cpp
TH1F *h = new TH1F("h","Gaussian",100,-5,5);
for (int i=0; i<100000; ++i) {
  double x = gRandom->Gaus(0,1);
  h->Fill(x);
}
h->Draw();

PyROOT Shortcuts

Some very basic commands for using ROOT from Python.

Starting PyROOT simply requires importing ROOT:

python
import ROOT

Frequently used short forms:

Python CodeDescription
f = ROOT.TFile.Open("a.root")Open ROOT file
h = ROOT.TH1F("h","Title",100,0,10)Create histogram
h.Fill(x)Fill bin
c = ROOT.TCanvas("c","c",800,600)New canvas
h.Draw()Draw histogram
c.SaveAs("plot.png")Save plot

Access a TTree and draw:

python
t = f.Get("t")
t.Draw("x")

In PyROOT, object ownership and memory management are handled differently from C++, so be careful when mixing C++ and Python code in the same session.

Useful Global Objects

A final short reference to global objects often used in commands.

ObjectTypePurpose
gROOTTROOT*Top-level ROOT system manager
gApplicationTApplication*GUI event loop manager
gDirectoryTDirectory*Current directory or file
gPadTPad*Current pad or canvas
gStyleTStyle*Global plotting style
gRandomTRandom*Global random number generator

These pointers are always available in a ROOT session and let you configure or query the environment quickly.

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