13.7. Drawing Data from TTrees
Table of Contents
`TTree::Draw()`
The central tool for quick plotting from a TTree in ROOT is the member function TTree::Draw(). It connects your stored variables directly to histograms and graphs without writing an explicit event loop. Conceptually, Draw() loops over all selected entries, evaluates an expression for each event, and fills an internal histogram or graph, which is then displayed.
The simplest usage is:
tree->Draw("x");
Here x is usually the name of a branch or a valid C++ expression involving branches. ROOT creates a temporary histogram, fills it with the values of x for all entries, and draws it on the current canvas.
The generic form of TTree::Draw() that you will use most often is:
tree->Draw("expression", "selection", "options", nentries, firstentry);The arguments have the following roles:
expression
This is what you want to plot, for example a single variable or a combination of variables. Valid examples are:
"energy"
"px*px + py*py"
"sqrt(px*px + py*py)"
"energy:time"
For 1D histograms, you supply one expression. For 2D plots, you use y:x. For 3D plots, you use z:y:x.
selection
This is an optional cut expression, written like a C++ boolean condition. Only entries that satisfy the condition contribute to the plot. For example:
"energy > 0"
"energy > 1.0 && energy < 5.0"
"nHits > 5 && charge != 0"
If you pass an empty string "", all entries are used.
options
These are drawing options, similar to the options for histograms and graphs. Typical options include:
"" // default
"same" // draw on the same pad
"hist" // draw as histogram
"colz" // for 2D plots with color palette and z axis
"goff" // graphical output off, useful for scriptsMany histogram and TGraph drawing options work here as well.
nentriesandfirstentry
These let you restrict which entries are processed. For example:
tree->Draw("energy", "", "", 1000); // first 1000 entries
tree->Draw("energy", "", "", 1000, 5000); // 1000 entries starting at entry 5000If you omit them, all entries are processed.
Internally, TTree::Draw() creates objects such as TH1F, TH2F, or TGraph and stores pointers in the global directory. The most recent histogram can be retrieved with:
TH1 *h = (TH1*)gPad->GetPrimitive("htemp");
or by saving the pointer returned by TTree::GetHistogram() after a call to Draw().
TTree::Draw("expression", "selection") evaluates the expression and selection for each entry in the selected range and fills an internal histogram or graph. The expression uses branch names and valid C++ operations, and the selection is any boolean expression. Only entries for which the selection is true contribute to the output.
Because TTree::Draw() is interpreted and flexible, it is ideal for quick exploratory analysis. For large or final analyses, explicit loops or RDataFrame are often preferred, but understanding Draw() is essential for fast checks and interactive work.
Plotting variables
To make practical use of TTree::Draw(), you usually start by plotting individual variables directly from the tree. This allows you to inspect distributions, check ranges, and verify that your data look reasonable before doing more complex analysis.
A 1D distribution of a single branch is the most basic case:
tree->Draw("energy");
Assuming energy is a branch, this command fills a temporary 1D histogram with the energy values for all entries. The binning and range are chosen automatically by ROOT. The resulting histogram is usually named "htemp" in the current pad.
You can apply selection cuts directly in the Draw() call:
tree->Draw("energy", "energy > 0");
Only entries where energy > 0 will contribute. You can build more complex cuts using comparison and logical operators, for example:
tree->Draw("energy", "nHits >= 10 && abs(time) < 100");This selects events with at least 10 hits and time between −100 and +100.
You are not restricted to plotting simple branches. You can plot arbitrary expressions that combine multiple branches using standard C++ operators and many common functions:
tree->Draw("sqrt(px*px + py*py)"); // transverse momentum
tree->Draw("(E1 + E2)/2.0"); // average of two energies
tree->Draw("log10(energy)", "energy > 0"); // log10 of energyROOT parses these expressions, reads the corresponding branches, evaluates the expression per entry, and uses the result as the value to fill into the histogram.
Many mathematical functions are available in expressions, such as sqrt, log, exp, sin, cos, atan2, and others. You can also use TMath functions by prefixing with TMath::, for example:
tree->Draw("TMath::Abs(eta)");
tree->Draw("TMath::Sqrt(px*px + py*py + pz*pz)");
You can plot two variables against each other to see correlations using the general syntax y:x:
tree->Draw("energy:time");
This creates a 2D plot with time on the x axis and energy on the y axis. You can still apply selection cuts:
tree->Draw("energy:time", "qualityFlag == 1");
For three variables you can extend this to z:y:x. ROOT will typically use a 3D scatter representation when you enable the appropriate drawing options:
tree->Draw("z:y:x");You can also control the graphical style with options. For instance, to draw points instead of the default 1D histogram style:
tree->Draw("energy", "", "p"); // markers
tree->Draw("energy:time", "", "colz"); // 2D color plotThese options are passed directly to the internal histogram or graph drawing routine.
When you run several Draw() commands in a row, the new plot replaces the previous one unless you explicitly request to draw on top of an existing object. To overlay results from the same tree, you can use the "same" option:
tree->Draw("energy", "selection1");
tree->Draw("energy", "selection2", "same");
The second histogram is drawn on the same pad. For more control over styles and legends, you will often retrieve the histograms produced by each Draw() call and customize them, which connects naturally to the topic of creating histograms directly in the next section.
Creating histograms directly
Although the quick syntax tree->Draw("var") is convenient, you often want explicit control over the histogram name, binning, and axis ranges. TTree::Draw() supports this through a special expression format, and you can also create your own histograms and fill them using Draw() without a manual event loop.
The key feature is the bracket syntax inside the expression string, which allows you to specify the histogram binning and range. The general 1D form is:
tree->Draw("var>>histName(Nbins, xmin, xmax)", "selection");
Here, var is a branch or expression, histName is the name of the histogram that will be created or reused, and Nbins, xmin, xmax define the binning. For example:
tree->Draw("energy>>hE(100, 0.0, 10.0)");
This creates a histogram named hE with 100 bins from 0 to 10 and fills it with the values of energy from all entries. The object hE is now a real TH1F owned by the current directory, and you can access and manipulate it:
TH1F *hE = (TH1F*)gDirectory->Get("hE");
hE->SetLineColor(kRed);
hE->Draw("hist");
If you call Draw() again with the same histogram name and no option to reset, ROOT will refill or add to the existing histogram contents, depending on how you use it. If the histogram already exists and you want to clear it before refilling, you can reset it:
TH1F *hE = new TH1F("hE", "Energy", 100, 0.0, 10.0);
hE->Reset();
tree->Draw("energy>>hE", "energy > 0");
In this form, using >>hE without binning parameters instructs ROOT to use the existing histogram hE and its binning. This gives you full control over the histogram type and configuration:
TH1D *hE = new TH1D("hE", "High precision energy", 200, 0.0, 5.0);
tree->Draw("energy>>hE", "qualityFlag == 1");For 2D histograms, you can use a similar syntax with two sets of binning parameters:
tree->Draw("y:x>>h2(50, 0.0, 10.0, 40, -2.0, 2.0)");
This creates a TH2F named h2 with 50 x bins from 0 to 10 and 40 y bins from −2 to 2. As with 1D, if h2 already exists you can omit the binning to reuse it:
TH2F *h2 = new TH2F("h2", "Y vs X", 50, 0.0, 10.0, 40, -2.0, 2.0);
tree->Draw("y:x>>h2", "x > 0 && y > 0");
You can specify histogram type through the class you create manually. For instance, to store high precision data you might want TH1D or TH2D:
TH1D *hPrecise = new TH1D("hPrecise", "Precise distribution", 100, 0.0, 1.0);
tree->Draw("smallValue>>hPrecise");
Sometimes you want to create a histogram without drawing it to the screen, for example in batch scripts. You can do this by providing the "goff" option, which disables graphical output:
tree->Draw("energy>>hE(100, 0.0, 10.0)", "selection", "goff");
TH1F *hE = (TH1F*)gDirectory->Get("hE");
// now analyze or save hE without ever displaying it
You can also combine "goff" with other options if needed, keeping in mind that "goff" turns off the actual drawing.
TTree::Draw() can also create graphs directly, rather than histograms, when you use the proper options. For example:
tree->Draw("y:x", "selection", "goff"); // prepare internal arrays
TGraph *gr = new TGraph(tree->GetSelectedRows(), tree->GetV2(), tree->GetV1());
However, for beginners it is usually simpler to start by using Draw() to prepare histograms, then retrieve those histograms and manipulate them as you would any other ROOT object.
tree->Draw("expr>>histName(Nbins, xmin, xmax)", "selection");tree->Draw("expr>>histName", "selection");
To create a histogram with fixed binning and a chosen name directly from a TTree, use:
To fill an already existing histogram, omit the binning:
This lets you control both the histogram definition and the selection while still using ROOT’s internal event loop.
By combining these patterns, you can rapidly turn branches and expressions in a TTree into reusable histograms and 2D maps, all without writing explicit loops. This is the main power of drawing data directly from TTrees for exploratory and early-stage analyses.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to ROOT
- ☰ 1.1. What Is ROOT?
- ☰ 1.2. Installing ROOT
- ☰ 1.3. Starting ROOT
- ☰ 1.4. Your First ROOT Session
-
- ☰ 2. C++ Basics for ROOT
- ☰ 2.1. Why ROOT Uses C++
- ☰ 2.2. Variables and Data Types
- ☰ 2.3. Operators
- ☰ 2.4. Conditional Statements
- ☰ 2.5. Loops
- ☰ 2.6. Functions
- ☰ 2.7. Arrays and Vectors
-
- ☰ 3. ROOT Macros
- ☰ 3.1. What Is a ROOT Macro?
- ☰ 3.2. Running ROOT Macros
- ☰ 3.3. Functions Inside ROOT Macros
- ☰ 3.4. Compiling ROOT Macros
- ☰ 3.5. Organizing a ROOT Project
-
- ☰ 4. ROOT Objects and the ROOT Object Model
- ☰ 4.1. Introduction to ROOT Classes
- ☰ 4.2. Object Names and Titles
- ☰ 4.3. ROOT Collections
- ☰ 4.4. Inspecting ROOT Objects
-
- ☰ 5. Histograms
- ☰ 5.1. Introduction to Histograms
- ☰ 5.2. Creating a 1D Histogram
- ☰ 5.3. Filling Histograms
- ☰ 5.4. Drawing Histograms
- ☰ 5.5. Histogram Properties
- ☰ 5.6. Accessing Histogram Bins
- ☰ 5.7. Histogram Errors
- ☰ 5.8. Normalizing Histograms
- ☰ 5.9. Combining Histograms
-
- ☰ 6. Two-Dimensional Histograms
- ☰ 6.1. Creating 2D Histograms
- ☰ 6.2. Filling 2D Histograms
- ☰ 6.3. Drawing 2D Histograms
- ☰ 6.4. Projections
- ☰ 6.5. Profiles
-
- ☰ 7. Graphs
- ☰ 7.1. Introduction to TGraph
- ☰ 7.2. Creating a TGraph
- ☰ 7.3. Graph Styling
- ☰ 7.4. TGraphErrors
- ☰ 7.5. TGraphAsymmErrors
- ☰ 7.6. MultiGraph
-
- ☰ 8. Canvases and Plotting
- ☰ 8.1. TCanvas
- ☰ 8.2. Dividing a Canvas
- ☰ 8.3. Drawing Multiple Objects
- ☰ 8.4. Legends
- ☰ 8.5. Text and Annotations
- ☰ 8.6. Logarithmic Axes
- ☰ 8.7. Saving Plots
-
- ☰ 9. Styling ROOT Plots
- ☰ 9.1. ROOT Plot Styles
- ☰ 9.2. Axis Configuration
- ☰ 9.3. Line Styles
- ☰ 9.4. Marker Styles
- ☰ 9.5. Publication-Quality Figures
-
- ☰ 10. Mathematical Functions
- ☰ 10.1. Introduction to TF1
- ☰ 10.2. Built-in Functions
- ☰ 10.3. Custom Functions
- ☰ 10.4. Evaluating Functions
- ☰ 10.5. Function Integrals
-
- ☰ 11. Curve Fitting
- ☰ 11.1. Introduction to Fitting
- ☰ 11.2. Gaussian Fits
- ☰ 11.3. Polynomial Fits
- ☰ 11.4. Custom Fit Functions
- ☰ 11.5. Fit Parameters
- ☰ 11.6. Goodness of Fit
- ☰ 11.7. Fit Residuals
- ☰ 11.8. Fitting Graphs
-
- ☰ 12. ROOT Files
- ☰ 12.1. Introduction to ROOT Files
- ☰ 12.2. Creating ROOT Files
- ☰ 12.3. Writing Objects
- ☰ 12.4. Reading ROOT Files
- ☰ 12.5. Exploring ROOT Files
- ☰ 12.6. Directories Inside ROOT Files
-
- ☰ 13. TTrees
- ☰ 13.1. Introduction to TTrees
- ☰ 13.2. Creating a TTree
- ☰ 13.3. Filling a TTree
- ☰ 13.4. Writing a TTree to a File
- ☰ 13.5. Reading a TTree
- ☰ 13.6. Inspecting TTrees
- ☰ 13.7. Drawing Data from TTrees
- ☰ 13.8. Applying Selection Cuts
- ☰ 13.9. Branch Addresses
-
- ☰ 14. Event-Based Data Analysis
- ☰ 14.1. Understanding Event Data
- ☰ 14.2. Event Loops
- ☰ 14.3. Event Selection
- ☰ 14.4. Derived Quantities
- ☰ 14.5. Analysis Workflow
-
- ☰ 15. Working with Real Experimental Data
- ☰ 15.1. Importing Text Data
- ☰ 15.2. Converting Data to ROOT
- ☰ 15.3. Data Cleaning
- ☰ 15.4. Data Calibration
- ☰ 15.5. Signal and Background
-
- ☰ 16. Random Numbers and Simulations
- ☰ 16.1. Random Number Generation
- ☰ 16.2. Common Distributions
- ☰ 16.3. Simple Monte Carlo Simulation
- ☰ 16.4. Detector Resolution Simulation
- ☰ 16.5. Efficiency Simulation
-
- ☰ 17. Statistical Analysis with ROOT
- ☰ 17.1. Basic Statistics
- ☰ 17.2. Probability Distributions
- ☰ 17.3. Statistical Uncertainties
- ☰ 17.4. Chi-Square Tests
- ☰ 17.5. Confidence Intervals
-
- ☰ 18. Modern ROOT with RDataFrame
- ☰ 18.1. Introduction to RDataFrame
- ☰ 18.2. Loading Data
- ☰ 18.3. Filtering Data
- ☰ 18.4. Defining New Columns
- ☰ 18.5. Creating Histograms
- ☰ 18.6. Statistical Operations
- ☰ 18.7. Saving Results
- ☰ 18.8. Multithreading
-
- ☰ 19. ROOT and Python
- ☰ 19.1. Introduction to PyROOT
- ☰ 19.2. ROOT Objects in Python
- ☰ 19.3. Reading ROOT Files with Python
- ☰ 19.4. PyROOT and NumPy
- ☰ 19.5. PyROOT and Matplotlib
- ☰ 19.6. Choosing Between C++ and Python
-
- ☰ 20. Advanced TTree Techniques
- ☰ 20.1. Trees with Multiple Branches
- ☰ 20.2. Storing std::vector Objects
- ☰ 20.3. TChain
- ☰ 20.4. Friends
- ☰ 20.5. Efficient TTree Analysis
-
- ☰ 21. ROOT for Particle and Nuclear Physics
- ☰ 21.1. Four-Vectors
- ☰ 21.2. Particle Kinematics
- ☰ 21.3. Invariant Mass
- ☰ 21.4. Angular Distributions
- ☰ 21.5. Detector Spectra
-
- ☰ 22. Debugging and Common ROOT Problems
- ☰ 22.1. ROOT Object Ownership
- ☰ 22.2. Null Pointers
- ☰ 22.3. Segmentation Faults
- ☰ 22.4. Missing Histograms
- ☰ 22.5. ROOT File Problems
- ☰ 22.6. TTree Branch Problems
- ☰ 22.7. Histogram Range Problems
- ☰ 22.8. Fit Failures
- ☰ 22.9. Debugging ROOT Macros
-
- ☰ 23. Writing Better ROOT Analysis Code
- ☰ 23.1. Separating Analysis and Plotting
- ☰ 23.2. Using Functions
- ☰ 23.3. Using Header Files
- ☰ 23.4. Naming Conventions
- ☰ 23.5. Avoiding Hard-Coded Values
- ☰ 23.6. Configuration Parameters
- ☰ 23.7. Reproducible Analysis
- ☰ 23.8. Version Control with Git
-
- ☰ 24. Final Project
- ☰ 24.1. Project Overview
- ☰ 24.2. Analyze a complete scientific dataset using ROOT.
- ☰ 24.3. Import the Data
- ☰ 24.4. Explore the Dataset
- ☰ 24.5. Apply Data Selection
- ☰ 24.6. Create Histograms
- ☰ 24.7. Fit the Data
- ☰ 24.8. Calculate Physical Quantities
- ☰ 24.9. Estimate Statistical Uncertainties
- ☰ 24.10. Create Publication-Quality Figures
- ☰ 24.11. Save the Analysis Results
- ☰ 24.12. Write a Short Analysis Report
-
- ☰ 25. Appendices
- ☰ 25.1. A. ROOT Command Cheat Sheet
- ☰ 25.2. B. ROOT Histogram Classes
- ☰ 25.3. C. ROOT Graph Classes
- ☰ 25.4. D. Common TTree Commands
- ☰ 25.5. E. Common Drawing Options
- ☰ 25.6. F. Common Fit Functions
- ☰ 25.7. G. ROOT C++ Cheat Sheet
- ☰ 25.8. H. PyROOT Cheat Sheet
- ☰ 25.9. I. Common ROOT Errors and Solutions
- ☰ 25.10. J. Recommended ROOT Analysis Workflow
-
Comments
Please login to add a comment.
Don't have an account? Register now!