Fitting is the method for modeling the expected distribution of events in a physics data analysis. ROOT offers various options to perform the fitting of the data:
- Fit Panel: After a histogram is drawn, the Fit Panel GUI is best used for prototyping the fit.
- Fit() method: You can fit histograms and graphs programmatically with the
- Minimization packages: ROOT provides several minimization packages like Minuit2 and FUMILI.
- RooFit: The RooFit library is a toolkit for modeling the expected distribution of events in a physics analysis.
Using the Fit Panel
After you have drawn a histogram (see → Drawing a histograms), you can use the Fit Panel for fitting the data. The Fit Panel is best suited for prototyping
The following section describes how to use the Fit Panel using an example.
Given is a histogram following a Gaussian distribution.
Right-click on the object and then click
You also can select
Toolsand then click
Figure: FitPanel in the context menu.
The Fit Panel is displayed.
Figure: Fit Panel.
Fit Function section you can select the function that should be used for fitting.
The following types of functions are listed here:
Pre-defined functions that will depend on the dimensionality of the data.
Functions present in
gDirectory. These functions were already created by the user through a ROOT macro.
Previously used functions. Functions that fitted the current data previously, if the data is able to store such functions.
Select a fitting function.
Set Parameters...to set the parameters of the selected function.
Set Parameters of... dialog window is displayed.
Figure: Set Parameters of… dialog window.
Set the parameters for the fit function.
Generaltab, select the general options for fitting.
This includes the method that will be used, as well as what fit options will be used with it and the draw options. You can also constrain the range of the function used for the fitting.
Minimizationtab, select the minimization algorithm for fitting.
Figure: A fitted histogram.
Using the Fit() method
Fit() method is implemented for:
the histogram classes TH1
the sparse histogram classes THnSparse
- Use the TH1::Fit() method to fit a histogram programmatically.
By default, the fitted function object is added to the histogram and is drawn in the current pad.
The signature is:
function: Pointer to the fitted function (the fit model) object.
option: The fitting option, with the following options:
W: Sets all weights to 1 for non empty bins; ignore error bars.
WW: Sets all weights to 1 including empty bins; ignore error bars.
I: Uses integral of function in bin instead of value at bin center.
L: Uses a log likelihood method (default is chi-square method). To be used when the histogram represents counts.
WL: Weighted log likelihood method. To be used when the histogram has been filled with weights different than 1.
P: Uses Pearson chi-square method. Uses expected errors instead of the observed one given by TH1::GetBinError() (default case). The expected error is instead estimated from the square-root of the bin function value.
Q: Quiet mode (minimum printing).
V: Verbose mode (default is between
S: The result of the fit is returned in the TFitResultPtr .
E: Performs better errors estimation using the Minos technique.
M: Improves fit results, by using the IMPROVE algorithm of TMinuit .
R: Uses the range specified in the function range.
N: Does not store the graphics function, does not draw.
0: Does not plot the result of the fit. By default the fitted function is drawn unless the option
+: Adds this new fitted function to the list of fitted functions (by default, the previous function is deleted and only the last one is kept).
B: Use this option when you want to fix one or more parameters and the fitting function is a predefined one, like
Note that in case of pre-defined functions, some default initial values and limits are set.
C: In case of linear fitting, do no calculate the chisquare (saves time).
F: If fitting a linear function (e.g.,
polN), switch to use the default minimizer (e.g., TMinuit ). By default,
polNfunctions are fitted by the linear fitter.
goption: The graphics option that is the same as TH1::Draw().
xxmax: Specifies the range over which to apply the fit.
Only the following options only apply for fitting histograms:
The following options only apply for TGraph::Fit:
EX0: When fitting a TGraphErrors or a TGraphAsymmErrors , the errors on the coordinates are not used in the fit.
ROB: Use the Robust fitting in case of linear fitting . Computes the LTS regression coefficients (robust (resistant) regression), using the default fraction of good points.
ROB=0.x: As above, but compute the LTS regression coefficients, using 0.x as a fraction of good points.
Using the TF1 function class
In the following section is described how to use the TF1 class that is used for fitting histograms and graphs.
Fitting 1-D histograms with pre-defined functions
- Use the TH1::Fit() method to fit a 1-D histogram with a pre-defined function. The name of the pre-defined function is the first parameter. For pre-defined functions, you do not need to set initial values for the parameters.
A histogram object
hist is fit with a Gaussian:
The following pre-defined functions are available:
gaus: Gaussian function with three parameters:
f(x) = p0*exp(-0.5*((x-p1)/p2)ˆ2)
expo: Exponential function with two parameters:
f(x) = exp(p0+p1*x)
polN: Polynomial of degree
Nis a number between 0 and 9:
f(x) = p0 + p1*x + p2*x2 +...
chebyshevN: Chebyshev polynomial of degree
Nis a number between 0 and 9:
f(x) = p0 + p1*x + p2*(2*x2-1) +...
landau: Landau function with mean and sigma. This function has been adapted from the
G110 denlan(see → TMath::Landau).
gausn: Normalized form of the Gaussian function with three parameters
f(x) = p0*exp(-0.5*((x-p1)/p2)ˆ2)/(p2*sqrt(2PI))
Fitting 1-D histograms with user-defined functions
You can create the
TF1 fitting function as follows:
from an existing expressions defined in TFormula (with and without parameters),
by defining your own function.
Creating a TF1 fitting function with a TFormula expression
constructor is used with the formula
constructor is used with the formula
x*sin(x) and two parameters.
The parameter index is enclosed in square brackets.
SetParameter() to set the initial values.
SetParameters() to set multiple parameters at once.
Creating a user TF1 fitting function
Double_t *x: Pointer to the variable array. This array must be a 1-D array with
v = x in case of a 1-D histogram,
v = y for a 2-D histogram, etc.
Double_t *par: Pointer to the parameter array.
par contains the current values of parameters when it is called by the
An 1-D histogram is fit with a user-defined function.
See also the
fitf function is used to fit the histogram.
Accessing the fitted function parameters and results
- Use the TH1::GetFunction() method to access the fitted function parameters.
Configuring the fit
The following configuration actions are available when fitting a histogram or graph using the
Fixing and setting parameter bounds
For pre-defined functions like
landau, the parameter initial values are set automatically.
For not pre-defined functions, the fit parameters must be initialized before invoking the
- Use the TF1::SetParLimits() method to set the bounds for one parameter.
When the lower and upper limits are equal, the parameter is fixed.
The parameter is fixed 4 at 10.
- Use the TF1::FixParameter() method to fix a parameter to 0.
You do not need to set the limits for all parameters.
There is function with 6 parameters. Then there is a setup possible like the following: parameters 0 to 2 can vary freely, parameter 3 has boundaries [-10, 4] with the initial value -1.5, and parameter 4 is fixed to 0.
By default, TH1::Fit() fits the function on the defined histogram range. You can specify the
R option in the second
TH1::Fit() to restrict the fit to the range specified in the TF1
The fit will be limited to -3 to 3, the range specified in the
You can also specify a range in the call to
See also the ROOT macros
multifit.C for more detailed examples.
Fitting multiple sub ranges
You can find a ROOT macro for fitting multiple sub ranges at
$ROOTSYS/tutorials/fit/multifit.C. It shows how to use several Gaussian functions
with different parameters on separate sub ranges of the same histogram.
Four TF1 objects are created, one for each sub range.
The histogram are filled with bins defined in the array
When fitting simple functions, such as a Gaussian, the initial values of the parameters are automatically computed. In the more complicated case of the sum of 3 Gaussian functions, the initial values of parameters must be set. In this particular case, the initial values are taken from the result of the individual fits.
Result of the fit
You can obtain the following results of a fit:
One or more objects (typically a
TF1\*) can be added to the list of functions (
fFunctions) associated to each histogram.
TH1::Fit() adds the fitted function to this list.
Given a histogram
h, you can retrieve the associated function with:
Accessing the fit parameters and results
If the histogram or graph is made persistent, the list of associated functions is also persistent.
Retrieve a pointer to the function with the TH1::GetFunction() method. Then you can retrieve the fit parameters from the function.
With the fit option
S, you can access the full result of the fit including the covariance and correlation matrix.
By default, for each bin, the sum of weights is computed at fill time. You can also call TH1::Sumw2() to force the storage
and computation of the sum of the square of weights per bin. If
Sumw2() has been called, the error per bin is computed
as the sqrt(sum of squares of weights). Otherwise, the error is set equal to the sqrt(bin content).
To return the error for a given bin number, use:
Empty bins are excluded in the fit when using the Chi-square fit method. When fitting an histogram representing
counts (this is with Poisson statistics) it is recommended to use the Log-Likelihood method (option
in case of low statistics.
You can change the statistics box to display the fit parameters with the TStyle::SetOptFit() method. This parameter has four digits:
mode = pcev (default = 0111)
p = 1: Print probability.
c = 1: Print Chi-square/number of degrees of freedom.
e = 1: Print errors (if e=1, v must be 1).
v = 1: Print name/values of parameters.
To print the fit probability, parameter names/values, and errors, use:
Using ROOT::Fit classes
- Fit method classes: Classes describing fit method functions like:
Fit data classes: Classes for describing the input data for fitting. These classes are, among others, ROOT::Fit::BinData, for binned data sets (data points containing both coordinates and a corresponding value/weight with optionally an error on the value or the coordinate), and ROOT::Fit::UnBinDatac, for un-binned data sets.
- User fitting classes: Classes for fitting a given data set.
Creating the input data
There are two types of input data:
- Binned data (ROOT::Fit::BinData): They are used for least square (chi-square) fits of histograms or TGraph objects.
- Un-binned data (ROOT::Fit::UnBinData): They are used for fitting vectors of data points, for example from a TTree [TTree].
Using binned data
- Use the ROOT::Fit::BinData class for binned data.
There is histogram, represented as a TH1
type object. Now a
ROOT:Fit::BinData object is created and filled.
By using ROOT::Fit::DataOptions you can specify the data range and some fitting options.
Using un-binned data
- Use the ROOT::Fit::UnBinData class for un-binned data.
For creating un-binned data sets, there are two possibilities:
- Copy the data inside a
Create an empty
ROOT::Fit::UnBinDataobject, iterate on the data and add the data point one by one. An input
ROOT::Fit::DataRangeobject is passed in order to copy the data according to the given range.
ROOT::Fit::UnBinDataas a wrapper to an external data storage.
In this case the
ROOT::Fit::UnBinDataobject is created from an iterator or pointers to the data and the data are not copied inside. The data cannot be selected according to a specified range. All the data points will be included in the fit.
ROOT::Fit::UnBinData supports also weighted data. In addition to the data points (coordinates), which
can be of arbitrary
k dimensions, the class can be constructed from a vector of weights.
Data are taken from a histogram (TH1 object).
Creating a fit model
The model function needs to be expressed as function of some unknown parameters. The fitting will find the best parameter value to describe the observed data.
You can for example use the TF1 class, the parametric function class to describe the model function. But the ROOT::Fit::Fitter class takes as input a more general parametric function object, the abstract interface class ROOT::Math::IParametricFunctionMultiDim. It describes a generic one-dimensional or multi-dimensional function with parameters. This interface extends the abstract ROOT::Math::IBaseFunctionMultiDim class with methods to set/retrieve parameter values and to evaluate the function given the independent vector of values X and vector of parameters P.
Configuring the fit
There the following fit configurations:
- Setting the initial values of the parameters.
- Setting the parameter step sizes.
- Setting eventual parameter bounds.
- Setting the minimizer library and the particular algorithm to use.
- Setting different minimization options (print level, tolerance, max iterations, etc. . . ).
- Setting the type of parameter errors to compute (parabolic error, minor errors, re-normalize errors using fitted chi2 values).
Setting the lower/upper bounds for the first parameter and a lower bound for the second parameter:
Performing the fit
Depending on the available input data and the selected function for fitting, you can use one of the methods of the ROOT::Fit::Fitter class to perform the fit.
The following pre-defined fitting methods are available:
Least-square fit: Fitter::LeastSquare(const BinData &) or Fitter::Fit(const Bindata &). Both methods should be used when the binned data values follow a Gaussian distribution. These fit methods are implemented using the class ROOT::Fit::Chi2FCN.
Binned likelihood fit: Fitter::LikelihoodFit(const Bindata &). This method should be used when the binned data values follow a Poisson or a multinomial distribution. The Poisson case (extended fit) is the default and in this case the function normalization is also fit to the data. This method is implemented by the ROOT::Fit::PoissonLikelihoodFCN class.
Un-binned likelihood fit: Fitter::LikelihoodFit(const UnBindata &). By default the fit is not extended, this is the normalization is not fitted to the data. This method is implemented using the LogLikelihoodFCN class.
Linear fit: A linear fit can be selected, if the model function is linear in the parameters.
The result of the fit is contained in the ROOT::Fit::Result object.
You can print the result of the fit with the FitResult::Print() method.