10.2. Built-in Functions
Table of Contents
Gaussian
ROOT provides several built‑in Gaussian function types that you can use directly with TF1, without writing any C++ code. The most common one is "gaus". When you create a TF1 like
TF1 *f = new TF1("f", "gaus", xmin, xmax);
ROOT interprets "gaus" as the standard Gaussian function
$$
f(x) = A \exp\left( -\frac{1}{2} \left( \frac{x - \mu}{\sigma} \right)^2 \right)
$$
with three parameters:
| Parameter index | Meaning |
|---|---|
| 0 | $A$ (normalization) |
| 1 | $\mu$ (mean) |
| 2 | $\sigma$ (width) |
You can set or read these parameters through the usual TF1 parameter methods that are introduced in the chapter on TF1. For example,
f->SetParameters(1.0, 0.0, 1.0); // A, mu, sigmasets a Gaussian with unit amplitude, centered at zero, with $\sigma = 1$. ROOT will later adjust these parameters automatically if you use the function as a fit model.
ROOT also provides variants that allow you to specify the parameters in the expression itself, but "gaus" is the basic building block that is most often used for fits to peaks in histograms, especially in particle and nuclear physics. When you fit, ROOT automatically prints the mean and sigma from the Gaussian parameters, which you can convert to physical quantities such as energy resolution or detector timing resolution.
In ROOT, the built‑in Gaussian "gaus" always has three parameters in the order: amplitude, mean, sigma. The mathematical formula is
$$
f(x) = p_0 \exp\left( -\frac{1}{2}\left( \frac{x - p_1}{p_2} \right)^2 \right).
$$
Polynomial
Polynomials are another important family of built‑in functions. ROOT uses the name "polN" for a polynomial of degree $N$. For example
TF1 *p1 = new TF1("p1", "pol1", xmin, xmax); // linear
TF1 *p2 = new TF1("p2", "pol2", xmin, xmax); // quadratic
TF1 *p5 = new TF1("p5", "pol5", xmin, xmax); // 5th degreeA polynomial of degree $N$ is defined as
$$
f(x) = \sum_{i=0}^{N} p_i x^i
$$
where $p_i$ are the TF1 parameters. For example, "pol1" corresponds to
$$
f(x) = p_0 + p_1 x
$$
and "pol2" corresponds to
$$
f(x) = p_0 + p_1 x + p_2 x^2.
$$
You control the coefficients through the TF1 parameter interface. For instance
p2->SetParameters(1.0, -0.5, 0.1); // p0, p1, p2creates the polynomial
$$
f(x) = 1.0 - 0.5 x + 0.1 x^2.
$$
Polynomials are widely used as simple background models. In many physics analyses a narrow signal peak modeled by a Gaussian sits on top of a slowly varying background modeled by a low order polynomial. In ROOT, you can combine a polynomial and a Gaussian by writing an expression like
TF1 *f = new TF1("f", "gaus(0) + pol1(3)", xmin, xmax);
which uses the first three parameters for the Gaussian, and the next two for the linear background. The exact syntax for parameter indexing is explained in more detail when custom function expressions are discussed, but the key point here is that "polN" gives you a ready made polynomial that you can include in such expressions.
The built‑in polynomial "polN" uses parameters as coefficients:
$$
f(x) = \sum_{i=0}^{N} p_i x^i.
$$
For "pol1" this is
$$
f(x) = p_0 + p_1 x.
$$
Exponential functions
ROOT also includes exponential functions as built‑in models. The most commonly used is "expo" which represents an exponential of a linear function in $x$:
TF1 *e = new TF1("e", "expo", xmin, xmax);
By definition in ROOT, "expo" corresponds to
$$
f(x) = \exp(p_0 + p_1 x)
$$
where $p_0$ and $p_1$ are the first two TF1 parameters. Very often, this is interpreted as
$$
f(x) = \exp(\ln A - \lambda x) = A e^{-\lambda x}
$$
so that $p_0 = \ln A$ and $p_1 = -\lambda$. In that case, $A$ is a normalization constant and $\lambda$ controls the slope or decay constant.
You can set starting values, for instance
e->SetParameters(std::log(100.0), -0.5); // p0 = ln(A), p1 = -lambdawhich creates approximately
$$
f(x) = 100.0\, e^{-0.5 x}.
$$
In many experimental situations, especially when modeling decays or attenuations, an exponential can appear on its own, or as part of a more complex model combined with other built‑in functions. For example, you might model a falling background under a peak with an exponential and the peak itself with a Gaussian. In ROOT, this can be written as
TF1 *f = new TF1("f", "gaus(0) + expo(3)", xmin, xmax);which uses parameters 0 to 2 for the Gaussian and 3 to 4 for the exponential.
The built‑in exponential "expo" in ROOT is defined as
$$
f(x) = \exp(p_0 + p_1 x).
$$
To obtain a form $A e^{-\lambda x}$, use $p_0 = \ln A$ and $p_1 = -\lambda$.
These built‑in Gaussian, polynomial, and exponential functions are designed to be combined and reused with TF1. They provide standard building blocks that you can quickly plug into your analyses and fits without having to reimplement common mathematical expressions.
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!