6.4. Projections
Table of Contents
ProjectionX
A two dimensional histogram in ROOT, such as a TH2F or TH2D, stores counts in bins that are arranged on an X grid and a Y grid. A projection is a way to reduce this 2D information to a 1D histogram by summing over one axis and keeping the binning of the other axis. This is very common in analysis, for example when you want to look at the distribution of X values for a selected Y range.
ROOT provides member functions of TH2 to do this. To project a 2D histogram onto the X axis you use the method ProjectionX. The general idea is that you select a range of Y bins and for each X bin ROOT sums the contents of all selected Y bins. The result is a TH1 histogram whose X binning is identical to the original TH2, while the Y information has been integrated out.
In its most common form, you call:
TH1D *hx = h2->ProjectionX();
where h2 is a pointer to a TH2 histogram. This creates a new 1D histogram that contains, for each X bin index $i$, the sum
$$
N_i = \sum_{j=\text{all Y bins}} n_{ij},
$$
where $n_{ij}$ is the content of the bin with X index $i$ and Y index $j$. The bin errors are combined in quadrature, so the error of each X bin in the projection is
$$
\sigma_i = \sqrt{\sum_{j} \sigma_{ij}^2}.
$$
A projection histogram is a new histogram, independent of the original TH2. You are responsible for keeping a pointer to it and for writing it to a file or deleting it when you no longer need it.
Often you do not want to use the full Y range. For example you may have a correlation of energy vs position, and you are only interested in a strip of Y values. In that case you use the form
TH1D *hx = h2->ProjectionX("hx", ybin_min, ybin_max);
Here ybin_min and ybin_max are bin indices along the Y axis, not coordinate values. This projection keeps all X bins, but for each X bin it sums Y bins from ybin_min to ybin_max inclusive.
A practical workflow is to first decide the Y coordinate range you care about, then convert that to bin indices using the axis helper functions:
int ybin_min = h2->GetYaxis()->FindBin(ymin);
int ybin_max = h2->GetYaxis()->FindBin(ymax);
TH1D *hx = h2->ProjectionX("hx", ybin_min, ybin_max);
Now hx contains the X distribution for events where the original Y value lay between ymin and ymax. You can immediately draw it on a canvas with:
hx->Draw();
ROOT also lets you control whether underflow and overflow bins of the selected Y range are included, and whether bin labels are transferred, using additional options in ProjectionX. For most introductory use you can rely on the default behavior, which uses only the normal Y bins you specify.
A common pattern is to create several projections for different Y slices and compare them. You might write:
int y1_min = h2->GetYaxis()->FindBin(0.0);
int y1_max = h2->GetYaxis()->FindBin(1.0);
TH1D *hx1 = h2->ProjectionX("hx1", y1_min, y1_max);
int y2_min = h2->GetYaxis()->FindBin(1.0);
int y2_max = h2->GetYaxis()->FindBin(2.0);
TH1D *hx2 = h2->ProjectionX("hx2", y2_min, y2_max);
You can then draw hx1 and hx2 on the same canvas to see how the X distribution changes with Y.
The key points are that ProjectionX keeps the X axis and integrates over Y, that you choose Y ranges using bin indices or by converting from coordinate values with FindBin, and that the result is an ordinary 1D histogram which you can analyze with all the standard TH1 tools.
ProjectionY
ProjectionY is the complementary operation. It produces a 1D histogram along the Y axis by summing over selected X bins. You use it when you want to study how Y is distributed, either for the full X range or only for a restricted X interval.
The simplest call is:
TH1D *hy = h2->ProjectionY();
This builds a TH1 whose Y binning is identical to that of the parent TH2. For each Y bin index $j$, it stores
$$
M_j = \sum_{i=\text{all X bins}} n_{ij},
$$
with errors combined in quadrature, in exactly the same way as for ProjectionX.
To restrict the projection to a given X range you give explicit X bin indices:
TH1D *hy = h2->ProjectionY("hy", xbin_min, xbin_max);
Again, xbin_min and xbin_max refer to bin numbers along the X axis. In most analyses you will want to define those using axis coordinates:
int xbin_min = h2->GetXaxis()->FindBin(xmin);
int xbin_max = h2->GetXaxis()->FindBin(xmax);
TH1D *hy = h2->ProjectionY("hy", xbin_min, xbin_max);
Now hy represents the Y distribution for events that have X between xmin and xmax in the original 2D histogram. You can visualize it with:
hy->Draw();Just like ProjectionX, ProjectionY creates new histograms that you manage yourself. This means you can safely modify them, for example by rebinning or fitting, without affecting the original TH2. It is common to use ProjectionY to get 1D slices of a 2D distribution and then fit peaks or measure means in each slice.
For example, suppose h2 contains time vs energy. To study the time distribution for three different energy intervals you might write:
int e1_min = h2->GetXaxis()->FindBin(0.0);
int e1_max = h2->GetXaxis()->FindBin(1.0);
TH1D *ht1 = h2->ProjectionY("ht1", e1_min, e1_max);
int e2_min = h2->GetXaxis()->FindBin(1.0);
int e2_max = h2->GetXaxis()->FindBin(2.0);
TH1D *ht2 = h2->ProjectionY("ht2", e2_min, e2_max);You can then fit each projected histogram with a function or compare their means and widths.
In summary, ProjectionY keeps the Y axis and integrates away the X axis over a selectable bin range. Together, ProjectionX and ProjectionY are basic tools for extracting 1D information from 2D histograms and are used heavily in analysis to study slices, marginal distributions, and correlations from different views.
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!