11.8. Fitting Graphs
Table of Contents
TGraph fitting
When you fit a graph in ROOT you are fitting a set of explicit points, not binned counts as in a histogram. The typical workflow is to attach a function to the graph and let ROOT adjust the function parameters to best describe the points.
A TGraph holds pairs $(x_i, y_i)$ without any uncertainties. ROOT uses a least squares minimization that, by default, assumes all points have the same uncertainty. This means each point contributes equally to the fit.
To perform a fit you first define a TF1 that describes your model. For example, a straight line can be written as
$$
f(x) = p_0 + p_1 x,
$$
where $p_0$ is the intercept and $p_1$ is the slope. In ROOT this might look like
TF1 *fline = new TF1("fline", "[0] + [1]*x", xmin, xmax);
fline->SetParameters(0.0, 1.0); // initial guesses
The range you give to the TF1 is the default fit range. You can later override it in the Fit call. Choosing a sensible initial parameter set and fit range often makes the fit more stable, especially for nonlinear models.
Once you have a graph and a function, you call
graph->Fit("fline"); // by nameor
graph->Fit(fline); // by pointer
If a canvas is open and the graph is drawn, the fit will draw the function on top of the graph and print the parameter values and their uncertainties in the ROOT terminal. You can suppress drawing with the option "N" and suppress printing with "Q", for instance
graph->Fit(fline, "QN");
The most important fit options used with graphs are the same as with histograms. For example "R" tells ROOT to use the function range, not the full data range, and "W" activates point weights if you have set them manually. The full list of options is described in the general fitting chapter, so here you only need to remember that the second argument to Fit is a string of characters that modify how the fit is performed.
After the fit finishes, you can read the parameters from the TF1:
double p0 = fline->GetParameter(0);
double e0 = fline->GetParError(0);
double p1 = fline->GetParameter(1);
double e1 = fline->GetParError(1);
These values can be used in subsequent calculations, for example to compute a predicted value at a given $x$ with fline->Eval(x) or to build derived quantities from the fit result.
ROOT also reports a chi square and number of degrees of freedom for the fit. You can access them with
double chi2 = fline->GetChisquare();
int ndf = fline->GetNDF();The detailed interpretation of these quantities and of goodness of fit is covered in the dedicated chapter on that topic.
It is useful to be aware of one limitation: since TGraph has no uncertainties, the chi square is computed under the assumption of equal errors. If your points have very different uncertainties, you should use TGraphErrors and weighted fits, which are described next.
Important rule: Fitting a TGraph treats all points as equally precise. If your data points have different uncertainties, use TGraphErrors or TGraphAsymmErrors so ROOT can weight the points correctly.
TGraphErrors fitting
TGraphErrors extends TGraph by including uncertainty information for each point. Every point carries $(x_i, y_i, \sigma_{x,i}, \sigma_{y,i})$. In most common fits only the vertical uncertainties $\sigma_{y,i}$ are used as statistical weights, since standard chi square fits minimize deviations in the $y$ direction.
The chi square minimized by ROOT for a fit to TGraphErrors, when only $y$ errors are used, has the form
$$
\chi^2 = \sum_i \frac{\left(y_i - f(x_i)\right)^2}{\sigma_{y,i}^2},
$$
so points with smaller $\sigma_{y,i}$ pull the fit more strongly. This is a weighted least squares fit.
You create a TGraphErrors similarly to TGraph, either from arrays or by adding points one by one. For each point you provide the coordinates and their errors:
TGraphErrors *g = new TGraphErrors();
g->SetPoint(i, x, y);
g->SetPointError(i, ex, ey); // ex = sigma_x, ey = sigma_y
If you do not have meaningful $x$ uncertainties, you can set ex to zero and only use ey. ROOT will then only use the $y$ errors in the chi square.
The fitting call is identical to the TGraph case:
TF1 *fmodel = new TF1("fmodel", "[0] + [1]*x", xmin, xmax);
g->Fit(fmodel);
Internally ROOT detects that this is a TGraphErrors and uses the $y$ errors to build the chi square. The fit result parameters and their uncertainties are accessed in exactly the same way as for TGraph.
When your points have very different uncertainties the effect of weighting can be substantial. A data point with a large error bar will influence the fit less, which is usually what you want for experimental measurements, because it reflects the fact that the point is less precise.
If you have purely statistical uncertainties from counting experiments, and you have converted those into errors on some derived quantity, you should pass these as the ey values. ROOT does not calculate errors for TGraphErrors automatically, you are responsible for setting SetPointError for each point.
Sometimes you may want to ignore the errors and treat all points equally even though TGraphErrors is used. In that case you can set all ey values to the same constant. The fit will then behave like a TGraph fit, but you still retain error bars on the plot for visual information.
ROOT can also include $x$ errors in some more advanced fits or when transforming coordinates, although the simple chi square above only uses $y$ errors. For many standard analyses, setting meaningful $y$ uncertainties and fitting with TGraphErrors is enough.
Important rule: For TGraphErrors, the default chi square fit uses the $y$ uncertainties as weights according to
$$
\chi^2 = \sum_i \frac{\left(y_i - f(x_i)\right)^2}{\sigma_{y,i}^2}.
$$
Set ey correctly for each point if you want a statistically meaningful fit.
The visual output of a fit to TGraphErrors shows both the fitted function and the error bars. This combination is very useful in real experimental work, because it lets you immediately see where the model agrees within the measurement uncertainties and where the deviations are larger than expected.
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!