KAHIBARO Bookshelves
Discord Login Register

25.9. Finding Coincidence Events

Coincidence Events in PET

In a PET simulation, coincidence events are the key link between individual detector hits and the reconstructed image. In Geant4, coincidences are not provided automatically. You must build coincidence logic on top of the hits you already record for each detector crystal.

This chapter focuses on how to identify coincidence events from detector hits and how to organize that information so that later steps, like building lines of response and image reconstruction, become straightforward.

What a Coincidence Event Is

In PET, a positron annihilates with an electron and produces two 511 keV photons. These photons travel in nearly opposite directions and may be detected in two different detector crystals. A coincidence event is a pair of detector hits that are interpreted as originating from the same annihilation.

Two ingredients define a coincidence:

  1. The two hits must be close in time, within a coincidence time window.
  2. The two hits must correspond to valid gamma detections, often within an energy window around 511 keV.

Later in the course you will use coincidence pairs to form lines of response, but here the goal is simply to find and record those pairs.

A coincidence event is usually defined by three rules:

  1. Two detector hits occur in different detectors.
  2. The time difference between the hits is less than a coincidence window $\Delta t_{\text{coin}}$.
  3. Each hit passes the energy selection (for example, within an energy window around 511 keV).
    Any pair that does not satisfy all three conditions must not be treated as a valid coincidence.

Timing Windows and Coincidence Logic

The central quantity in coincidence finding is the difference between the detection times of two hits. Each hit in your Geant4 simulation already has a time, typically derived from the global time of the step when the hit is recorded, or from a derived detector time that you define.

Given two hits with detection times $t_1$ and $t_2$, the coincidence condition in time is

$$
\Delta t = |t_1 - t_2| < \Delta t_{\text{coin}} ,
$$

where $\Delta t_{\text{coin}}$ is the coincidence time window. In real systems this can be a few nanoseconds or less. In your simulation you may choose a value that reflects your detector timing resolution.

Coincidence time rule
Two hits form a coincidence only if
$$
|t_1 - t_2| < \Delta t_{\text{coin}}.
$$
If you adjust $\Delta t_{\text{coin}}$ in your macros, make sure the same value is used in your analysis code, otherwise your coincidence selection will be inconsistent.

In a simple PET simulation, you often consider coincidences within the same Geant4 event. In that case, $t_1$ and $t_2$ are times within one simulated annihilation. For more advanced setups, such as continuous sources, you may simulate multiple annihilations in one event and must apply the timing window without relying on event boundaries.

When you implement coincidence logic, it helps to think in two coordinate systems:

Global time: the Geant4 global time of a hit, obtained from methods like GetGlobalTime(). This includes any delays between annihilation and detection.

Detector time: a shifted time that describes what the detector readout would see. You can build this from the global time plus simulated effects, such as light propagation delays or electronic shaping, which are introduced in other chapters.

For beginners, using the global time directly for coincidence logic is sufficient. You simply use the hit time stored in your hit class.

Implementing Coincidence Selection

Geant4 does not provide a coincidence finder, but it does provide all the ingredients you need. You typically implement coincidence selection in one of two places:

Within a user action that has access to all hits in an event, often EventAction.

In an analysis step after you have written all hits to a file, for example in ROOT.

For a first PET example it is often easier to implement coincidence logic inside EventAction, because you already have direct access to the hit collections for that event.

Accessing hits for a PET event

You already created a sensitive detector for the PET crystals and a hit class that stores, at a minimum, the detector ID, the energy deposited in that crystal, and the time of the hit. In your EndOfEventAction, you obtain the hit collection and loop over the hits.

In pseudocode, the logical steps look like this:

  1. Collect all hits in the PET detector for the current event.
  2. Apply an energy window to select valid gamma detections.
  3. Sort or group the remaining hits by their detection time.
  4. Form pairs of hits that satisfy the coincidence time condition.
  5. Reject pairs with hits in the same crystal, if your design requires distinct detectors.
  6. Store information about each valid pair as a coincidence event.

A simple way to manage step 4 is to consider all possible pairs of hits and check whether each pair satisfies the timing and detector conditions. For $N$ hits in the event, there are $N(N - 1)/2$ pairs. In typical PET events, $N$ is small, so this method is practical for a beginner example.

Single hit per detector and energy summation

In a physical detector, a single gamma may deposit its energy in several steps inside one crystal. In Geant4, that yields several hits or several steps. For coincidence logic you often want a single energy and time per detector.

You can achieve this by building one hit per detector crystal per event and accumulating energy in that hit. When a step occurs in a crystal:

If a hit for that crystal already exists in the current event, you add the new energy deposit to the hit and update the time if needed.

If not, you create a new hit, record the crystal ID, the energy, and the time.

By the end of the event, you have at most one hit per detector crystal. Coincidence logic then operates on detector level hits, not on individual steps.

If you design your hit class to already represent a full detector signal, then coincidence finding becomes much cleaner and more realistic.

Energy and Time Conditions for Coincidences

Coincidence selection almost always combines timing and energy requirements. You already defined an energy window to select gamma detections. Now you use that same energy window as a first filter before comparing times.

For a hit with measured energy $E$, a simple energy window around 511 keV is

$$
E_{\min} < E < E_{\max}.
$$

Only hits that pass this energy window are considered candidates for coincidence. In practice, $E_{\min}$ and $E_{\max}$ are chosen based on the detector energy resolution. You will explore this in more detail when applying detector effects and energy smearing.

The typical order of operations is:

  1. Start from all detector hits in the event.
  2. Discard hits outside the energy window.
  3. Work with the remaining hits to form coincidence pairs based on time.

You may also require that the energy in each hit is not too low to avoid random coincidences from noise or scattered photons.

A valid PET coincidence hit should satisfy both:

  1. Energy selection: $E_{\min} < E < E_{\max}$.
  2. Timing selection when paired: $|t_1 - t_2| < \Delta t_{\text{coin}}$.
    Skipping the energy filter can dramatically increase the rate of accidental coincidences.

In some PET systems, additional logic is applied to reduce ambiguities, such as requiring that an event has exactly two valid hits in the time window. You can experiment with these conditions as an extension to the basic example.

Storing Coincidence Information

Once you identify a pair of hits that forms a coincidence, you must decide what to store. Later chapters on lines of response and analysis with ROOT will use this stored information. A clean representation at this stage will simplify those steps.

For each coincidence event you typically want:

The detector ID of the first hit.

The detector ID of the second hit.

The energies of both hits.

The detection times of both hits, or at least their time difference.

The event ID, or some unique ID, for bookkeeping.

Optionally, the positions of the detector crystals, which can be reconstructed later from the detector IDs and geometry.

If you already use G4AnalysisManager, it is natural to define an ntuple that stores coincidence events. Each row of the ntuple corresponds to one coincidence pair. You fill this ntuple in EndOfEventAction, after you have built the coincidence list for that event.

A simple conceptual table for coincidence data could look like this:

Column nameDescription
eventIDGeant4 event number
detID1ID of first detector
detID2ID of second detector
E1Energy in first detector
E2Energy in second detector
t1Time of first detector hit
t2Time of second detector hit
dtTime difference, $t_2 - t_1$

With this information, later you can:

Reconstruct the geometry positions for each detector ID.

Check timing distributions and optimize the coincidence window.

Apply further selection cuts in external analysis tools, such as ROOT.

To avoid double counting, ensure that each detector pair is stored only once per coincidence. You can enforce an ordering rule, for example, always treat the hit with earlier time as hit 1, or always require detID1 < detID2.

Random and Multiple Coincidences

In an idealized simulation with a single annihilation per event and no background, every coincidence you find might be a true coincidence. In more realistic PET simulations, you must deal with random and multiple coincidences.

A random coincidence occurs when two unrelated gamma detections accidentally fall within the coincidence time window. Multiple coincidences occur when more than two detectors fire within the time window and several possible pairs could be constructed.

You can experiment with these effects even in a simple Geant4 simulation by increasing the activity of the positron source, or by grouping multiple annihilations into a single event.

To handle multiple hits in one event with coincidence selection, you may:

Allow all valid pairs within the time window and study how many pairs appear.

Impose a rule that only one pair is accepted per event, for example, the pair with the highest sum of energies or the smallest time difference.

Flag events with more than two valid hits and treat them separately in later analysis.

These choices replicate real system behaviors and can strongly influence image quality, but the underlying Geant4 implementation remains the same: you still operate on the set of hits, apply energy and time filters, and record pairs that satisfy your chosen rules.

Summary

Coincidence finding is the bridge from low level detector hits to PET specific observables. In your Geant4 PET simulation you identify coincidences by:

Building clear detector hits that store energy, time, and detector ID.

Selecting hits that pass an energy window around 511 keV.

Applying a coincidence time window to pairs of hits in different detectors.

Recording each valid pair as a coincidence event in an ntuple or other data structure.

With this machinery in place, the next steps, such as recording detector positions and creating lines of response, become an exercise in geometry and analysis rather than low level detector bookkeeping.

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

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