KAHIBARO Bookshelves
Discord Login Register

33.2. Optical Photons

Table of Contents

Optical photons in Geant4 represent visible and near visible light produced and transported inside a detector. They are treated differently from high energy particles such as gammas, electrons, or protons. For beginners, it is important to see optical photons as a special, low energy part of the simulation that is tightly coupled to materials, surfaces, and photodetectors.

In Geant4, an optical photon is a particle type, just like an electron or a proton. Its C++ definition is available through the class G4OpticalPhoton. You never construct this particle class directly. Instead, you use it through standard Geant4 mechanisms, such as defining it in your physics list and letting processes create and transport it.

Optical photons have energy, position, direction, polarization, time, and wavelength. However, the most common way to describe their interaction with materials is in terms of photon energy, usually given in electronvolts, rather than wavelength. Geant4 internally represents optical properties as functions of photon energy, so whenever you think of a wavelength in nanometers, you should convert it to an energy with the relation $E = hc/\lambda$.

In Geant4, optical properties must be tabulated as a function of photon energy, not wavelength. Always convert your wavelength dependent data to energy before defining material properties.

Unlike ionizing particles, optical photons do not deposit significant ionization energy in Geant4. They are used to model light transport, reflections, refractions, absorption, and detection at photodetectors. This is particularly important in scintillators, Cherenkov detectors, wavelength shifters, and optical fiber systems.

Geant4 uses dedicated optical processes for optical photons. These include bulk absorption, Rayleigh scattering, boundary processes at surfaces, and wavelength shifting if configured. These processes do not use the same physics lists as the electromagnetic interactions of charged particles. Instead, they rely on material and surface properties that you define in your geometry and materials description.

For an optical photon to exist in your simulation, there must be some process that creates it. In typical detector simulations, this is done by scintillation or Cherenkov processes associated with other charged particles. When a charged particle propagates through a scintillator material, the scintillation process creates optical photons. When it moves faster than the local phase velocity of light in a medium, the Cherenkov process can create optical photons. Both types of photons then propagate as separate tracks through your geometry.

Optical photons are tracked step by step in the same way as other particles. Each optical photon has its own G4Track, can cross volumes, and interacts with surfaces. However, optical tracking can be very time consuming, because you might produce thousands or millions of photons per event. You will often need to balance realism against computing time by choosing appropriate light yields, cutoffs, and simplifications.

Because optical photons are low energy, they are influenced strongly by material properties such as refractive index, absorption length, and scattering length. When a photon reaches a boundary between two volumes, the boundary process uses the refractive indices of the two media, and any defined optical surface, to decide if the photon is reflected, refracted, absorbed, or undergoes diffuse reflection. This means that careful definition of material and surface properties is essential for meaningful optical simulations.

Optical photons are especially important when you need to connect the energy deposited in a scintillator to a final measurable quantity such as the number of photoelectrons at a photodetector. While the physical processes that govern scintillation and Cherenkov light are defined elsewhere in the course, it is here that their products, the optical photons, are moved through your detector. You can follow their trajectories, count how many reach a detector, and study timing distributions.

Optical photon simulations can dramatically increase runtime. Always check whether full optical tracking is necessary for your study, and consider simplified models when timing or resource constraints are important.

In practice, working with optical photons means enabling optical physics in your physics list, defining material optical properties, and setting up optical surfaces and photodetectors. Once these are in place, Geant4 will automatically generate and track optical photons whenever the relevant processes are active. This enables detailed studies of light collection efficiency, timing, and spatial response in a wide variety of detectors without you having to manually manage every photon.

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