16.3. Simple Monte Carlo Simulation
Table of Contents
Generating events
A simple Monte Carlo simulation in ROOT follows a clear pattern. You define a model for how events should look, you generate many random events according to that model, and then you study the resulting distributions with histograms.
In ROOT, random numbers are produced by classes such as TRandom and TRandom3. For simple exercises it is common to create one global random generator and use it for the whole simulation. A minimal setup in a macro might look like:
void simple_mc()
{
TRandom3 rng(12345); // fixed seed for reproducibility
const Int_t nEvents = 100000;
// ... create histograms here ...
for (Int_t i = 0; i < nEvents; ++i) {
// generate one event here
}
}The important idea is that an "event" is one independent trial of your process. In a physics context one event could be a collision, a decay, or a single measurement. In a more abstract context an event could be one draw from a probability distribution.
Within the event loop, you use methods of rng to draw random numbers from the distributions that describe your model. For instance:
double x_uniform = rng.Uniform(0.0, 1.0); // uniform in [0, 1)
double x_gauss = rng.Gaus(0.0, 1.0); // Gaussian with mean 0, sigma 1
int n_poisson = rng.Poisson(3.0); // Poisson with mean 3
double t_exp = rng.Exp(2.0); // exponential with mean 2You can combine several random draws to represent more complex situations. For example, you might model a measurement as a "true" physical quantity plus a random Gaussian fluctuation that represents detector resolution:
double true_energy = rng.Exp(1.0); // true energy, exponential distribution
double measured_energy = rng.Gaus(true_energy, 0.1); // smear with sigma = 0.1In a simple Monte Carlo, each pass through the event loop corresponds to generating such quantities once and then recording them. The number of events is under your control. In most cases you choose it so that statistical fluctuations become small enough for your purpose. If the number of events is $N$, the typical relative statistical uncertainty on simple counts scales as $1/\sqrt{N}$.
In a Monte Carlo simulation each event must be statistically independent and generated from the correct underlying distribution. Reusing the same random number or introducing correlations that are not part of the model will distort the simulated distributions.
Filling histograms
Once you generate values event by event, you usually fill histograms to build the corresponding distributions. This lets you visualize the model and compare it with data later.
To prepare for this, create histograms before the event loop:
TH1D *h_true = new TH1D("h_true", "True energy;E_{true};Events", 100, 0.0, 5.0);
TH1D *h_meas = new TH1D("h_meas", "Measured energy;E_{meas};Events", 100, 0.0, 5.0);
TH1D *h_resid = new TH1D("h_resid", "Residuals;E_{meas} - E_{true};Events", 100, -1.0, 1.0);Inside the event loop you fill them:
for (Int_t i = 0; i < nEvents; ++i) {
double true_energy = rng.Exp(1.0);
double measured_energy = rng.Gaus(true_energy, 0.1);
double residual = measured_energy - true_energy;
h_true->Fill(true_energy);
h_meas->Fill(measured_energy);
h_resid->Fill(residual);
}
Each call to Fill() corresponds to one event contributing to the appropriate bin. The bin content is a count of how many events fall in that range. If you use weights, for example to represent variable event importance or cross sections, you can pass a second argument:
double weight = 0.5; // example weight
h_meas->Fill(measured_energy, weight);Weights are common when simulated events represent different amounts of real data. If you use weights, you should enable storage of proper bin errors before filling:
h_meas->Sumw2();After your event loop, you can draw the histograms on a canvas:
TCanvas *c1 = new TCanvas("c1", "Simple Monte Carlo", 800, 600);
h_meas->SetLineColor(kRed);
h_true->SetLineColor(kBlue);
h_true->Draw();
h_meas->Draw("SAME");
c1->Update();The whole structure of a simple Monte Carlo simulation is summarized as:
| Step | Example in ROOT |
|---|---|
| Create random generator | TRandom3 rng(seed); |
| Define histograms | new TH1D("name", "title", nbins, min, max); |
| Event loop | for (int i = 0; i < nEvents; ++i) |
| Generate event quantities | x = rng.Gaus(mean, sigma); |
| Fill histograms | hist->Fill(x); |
| Visualize results | hist->Draw(); |
Always create histograms before the event loop and fill them consistently inside the loop. Changing histogram binning or range after filling is not equivalent to regenerating the events and can misrepresent your simulated distribution.
Comparing simulated distributions
A key purpose of Monte Carlo is to compare your simulated distributions with expectations or with real experimental data. In simple exercises, this often means overlaying histograms or checking whether the shape matches an analytical probability density function.
To compare two histograms that represent the same physical quantity, such as a simulated distribution and a reference, you usually draw them on the same canvas and make sure they are normalized in a meaningful way. For example:
TCanvas *c2 = new TCanvas("c2", "Comparison", 800, 600);
h_true->SetLineColor(kBlue);
h_meas->SetLineColor(kRed);
// Option 1: compare raw counts
h_true->Draw("HIST");
h_meas->Draw("HIST SAME");If the total number of events is different in the two histograms, it is often better to normalize them to unit area before comparing shapes:
h_true->Scale(1.0 / h_true->Integral());
h_meas->Scale(1.0 / h_meas->Integral());After scaling, each histogram represents an estimate of the underlying probability density, up to bin width. If you want to make this explicit, you can divide by bin width as well, but for many beginner uses comparing unit-area histograms is sufficient.
You can also compare simulated distributions to known theoretical forms. For example, if you expect the measured energy residuals to follow a Gaussian, you can fit a Gaussian to the h_resid histogram and inspect the parameters:
h_resid->Fit("gaus");This gives you estimates of the mean and sigma from the simulation and lets you check whether they match the values you used as input.
More formal comparisons can rely on statistical tests, such as chi-square tests, that compare binned distributions or test a histogram against a known function. Even without formal tests, you can gain intuition by visually inspecting whether the simulated histogram follows the expected shape, where deviations occur, and how fluctuations decrease as you increase the number of events.
A simple workflow might be:
- Generate events according to a model.
- Fill histograms for observables of interest.
- Normalize histograms if you want to compare shapes.
- Overlay several histograms on the same axes.
- Optionally fit analytical functions to the histograms.
- Adjust your model if the simulated distributions do not match expectations.
When comparing simulated distributions, always ensure that you are comparing quantities with the same definition, units, and normalization. Misaligned definitions or inconsistent normalization can lead to incorrect conclusions about agreement or disagreement between models and data.
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!