5.3. Filling Histograms
Table of Contents
`Fill()`
The central operation for using a histogram in ROOT is to fill it with data. Every time you call the Fill() method, you add one entry to the histogram, usually corresponding to a single measurement or event.
For a one dimensional histogram like TH1F or TH1D, the most common form is:
h->Fill(x);
Here x is the value that will be placed into the appropriate bin according to the histogram range and binning that were defined when the histogram was created. ROOT automatically finds the correct bin for x and increases its content.
By default, each call to Fill(x) increases the selected bin by 1 and increases the total number of entries by 1. This is equivalent to counting how many times a particular value, or a value inside a particular interval, appears in your data.
There is also a weighted version of Fill():
h->Fill(x, w);
In this case, instead of incrementing the bin content by 1, ROOT increments it by the weight w. This is useful when each event should contribute with a different importance, for example when you have simulated events that represent different numbers of real events, or when you apply efficiency or luminosity corrections.
The histogram keeps track of the sum of weights internally, but the basic idea remains the same. Each call to Fill() modifies one bin and updates the entry count. Out of range values are handled with the underflow and overflow bins, which are updated automatically when x is smaller than the minimum or larger than the maximum of the histogram range.
Key rule: Use h->Fill(x) to add an unweighted event and h->Fill(x, w) to add an event with weight w. Every call to Fill() changes one bin and updates the histogram entries, including underflow or overflow for out of range values.
Filling histograms manually
Sometimes you work with a small number of values or want to check behavior interactively. In that case, you can fill a histogram directly from the ROOT prompt or inside a very short macro by typing explicit Fill() calls.
For example, suppose you have created a histogram:
TH1F *h = new TH1F("h", "Example;X;Counts", 10, 0.0, 10.0);You can now fill it manually:
h->Fill(1.2);
h->Fill(3.8);
h->Fill(3.8);
h->Fill(9.5);In this example, the bin that contains 3.8 will receive two counts, and the bins around 1.2 and 9.5 will receive one count each. You can then inspect the histogram with:
h->Draw();Manual filling is also useful when you want to test how binning behaves for specific values near bin edges. For instance, you might fill values at the exact edges:
h->Fill(0.0);
h->Fill(10.0);and then draw the histogram to see where these values end up. This helps you build intuition about how ROOT treats interval boundaries for bins.
You can also set bin contents directly without calling Fill(), using methods such as SetBinContent(bin, value), but that bypasses the automatic bin search, underflow and overflow handling, and the bookkeeping of entries and sums of weights. For learning and for most analyses where you have a list of measurements, it is better to use Fill() and let ROOT handle the internal details.
Important: For normal analysis with event data, prefer Fill() instead of directly setting bin contents. Direct bin manipulation skips some internal statistics and should only be used when you have a specific reason and know exactly what you are doing.
Filling histograms inside loops
In real analyses, you rarely call Fill() only a few times. Instead, you usually have a collection of many values and you want to accumulate them into a histogram. The standard pattern is to create the histogram once, then loop over your data and call Fill() inside the loop.
For example, if you have an array of measurements:
const int N = 5;
double data[N] = {1.0, 2.3, 2.3, 4.7, 9.1};
TH1F *h = new TH1F("h", "Data;X;Counts", 10, 0.0, 10.0);
for (int i = 0; i < N; ++i) {
h->Fill(data[i]);
}After this loop, the histogram contains all five entries from the array. You can then draw or analyze the histogram further.
If you have weights associated with each measurement, you include them in the call:
double weight[N] = {1.0, 0.5, 0.5, 2.0, 1.0};
for (int i = 0; i < N; ++i) {
h->Fill(data[i], weight[i]);
}Each data point now contributes according to its weight, which influences both bin contents and the statistical interpretation of the histogram.
In event based analysis with TTrees, the pattern is similar. You loop over events, extract the variable of interest from each event, and call Fill():
TH1F *hEnergy = new TH1F("hEnergy", "Energy;E (MeV);Events", 100, 0.0, 1000.0);
for (Long64_t i = 0; i < nEntries; ++i) {
tree->GetEntry(i);
double E = energy; // assume 'energy' is a branch variable
hEnergy->Fill(E);
}
This structure, a loop over data with Fill() calls inside, is the basic building block of almost every analysis in ROOT that uses histograms.
You can also combine calculations with filling. For example, if you want to histogram the square of a variable instead of the variable itself, you can compute it in the loop:
for (Long64_t i = 0; i < nEntries; ++i) {
tree->GetEntry(i);
double x2 = x * x;
h->Fill(x2);
}
Standard pattern: Create the histogram once, then loop over all your data and call Fill() for each event or measurement. This loop based filling is the core of practical histogram usage in ROOT.
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!