6.2. Filling 2D Histograms
Table of Contents
Filling X-Y data
A two dimensional histogram stores counts as a function of two variables, for example energy versus time or position $x$ versus $y$. In ROOT, classes such as TH2F and TH2D represent these histograms. To use them effectively, you must understand how to fill them with pairs of values.
The basic method is the Fill member function. For a 2D histogram h2, the simplest form is
h2->Fill(xValue, yValue);
This call finds the bin whose $x$ range contains xValue and whose $y$ range contains yValue, then increases that bin content by 1. This is completely analogous to TH1::Fill, but with an extra coordinate. Just as with 1D histograms, there is also a weighted version,
h2->Fill(xValue, yValue, weight);
which adds weight to the bin instead of 1. This is crucial when events carry different statistical weights, for example when correcting for detector efficiency or when using simulated events with event weights.
The mapping from numeric coordinates to bins uses the axis definitions that you chose when you created the histogram. If you created
TH2F *h2 = new TH2F("h2", "X vs Y",
50, 0.0, 5.0, // X axis: 50 bins from 0 to 5
40, -2.0, 2.0); // Y axis: 40 bins from -2 to 2
then any call to Fill(x, y) will place the pair (x, y) into one of $50 \times 40$ interior bins, or into the underflow or overflow along one or both axes if the values lie outside the specified ranges.
It is often useful to know which bin a given coordinate will fall into. For this, use the axis helpers:
Int_t binx = h2->GetXaxis()->FindBin(xValue);
Int_t biny = h2->GetYaxis()->FindBin(yValue);
Each of these returns an integer bin index, including underflow and overflow. For 2D histograms, there is also a global bin number that corresponds to a particular (binx, biny) pair:
Int_t globalBin = h2->GetBin(binx, biny);
Although you normally just use Fill, understanding the bin indices is helpful when you later read or modify the bin contents directly.
By default, both coordinates are treated symmetrically. ROOT does not assign any special meaning to the X or Y axis beyond the labels you give them. In practice, however, it is good style to keep a consistent convention, for example using X for the more fundamental or independent variable and Y for the response or dependent variable. This consistency makes your plots easier to interpret.
If your X and Y values are stored in parallel C++ arrays or std::vectors, you will typically loop over them and call Fill once per pair. For example:
std::vector<double> xs, ys;
// fill xs and ys with your data, same length N
for (size_t i = 0; i < xs.size(); ++i) {
double x = xs[i];
double y = ys[i];
h2->Fill(x, y);
}The crucial point is that each entry in the 2D histogram corresponds to one observation of the pair $(x, y)$, not to independent counts in X and Y. Keeping the one to one pairing of values is essential for a correct 2D distribution.
Important rule: Always call Fill(x, y) with the correct paired values from the same event or measurement. Never mix X values from one source with Y values from another, or you will destroy genuine correlations and create misleading patterns in the 2D histogram.
Weights can also come from arrays or be computed on the fly. For example, if each event has an associated weight w[i], then:
for (size_t i = 0; i < xs.size(); ++i) {
h2->Fill(xs[i], ys[i], w[i]);
}This is the standard way to encode variable statistical importance of events into a 2D histogram.
Event-by-event filling
In real analyses, you typically fill 2D histograms directly inside an event loop. Often the event data are stored in a TTree or come from a custom data structure in your code. In both cases, the logic is similar: for every event, compute or read the relevant X and Y quantities, apply any selection criteria, and then call Fill(x, y).
A common pattern with TTrees is:
TFile *f = TFile::Open("data.root");
TTree *t = (TTree*)f->Get("tree");
float x, y;
t->SetBranchAddress("x", &x);
t->SetBranchAddress("y", &y);
TH2F *h2 = new TH2F("h2", "Y vs X",
100, 0.0, 10.0,
80, -4.0, 4.0);
Long64_t nentries = t->GetEntries();
for (Long64_t i = 0; i < nentries; ++i) {
t->GetEntry(i);
// Optional: event selection
if (x < 0.0) continue;
if (std::abs(y) > 4.0) continue;
h2->Fill(x, y);
}
In this case, each call to GetEntry(i) loads the branches for one event, and the variables x and y hold the values for that event only. You then use exactly one Fill call per event that passes your selection cuts.
Event by event filling is also where you typically construct derived quantities. For example, suppose your TTree contains momentum components px and py, and you want to study the distribution of transverse momentum $p_T = \sqrt{p_x^2 + p_y^2}$ as a function of azimuthal angle $\phi = \arctan2(p_y, p_x)$:
float px, py;
t->SetBranchAddress("px", &px);
t->SetBranchAddress("py", &py);
TH2F *hPtPhi = new TH2F("hPtPhi", "p_{T} vs #phi",
64, -3.1416, 3.1416, // phi bins
100, 0.0, 10.0); // pT bins
for (Long64_t i = 0; i < nentries; ++i) {
t->GetEntry(i);
double pt = std::sqrt(px*px + py*py);
double phi = std::atan2(py, px);
// apply any physics selection here
if (pt < 0.1) continue;
hPtPhi->Fill(phi, pt);
}
Here you do not store pt and phi in the tree, but you calculate them on the fly from the raw components. The 2D histogram captures the correlation between these two derived observables across your entire dataset.
If events have associated weights, for example a branch w, you incorporate it directly:
float w;
t->SetBranchAddress("weight", &w);
for (Long64_t i = 0; i < nentries; ++i) {
t->GetEntry(i);
// compute x and y for this event
double x = /* ... */;
double y = /* ... */;
// selection
if (!passSelection(x, y)) continue;
h2->Fill(x, y, w);
}In simulations, weights might represent cross section normalization or efficiency corrections. In data analyses, they may encode luminosity scaling or background subtraction factors.
Event by event filling is not limited to TTrees. You can apply exactly the same pattern when you read text files line by line, iterate over a container of event objects, or loop through generated Monte Carlo events. The essential structure is always:
- Access one event.
- Compute or read the X and Y variables.
- Check any required conditions.
- Call
Fill(x, y)orFill(x, y, weight).
Important rule: The event loop must be structured so that all per event quantities are updated before each Fill call. Never reuse values from the previous event unintentionally, and ensure that each event contributes at most the intended number of entries to the 2D histogram.
Once you have filled your 2D histogram event by event, you can proceed to visualization and further analysis, for example by drawing the histogram with color scales, extracting projections along one axis, or converting the 2D distribution into a profile, all covered in subsequent sections.
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!