11.3. Polynomial Fits
Table of Contents
Linear fits
Polynomial fitting in ROOT is most commonly done with the generic polynomial function class TF1("polN", ...), where N is the degree of the polynomial. The simplest case is a linear fit, which corresponds to pol1 in ROOT. The model is
$$
f(x) = p_0 + p_1 x
$$
where p0 is the intercept and p1 is the slope.
For a histogram h, a typical linear fit in the current X axis range looks like:
h->Fit("pol1");
ROOT internally constructs a TF1 with name "pol1" and adjusts its parameters to minimize the chi square. If you want to restrict the fit to a particular range, you can either set a range on the histogram before fitting, or create your own TF1 with explicit limits:
TF1 *f_lin = new TF1("f_lin", "pol1", x_min, x_max);
h->Fit("f_lin", "R"); // "R" tells ROOT to use the TF1 range
The same idea applies to fitting a TGraph or TGraphErrors:
TGraph *g = ...;
g->Fit("pol1");
After the fit, you can inspect the parameters through the TF1 object:
TF1 *fit = h->GetFunction("pol1");
double intercept = fit->GetParameter(0); // p0
double slope = fit->GetParameter(1); // p1
double e_intercept = fit->GetParError(0);
double e_slope = fit->GetParError(1);For linear fits with ROOT:
- Use
"pol1"as the built-in model. - Parameter index 0 is the intercept, parameter index 1 is the slope.
- Use the option
"R"and aTF1with explicit limits to control the fit range.
Be careful that the quality of a linear fit depends strongly on the chosen X interval. A straight line can approximate many shapes over a small region, so always check that the linear model is physically or logically justified for your data in that range, and inspect residuals rather than trusting the line visually.
Quadratic fits
Quadratic fits use the pol2 model, which has three parameters:
$$
f(x) = p_0 + p_1 x + p_2 x^2.
$$
This allows you to capture simple curvature in your data, such as parabolic peaks or troughs.
To fit a histogram with a quadratic function over its default range:
h->Fit("pol2");
For more control, define an explicit TF1:
TF1 *f_quad = new TF1("f_quad", "pol2", x_min, x_max);
h->Fit("f_quad", "R");The meaning of the parameters is fixed by the polynomial definition:
p0is the constant term, the value atx = 0.p1is the linear coefficient.p2is the quadratic coefficient, which sets the curvature. Ifp2 < 0the parabola opens downward, ifp2 > 0it opens upward.
You can extract parameters and their uncertainties just as for the linear case:
TF1 *fit = h->GetFunction("f_quad");
double p0 = fit->GetParameter(0);
double p1 = fit->GetParameter(1);
double p2 = fit->GetParameter(2);
double e_p2 = fit->GetParError(2);
Quadratic fits are particularly useful to approximate a smooth maximum or minimum when you do not want to assume a specific physical line shape. For example, to find the position of a smooth peak you can fit with pol2 in a limited window around the maximum. The extremum of the fitted parabola is at
$$
x_{\text{ext}} = -\frac{p_1}{2 p_2}
$$
provided p2 is not zero.
In a quadratic fit with pol2:
- The model is $f(x) = p_0 + p_1 x + p_2 x^2$.
- Parameter 2 controls the curvature, and its sign determines if the parabola opens up or down.
- The extremum of the parabola is at $x_{\text{ext}} = -p_1/(2 p_2)$, which you must compute from the fit parameters.
When using pol2, always restrict the fit to a region where a quadratic approximation is reasonable. Over a very wide range, even a small higher order structure in the true data can make a simple parabola a poor model and distort the extracted extremum or other derived quantities.
Higher-order polynomials
Higher-order polynomial fits generalize the previous cases to arbitrary degree. ROOT provides built-in polynomial functions "polN" where N can be 0, 1, 2, 3, and so on. The general model is
$$
f(x) = \sum_{k=0}^{N} p_k x^k
$$
with N + 1 free parameters. For instance, a cubic polynomial pol3 has
$$
f(x) = p_0 + p_1 x + p_2 x^2 + p_3 x^3.
$$
To perform a cubic fit over a chosen interval:
TF1 *f_cubic = new TF1("f_cubic", "pol3", x_min, x_max);
h->Fit("f_cubic", "R");For an even higher order, say order 5:
TF1 *f5 = new TF1("f5", "pol5", x_min, x_max);
h->Fit("f5", "R");You can also fit graphs with higher-order polynomials in exactly the same way:
TGraphErrors *g = ...;
g->Fit("pol3"); // simple cubic fit
g->Fit("pol4", "R"); // quartic in the graph range
For large N, the parameters individually have less obvious physical meaning. Instead of interpreting each coefficient, you usually use high-order polynomials as a flexible empirical model for a smooth background or a slowly varying trend. ROOT still provides parameter values, uncertainties, and correlations, but the main information is often the fitted curve itself.
Higher-order fits can be powerful, but they come with two important caveats.
First, there is a risk of overfitting. With many free parameters, a polynomial can reproduce small statistical fluctuations in the data rather than the underlying trend. This often leads to a curve that oscillates between points, especially near the edges of the fitted range, and to unstable extrapolation beyond the fitted region.
Second, numerical stability can degrade as the order increases, especially if the X values are very large or the fit range is very wide. The powers of x can become huge and highly correlated, which makes the parameter estimates more sensitive to small changes in the data.
When using higher-order polynomials in ROOT:
"polN"has $N+1$ parameters and models $f(x) = \sum_{k=0}^{N} p_k x^k$.- Always limit the fit to a range where such a flexible polynomial is justified.
- More parameters increase the risk of overfitting and numerical instability, especially for wide ranges or large X values.
To reduce these issues, keep the polynomial order as low as possible, work in a limited X interval, and choose an order that is motivated by the physics or by clear structure in the data rather than by the desire to minimize chi square at all costs. After fitting, always inspect the residuals and, if possible, compare different polynomial orders to see whether the extra complexity is really needed.
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!