11.7. Fit Residuals
Table of Contents
Calculating residuals
Residuals are the differences between your data and the values predicted by your fit function. They show where the fit works well and where it fails. For a data point with coordinate $x_i$, measured value $y_i$, and fit function $f(x)$, the residual is
$$r_i = y_i - f(x_i).$$
If the data point has an uncertainty $\sigma_i$ on $y_i$, you can also use the normalized (or pull) residual
$$r_i^{\text{norm}} = \frac{y_i - f(x_i)}{\sigma_i}.$$
Key definitions
Residual:
$$r_i = y_i - f(x_i).$$
Normalized residual (pull):
$$r_i^{\text{norm}} = \dfrac{y_i - f(x_i)}{\sigma_i}.$$
In ROOT, the way you compute residuals depends on whether you fit a histogram or a graph.
For a histogram TH1 h with a fit TF1 f already applied, residuals are naturally defined per bin. For bin index i you have a bin center x = h->GetBinCenter(i) and content y = h->GetBinContent(i). The predicted value from the fit is f->Eval(x). You can compute and store residuals in a separate histogram, which is usually created with the same binning as the original. For example, for simple unnormalized residuals:
TH1D* hRes = (TH1D*)h->Clone("hRes");
hRes->SetTitle("Residuals;X;Data - Fit");
hRes->Reset();
int nbins = h->GetNbinsX();
for (int i = 1; i <= nbins; ++i) {
double x = h->GetBinCenter(i);
double y = h->GetBinContent(i);
double yfit = f->Eval(x);
double r = y - yfit;
hRes->SetBinContent(i, r);
}
If you want normalized residuals for a histogram, you should divide by the bin error returned by GetBinError(i), which typically comes from Poisson counting statistics or from Sumw2 if you use weights. The code then looks like:
TH1D* hPull = (TH1D*)h->Clone("hPull");
hPull->SetTitle("Pulls;X;(Data - Fit) / #sigma");
hPull->Reset();
for (int i = 1; i <= nbins; ++i) {
double x = h->GetBinCenter(i);
double y = h->GetBinContent(i);
double err = h->GetBinError(i);
if (err <= 0) continue; // skip empty or ill-defined bins
double yfit = f->Eval(x);
double rnorm = (y - yfit) / err;
hPull->SetBinContent(i, rnorm);
}
The same idea applies when fitting TGraph or TGraphErrors objects. You loop over points instead of bins and then fill a residual or pull histogram. For a TGraphErrors* g, for instance:
int n = g->GetN();
double* xs = g->GetX();
double* ys = g->GetY();
double* yerrs = g->GetEY();
TH1D* hPull = new TH1D("gPull","Pulls; (Data - Fit) / #sigma; Entries",
40, -5, 5);
for (int i = 0; i < n; ++i) {
double x = xs[i];
double y = ys[i];
double err = yerrs ? yerrs[i] : 0.0;
if (err <= 0) continue;
double yfit = f->Eval(x);
double rnorm = (y - yfit) / err;
hPull->Fill(rnorm);
}This separates the residual computation from the visualization and lets you inspect how the residuals themselves are distributed.
Plotting residual distributions
Residual plots help you to see patterns that are hidden in the main fit plot. With ROOT you often use two complementary types of residual displays: residuals as a function of $x$, and the distribution of residual values in a histogram.
A common layout uses a canvas divided into two pads. The upper pad shows the data with the fitted function, and the lower pad shows the residuals as a function of $x$. For histogram fits, you can do something like:
TCanvas* c = new TCanvas("c","Fit with residuals",800,800);
c->Divide(1,2);
// Top pad: data and fit
c->cd(1);
gPad->SetPad(0.0,0.3,1.0,1.0); // top 70% of canvas
h->Draw("E"); // draw with errors
f->Draw("SAME");
// Bottom pad: residuals vs X
c->cd(2);
gPad->SetPad(0.0,0.0,1.0,0.3); // bottom 30%
gPad->SetGridy(); // horizontal grid helps reading
hRes->SetStats(0);
hRes->Draw("E");
You can replace hRes by your pull histogram hPull. For normalized residuals, you often set the y axis range to a few sigma, for example from −5 to +5, so you can quickly see outliers:
hPull->GetYaxis()->SetRangeUser(-5,5);
hPull->Draw("E");Residuals versus $x$ should fluctuate around zero with no obvious structure. Systematic trends, such as residuals mostly positive in one region and mostly negative in another, are a strong indication that the model does not capture the data correctly or that the fit range is not suitable.
To examine the distribution of residuals themselves, you can draw the pull histogram as a 1D distribution. This shows how often a given residual value appears, independent of $x$:
TCanvas* c2 = new TCanvas("c2","Pull distribution",600,400);
hPull->SetTitle("Pull distribution;(Data - Fit) / #sigma;Entries");
hPull->Draw();You can optionally fit this distribution with a Gaussian to test whether the residuals behave as expected. For properly estimated uncertainties and a good model, the normalized residuals should be close to a standard normal distribution with mean near zero and width near one:
hPull->Fit("gaus");The fitted mean and sigma from this Gaussian give you a quick check of your error model. A mean significantly different from zero suggests a bias in the fit. A width significantly larger than one suggests that the data uncertainties are underestimated or that the model is missing fluctuations. A width much smaller than one suggests that the uncertainties are overestimated.
In summary, plotting residuals against $x$ reveals local structures, while plotting the distribution of normalized residuals shows whether the residuals globally behave like random statistical fluctuations. Both views are valuable when you interpret ROOT fits to histograms or graphs.
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!