KAHIBARO Bookshelves
Discord Login Register

11.2. Gaussian Fits

Fitting histogram peaks

Gaussian fits are used when your histogram peak is shaped like a normal distribution, for example a detector energy peak or a time-of-flight signal. In ROOT, the typical workflow is to have a 1D histogram, then fit a Gaussian function to a region around the peak in order to extract its position and width.

Assume you already have a histogram, for example a TH1F *h filled with your data. The simplest way to fit a Gaussian peak is to call the Fit method on the histogram with the built-in function name "gaus":

cpp
h->Fit("gaus");

This creates, behind the scenes, a temporary TF1 with the Gaussian shape and fits it to the whole histogram range. After the fit, you can draw the histogram and the fitted function on a canvas:

cpp
h->Draw();

ROOT automatically overlays the Gaussian curve and prints the fit results in the canvas statistics box if the style allows it.

The underlying Gaussian function used by "gaus" has the form

$$
f(x) = p_0 \exp\left[-\frac{1}{2} \left(\frac{x - p_1}{p_2}\right)^2 \right],
$$

where the three parameters are:

Parameter index | Meaning
--------------- | -------
$p_0$ | Amplitude (peak height)
$p_1$ | Mean (peak position)
$p_2$ | Sigma (standard deviation, peak width)

To have more control, you can explicitly create a TF1:

cpp
TF1 *g = new TF1("g", "gaus", xMin, xMax);
h->Fit(g, "R");  // "R" tells ROOT to respect the range of g

This is very useful for fitting only one peak in a complex spectrum or for restricting the fit to a region that is approximately Gaussian. The function range and the initial guesses of parameters influence how well the fit converges, which you will see in the section on the fit range.

After the fit, all relevant information is stored both in the histogram and in the TF1 object. The histogram keeps a pointer to the last fitted function, accessible with

cpp
TF1 *fitFunc = h->GetFunction("gaus");  // or "g" if that was its name

You usually extract the peak position and width from this function, as described in the next sections.

A Gaussian fit with "gaus" always has three parameters:

  1. $p_0$ amplitude.
  2. $p_1$ mean.
  3. $p_2$ sigma.
    Always interpret the parameters in this order and use the corresponding index when reading them from the fitted function.

Mean

In the context of a Gaussian fit, the mean parameter $p_1$ gives the position of the center of the peak. This is often the main physical quantity you want, for example a calibrated energy, a mass or a time offset.

Once you have performed a Gaussian fit on a histogram h, you can retrieve the fitted mean using the GetParameter method of the fit function. If you used the automatic "gaus" fit,

cpp
h->Fit("gaus");
TF1 *fgaus = h->GetFunction("gaus");
double mean  = fgaus->GetParameter(1);
double emean = fgaus->GetParError(1);

Here mean is the fitted peak position and emean is the statistical uncertainty given by the fit. The index 1 is always the mean for the Gaussian built-in function.

In many analyses, you will compare the Gaussian mean to a known or expected value. For example, in a calibration run you might fit peaks from known reference lines and then use the fitted means as input to a calibration function. The uncertainty emean then propagates into the total calibration uncertainty.

If you create your own Gaussian TF1, the interpretation of parameter 1 as the mean remains the same as long as you use the "gaus" formula:

cpp
TF1 *g = new TF1("g", "gaus", xMin, xMax);
h->Fit(g, "R");
double mean  = g->GetParameter(1);
double emean = g->GetParError(1);

If you later define more complex models, for example a Gaussian plus a constant background, the mean will no longer be parameter 1 by default, so you should keep track of your parameter ordering. For the simple built-in "gaus" function, however, the mean is always parameter 1.

For the ROOT built-in Gaussian "gaus":

  • The mean of the peak is always parameter index 1.
  • Use GetParameter(1) for the mean value and GetParError(1) for its uncertainty.

Sigma

The sigma parameter $p_2$ is the standard deviation of the Gaussian and describes how wide the peak is. In physics applications, sigma is directly related to the detector resolution or to the spread of the measured quantity.

After fitting, you can read sigma and its uncertainty just like the mean:

cpp
h->Fit("gaus");
TF1 *fgaus = h->GetFunction("gaus");
double sigma  = fgaus->GetParameter(2);
double esigma = fgaus->GetParError(2);

The width of the peak is sometimes more conveniently expressed in terms of the full width at half maximum, FWHM. For a perfect Gaussian, FWHM is related to sigma by the formula

$$
\text{FWHM} = 2 \sqrt{2 \ln 2}\,\sigma \approx 2.355\,\sigma.
$$

You can compute this after the fit:

cpp
double fwhm = 2.35482 * sigma;

Sigma allows you to quantify how well your detector or measurement technique performs. A smaller sigma indicates better resolution. By comparing sigma for different settings or different detectors, you can evaluate performance improvements.

If your histogram bins are in physical units, then sigma and FWHM are also in these units. For example, if the x axis is calibrated in MeV, then sigma represents the energy resolution in MeV.

As with the mean, if you create your own multi-parameter model, the index 2 might no longer correspond to sigma, but for a pure "gaus" function it always does.

For a Gaussian distribution:

  • The sigma (standard deviation) of the peak is parameter index 2 for "gaus".
  • The full width at half maximum is related by
    $$\text{FWHM} \approx 2.355\,\sigma.$$

Fit range

The choice of fit range is crucial for a reliable Gaussian fit. If you fit too wide a range, background structures or non-Gaussian tails can distort the result. If you fit too narrow a range, you may not capture enough of the peak shape for a stable fit.

By default,

cpp
h->Fit("gaus");

uses the full histogram x range. In many real data situations this is not optimal, especially when several peaks or a sloping background are present.

To specify a fit range explicitly, define a TF1 with a given x range and then fit with the "R" option so ROOT respects that range:

cpp
double xlow  = 100.0;
double xhigh = 140.0;
TF1 *g = new TF1("g", "gaus", xlow, xhigh);
h->Fit(g, "R");

Here, only bins whose centers lie between xlow and xhigh are used in the fit. This is the standard way to isolate a single peak.

A common practical strategy is:

  1. Inspect the histogram visually to estimate the peak region.
  2. Choose a range that covers about plus or minus two to three sigmas around the peak center.
  3. Set that as the initial function range and perform the fit.
  4. Optionally refine the range based on the fitted mean and sigma.

If the peak position is not known beforehand, you can still start with a rough range that clearly covers the whole peak and a bit of the nearby background. In some cases it helps to initialize the Gaussian parameters before fitting:

cpp
TF1 *g = new TF1("g", "gaus", xlow, xhigh);
g->SetParameters(h->GetMaximum(), peakGuess, widthGuess);
h->Fit(g, "R");

Here peakGuess and widthGuess are your approximate estimates of the mean and sigma. Good initial values and a sensible fit range together make the fit more stable and less likely to converge to an unphysical solution.

You can also change the fit range of an existing TF1 without recreating it:

cpp
g->SetRange(newLow, newHigh);
h->Fit(g, "R");

Finally, remember that the statistical quality of the fit depends on the number of entries in the fit range. If you choose a very narrow range around a small peak, the uncertainty on the mean and sigma will be large. In that case, collecting more data or widening the range slightly can help.

When fitting a Gaussian peak:

  • Do not blindly fit the full histogram range.
  • Define a reasonable fit range that covers the peak but avoids unrelated structures.
  • Use a TF1 with the desired range and the "R" fit option to constrain the fit.

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

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