KAHIBARO Bookshelves
Discord Login Register

25.4. D. Common TTree Commands

Overview

This appendix collects commonly used TTree commands and idioms so you do not have to search through the whole course. The focus is on practical, short snippets that you will use frequently when working with TTrees in interactive ROOT sessions or in macros.

Where relevant, examples assume you have a TTree* t already available, either read from a file or created in your analysis.

Use this appendix as a quick reference, not as a full tutorial. Detailed explanations of concepts appear in the main TTree chapters.

Opening Files and Accessing TTrees

A typical first step is to open a ROOT file and get a pointer to a TTree.

Opening a file and listing its contents:

cpp
TFile *f = TFile::Open("data.root");   // or new TFile("data.root", "READ");
f->ls();                               // list objects in the file

Getting a TTree from a file:

cpp
TTree *t = (TTree*)f->Get("treeName");

If you are not sure of the tree name, use the ROOT browser:

cpp
TBrowser *b = new TBrowser();

or list keys and look for type TTree:

cpp
f->GetListOfKeys()->Print();

Checking basic information:

cpp
t->Print();          // structure and some stats
t->GetName();        // tree name
t->GetTitle();       // tree title
t->GetEntries();     // total number of entries (Long64_t)
t->GetNbranches();   // number of branches

Inspecting Structure and Content

When you first encounter a tree, you will usually want to see its branches and some example values.

Printing the TTree structure:

cpp
t->Print();          // full summary
t->Print("toponly"); // only top-level branches

Showing a single entry:

cpp
t->Show(0);          // show entry 0
t->Show(10);         // show entry 10

Scanning values of branches:

cpp
t->Scan();                // scan all branches for all entries
t->Scan("E:px:py");       // scan specific branches
t->Scan("E:pt", "E>10");  // only entries with E > 10

Limiting the number of scanned entries:

cpp
t->Scan("E:pt", "", "", 20);   // first 20 entries

Getting lists of branches and leaves:

cpp
t->GetListOfBranches()->Print();
t->GetListOfLeaves()->Print();

Creating TTrees and Branches

For quick tests, you can create a tree directly in an interactive session or macro.

Creating an empty tree:

cpp
TTree *t = new TTree("t", "example tree");

Creating branches for simple variables:

cpp
Float_t E;
Int_t   nHits;
t->Branch("E", &E, "E/F");          // /F for float
t->Branch("nHits", &nHits, "nHits/I"); // /I for int

Using automatic leaf lists with t->Branch(name, address):

cpp
Double_t x;
t->Branch("x", &x); // ROOT infers type, simple but less explicit

Branches with object types (for example std::vector):

cpp
std::vector<float> *px = new std::vector<float>;
t->Branch("px", &px);

For std::vector branches in compiled code, you must include the proper headers and have a dictionary available. See the advanced TTree and vector storage chapters for details.

Filling TTrees

After branches are created, you fill entries inside an event loop.

Simple filling loop:

cpp
for (Int_t i = 0; i < 1000; ++i) {
  E     = gRandom->Gaus(50, 10);
  nHits = (Int_t)gRandom->Poisson(5);
  t->Fill();
}

For vector branches, you typically clear and fill the vector each event:

cpp
for (Int_t evt = 0; evt < 100; ++evt) {
  px->clear();
  Int_t n = gRandom->Poisson(3);
  for (Int_t i = 0; i < n; ++i) {
    px->push_back(gRandom->Gaus(0, 1));
  }
  t->Fill();
}

Writing the tree to a file:

cpp
TFile *fout = new TFile("out.root", "RECREATE");
t->Write();
fout->Close();

Drawing from TTrees

One of the most convenient features of TTrees is the TTree::Draw function.

Basic histogram from a single variable:

cpp
t->Draw("E");           // 1D histogram of E with default binning

Setting custom binning and range:

cpp
t->Draw("E >> h1(100, 0, 200)");   // 100 bins from 0 to 200
TH1F *h1 = (TH1F*)gDirectory->Get("h1");

Storing output in an existing histogram:

cpp
TH1F *hE = new TH1F("hE", "Energy", 50, 0, 100);
t->Draw("E >> hE");                // fill existing hE

Drawing with a selection cut:

cpp
t->Draw("E", "nHits > 5");         // only events with nHits > 5
t->Draw("E", "E > 10 && E < 80");  // compound logical conditions

2D histograms from TTrees:

cpp
t->Draw("py:px");                   // py vs px, default bins
t->Draw("py:px >> h2(50, -5, 5, 50, -5, 5)");

Drawing expressions:

cpp
t->Draw("sqrt(px*px + py*py)");    // transverse momentum
t->Draw("E / nHits", "nHits > 0");

Specifying drawing options:

cpp
t->Draw("E", "", "hist");    // histogram option
t->Draw("E", "", "same");    // draw on same pad
t->Draw("py:px", "", "colz");// 2D color plot

Storing the result histogram created by Draw:

cpp
t->Draw("E >> htemp(50, 0, 100)");
TH1 *htemp = (TH1*)gDirectory->Get("htemp");

TTree::Draw creates histograms in the current directory. If you call it repeatedly with the same name without the >>+ option, the histogram is replaced. Use >>+hname to add to an existing histogram.

Example of adding to an existing histogram:

cpp
t->Draw("E >> hE(50,0,100)", "run==1");
t->Draw("E >>+hE", "run==2");   // add events from run==2 to hE

Setting Branch Addresses and Manual Reading

For more complex analyses, you often loop over tree entries yourself instead of using TTree::Draw.

Connecting branch addresses to variables:

cpp
Float_t E;
Int_t   nHits;
t->SetBranchAddress("E", &E);
t->SetBranchAddress("nHits", &nHits);

Reading entries in a loop:

cpp
Long64_t nentries = t->GetEntries();
for (Long64_t i = 0; i < nentries; ++i) {
  t->GetEntry(i);
  // now E and nHits hold values for entry i
}

Partial reading of branches to speed up access:

cpp
t->SetBranchStatus("*", 0);     // disable all branches
t->SetBranchStatus("E", 1);     // enable only E
t->SetBranchStatus("nHits", 1); // and nHits

GetEntry only loads active branches.

Using GetEntry in combination with selection logic:

cpp
for (Long64_t i = 0; i < t->GetEntries(); ++i) {
  t->GetEntry(i);
  if (E < 20) continue;
  // further analysis for selected events
}

Tree Information and Statistics

There are several helper functions to access metadata and simple statistics.

Getting number of entries, bytes, and approximate size:

cpp
t->GetEntries();         // total entries
t->GetTotBytes();        // total bytes read
t->GetZipBytes();        // compressed bytes on disk

Retrieving branch objects:

cpp
TBranch *bE     = t->GetBranch("E");
TBranch *bNHits = t->GetBranch("nHits");
bE->Print();

Estimating event size:

cpp
Double_t approxSize = t->GetEntry(0); // bytes read for this entry

Printing timer and statistics for TTree::Draw:

cpp
t->SetEstimate(1000000);          // hint for large scans
t->Scan("E:nHits");

Creating Histograms from TTrees in Macros

A common pattern in analysis macros is to create histograms and fill them from a TTree loop.

Example: histogram from manual loop:

cpp
TH1F *hE = new TH1F("hE", "Energy", 100, 0, 200);
Float_t E;
t->SetBranchAddress("E", &E);
Long64_t nentries = t->GetEntries();
for (Long64_t i = 0; i < nentries; ++i) {
  t->GetEntry(i);
  if (E < 10) continue;
  hE->Fill(E);
}

Example: 2D histogram from two branches:

cpp
TH2F *h2 = new TH2F("h2", "py vs px", 50, -5, 5, 50, -5, 5);
Float_t px, py;
t->SetBranchAddress("px", &px);
t->SetBranchAddress("py", &py);
for (Long64_t i = 0; i < t->GetEntries(); ++i) {
  t->GetEntry(i);
  h2->Fill(px, py);
}

TChain Basics

TChain lets you treat many TTrees from different files as a single logical tree.

Creating and filling a chain:

cpp
TChain *ch = new TChain("treeName");
ch->Add("data_run1.root");
ch->Add("data_run2.root");
ch->Add("data_run*.root");   // wildcard pattern

Using a chain like a tree:

cpp
ch->Draw("E");               // same interface as TTree
ch->Scan("E:nHits");

Setting branch addresses for a chain:

cpp
Float_t E;
ch->SetBranchAddress("E", &E);
for (Long64_t i = 0; i < ch->GetEntries(); ++i) {
  ch->GetEntry(i);
  // analysis code
}

Checking which file a given entry belongs to:

cpp
TFile *currentFile = ch->GetCurrentFile();
currentFile->GetName();

Friends and Derived Variables

Friend trees let you combine information from multiple TTrees that share the same entry numbering or event structure.

Adding a friend tree:

cpp
TFile *f1 = TFile::Open("data.root");
TTree *t1 = (TTree*)f1->Get("t1");
TFile *f2 = TFile::Open("extra.root");
TTree *t2 = (TTree*)f2->Get("t2");
t1->AddFriend(t2);   // t2 becomes a friend of t1

Now you can refer to branches from both trees in Draw:

cpp
t1->Draw("E:extraVar");              // extraVar from friend tree
t1->Draw("E", "extraVar > 0.5");

Creating simple on-the-fly aliases:

cpp
t->SetAlias("pt", "sqrt(px*px + py*py)");
t->Draw("pt");
t->Scan("pt:E");

Listing aliases:

cpp
t->GetListOfAliases()->Print();

File Writing and Closing

At the end of an analysis that creates or modifies TTrees you usually write objects and close files.

Creating a file and writing a tree:

cpp
TFile *fout = new TFile("result.root", "RECREATE");
t->Write();           // writes tree into result.root
fout->Close();

Writing multiple objects:

cpp
TFile *fout = new TFile("result.root", "RECREATE");
t->Write();
hE->Write();
h2->Write();
fout->Close();

Writing into subdirectories:

cpp
TFile *fout = new TFile("result.root", "RECREATE");
TDirectory *dir = fout->mkdir("trees");
dir->cd();
t->Write();
fout->cd();
hE->Write();
fout->Close();

Always close files with Close() in macros and long sessions. In interactive, short ROOT sessions it is easy to forget, but forgetting in larger workflows can lead to incomplete files.

Quick Reference Table

The following table summarizes some of the most common TTree commands by task.

TaskCommand / Pattern
Open fileTFile *f = TFile::Open("file.root");
Get tree from fileTTree t = (TTree)f->Get("T");
Print structuret->Print();
Show entryt->Show(0);
List branchest->GetListOfBranches()->Print();
Quick view of datat->Scan("E:pt");
Simple drawt->Draw("E");
Draw with cutt->Draw("E", "pt>1.0");
Draw 2Dt->Draw("y:x");
Create histogram from treet->Draw("E >> h(100,0,200)");
Create treeTTree *t = new TTree("t","title");
Create brancht->Branch("E", &E, "E/F");
Fill treet->Fill();
Write treet->Write();
Set branch addresst->SetBranchAddress("E", &E);
Loop over entriesfor (i=0; i<t->GetEntries(); ++i) t->GetEntry(i);
Disable branchest->SetBranchStatus("*",0);
Enable single brancht->SetBranchStatus("E",1);
Build chainTChain ch = new TChain("T"); ch->Add(".root");
Add friendt->AddFriend("friendTree","friend.root");
Set aliast->SetAlias("pt","sqrt(pxpx+pypy)");

Use this appendix whenever you need a quick reminder of the exact function names and simple usage patterns for TTrees in ROOT.

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