2.6. Functions
Table of Contents
Defining functions
Functions in C++ group a sequence of statements into a reusable block. In ROOT analysis you will often wrap parts of your code into functions so that you can call them many times without repeating the same lines.
A function has four essential parts: a return type, a name, a list of parameters in parentheses, and a body in curly braces. A very simple function that prints a message could look like this in a ROOT macro:
void Hello() {
std::cout << "Hello from ROOT!" << std::endl;
}
Here, void is the return type, Hello is the function name, the empty parentheses mean it takes no arguments, and the body is everything inside {}.
In a .C macro file you typically place function definitions at file scope, not inside other functions. ROOT’s C++ interpreter can then see them and you can call them from the ROOT prompt or from other functions in the same file. For example, you could put the definition of Hello in hello.C, start ROOT, and then type:
root [0] .L hello.C
root [1] Hello()
Hello from ROOT!A function body can contain any valid C++ statements: variable declarations, loops, conditionals, calls to ROOT classes, and so on. For example, a function that creates and draws a small histogram might look like:
void SmallHist() {
TH1F h("h", "Example histogram", 50, 0.0, 5.0);
h.Fill(1.0);
h.Fill(2.3);
h.Draw();
}
This defines a new function called SmallHist that you can call from ROOT to quickly create and display this histogram.
You can also forward declare functions before you define them. A declaration tells the compiler that a function exists and what its signature is, without giving the body. In simple ROOT macros you can often avoid separate declarations by putting your full function definitions before they are first used, that is, define helper functions above void main()-style entry functions such as void myAnalysis().
A function definition must specify the return type, the name, the full parameter list with types, and the body in {}. In a ROOT macro, define functions at file scope, above the code that calls them, to avoid missing-declaration problems.
Function arguments
Most useful functions need input values to work with. These inputs are called arguments, and in the function definition they are called parameters. Each parameter has a type and a name. When you call the function, you provide values, and those values are copied into the parameters.
Here is an example of a function that computes the area of a rectangle given its width and height:
double RectangleArea(double width, double height) {
double area = width * height;
return area;
}
In this example, width and height are parameters of type double. When you call this function, you pass two numbers:
double a = RectangleArea(3.5, 2.0); // width = 3.5, height = 2.0
The order of arguments matters. The first argument goes into the first parameter, the second into the second parameter, and so on. Types must be compatible with the parameter types. If you define a function that expects int and you pass a double, an implicit conversion may occur, which can lose information.
You can use different types for different parameters in one function. For example, in analysis code you might write:
void FillWithConstant(TH1F &hist, float value, int nTimes) {
for (int i = 0; i < nTimes; ++i) {
hist.Fill(value);
}
}
Here the function takes a histogram by reference, a floating point value, and an integer number of times. The & means the function can modify the original histogram object, not a copy. This is very common in ROOT when you want a function to fill or style objects that you created elsewhere.
C++ also supports default argument values in function declarations, which means you can omit some arguments when calling the function. For simple ROOT macros you might see:
void DrawGaussian(int nEvents = 1000) {
TH1F h("h", "Gaussian", 100, -5, 5);
for (int i = 0; i < nEvents; ++i) {
h.Fill(gRandom->Gaus(0, 1));
}
h.Draw();
}
You can call DrawGaussian() with no arguments, and nEvents will be 1000, or you can call DrawGaussian(5000) to override the default.
To summarize the basic rules, consider the following table:
| Concept | Example | Effect |
|---|---|---|
| Parameter type | double x | Function expects a double input |
| Multiple parameters | double f(int n, float x) | Function takes two inputs of different types |
| Reference parameter | TH1F &h | Function can modify the original histogram |
| Default argument | int nEvents = 1000 | Function can be called with or without this argument |
Function parameters must include both type and name, and the order and types of arguments in calls must match the parameter list. Use reference parameters like TH1F &h when you want to modify ROOT objects passed into your function.
Return values
The return value is the result that a function gives back to the caller. The type of this result is written before the function name in the definition. Inside the function body, the return statement provides the actual value.
We already saw a simple example:
double RectangleArea(double width, double height) {
double area = width * height;
return area;
}
Here, double is the return type, and the function returns the variable area. When you call this function, you can store its return value in another double:
double a = RectangleArea(3.5, 2.0);The type of the variable that receives the return value must be compatible with the function’s return type.
If a function should not return a value, you use the special return type void. In that case you usually omit return, except if you want to exit the function early:
void PrintIfPositive(double x) {
if (x <= 0) {
return; // exit without printing
}
std::cout << "x is positive: " << x << std::endl;
}Many ROOT-related functions return numbers that characterize objects, such as the mean of a histogram, or return pointers to created objects. For example:
TH1F* MakeEmptyHist(const char* name, const char* title,
int nBins, double xMin, double xMax) {
TH1F *h = new TH1F(name, title, nBins, xMin, xMax);
return h;
}
Here the return type is TH1F*, a pointer to a histogram. The function allocates a histogram and returns its pointer. The caller can then do:
TH1F *myHist = MakeEmptyHist("h1", "My hist", 100, 0.0, 10.0);
myHist->Draw();In this pattern you must understand ROOT’s object ownership rules, which are discussed in a later chapter, to avoid memory and lifetime problems.
You can also return bool to signal success or failure of an operation:
bool IsInRange(double x, double low, double high) {
return (x >= low) && (x <= high);
}
This function returns either true or false, which is very useful in selection logic for analysis.
For numerical functions, it is often helpful to document, in comments, what the return value represents and in which units. This is especially important in physics analysis to avoid mixing centimeters with millimeters or MeV with GeV.
The return type at the start of a function must match the type of the value supplied in return. Functions with non-void return types must return a value on every possible execution path. Use void for functions that only perform actions, and non-void types when you need a result to use later in your ROOT analysis.
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!