2.5. Loops
Table of Contents
for loops
Loops let you repeat a block of code many times without writing it over and over. In C++ the most common loop in ROOT-style analysis code is the for loop. It is especially useful when you know exactly how many times you want to repeat an operation, for example when you process all bins of a histogram or all elements of an array.
The general form of a for loop in C++ is:
for (initialization; condition; update) {
// code to repeat
}The three parts inside the parentheses control the loop:
- The initialization runs once before the loop starts, typically to declare and set a counter variable.
- The condition is checked before every iteration. If it is
true, the loop body runs. If it isfalse, the loop stops. - The update runs after each iteration, usually to change the counter variable.
A very common pattern is counting from zero up to, but not including, some upper limit N:
int N = 10;
for (int i = 0; i < N; ++i) {
cout << "i = " << i << endl;
}
Here i starts at 0, the loop continues while i < N, and ++i increases i by 1 after each iteration. This prints the values 0 through 9.
Important rule: In C++ arrays and many ROOT collections are indexed starting at 0. A loop that visits all elements usually goes from index 0 to N - 1 with a condition like i < N, not i <= N.
Inside a for loop you can use any valid C++ statements, including if conditions, arithmetic operations, function calls, and ROOT commands. For example, you can use a for loop directly in the ROOT interactive shell:
root [0] for (int i = 0; i < 5; ++i) {
root [1] cout << "Hello " << i << endl;
root [2] }
You can also use break and continue to control the loop more precisely. break stops the loop immediately, and continue skips the rest of the current iteration and goes on to the next one.
for (int i = 0; i < 10; ++i) {
if (i == 3) continue; // skip printing 3
if (i == 7) break; // stop completely when i is 7
cout << i << endl;
}
In ROOT analysis code, for loops are heavily used to iterate over known ranges such as bins of a histogram, indices in a C++ array, or elements of a std::vector when you want explicit control over the index.
while loops
A while loop repeats code as long as a condition remains true. It is most useful when you do not know in advance how many iterations you will need. Instead, the loop depends on some condition that can change in complex ways inside the loop body.
The general form is:
while (condition) {
// code to repeat
}
The condition is checked before each iteration. If it is true, the body runs. If it is false, the loop stops and execution continues after the loop.
For example, consider a simple counter:
int i = 0;
while (i < 5) {
cout << "i = " << i << endl;
++i;
}
This produces the same output as the previous for example. The important difference is that the initialization (int i = 0) is outside the loop header, and the update (++i) appears inside the loop body. With a while loop it is your responsibility to make sure that the condition eventually becomes false, otherwise the loop will run forever.
Important rule: Always ensure that something inside a while loop changes the variables used in the condition in a way that makes the condition false at some point, otherwise you create an infinite loop.
A while loop is especially natural when you are reading data until there is nothing left. For example, when reading lines from a text file, you often do not know the number of lines in advance, so a while loop that checks for end of file is a good choice.
C++ also has a do { ... } while (condition); loop, where the body is executed at least once before the condition is checked, but that form is used less often in typical ROOT analysis code. Most of the time you will work with for and while loops.
Just like in for loops, you can use break to exit early and continue to skip to the next iteration. while loops appear in many ROOT macros to repeat operations until a certain analysis condition is met, such as reading all events, processing input from a file, or waiting until a counter reaches a threshold.
Looping over data
In ROOT analysis you repeatedly perform the same calculation for many data items, such as events in a TTree, bins in a histogram, or elements in a C++ container. Loops are the tool that lets you express these repetitive operations clearly and compactly.
A typical pattern in beginner macros is to loop over a simple C++ array. Suppose you have an array of ten values and you want to print them:
double values[10] = {1.2, 3.4, 2.2, 5.0, 4.1, 6.3, 7.7, 8.8, 9.0, 0.5};
for (int i = 0; i < 10; ++i) {
cout << "values[" << i << "] = " << values[i] << endl;
}
Here the loop index i selects each element. This is exactly the same pattern you will use later with histogram bin indices or with vector indices.
When you work with standard C++ containers such as std::vector, you often have a variable that stores the number of elements, and you use that size in the loop condition:
std::vector<double> energy;
energy.push_back(10.5);
energy.push_back(12.3);
energy.push_back(9.8);
for (int i = 0; i < energy.size(); ++i) {
cout << "energy[" << i << "] = " << energy[i] << endl;
}In ROOT, many operations on data combine loops with simple arithmetic or conditions. For example, you might compute the sum of an array of measurements:
double sum = 0.0;
for (int i = 0; i < 10; ++i) {
sum += values[i];
}
cout << "Sum = " << sum << endl;Or you might count how many values pass a simple cut:
int count = 0;
for (int i = 0; i < 10; ++i) {
if (values[i] > 5.0) {
++count;
}
}
cout << "Number of values > 5 = " << count << endl;These simple examples mirror real analysis tasks, where you will loop over events, apply selection criteria, and update counters or histograms. You can already see the structure that you will reuse when you fill histograms, select events, or process TTrees in later chapters.
Important pattern: Loop over all data items, apply selection conditions with if, and update accumulated quantities such as sums, counters, or histogram fills inside the loop.
By becoming comfortable with for and while loops on basic C++ data, you prepare yourself to understand the larger event loops and data processing structures that are central to 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!