11.5. Fit Parameters
Table of Contents
Reading parameter values
When you fit a histogram or graph in ROOT, the fit function is a TF1 object. The numerical results of the fit, such as the best fit parameters and their uncertainties, are stored inside that TF1. You rarely need to extract anything from the histogram or graph itself; you read the results from the associated TF1.
There are two common ways to get the TF1 after a fit. The first way is to create the TF1 yourself, pass it to Fit, and keep the pointer:
TH1F *h = new TH1F("h", "Example", 100, -5, 5);
// ... fill h ...
TF1 *fgaus = new TF1("fgaus", "gaus", -2, 2);
h->Fit(fgaus, "R"); // R = use function range
Now fgaus holds the fit result. You can access the fitted parameter values with
double p0 = fgaus->GetParameter(0);
double p1 = fgaus->GetParameter(1);
double p2 = fgaus->GetParameter(2);
The parameter index starts at 0. For standard ROOT functions the meaning of each index is fixed. For example, for "gaus" the convention is:
| Index | Meaning |
|---|---|
| 0 | Amplitude |
| 1 | Mean |
| 2 | Sigma |
You can give the parameters names and then access them by name instead of by index. You typically do this right after creating the TF1:
TF1 *fgaus = new TF1("fgaus", "gaus", -2, 2);
fgaus->SetParName(0, "Amplitude");
fgaus->SetParName(1, "Mean");
fgaus->SetParName(2, "Sigma");
h->Fit(fgaus, "R");
double mean = fgaus->GetParameter("Mean");
double sigma = fgaus->GetParameter("Sigma");You can also query the number of parameters and loop over them. This is useful for generic code that should work with different models:
int npar = fgaus->GetNpar();
for (int i = 0; i < npar; ++i) {
const char *name = fgaus->GetParName(i);
double value = fgaus->GetParameter(i);
std::cout << i << " " << name << " " << value << "\n";
}If you let ROOT create the TF1 internally, for example by calling
h->Fit("gaus");
ROOT automatically creates a TF1 with name "gaus" and attaches it to the histogram. You can retrieve it later with:
TF1 *fitfunc = h->GetFunction("gaus");
double mean = fitfunc->GetParameter(1);
double sigma = fitfunc->GetParameter(2);Or, if you used a custom name
h->Fit("myfit", "R");
TF1 *fitfunc = h->GetFunction("myfit");The same logic works for fits to graphs. For example:
TGraphErrors *g = new TGraphErrors(/* ... */);
// Define a linear function
TF1 *fline = new TF1("fline", "[0] + [1]*x", 0.0, 10.0);
fline->SetParName(0, "Intercept");
fline->SetParName(1, "Slope");
g->Fit(fline, "R");
double slope = fline->GetParameter("Slope");
double intercept = fline->GetParameter("Intercept");
For many analyses you will print the final physics result, for example a mean lifetime, to the screen or a file. You typically combine the value and its uncertainty, which you read with GetParameter and GetParError:
double tau = fexp->GetParameter(1);
double tauErr = fexp->GetParError(1);
std::cout << "Tau = " << tau << " +/- " << tauErr << "\n";
If you need the full fit result, including the covariance matrix, you can ask ROOT to return a TFitResultPtr:
TFitResultPtr r = h->Fit(fgaus, "RS"); // R = range, S = return result
double p0 = r->Parameter(0);
double p1 = r->Parameter(1);
double p2 = r->Parameter(2);
The parameters inside TFitResultPtr are the same values as in the TF1. This object is especially useful when you need correlations or the covariance matrix, which are described in more detail in the chapter about goodness of fit.
Fit parameter values are always stored in the TF1 object. Use GetParameter(i) or GetParameter("name") to read them after the fit.
Parameter uncertainties
Every fitted parameter has a statistical uncertainty that comes from the shape and size of your data sample. These uncertainties quantify how precisely the fit determines the parameters. In ROOT these are given as 1 standard deviation (1 sigma) errors and are stored alongside the parameter values.
For each parameter you can retrieve its uncertainty from the TF1 with
double value = fgaus->GetParameter(i);
double error = fgaus->GetParError(i);or with parameter names:
double mean = fgaus->GetParameter("Mean");
double meanErr = fgaus->GetParError("Mean");
double sigma = fgaus->GetParameter("Sigma");
double sigmaErr = fgaus->GetParError("Sigma");A typical printout after a Gaussian fit might look like:
std::cout << "Mean = " << mean << " +/- " << meanErr << "\n";
std::cout << "Sigma = " << sigma << " +/- " << sigmaErr << "\n";The interpretation is purely statistical. If the errors are computed with standard assumptions, then in many common situations there is about a 68 percent probability that the true parameter value lies within one error of the fitted value. This interpretation depends on the model and on the validity of the fit, topics covered in the chapter on goodness of fit.
There is a direct relation between parameter uncertainties and the quality or amount of data. If you have more entries or a sharper feature, the errors tend to be smaller. If the model is a poor description of the data, the parameter uncertainties may be misleading. It is good practice to examine the chi square or other goodness of fit indicators before you trust the reported errors.
By default ROOT uses the chosen minimizer, for example MINUIT, to compute the parameter errors. If you ask for a TFitResultPtr as described above, you can also access richer error information. For example, you can get the error and the covariance matrix:
TFitResultPtr r = h->Fit(fgaus, "RS");
// Parameter errors
for (int i = 0; i < fgaus->GetNpar(); ++i) {
double val = r->Parameter(i);
double err = r->ParError(i);
std::cout << fgaus->GetParName(i) << " = " << val
<< " +/- " << err << "\n";
}
// Covariance between parameter 0 and 1
double cov01 = r->CovMatrix(0, 1);The diagonal elements of the covariance matrix are the variances of each parameter, so the errors are
$$
\sigma_i = \sqrt{\text{CovMatrix}(i, i)}.
$$
ROOT already computes these for you, so in practice you use GetParError or ParError instead of this formula, but it is useful to know what is behind it.
Use GetParError(i) or GetParError("name") to obtain the 1 sigma statistical uncertainty of a fit parameter. These errors come from the fit covariance matrix and are meaningful only if the fit model describes the data adequately.
When you propagate parameter uncertainties to derived quantities, for example when you compute a lifetime from a slope, you need more than just the individual parameter errors. You may also need their correlations, because fit parameters are often not independent. The details of uncertainty propagation and correlation use are covered later, but the starting point is always the parameter values and their errors stored in the TF1 and, optionally, the full TFitResult.
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!