19.4. Event Analysis
Table of Contents
Applying cuts
In ROOT, an event is usually represented by one entry in a TTree. When you analyze Geant4 results, you will often want to keep only events that satisfy certain physical or detector conditions. These conditions are called cuts. Conceptually, a cut is a logical expression that is either true or false for each event.
The simplest way to apply cuts in ROOT is through the TTree::Draw or TTree::GetEntry loop, using a selection string. Suppose your Geant4 application created a TTree called "Events" in a file "output.root" and that the tree contains branches such as "eventID", "edep", "x", "y", "z", "particle", and "time". In an interactive ROOT session you can apply cuts directly in a draw command:
Events->Draw("edep", "edep > 0");This fills a histogram with energy deposition only for events with strictly positive "edep". The second argument is the cut, written as a C++ boolean expression using branch names. You can combine several conditions:
Events->Draw("edep", "edep > 0 && x > -5 && x < 5 && z > 0");This cut keeps only events with nonzero energy deposit and with positions inside a specific region of the detector. Logical operators are written as in C++, such as "&&" for AND, "||" for OR, and "!" for NOT. Comparisons use ">", "<", ">=", "<=", and "==". You can also use mathematical functions, for example "sqrt(xx + yy) < 10" to select a cylinder of radius 10 around the beam axis.
Cuts are not limited to numeric variables. You can write conditions that depend on particle names or identifiers. If you stored particle type as a string branch "particle", you might write "particle == \"gamma\"" in a cut. If instead you stored integer PDG codes, you would use numeric comparisons such as "pdg == 11" for electrons.
ROOT lets you define named cuts to reuse them. In C++:
TCut centralRegion = "sqrt(x*x + y*y) < 10";
TCut energyCut = "edep > 0.1 && edep < 1.0";
Events->Draw("edep", centralRegion && energyCut);This is especially convenient when you analyze data from many files or run the same selection repeatedly. You can also combine cuts with weights, for example to form a weighted histogram:
Events->Draw("edep >> hWeighted(100,0,2)", "edep > 0 && weight", "goff");where "weight" is a branch that contains an event weight. The "goff" option disables graphics output and is useful in batch mode.
In more complex analyses you often write a dedicated C++ or Python script that loops over tree entries, evaluates cuts explicitly, and fills histograms or ntuples. In this case the logic looks like:
for (Long64_t i = 0; i < Events->GetEntries(); ++i) {
Events->GetEntry(i);
if (edep <= 0.1) continue;
if (fabs(z) > 50.0) continue;
// Fill histograms
}This approach gives you full control over selection flow and can be easier to maintain for long analyses.
Important rule: Always define and document cuts in physics terms first, then translate them into ROOT expressions. This reduces the risk of silently applying the wrong selection and misinterpreting your Geant4 simulation results.
When you design cuts, you should keep in mind that every cut removes events and therefore increases the statistical uncertainty of your remaining sample. It is useful to check how many events survive each stage of selection. A common pattern is to count entries before and after a cut with TTree::GetEntries:
Long64_t nAll = Events->GetEntries();
Long64_t nPass = Events->GetEntries("edep > 0.1");
double eff = double(nPass) / nAll;You can then quote the efficiency of each cut and understand how strongly you are filtering your sample.
There is an important distinction between event level cuts and object level cuts. An event may contain several detector hits or several tracks. If your tree structure stores hits in a separate TTree or as arrays within one entry, you should decide whether a cut applies to the event as a whole or just to a single hit. For example, you might want to keep all events that contain at least one hit with "edep > 0.5 MeV", but you still want to keep information about other hits in the same event. In that case, your selection code should test all hits before discarding the event.
In ROOT, cuts can also be used for projections. For instance, you can project a 2D correlation only for a subset of events:
Events->Draw("y:x", "edep > 0.2 && particle == 22");which creates a scatter plot of y versus x for gamma interactions with energy deposition above 0.2. Similarly, you can build conditional spectra such as "energy spectrum in a given detector module" by including the detector ID in the cut expression.
Key statement: Cuts define which subset of simulated events you interpret as "measured data". Changing cuts can strongly affect derived quantities such as efficiency, resolution, and background level, so treat them as part of the physics definition of your analysis.
Selecting particles
Geant4 simulations typically contain many particle types and interaction products, but for a given analysis only some of them are relevant. In ROOT, selecting particles means building cuts that keep only tracks, hits, or events associated with certain particle properties.
In your Geant4 application you usually decide how to encode particle identity in the output. Common choices are particle name as a string, PDG code as an integer, or separate flags indicating primaries and secondaries. For example, you might write a hit ntuple with branches called "pdg", "isPrimary", "parentID", and "trackID". During event analysis in ROOT you then use these branches in selection expressions.
If you store PDG codes, each particle type is identified by a unique integer. For common particles:
| Particle | PDG code |
|---|---|
| gamma | 22 |
| electron $e^-$ | 11 |
| positron $e^+$ | -11 |
| proton | 2212 |
| neutron | 2112 |
| muon $\\mu^-$ | 13 |
| muon $\\mu^+$ | -13 |
You can select only electrons with:
Hits->Draw("edep", "pdg == 11");or only gammas with:
Hits->Draw("edep", "pdg == 22");To group particles, you can combine conditions, for example to select all charged leptons:
Hits->Draw("edep", "pdg == 11 || pdg == -11 || pdg == 13 || pdg == -13");If you stored particle names as strings, selection uses string comparison:
Hits->Draw("edep", "particle == \"gamma\"");Be careful with spelling and capitalization. Particle names should be consistent with what your Geant4 code writes, for example "gamma", "e-", "proton", and not arbitrary labels.
Frequently you need to distinguish primary particles from secondaries. If you wrote a branch "parentID", where primary particles have "parentID == 0", you can select primaries with:
Tracks->Draw("energy", "parentID == 0");and secondaries with:
Tracks->Draw("energy", "parentID != 0");Alternatively you might store a boolean "isPrimary". Similarly, you can follow the ancestry of secondaries by recording parent and track IDs during simulation, then applying cuts such as "parentID == someTrackID" in ROOT.
For event level analyses, you might need to select events according to the presence of a given particle. Suppose you have an event TTree and a separate hits TTree. One approach is to loop over hits in C++, group them by eventID, and decide whether each event contains at least one particle of interest. You can then write out a new TTree that contains only those events, or define a boolean event flag branch such as "hasGamma". The ROOT logic then becomes straightforward:
Events->Draw("edep", "hasGamma");Another common pattern is to analyze only particles in a certain energy or angular range. In that case you combine particle selection with kinematic cuts. For example, to select forward protons:
Tracks->Draw("energy", "pdg == 2212 && theta < 20*TMath::DegToRad()");where "theta" is the polar angle in radians. You can also restrict to particles passing through specific detector elements using detector IDs.
Important rule: Always record enough information in your Geant4 ntuples to distinguish particle type and origin, for example PDG code and parent ID. Without this you will not be able to perform precise particle selection during ROOT event analysis.
When you build physics observables such as energy spectra, angular distributions, or time of flight histograms, particle selection is part of the definition of the observable. An "electron energy spectrum" must explicitly require "pdg == 11". A "prompt gamma time distribution" must include both particle identity and a timing cut, such as "pdg == 22 && time < 10 ns". In practice you will often write compact selection expressions like:
Hits->Draw("time", "pdg == 22 && edep > 0.05 && detectorID == 3");This selects gamma hits above a minimum energy threshold in one detector element.
If you have multiple detector regions with different materials, you might want to compare how different particles behave in each region. You can do so by filling separate histograms with different particle selections, or by using 2D plots with particle identity on one axis. Another useful technique is to overlay histograms for different particle types in one canvas, for instance electrons vs gammas, to study backgrounds and signal composition.
Finally, particle selection is tightly connected to background rejection. In realistic simulations, undesired particles may enter your sensitive volume. By selecting only the particle types and energies that correspond to your measurement, you can reduce simulated background contributions and obtain distributions that are easier to interpret and compare with experimental data.
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!