KAHIBARO Bookshelves
Discord Login Register

6.4. Physical Volumes

Positioning objects

A physical volume represents one concrete copy of a logical volume placed at a specific position and orientation inside another volume. In practical terms, it answers the question: “Where is this piece of detector located in the world or inside its mother volume?” While logical volumes describe shape and material, physical volumes describe placement.

Every physical volume has a mother volume. The mother is always a logical volume, and the placement defines how the daughter logical volume is embedded inside this mother. The coordinates of the placement are given in the coordinate system of the mother volume, not in global coordinates. This relative placement is the basic rule that builds geometric hierarchies in Geant4.

Geant4 uses a right handed Cartesian coordinate system. When you place a volume, you specify a translation vector and, optionally, a rotation. The translation defines the origin of the daughter’s local coordinate system relative to the mother’s local origin. The rotation defines how the daughter’s local axes are oriented relative to the mother’s axes. If you do not provide a rotation, the daughter shares the same orientation as the mother.

It is very important that a physical volume lies entirely inside its mother volume. Its solid must be fully contained within the mother’s solid, with no part extending outside. Volumes that touch or nearly touch the mother’s boundaries can cause numerical issues, so a small safety margin is usually maintained between daughter edges and mother boundaries.

All daughter physical volumes must be completely contained within their mother volume, without extending outside, and must not overlap each other.

When you build a world volume, you place it with a null mother pointer, so it defines the top of the hierarchy. All other volumes must have a mother, directly or indirectly, that ultimately belongs to this world.

The combination of many placements creates complex detectors. For instance, you may define one logical volume for a detector element and then create many physical volumes of that logical volume at different positions, forming an array. Each physical volume represents one concrete copy, but they all share the same shape and material definition. This reuse of logical volumes is both memory efficient and conceptually clean.

Because coordinates are always relative to the mother, transformations are nested. The global position of a point inside a daughter volume is obtained by applying the daughter transformation, then the mother transformation, and so on up to the world. Geant4 performs this transformation chain internally during tracking, so you normally specify only the local placement and let Geant4 handle global coordinates.

`G4PVPlacement`

The main class for placing a single copy of a volume is G4PVPlacement. It connects a logical volume to a mother logical volume and defines how it is located and oriented.

Conceptually, a G4PVPlacement object stores:
the rotation of the daughter relative to the mother,
the translation of the daughter origin in the mother coordinate system,
a pointer to the logical volume being placed,
a name that identifies this specific physical volume,
and a pointer to the mother logical volume.

The most commonly used constructor has the following structure, simplified here to highlight the essential parameters:

cpp
new G4PVPlacement(
    rotation,           // G4RotationMatrix* (or nullptr)
    translation,        // G4ThreeVector
    logicalDaughter,    // G4LogicalVolume*
    name,               // G4String
    logicalMother,      // G4LogicalVolume*
    false,              // pMany (obsolete in most simple uses)
    copyNo,             // G4int
    checkOverlaps       // G4bool
);

The rotation is usually a pointer to a G4RotationMatrix. If you pass nullptr, no rotation is applied and the daughter is aligned with the mother. The translation is a G4ThreeVector that sets the daughter’s origin relative to the mother’s origin. For example, G4ThreeVector(0, 0, 5*cm) shifts the volume 5 cm along the mother’s +z axis.

The logicalDaughter parameter is the logical volume you want to place. The logicalMother is the logical volume that will contain the daughter. The name is a label for this physical volume instance, and appears in visualization and in some debugging outputs.

The copy number is an integer that uniquely identifies this instance among other copies of the same logical volume inside the same mother. Geant4 uses this copy number when you want to know which specific detector element a step occurred in. For arrays or repeated structures, you normally assign each placement a distinct copy number, such as 0, 1, 2, and so on.

The last argument, checkOverlaps, controls an internal overlap check. If it is set to true, Geant4 will perform a basic test to detect whether the new placement overlaps with other volumes. This is very helpful during geometry development and debugging.

Use unique copy numbers for different physical instances of the same logical volume in the same mother, and enable overlap checking during development to detect geometry problems.

Typical usage in the Construct() method of your detector construction class looks like this:

cpp
auto rotation = nullptr;  // no rotation
G4ThreeVector position(0., 0., 2.0*cm);
new G4PVPlacement(
    rotation,
    position,
    logicDetector,        // daughter
    "DetectorPV",         // name
    logicWorld,           // mother
    false,
    0,                    // copy number
    true                  // check overlaps
);

In this example, the detector logical volume logicDetector is placed 2 cm along the z axis inside the world logical volume logicWorld, without rotation. Its physical volume is called "DetectorPV", and its copy number is 0.

If you want to place several identical detector elements, you can call G4PVPlacement multiple times with different translations and copy numbers, while reusing the same logical volume. This pattern is common when building simple arrays without using more advanced replication or parameterization features, which are covered elsewhere.

G4PVPlacement is the simplest bridge between your abstract geometry description and the concrete layout in space. Once placements are defined, Geant4 uses them internally to locate particles, navigate between volumes, and evaluate interactions within your detector.

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