KAHIBARO Bookshelves
Discord Login Register

25.7. G. ROOT C++ Cheat Sheet

General Syntax Reminders

C++ used inside ROOT follows standard C++ syntax, with a few conveniences provided by the ROOT interpreter. This section lists the most common elements you will use in ROOT analysis code.

Basic Program and Macro Structure

A minimal standalone C++ program:

cpp
#include <iostream>
using namespace std;
int main() {
   cout << "Hello ROOT C++" << endl;
   return 0;
}

A minimal ROOT macro function (in myMacro.C):

cpp
void myMacro() {
   cout << "Hello from ROOT macro" << endl;
}

Calling the macro from the ROOT prompt:

cpp
root[] .x myMacro.C          // interpreted
root[] .x myMacro.C(10, 2.5) // with arguments
root[] .L myMacro.C+         // compile with ACLiC
root[] myMacro();            // call compiled function

Use // for single line comments and / ... / for block comments.

Includes and Namespaces

Standard library includes:

cpp
#include <iostream>
#include <cmath>
#include <vector>
#include <string>
#include <algorithm>

ROOT includes (when compiling with a compiler):

cpp
#include "TFile.h"
#include "TH1F.h"
#include "TTree.h"
#include "TCanvas.h"
#include "TRandom3.h"
#include "TGraph.h"

At the ROOT prompt, most ROOT headers are already available. For standard C++ you still need includes when you compile with +.

Using namespaces:

cpp
using namespace std;

In ROOT, std:: prefix is often optional but you should use it in modern code:

cpp
std::cout << "Value = " << value << std::endl;

Variables and Data Types

Fundamental Types

Common C++ types for ROOT work:

cpp
int           nEvents   = 1000;
long          bigIndex  = 1000000L;
float         energy    = 3.14f;
double        mass      = 0.13957;
bool          passedCut = true;
char          letter    = 'A';

String types:

cpp
std::string   name = "pion";
// ROOT C-style string for some older interfaces
char          cname[16] = "histName";

Pointer syntax (very common with ROOT objects):

cpp
TH1F *h1 = new TH1F("h1", "Title", 100, 0, 10);
TFile *f = TFile::Open("file.root", "READ");

Type Conversions

Explicit casts:

cpp
double x = 3.7;
int    i = (int)x;       // truncates to 3
int    j = int(x);       // same

Automatic promotion in expressions:

cpp
int    n = 5;
double y = 2.0;
double z = n * y;        // n is promoted to double

Operators

Arithmetic Operators

cpp
a + b;  // addition
a - b;  // subtraction
a * b;  // multiplication
a / b;  // division
a % b;  // remainder (integers)

Increment and decrement:

cpp
i++;  // post-increment
++i;  // pre-increment
i--;  // post-decrement
--i;  // pre-decrement

Compound assignment:

cpp
x += 5;
y -= 2;
z *= 3;
w /= 4;

Comparison and Logical Operators

Comparison:

cpp
a == b;  // equal
a != b;  // not equal
a <  b;  // less than
a <= b;  // less or equal
a >  b;  // greater than
a >= b;  // greater or equal

Logical:

cpp
a && b;  // logical AND
a || b;  // logical OR
!a;      // logical NOT

Combined logical expressions, very common in cuts:

cpp
if (pt > 0.5 && fabs(eta) < 2.5 && charge != 0) { ... }

Control Flow

if, else if, else

cpp
if (x > 0) {
   cout << "Positive" << endl;
} else if (x < 0) {
   cout << "Negative" << endl;
} else {
   cout << "Zero" << endl;
}

Pay attention to braces when you have more than one statement.

for Loops

Standard index loop:

cpp
for (int i = 0; i < 10; ++i) {
   cout << "i = " << i << endl;
}

Loop over a std::vector by index:

cpp
std::vector<double> v = {1.0, 2.0, 3.0};
for (size_t i = 0; i < v.size(); ++i) {
   cout << v[i] << endl;
}

Range based loop (C++11 and later, works in modern ROOT):

cpp
for (auto value : v) {
   cout << value << endl;
}

while Loops

cpp
int i = 0;
while (i < 10) {
   cout << "i = " << i << endl;
   ++i;
}

switch

Useful for simple integer or enum cases:

cpp
int code = 2;
switch (code) {
   case 1:
      cout << "One"; 
      break;
   case 2:
      cout << "Two"; 
      break;
   default:
      cout << "Other"; 
      break;
}

Functions

Defining and Calling Functions

General pattern:

cpp
return_type functionName(arg_type1 arg1, arg_type2 arg2) {
   // body
   return value; // if not void
}

Example:

cpp
double kineticEnergy(double mass, double momentum) {
   return momentum * momentum / (2.0 * mass);
}

Calling:

cpp
double ke = kineticEnergy(0.5, 1.2);

Functions with no return value:

cpp
void printEvent(int i) {
   cout << "Event " << i << endl;
}

Function prototypes are needed before use in compiled code:

cpp
double myFunc(double x);   // declaration
double myFunc(double x) {  // definition
   return x * x;
}

ROOT interpreter is often more forgiving, but for compiled macros you must respect correct declaration order or use header files.

Passing by Value and by Reference

By value:

cpp
void incrementByValue(int x) {
   x += 1;        // original variable unchanged
}

By reference:

cpp
void incrementByRef(int &x) {
   x += 1;        // original variable is changed
}

Using references is common for output parameters:

cpp
void computeMeanRMS(const TH1 *h, double &mean, double &rms) {
   mean = h->GetMean();
   rms  = h->GetRMS();
}

Arrays and std::vector

C Arrays

Declaration:

cpp
int    a[5];            // uninitialized
double b[3] = {1,2,3};  // initialized

Index from 0:

cpp
a[0] = 10;
cout << b[2] << endl;

Arrays are often used with TGraph:

cpp
const int n = 3;
double x[n] = {1.0, 2.0, 3.0};
double y[n] = {2.0, 4.0, 6.0};
TGraph *gr = new TGraph(n, x, y);

std::vector

Declaration and initialization:

cpp
std::vector<double> v;             // empty
v.push_back(1.0);
v.push_back(2.0);
std::vector<int> ids = {11, 13, 211};

Access:

cpp
cout << v[0] << endl;
cout << v.at(1) << endl;  // bounds-checked
size_t n = v.size();

Iteration:

cpp
for (size_t i = 0; i < v.size(); ++i) {
   cout << v[i] << endl;
}
for (auto value : v) {
   cout << value << endl;
}

In TTrees, std::vector<T> is commonly used as a branch type for variable length data.

ROOT Specific C++ Idioms

Creating and Using ROOT Objects

Use new when you want objects to live on the heap:

cpp
TH1F *h = new TH1F("h", "My hist", 100, 0, 10);
h->Fill(1.0);
h->Draw();

You can also create objects on the stack in macros:

cpp
void myHist() {
   TH1F h("h", "My hist", 100, 0, 10);
   h.Fill(2.0);
   h.Draw();
}

Pay attention to ROOT ownership rules when working with files, canvases, and histograms attached to directories.

Accessing Members and Methods

Use . for objects, -> for pointers:

cpp
TH1F h("h", "title", 100, 0, 1);
TH1F *hp = &h;
h.Fill(0.5);      // object
hp->Fill(0.5);    // pointer

Input and Output

C++ stream output:

cpp
cout << "Mean = " << h.GetMean() << endl;

ROOT specific Print:

cpp
h.Print();

Formatted output via Form:

cpp
cout << Form("Entries = %d, Mean = %.3f", int(h.GetEntries()), h.GetMean()) << endl;

Pointers, References, and auto

Pointers

Declaration and usage:

cpp
TFile *f = TFile::Open("data.root", "READ");
if (!f || f->IsZombie()) {
   cout << "Could not open file" << endl;
   return;
}

Dereferencing:

cpp
TH1F *h = (TH1F*)f->Get("h1");
if (h) {
   cout << "Entries: " << h->GetEntries() << endl;
}

References

Binding a reference:

cpp
TH1F &href = *h;        // href is another name for *h
href.Fill(3.14);

References cannot be null. They are useful for function parameters.

auto Type Deduction

Handy with long ROOT type names:

cpp
auto c  = new TCanvas("c","c",800,600);
auto h1 = new TH1F("h1","h1",100,0,1);
auto tree = (TTree*)f->Get("events");

auto lets the compiler deduce the type from the initializer. Use it especially for iterator types.

Common ROOT Loop Patterns

Loop over Histogram Bins

cpp
int nbins = h->GetNbinsX();
for (int i = 1; i <= nbins; ++i) {
   double x    = h->GetBinCenter(i);
   double cont = h->GetBinContent(i);
   double err  = h->GetBinError(i);
}

Note that ROOT histogram bins start at 1 and go to nbins. Bin 0 is underflow and bin nbins+1 is overflow.

Loop over TTree Entries

cpp
TTree *t = (TTree*)f->Get("tree");
double energy;
t->SetBranchAddress("energy", &energy);
Long64_t nentries = t->GetEntries();
for (Long64_t i = 0; i < nentries; ++i) {
   t->GetEntry(i);
   if (energy > 10.0) {
      h->Fill(energy);
   }
}

Memory and new/delete Basics

ROOT often manages memory for you, but in modern C++ you still need to understand dynamic allocation.

cpp
TH1F *h = new TH1F("h","h",100,0,1);
// use h
delete h; // free memory when you created it with new and ROOT does not own it

If an object is written to a TFile or created on a TCanvas, ROOT may take ownership. In many analyses you rely on ROOT cleanup at end of session, but for long running programs you should manage lifetimes carefully.

Always match new with delete for objects you own. Do not delete objects that ROOT owns, such as histograms retrieved from a TFile directory, unless you explicitly detached or cloned them. Incorrect deletes can lead to crashes.

Preprocessor and Macros

Preprocessor Directives

Conditional compilation:

cpp
#ifdef DEBUG
   cout << "Debug info" << endl;
#endif

Include guards for headers:

cpp
#ifndef MYHEADER_H
#define MYHEADER_H
// declarations
#endif

Simple macro definitions:

cpp
#define N_BINS 100
#define PI 3.141592653589793

Use constants or constexpr in modern C++ instead of preprocessor where possible:

cpp
constexpr int N_BINS = 100;

Common Math Functions

Include <cmath>:

cpp
#include <cmath>
double y = std::sqrt(x);
double z = std::sin(phi);
double a = std::exp(-x);
double b = std::log(x);     // natural log
double c = std::log10(x);   // base 10 log
double d = std::fabs(x);    // absolute value

With ROOT you also have TMath:

cpp
#include "TMath.h"
double y = TMath::Sqrt(x);
double z = TMath::Sin(phi);

String Handling

std::string operations:

cpp
std::string name = "run";
name += "_42";
cout << name << endl;
if (name == "run_42") { ... }
const char *cname = name.c_str(); // for ROOT APIs that need const char*

Formatting with Form or std::to_string:

cpp
int run = 42;
std::string hname = "h_run_" + std::to_string(run);
TH1F *h = new TH1F(hname.c_str(), "title", 100, 0, 1);
TH1F *h2 = new TH1F(Form("h_run_%d", run), "title", 100, 0, 1);

Error Handling Patterns

Simple checks:

cpp
TFile *f = TFile::Open("input.root");
if (!f || f->IsZombie()) {
   cerr << "Error opening file" << endl;
   return;
}
TH1F *h = (TH1F*)f->Get("hData");
if (!h) {
   cerr << "Histogram hData not found" << endl;
   return;
}

Guard against division by zero:

cpp
double denom = h->Integral();
if (denom > 0) {
   h->Scale(1.0 / denom);
} else {
   cerr << "Cannot normalize, integral is zero" << endl;
}

Always check pointers returned by ROOT factory methods (like Get, Open, GetHistogram) before dereferencing them. Attempting to use a null pointer is a common source of segmentation faults.

Quick Reference Tables

Common fundamental types:

PurposeTypeTypical usage example
Integer countsintnumber of events, bins
Large integer indexlongentry index, sizes
Single precisionfloatdetector coordinates, quick vars
Double precisiondoubleenergies, masses, physics calc
True or falseboolcuts, flags
Charactercharsingle letter code
Text stringstd::stringfilenames, labels

Common loop patterns:

TaskPattern example
Simple counterfor (int i = 0; i < N; ++i) { ... }
Over vector elementsfor (auto v : vec) { ... }
TTree entriesfor (Long64_t i = 0; i < n; ++i) { t->GetEntry(i); }
Histogram binsfor (int i = 1; i <= nb; ++i) { ... }

These patterns and snippets cover most C++ constructs that you will routinely use with 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