10.5. Function Integrals
Table of Contents
Numerical integration
In ROOT, function integrals are usually computed through the TF1 class. Whenever you integrate a function numerically, you are approximating the area under a curve by evaluating the function at many points and combining these values according to some numerical algorithm. ROOT hides most of this complexity behind simple methods, but it is important to understand the basic usage pattern.
For a TF1 named f, the most common way to perform a numerical integration is to use the Integral method. You provide a lower and an upper bound, and ROOT returns a double that approximates the integral
$$
\int_{x_{\text{min}}}^{x_{\text{max}}} f(x)\,\mathrm{d}x.
$$
For example, if you have defined a Gaussian function:
TF1 *gaus = new TF1("gaus","gaus", -5, 5); // built-in Gaussian
gaus->SetParameters(1.0, 0.0, 1.0); // amplitude, mean, sigmayou can compute its integral between -1 and 1 as follows:
double area = gaus->Integral(-1.0, 1.0);The result is a numerical approximation. ROOT chooses the integration step sizes internally, and adapts them to the shape of the function. This is usually sufficient for smooth functions, which are the typical case for physics models.
There is an important distinction between integrating a pure mathematical expression and integrating a function that internally calls more complex C++ code. TF1 can represent both. When you define a function using a formula string, such as "sin(x)/x", ROOT uses a fast internal evaluator. When you define a function from a user C++ function, ROOT calls your function at many x-values during the integration. Either way, the interface through Integral is the same.
If your function depends on parameters, such as a Gaussian with amplitude, mean, and sigma, the integral automatically uses the current parameter values stored in the TF1. You can modify parameters with SetParameter or SetParameters and then call Integral again to see how the integral changes.
The integration limits that you pass to Integral do not have to match the range that you used when creating the TF1. You can integrate over any subrange or a larger range, for example
double full = gaus->Integral(-5.0, 5.0); // more than the definition rangeROOT will still evaluate the function at the requested x values.
For some functions, especially those with sharp peaks or non-smooth behavior, default numerical settings might not be precise enough. TF1 offers variants of Integral that accept additional arguments, where you can control the maximum allowed relative and absolute error, and the maximum number of function evaluations. These are more advanced and typically become relevant only in precision studies or complicated models.
Whenever you rely on a numerical integral for a physics result, you should develop the habit of checking its stability. You can compare integrals computed with slightly different accuracy settings, or compare with an approximate analytical result when it is available. ROOT does not warn you automatically if the integration was difficult, so this manual cross check is good practice.
For a TF1 named f, the basic numerical integral over a range is obtained with
double I = f->Integral(xmin, xmax);
which approximates
$\displaystyle I \approx \int_{x_{\min}}^{x_{\max}} f(x)\,\mathrm{d}x.$
Calculating areas
In many analyses, an integral is interpreted as an area: for example, the area under a peak in a distribution, or the total probability in a given interval. TF1 is often used to model such peaks, and integration is then used to extract physical quantities like yields or probabilities.
When you use a normalized function, the total area over the full range is 1. For example, the standard Gaussian probability density function
$$
g(x) = \frac{1}{\sqrt{2\pi}\sigma} \exp\left(-\frac{(x-\mu)^2}{2\sigma^2}\right)
$$
is normalized so that
$$
\int_{-\infty}^{\infty} g(x)\,\mathrm{d}x = 1.
$$
If your TF1 represents a properly normalized probability density, then the integral between two values $a$ and $b$ gives the probability that the variable lies in that interval:
$$
P(a < X < b) = \int_a^b g(x)\,\mathrm{d}x.
$$
In ROOT, this is simply:
double prob = g->Integral(a, b);When your function has a free normalization parameter, the integral represents an expected count or yield instead of a probability. For instance, suppose you fit a Gaussian to a histogram of events and the Gaussian amplitude parameter is proportional to the number of events in the peak. The integral of the fitted function over an interval around the peak is then the estimated number of events in that region. This is a standard way to extract signal yields from background models.
Often, you will compare the area in a subrange to the total area. This gives a fraction, for example the fraction of events in a signal window relative to the total modeled events:
double total = f->Integral(xmin_total, xmax_total);
double window = f->Integral(xmin_win, xmax_win);
double fraction = window / total;This is especially useful for efficiency calculations, where the function represents an ideal distribution and you want to know what fraction lies inside a detector acceptance or selection cut. The key point is that you interpret the integral as an area, and the ratio of areas as an efficiency or probability.
A frequent practical task is to convert between a function area and a histogram count. If you have a histogram with bin width $\Delta x$ and bin content $N_i$ in bin $i$, then the total number of entries in a range is approximately the sum of bin contents in that range. The integral of a TF1 fitted to that histogram should match this sum if the function parameters have been chosen appropriately. Integration helps you translate the smooth fitted curve into a count that is comparable to your discrete histogram data.
Another common area calculation is normalization. Suppose you have defined a function that is not normalized. You can compute its integral over some range, and then divide the function by that integral so that the new function has unit area in that range. In code, you can retrieve the integral and then scale the function using SetParameter or by creating a new TF1 that multiplies the original expression by a constant factor. This is the basic idea behind building probability density functions from arbitrary shapes.
Finally, note that TF1 provides methods closely related to integrals, such as IntegralError, which propagate parameter uncertainties into an uncertainty on the integral. This allows you to attach an error estimate to your area, which is essential when the area is used as a physics result, for example a measured cross section or branching ratio.
Interpreting TF1 integrals as areas:
- If $f(x)$ is a probability density normalized to 1, then
$\displaystyle \int_a^b f(x)\,\mathrm{d}x$ gives the probability for $x$ in $[a,b]$. - If $f(x)$ is scaled to match event yields, then
$\displaystyle \int_a^b f(x)\,\mathrm{d}x$ gives the expected number of events in $[a,b]$. - Fractions and efficiencies are computed as ratios of integrals,
for example $f_{\text{frac}} = \dfrac{\int_a^b f(x)\,\mathrm{d}x}{\int_{x_{\min}}^{x_{\max}} f(x)\,\mathrm{d}x}$.
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!