21.1. Monte Carlo Random Numbers
Table of Contents
Random engines
In Geant4, every Monte Carlo decision is based on calls to a random number generator. This includes choosing free paths between interactions, selecting which physical process happens, scattering angles, and energy shares between secondaries. Understanding how these numbers are produced is essential if you want to control reproducibility or debug your simulations.
Geant4 does not implement its own random algorithms. Instead, it uses the CLHEP random number package behind a common interface. The central access point is the singleton class G4Random. All random numbers used internally by Geant4 are drawn from the engine that is currently attached to G4Random.
The engine is the object that actually implements a particular random number algorithm. Typical CLHEP engines you may encounter are CLHEP::HepJamesRandom, CLHEP::RanecuEngine, or CLHEP::MTwistEngine. Each of them has its own internal state and period. For example, a Mersenne Twister engine such as MTwistEngine has a very long period and is suitable for large simulations, while other engines can be faster but with a shorter period.
You rarely need to choose a specific engine as a beginner, because Geant4 selects a reasonable default. However, it is important to know that the choice of engine and its state together determine the exact sequence of random numbers and therefore the exact microscopic sequence of events in your simulation.
The connection between Geant4 and the CLHEP engine can be summarized in three layers:
- The engine object, defined in CLHEP, which stores the internal random state and algorithm.
- The CLHEP distribution helpers, such as
CLHEP::RandFlat,CLHEP::RandGauss, which build specific distributions on top of the engine. - The Geant4
G4Randominterface, which provides static methods likeG4UniformRand()that many Geant4 classes use.
Inside your own user code, you can use the same random engine that Geant4 uses. The recommended way is to call
G4double x = G4UniformRand();
which returns a double in the interval $(0,1)$. This call is equivalent to using a CLHEP flat distribution bound to the current engine. By using G4UniformRand() instead of creating your own separate engine, you keep your code consistent with Geant4 and preserve the reproducibility that comes from having a single well defined random sequence.
Sometimes you may need other distributions, for example Gaussian-distributed errors or angular distributions. In that case, you can either build them from uniform numbers yourself or use CLHEP distribution classes directly, but still pointing them to the engine that Geant4 manages. For example:
CLHEP::RandGauss gaussEngine(G4Random::getTheEngine());
G4double smearedE = gaussEngine.shoot(meanE, sigmaE);
Here G4Random::getTheEngine() returns a pointer to the current engine, so calls to shoot consume numbers from the same sequence that Geant4 uses for geometry and physics choices.
Multithreading introduces another layer. In a multithreaded Geant4 application, each worker thread has its own random engine instance and its own state. This prevents race conditions and guarantees that individual threads can be seeded independently. The master thread typically initializes the engines or seeds for each worker. As a result, the total random sequence of a multithreaded job depends not only on seeds but also on how events are distributed across threads, which means exact bit-by-bit reproducibility between single-threaded and multithreaded runs is not guaranteed.
To summarize the practical points about random engines in Geant4:
You should rely on G4Random and G4UniformRand() instead of inventing an independent random source.
You should recognize that the engine type and its state determine the entire microscopic history of your simulation.
In multithreaded runs, engines are per thread, so state control and seeding are done per engine and per thread.
Important rule: Always use G4UniformRand() or CLHEP distributions tied to G4Random::getTheEngine() in your own code if you want your results to be reproducible and consistent with Geant4’s internal random usage.
Random seeds
The random seed initializes the internal state of the engine and thereby fixes the future sequence of random numbers. For a given engine and a given seed, the generated sequence is deterministic. This is the key to reproducible Monte Carlo simulations in Geant4.
When you start a Geant4 application without explicitly setting a seed, Geant4 may either use a default fixed seed or derive one from the system time, depending on how the application is written. For controlled studies, this is usually not enough, and you should take explicit control over the seeds.
Geant4 provides methods in G4Random to set and inspect seeds. The most common entry point in user code is the run action, because seeds should be fixed before events are generated. A typical pattern in your RunAction::BeginOfRunAction might look like this:
#include "Randomize.hh"
// ...
void MyRunAction::BeginOfRunAction(const G4Run*)
{
G4long seed = 123456; // choose a fixed value
CLHEP::HepRandom::setTheSeed(seed);
}
Here CLHEP::HepRandom::setTheSeed affects the engine that Geant4 uses through its interface. From this moment on, all random choices inside the run will follow the same sequence each time you execute the program with the same seed and the same configuration.
You can also use more than one number to initialize an engine state. Many CLHEP engines provide setSeeds(const long* seeds, int nSeeds), which lets you specify a vector of integers. This is especially useful in multithreaded runs, where each worker thread can be given a separate seed sequence:
G4long seeds[2];
seeds[0] = baseSeed + threadId;
seeds[1] = baseSeed + 1000*threadId;
CLHEP::HepRandom::setTheSeeds(seeds);In this example each thread gets a distinct seed pair, so its random sequence is independent from other threads. This independence is essential for correct statistics when you run the same simulation multiple times or on multiple cores.
There are also built in Geant4 macro commands that allow you to control seeds without recompiling. For instance, the command
/random/setSeeds s1 s2
sets the seeds of the current engine at runtime, with s1 and s2 as integer values. By including such commands in a macro file, you can run the same simulation many times with different seeds, such as in parameter scans or when estimating statistical uncertainties.
Saving and restoring random states is a useful technique when debugging a specific event. At the beginning of a run, you can ask the engine for its current state in ASCII form, write it to a file, and later reload it to reproduce exactly the same random sequence from that point onward. CLHEP provides functions like saveEngineStatus("fileName") and restoreEngineStatus("fileName"), which Geant4 mirrors with macro commands such as
/random/saveThisRun
/random/readFromFile fileNameUsing these, you can track a problematic event, store the random state before it occurs, and reproduce the simulation again and again with identical microscopic details.
From a statistical point of view, good seed management supports both reproducibility and independence. If you want to compare two different physics settings under identical random fluctuations, you can run both with the same seed. If you want statistically independent results for error estimation, use different seeds for each run or each batch job.
A simple pattern for independent batch runs is to take a base seed and add a run index:
G4long baseSeed = 98765;
G4long seed = baseSeed + runIndex;
CLHEP::HepRandom::setTheSeed(seed);
Here runIndex might be a number given on the command line or derived from a job ID. Each job then covers a different region of the engine sequence.
Important rules:
- Same engine, same seed, same application configuration implies an identical sequence of random numbers and therefore reproducible results.
- To obtain statistically independent runs, always vary the seeds, for example by using a different seed for each run or each worker thread.
By combining a clear understanding of random engines with explicit seed control, you can make your Geant4 simulations both reproducible when needed and statistically sound when you perform large studies.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to Geant4
- ☰ 1.1. What Is Geant4?
- ☰ 1.2. How Geant4 Works
- ☰ 1.3. Geant4 Simulation Structure
- ☰ 1.4. Geant4 and C++
-
- ☰ 2. Installing Geant4
- ☰ 2.1. Geant4 Requirements
- ☰ 2.2. Installing Geant4 on Linux
- ☰ 2.3. Installing Visualization Libraries
- ☰ 2.4. Verifying the Installation
- ☰ 2.5. Geant4 Example Applications
-
- ☰ 3. C++ Basics for Geant4
- ☰ 3.1. Classes and Objects
- ☰ 3.2. Inheritance
- ☰ 3.3. Pointers and References
- ☰ 3.4. Header and Source Files
- ☰ 3.5. Standard Library Containers
-
- ☰ 4. Creating Your First Geant4 Project
- ☰ 4.1. Project Structure
- ☰ 4.2. CMake Configuration
- ☰ 4.3. The Main Program
- ☰ 4.4. User Initialization Classes
- ☰ 4.5. Building and Running
-
- ☰ 5. Geant4 Units and Constants
- ☰ 5.1. Geant4 Unit System
- ☰ 5.2. Using Units in C++
- ☰ 5.3. Physical Constants
- ☰ 5.4. Printing Values with Units
-
- ☰ 6. Creating the Simulation World
- ☰ 6.1. DetectorConstruction
- ☰ 6.2. Solids
- ☰ 6.3. Logical Volumes
- ☰ 6.4. Physical Volumes
- ☰ 6.5. Creating the World Volume
-
- ☰ 7. Materials
- ☰ 7.1. Geant4 Materials
- ☰ 7.2. NIST Material Database
- ☰ 7.3. Common Materials
- ☰ 7.4. Creating Custom Materials
- ☰ 7.5. Detector Materials
-
- ☰ 8. Building Detector Geometry
- ☰ 8.1. Basic Geometrical Shapes
- ☰ 8.2. Boolean Solids
- ☰ 8.3. Positioning Volumes
- ☰ 8.4. Repeated Geometry
- ☰ 8.5. Detector Arrays
- ☰ 8.6. Geometry Overlap Checking
-
- ☰ 9. Geometry Visualization
- ☰ 9.1. Visualization in Geant4
- ☰ 9.2. Starting the Visualization System
- ☰ 9.3. Changing the View
- ☰ 9.4. Visualization Attributes
- ☰ 9.5. Displaying Particle Tracks
-
- ☰ 10. Primary Particle Generation
- ☰ 10.1. PrimaryGeneratorAction
- ☰ 10.2. Particle Gun
- ☰ 10.3. Particle Energy
- ☰ 10.4. Particle Position
- ☰ 10.5. Particle Direction
- ☰ 10.6. Common Particle Sources
-
- ☰ 11. General Particle Source
- ☰ 11.1. Introduction to GPS
- ☰ 11.2. Position Distributions
- ☰ 11.3. Angular Distributions
- ☰ 11.4. Energy Distributions
- ☰ 11.5. Configuring Sources with Macros
-
- ☰ 12. Physics Lists
- ☰ 12.1. What Is a Physics List?
- ☰ 12.2. Reference Physics Lists
- ☰ 12.3. Electromagnetic Physics
- ☰ 12.4. Gamma Interactions
- ☰ 12.5. Positron Physics
- ☰ 12.6. Hadronic Physics
- ☰ 12.7. Choosing a Physics List
-
- ☰ 13. Particle Tracking
- ☰ 13.1. Tracks
- ☰ 13.2. Steps
- ☰ 13.3. Energy Deposition
- ☰ 13.4. Track Status
- ☰ 13.5. Parent and Secondary Particles
-
- ☰ 14. User Actions
- ☰ 14.1. RunAction
- ☰ 14.2. EventAction
- ☰ 14.3. SteppingAction
- ☰ 14.4. TrackingAction
- ☰ 14.5. StackingAction
- ☰ 14.6. ActionInitialization
-
- ☰ 15. Sensitive Detectors
- ☰ 15.1. What Is a Sensitive Detector?
- ☰ 15.2. Creating a Sensitive Detector
- ☰ 15.3. Hits
- ☰ 15.4. Hit Collections
- ☰ 15.5. Assigning Sensitive Detectors
-
- ☰ 16. Recording Energy Deposition
- ☰ 16.1. Energy Deposition
- ☰ 16.2. Energy per Event
- ☰ 16.3. Energy per Detector
- ☰ 16.4. Energy Spectra
- ☰ 16.5. Detector Efficiency
-
- ☰ 17. Particle Position and Timing
- ☰ 17.1. Particle Position
- ☰ 17.2. Interaction Position
- ☰ 17.3. Global Time
- ☰ 17.4. Time of Flight
- ☰ 17.5. Detector Timing
-
- ☰ 18. Geant4 Analysis System
- ☰ 18.1. Introduction to G4AnalysisManager
- ☰ 18.2. Histograms
- ☰ 18.3. Ntuples
- ☰ 18.4. Filling Ntuples
- ☰ 18.5. Writing Output Files
- ☰ 18.6. Closing Analysis Files
-
- ☰ 19. Geant4 and ROOT
- ☰ 19.1. ROOT Output from Geant4
- ☰ 19.2. Reading Geant4 Output with ROOT
- ☰ 19.3. Plotting Energy Spectra
- ☰ 19.4. Event Analysis
- ☰ 19.5. Simulation-to-Analysis Workflow
-
- ☰ 20. Geant4 Macro Commands
- ☰ 20.1. Macro Files
- ☰ 20.2. Run Commands
- ☰ 20.3. Particle Source Commands
- ☰ 20.4. Visualization Commands
- ☰ 20.5. Controlling Simulations Without Recompiling
-
- ☰ 21. Random Numbers and Reproducibility
- ☰ 21.1. Monte Carlo Random Numbers
- ☰ 21.2. Setting Random Seeds
- ☰ 21.3. Running Independent Simulations
- ☰ 21.4. Reproducing an Event
-
- ☰ 22. Multithreading
- ☰ 22.1. Geant4 Multithreading
- ☰ 22.2. Running with Multiple Threads
- ☰ 22.3. Thread-Safe User Code
- ☰ 22.4. Analysis with Multithreading
- ☰ 22.5. Performance Considerations
-
- ☰ 23. Practical Example: Gamma-Ray Detector
- ☰ 23.1. Project Overview
- ☰ 23.2. Creating the World
- ☰ 23.3. Creating the Detector
- ☰ 23.4. Adding the Material
- ☰ 23.5. Creating a Gamma Source
- ☰ 23.6. Selecting Electromagnetic Physics
- ☰ 23.7. Recording Energy Deposition
- ☰ 23.8. Creating an Energy Spectrum
- ☰ 23.9. Simulating Detector Resolution
- ☰ 23.10. Analyzing the Spectrum with ROOT
-
- ☰ 24. Practical Example: Radiation Shielding
- ☰ 24.1. Project Overview
- ☰ 24.2. Creating the Source
- ☰ 24.3. Creating the Shield
- ☰ 24.4. Comparing Shielding Materials
- ☰ 24.5. Varying Shield Thickness
- ☰ 24.6. Recording Transmitted Particles
- ☰ 24.7. Calculating Transmission
- ☰ 24.8. Calculating Attenuation
- ☰ 24.9. Comparing Simulation Results
-
- ☰ 25. Practical Example: PET Scanner
- ☰ 25.1. Introduction to PET Simulation
- ☰ 25.2. Creating a PET Detector Ring
- ☰ 25.3. Creating Detector Crystals
- ☰ 25.4. Assigning Detector IDs
- ☰ 25.5. Creating a Positron Source
- ☰ 25.6. Simulating Positron Annihilation
- ☰ 25.7. Recording Detector Hits
- ☰ 25.8. Applying an Energy Window
- ☰ 25.9. Finding Coincidence Events
- ☰ 25.10. Recording Detector Positions
- ☰ 25.11. Creating Lines of Response
- ☰ 25.12. Saving PET Events to ROOT
- ☰ 25.13. Analyzing PET Data with ROOT
-
- ☰ 26. Practical Example: Proton Beam in Water
- ☰ 26.1. Project Overview
- ☰ 26.2. Creating the Water Phantom
- ☰ 26.3. Creating a Proton Beam
- ☰ 26.4. Selecting the Physics List
- ☰ 26.5. Recording Energy Deposition
- ☰ 26.6. Dividing the Phantom into Slices
- ☰ 26.7. Calculating Depth Dose
- ☰ 26.8. Observing the Bragg Peak
- ☰ 26.9. Plotting the Depth-Dose Curve
-
- ☰ 27. Detector Resolution and Smearing
- ☰ 27.1. Ideal vs Realistic Detector Response
- ☰ 27.2. Energy Resolution
- ☰ 27.3. Position Resolution
- ☰ 27.4. Time Resolution
- ☰ 27.5. Applying Detector Effects
- ☰ 27.6. Comparing Ideal and Smeared Results
-
- ☰ 28. Simulation Validation
- ☰ 28.1. Why Validate a Simulation?
- ☰ 28.2. Checking Geometry
- ☰ 28.3. Checking Energy Conservation
- ☰ 28.4. Comparing with Analytical Calculations
- ☰ 28.5. Comparing with Reference Data
- ☰ 28.6. Statistical Uncertainties
- ☰ 28.7. Number of Simulated Events
-
- ☰ 29. Improving Simulation Performance
- ☰ 29.1. Geometry Performance
- ☰ 29.2. Physics List Performance
- ☰ 29.3. Production Cuts
- ☰ 29.4. Reducing Unnecessary Output
- ☰ 29.5. Multithreading
- ☰ 29.6. Running Large Simulations
- ☰ 29.7. Parameter Scans
-
- ☰ 30. Debugging Geant4 Simulations
- ☰ 30.1. Compilation Errors
- ☰ 30.2. Geometry Errors
- ☰ 30.3. Overlapping Volumes
- ☰ 30.4. Missing Particles
- ☰ 30.5. Missing Energy Deposition
- ☰ 30.6. Physics List Problems
- ☰ 30.7. Sensitive Detector Problems
- ☰ 30.8. Empty Output Files
- ☰ 30.9. Segmentation Faults
- ☰ 30.10. Using Geant4 Verbose Output
-
- ☰ 31. Writing Better Geant4 Applications
- ☰ 31.1. Organizing Source Code
- ☰ 31.2. Separating Geometry and Analysis
- ☰ 31.3. Using Configuration Parameters
- ☰ 31.4. Avoiding Hard-Coded Values
- ☰ 31.5. Creating Reusable Detector Components
- ☰ 31.6. Naming Conventions
- ☰ 31.7. Documentation
- ☰ 31.8. Version Control with Git
-
- ☰ 32. Advanced Geometry
- ☰ 32.1. Parameterized Geometry
- ☰ 32.2. Replica Volumes
- ☰ 32.3. Nested Geometry
- ☰ 32.4. Complex Detector Arrays
- ☰ 32.5. Importing CAD Geometry
- ☰ 32.6. Exporting Geometry with GDML
-
- ☰ 33. Optical Photons
- ☰ 33.1. Introduction to Optical Physics
- ☰ 33.2. Optical Photons
- ☰ 33.3. Material Optical Properties
- ☰ 33.4. Scintillation Light
- ☰ 33.5. Optical Surfaces
- ☰ 33.6. Photodetectors
- ☰ 33.7. Counting Optical Photons
-
- ☰ 34. Medical Physics Applications
- ☰ 34.1. Geant4 in Medical Physics
- ☰ 34.2. Radiation Dose Simulation
- ☰ 34.3. PET Simulation
- ☰ 34.4. SPECT Simulation
- ☰ 34.5. Radiotherapy Simulation
- ☰ 34.6. Proton Therapy Simulation
- ☰ 34.7. Biological Tissue Materials
-
- ☰ 35. Final Project
- ☰ 35.1. Project Overview
- ☰ 35.2. Define the Simulation Goal
- ☰ 35.3. Create the Geometry
- ☰ 35.4. Define Materials
- ☰ 35.5. Configure the Particle Source
- ☰ 35.6. Select the Physics List
- ☰ 35.7. Implement Sensitive Detectors
- ☰ 35.8. Record Simulation Data
- ☰ 35.9. Run the Simulation
- ☰ 35.10. Analyze the Results with ROOT
- ☰ 35.11. Validate the Simulation
- ☰ 35.12. Create Scientific Figures
- ☰ 35.13. Document the Simulation
-
- ☰ 36. Appendices
- ☰ 36.1. Geant4 Class Cheat Sheet
- ☰ 36.2. Geant4 Units Cheat Sheet
- ☰ 36.3. Common Geant4 Macro Commands
- ☰ 36.4. Common Geometry Classes
- ☰ 36.5. Common Particle Definitions
- ☰ 36.6. Common Physics Lists
- ☰ 36.7. G4AnalysisManager Cheat Sheet
- ☰ 36.8. Common Visualization Commands
- ☰ 36.9. Common Geant4 Errors and Solutions
- ☰ 36.10. Recommended Geant4 Project Structure
- ☰ 36.11. Recommended Geant4 Simulation Workflow
-
Comments
Please login to add a comment.
Don't have an account? Register now!