KAHIBARO Bookshelves
Discord Login Register

24.9. Comparing Simulation Results

Looking at Results from Different Shielding Configurations

In a radiation shielding study you do not just want plots from a single configuration. The real goal is to compare how different materials and thicknesses perform under the same irradiation conditions, and to understand what those differences mean physically. This chapter focuses on how to compare results from your shielding simulations in a clear and quantitative way once each configuration has already been simulated and you have transmission or attenuation values available.

Normalizing Results Across Simulations

Before comparing shielding configurations you must ensure that the results from different simulations can be put on the same scale. In a Monte Carlo simulation the most natural normalization is the number of primary particles fired at the source.

If you denote by $N_\text{inc}$ the number of incident primary photons simulated for a given run, and by $N_\text{det}$ the number of particles transmitted through the shield and recorded in your scoring region, the basic transmission is
$$
T = \frac{N_\text{det}}{N_\text{inc}}.
$$

For a meaningful comparison between different shields, always compare dimensionless quantities, such as:

  1. Transmission: $T = N_\text{det} / N_\text{inc}$
  2. Attenuation factor: $A = 1 / T$
  3. Attenuation coefficient: $\mu$ extracted from $T = e^{-\mu x}$
    Never compare raw counts from simulations with different $N_\text{inc}$ or different scoring definitions.

If you used the same number of primary particles and identical source and detector definitions in all runs, then you can safely compare $N_\text{det}$ directly across runs because the normalization is implicit. However, computing and storing $T$ explicitly in your analysis code avoids confusion and helps later when you overlay results from several runs on the same plot.

When your analysis includes energy information, for example transmitted energy spectra, you should still normalize those spectra in a consistent way. A simple choice is to divide each histogram bin content by $N_\text{inc}$ so that the vertical axis represents a probability per event or per primary rather than a raw count.

Comparing Different Shielding Materials

If you have simulated several materials at the same thickness, for example lead, aluminum, and concrete slabs of a fixed thickness, you can compare their performance in a straightforward way. The essential question is: for the same incident radiation, which material reduces the flux more efficiently?

A simple comparison table might look like this:

MaterialThickness $x$ (cm)Transmission $T$Attenuation $1 - T$
Lead2.00.050.95
Aluminum2.00.400.60
Concrete2.00.300.70

From this type of summary you can already see which material gives the lowest transmission for the same thickness. If your simulation also records energy deposition in a detector behind the shield, you can create a similar table using deposited dose or average deposited energy per incident photon instead of transmission.

It is often useful to connect your simulation results with the exponential attenuation model that is frequently used in shielding calculations. For a monoenergetic beam and a uniform slab, the transmission is approximated by
$$
T(x) = e^{-\mu x},
$$
where $x$ is the shield thickness and $\mu$ is the linear attenuation coefficient of the material for the given photon energy.

From a single simulation at thickness $x$ you can extract an effective attenuation coefficient by rearranging this formula:
$$
\mu_\text{eff} = -\frac{1}{x}\,\ln T(x).
$$

If you do this for each material, you can present a comparison like:

MaterialThickness $x$ (cm)Transmission $T$$\mu_\text{eff}$ (cm$^{-1}$)
Lead2.00.05$\mu_\text{Pb}$
Aluminum2.00.40$\mu_\text{Al}$
Concrete2.00.30$\mu_\text{conc}$

Even though your Geant4 simulation uses detailed physics and multiple interaction mechanisms, this effective coefficient helps relate the results to simple analytical formulas and to reference shielding data.

When comparing different materials, pay attention to the shape of the transmitted energy spectra as well as overall transmission. High‑Z materials such as lead tend to produce more high‑energy scattered photons and characteristic X rays, while lower‑Z materials often produce broader Compton‑scattered spectra. Geant4 can show these differences directly in the spectra recorded in your scoring region.

Comparing Different Shield Thicknesses

When you simulate several thicknesses of the same material, you can study how the transmission changes with thickness and check how well it follows the expected exponential trend. For example, you might simulate thicknesses $x = 0, 1, 2, 5, 10$ cm and compute transmission for each.

A convenient way to present the results is a plot of $T(x)$ versus $x$ for a given material. If the incident beam is approximately monoenergetic and narrow, you will often see a roughly exponential decrease of $T$ on a linear scale. On a semi‑logarithmic plot where you show $\ln T$ versus $x$, an ideal exponential attenuation would appear as a straight line. You can compare your Geant4 data points with such a line extracted from a fit or from reference values of $\mu$.

If you have simulated several materials at multiple thicknesses, you can overlay curves of $T(x)$ for each material. The result might look conceptually like this: at $x = 0$ cm all curves start at $T = 1$, and as $x$ increases lead drops the fastest, then concrete, then aluminum. You can use the same approach for other quantities such as transmitted dose.

To compare thickness performance in a more compact way, you can present half‑value layer (HVL) and tenth‑value layer (TVL) extracted from your simulation. The HVL is defined as the thickness for which the transmission is $T = 0.5$, and the TVL for $T = 0.1$. From your discrete simulation points you can estimate these values, for example by interpolating between thicknesses where the transmission crosses 0.5 or 0.1. Then you can compare which material achieves the same transmission with a smaller thickness, which is often a practical design question.

Including Statistical Uncertainties

Because Geant4 uses Monte Carlo sampling, every quantity you compute from the simulation has a statistical uncertainty that depends on the number of events. When comparing different shielding configurations, you should include these uncertainties to know whether an observed difference is statistically meaningful.

For a simple count $N_\text{det}$ with $N_\text{inc}$ primaries, if each primary has a probability $T$ of being transmitted, then the distribution of $N_\text{det}$ is approximately binomial. For large $N_\text{inc}$ and small $T$, it is also well approximated by a Poisson distribution. In either case, the variance on $N_\text{det}$ is roughly
$$
\sigma_{N_\text{det}}^2 \approx N_\text{det},
$$
so the standard deviation is $\sigma_{N_\text{det}} \approx \sqrt{N_\text{det}}$.

The transmission $T = N_\text{det} / N_\text{inc}$ then has an uncertainty
$$
\sigma_T = \frac{\sigma_{N_\text{det}}}{N_\text{inc}} \approx \frac{\sqrt{N_\text{det}}}{N_\text{inc}}.
$$

If you use an attenuation coefficient extracted from $T$, the uncertainty propagates through the logarithm. With
$$
\mu_\text{eff} = -\frac{1}{x}\,\ln T,
$$
the standard error on $\mu_\text{eff}$ is
$$
\sigma_{\mu_\text{eff}} = \frac{1}{x}\,\frac{\sigma_T}{T}.
$$

Whenever you present transmission or attenuation curves from Monte Carlo simulations, include error bars based on the statistical uncertainties. Do not over‑interpret small differences between configurations when the error bars overlap significantly.

In practice, you can compute these uncertainties during the analysis stage using the accumulated counts from your runs, or you can use the error handling built into the Geant4 analysis system for histograms and profiles.

When you compare two shield configurations, for example two materials at the same thickness, and their transmissions are $T_1 \pm \sigma_{T_1}$ and $T_2 \pm \sigma_{T_2}$, you can estimate the significance of their difference as
$$
\Delta T = T_1 - T_2,
$$
with an uncertainty
$$
\sigma_{\Delta T} = \sqrt{\sigma_{T_1}^2 + \sigma_{T_2}^2}.
$$

If $|\Delta T|$ is smaller than or comparable to $\sigma_{\Delta T}$, then the two results are statistically compatible at the level of your simulation statistics.

Visual Presentation of Shielding Performance

Once you have normalized results and uncertainties for different materials and thicknesses, the last step is to present them in a way that is easy to interpret. This is especially important when the shielding study is intended to guide design decisions.

Typical visualizations include transmission versus thickness plots with different materials shown as separate curves, dose behind the shield as a function of thickness, and bar charts of $1 - T$ for a fixed thickness comparing materials. When energy information is available, comparative spectra of transmitted photons for different shields can reveal how the shield changes the radiation quality. For example, you might see that one material suppresses the primary peak effectively but produces a noticeable secondary peak at lower energies from scattered photons.

In all such comparisons, clearly label the incident beam conditions, such as photon energy and beam geometry, so that the viewer understands that all curves correspond to identical source definitions and scoring conditions. You can then point out patterns, such as which material achieves a certain transmission at the smallest thickness, or how much thicker a lighter material must be to match the attenuation of a denser one.

By combining normalized quantities, effective attenuation parameters, statistical uncertainties, and clear visualizations, you can extract meaningful conclusions from your Geant4 shielding simulations, and you can compare different design options with confidence based on the same underlying Monte Carlo model.

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