28.2. Checking Geometry
Table of Contents
Why Geometry Checking Matters
Geometry mistakes are among the most common and most frustrating problems in Geant4. A tiny overlap, a misplaced rotation, or a wrong hierarchy can silently distort your physics results. Before trusting any simulation output, you should deliberately test and validate the geometry.
Geometry validation focuses on two questions. First, is the geometry internally consistent for the Geant4 kernel, with no overlaps or illegal configurations. Second, is the geometry the one you actually intended to build, with the right dimensions, positions, and materials.
In practice, you will combine visual inspection, built‑in overlap checks, and simple physical tests to gain confidence in your setup.
Always validate geometry before you interpret physics results. Undetected overlaps or wrong dimensions can change step lengths, material assignments, and interaction probabilities in subtle ways.
Visual Inspection of the Geometry
The first line of defense is to look at the geometry in a viewer. Visualization will not prove correctness, but it will often reveal large mistakes quickly.
After you have constructed your geometry and initialized the run manager, open a visualization driver and draw your geometry. For example, with OpenGL and a typical interactive session, you can use macro commands like /vis/open and /vis/drawVolume. In your first checks, show only a few key volumes instead of the full detector, for instance the world, the main detector, and a shielding layer. This avoids clutter that can hide problems.
Carefully inspect positions and orientations. If you place a cylindrical detector that should be centered on the beam axis, confirm that its center coincides with the origin or the intended point. If you rotate a volume, look at the geometry from several viewpoints to make sure the rotation is applied as expected.
Use visualization attributes to make inspection easier. Transparent outer volumes can reveal whether inner volumes are fully contained. Wireframe views often make overlaps or gaps easier to see than solid rendering. You can also temporarily enlarge or simplify some volumes in your code to exaggerate and reveal possible problems, then restore the correct dimensions once you are satisfied.
Visual inspection has limitations. Fine overlaps can be smaller than a pixel, and complex nested structures are hard to judge by eye. This is why you must complement visualization with programmatic checks.
Using Built‑in Overlap Checking
Geant4 provides automatic overlap detection when you construct physical volumes. Many placement constructors have an optional pSurfChk flag as their last argument. If you set this flag to true, Geant4 will test for overlaps between the new volume and its neighbors.
For example, when you create a placed volume:
auto phys = new G4PVPlacement(
rotation, // rotation matrix, or nullptr
position, // translation
logicalVolume, // logical volume to place
"Detector", // name
motherLogical, // mother volume
false, // no boolean operation
copyNumber, // copy number
true // pSurfChk: enable overlap check
);
With pSurfChk set to true, Geant4 samples points on the surface of the placed volume and checks whether these points are inside any other solid in the same mother volume. If an overlap is found, it prints diagnostic messages to standard output, including the name of the overlapping volumes and an estimate of the overlap depth.
You can also control more global geometry checks through the geometry manager and related commands. This lets you run deeper or repeated checks after construction. Overlap checking can be costly in CPU time if you have many volumes, but for validation runs this cost is usually acceptable.
Always enable overlap checking for new or modified volumes during development. Turn it off later only if you fully understand its performance impact and have already validated the geometry.
Checking for Overlaps with Commands
In addition to per‑volume pSurfChk, Geant4 provides user interface commands to probe overlaps in a more systematic way. These are particularly useful for complex geometries or when you want to test volumes without recompiling.
One common approach is to use the command interface to sample points on a solid and test for overlaps. You can choose a specific physical volume by name and ask Geant4 to generate a number of random points on its surface. For each point, Geant4 checks whether that position lies within more than one volume at the same hierarchy level.
You typically proceed in three steps. First, initialize the run and geometry. Second, select the target physical volume in your macro. Third, run the overlap test with a chosen number of points and a tolerance. The tolerance defines how close two surfaces can be before they are treated as overlapping. For very tight geometries you may need to reduce this value, but be aware of numeric precision limits.
If overlaps exist, Geant4 prints messages that include the names of the overlapping volumes and a representative point where the problem occurs. Taking note of these names and positions will guide you to the corresponding placements in your DetectorConstruction class.
You can repeat these checks after each modification of the geometry. For example, if you are building a complex detector array, run overlap checks after adding a new layer or submodule. This incremental approach makes it much easier to identify which change introduced a problem.
A useful strategy is to automate some checks in your standard initialization macro. Add commands that perform overlap tests on your most important volumes. When you run a new build, you immediately see warnings in the console if something is wrong, without needing to remember to run checks manually.
Debugging Overlapping Volumes
Once an overlap is reported, you need to interpret the messages and fix the underlying cause. Overlaps usually come from one of a few typical sources: incorrect dimensions, inconsistent half‑lengths, coordinate mistakes, or imprecise rotations and translations.
Start by locating the individual G4PVPlacement or boolean solid creation in your DetectorConstruction that corresponds to the reported volume names. Compare the intended geometry with the parameters you actually used. For example, if you expect a volume to sit exactly against another without overlap, the sum of their half‑lengths along that axis must exactly match the separation of their center positions.
You can use simple algebra to reason about possible overlaps. Suppose two boxes share a mother volume, are aligned along the x axis, and are intended to be just touching. Let the first box have half length $a$ along x and center at $x = 0$. Let the second have half length $b$ and center at $x = a + b$. If you accidentally use $x = a + b - \epsilon$ for the second center, you create an overlap of depth $\epsilon$. The overlap checker will report this as a problem.
To debug, it often helps to temporarily exaggerate positions or sizes. Increase the suspected overlap by making one dimension clearly larger, recompile, and inspect the geometry visually. Once you are sure where the conflict lies, restore the correct dimensions with more care.
Rotations can be a more subtle source of overlaps. If you build a ring of detectors, small numeric errors in rotation angles or radii can make end volumes intrude into neighbors. In such cases, derive positions and angles from a single set of parameters and compute them programmatically, instead of hard coding slightly inconsistent values.
Geant4 prints a suggested overlap depth. This is an estimate based on the sampled points and is not exact, but it can give you a sense of scale. Overlaps comparable to or larger than the tracking step size are clearly dangerous. Even much smaller overlaps can confuse navigation, so aim to eliminate them rather than relying on their smallness.
Do not ignore overlap warnings, even if the reported depth looks small. Any overlap can cause navigation failures or incorrect material assignments. Fix the geometry itself instead of adjusting tolerances to hide the problem.
Checking Volume Hierarchy and Containment
Correct geometry is not just about avoiding overlaps. The hierarchy and containment of volumes must also match your design. A volume must always be fully contained inside its mother volume. If any part lies outside, navigation may fail, and particles can be incorrectly transported.
When you define a solid and then place it as a physical volume, check that its maximum extent along each axis is smaller than the corresponding dimension of its mother. For axis aligned boxes, this means that the sum of the absolute value of the translation and the half length must be less than the mother half length. Concretely, for a box with half length $h$ inside a mother with half length $H$, and center offset $x_0$ along x, you should satisfy
$$
|x_0| + h \leq H.
$$
If this condition is violated by any coordinate, part of the volume falls outside the mother.
For other primitives such as tubes and spheres, use the outer radii and angular spans in a similar way. For example, a cylindrical volume with outer radius $r$ must lie within the mother radius or within its half lengths, depending on the chosen orientation.
Mathematically consistent hierarchy does not guarantee physical correctness. You must also check that the hierarchy reflects your detector concept. Inner detector elements should be children of the correct support structures, and sensitive volumes should not be assigned as mothers of structural components by mistake. You can use your detector diagram as a guide and compare it to the scene graph that Geant4 effectively constructs.
In some setups you will use assemblies or parameterized volumes. In that case, validate the contour of the whole assembly. Ensure that the assembled structure still fits within the intended mother volume and that parameterized placements do not exceed expected bounds. For example, the product of the number of repetitions and the pitch must not extend beyond the parent dimension.
Verifying Dimensions and Materials
Geometry validation also includes checking that each volume has the intended size and material. A mis‑typed unit or wrong constant can produce a detector that is off by orders of magnitude, which will invalidate all results even if no overlaps occur.
In Geant4, you usually specify dimensions with unit multipliers, such as 5cm or 10mm. If you accidentally use cm instead of mm, a volume can expand by a factor of ten. To catch such mistakes, systematically review your dimensions in the DetectorConstruction and compare them to your design document or drawings.
You can programmatically print diagnostic information at construction time. For example, after creating a G4Box, you can print its half lengths and the material name of the corresponding logical volume. Combine this with unit handling to obtain human readable outputs. A simple strategy is to add a method that loops over key volumes, retrieves their sizes and materials, and writes them to the log during initialization.
Materials can also be misassigned. If you use the wrong material pointer when constructing a logical volume, or if you search for a NIST material with a misspelled name, your detector might be built out of air instead of lead, or vice versa. Check all calls to G4LogicalVolume constructors and confirm that the material arguments are what you expect.
A useful consistency check is to use the geometry viewer to color volumes by material. Assign a distinctive color to each critical material, such as bright blue for water or dark gray for lead. Then visually inspect the geometry to see whether the colors appear in the correct regions. This is often faster and more intuitive than examining code alone.
Always double check units and material assignments. A single wrong unit or material can produce convincing but completely unphysical results, even when the geometry has no overlaps.
Simple Physics Tests to Probe Geometry
After structural checks, run a few simple physics tests to probe the geometry behavior. The goal is not to validate the full physics model, but to confirm that particles move through the detector as intended, and that boundaries and regions are where you think they are.
One basic test is to send a monoenergetic pencil beam through your setup along a known direction, for example along the z axis, with no scattering physics or with minimal processes enabled. Record the positions where tracks enter and exit key volumes. If the geometry is correct, these crossing points should match the expected boundaries given by your dimensions.
For a homogeneous slab of thickness $d$, you can check that the path length inside the slab is close to $d$ for straight tracks. In other words, if a particle starts just before the front surface and travels perpendicularly, the difference between the positions at the entrance and exit along the beam axis should be $d$:
$$
L_{\text{slab}} \approx d.
$$
If you observe systematically shorter or longer path lengths than expected, this may indicate misplaced surfaces or incorrect thickness.
Another test is to look at the material sequence encountered by a track. You can print the material names at each step or boundary for a small number of particles. The sequence should match your mental picture, for instance air, then entrance window, then scintillator, then reflector, and so on. Any unexpected material in the sequence may reveal wrong mother volumes or misplaced components.
You can also use energy deposition patterns to probe geometry qualitatively. For example, in a layered structure, the fraction of energy deposited in each layer should roughly follow their thicknesses and material properties. While this is a physics dependent quantity, gross inconsistencies can hint at geometry problems.
By combining visual checks, overlap detection, hierarchy verification, and simple physics probes, you build a consistent picture of your geometry. Only when this picture is stable and aligned with your design should you proceed to detailed physics validation and quantitative analysis.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to Geant4
- ☰ 1.1. What Is Geant4?
- ☰ 1.2. How Geant4 Works
- ☰ 1.3. Geant4 Simulation Structure
- ☰ 1.4. Geant4 and C++
-
- ☰ 2. Installing Geant4
- ☰ 2.1. Geant4 Requirements
- ☰ 2.2. Installing Geant4 on Linux
- ☰ 2.3. Installing Visualization Libraries
- ☰ 2.4. Verifying the Installation
- ☰ 2.5. Geant4 Example Applications
-
- ☰ 3. C++ Basics for Geant4
- ☰ 3.1. Classes and Objects
- ☰ 3.2. Inheritance
- ☰ 3.3. Pointers and References
- ☰ 3.4. Header and Source Files
- ☰ 3.5. Standard Library Containers
-
- ☰ 4. Creating Your First Geant4 Project
- ☰ 4.1. Project Structure
- ☰ 4.2. CMake Configuration
- ☰ 4.3. The Main Program
- ☰ 4.4. User Initialization Classes
- ☰ 4.5. Building and Running
-
- ☰ 5. Geant4 Units and Constants
- ☰ 5.1. Geant4 Unit System
- ☰ 5.2. Using Units in C++
- ☰ 5.3. Physical Constants
- ☰ 5.4. Printing Values with Units
-
- ☰ 6. Creating the Simulation World
- ☰ 6.1. DetectorConstruction
- ☰ 6.2. Solids
- ☰ 6.3. Logical Volumes
- ☰ 6.4. Physical Volumes
- ☰ 6.5. Creating the World Volume
-
- ☰ 7. Materials
- ☰ 7.1. Geant4 Materials
- ☰ 7.2. NIST Material Database
- ☰ 7.3. Common Materials
- ☰ 7.4. Creating Custom Materials
- ☰ 7.5. Detector Materials
-
- ☰ 8. Building Detector Geometry
- ☰ 8.1. Basic Geometrical Shapes
- ☰ 8.2. Boolean Solids
- ☰ 8.3. Positioning Volumes
- ☰ 8.4. Repeated Geometry
- ☰ 8.5. Detector Arrays
- ☰ 8.6. Geometry Overlap Checking
-
- ☰ 9. Geometry Visualization
- ☰ 9.1. Visualization in Geant4
- ☰ 9.2. Starting the Visualization System
- ☰ 9.3. Changing the View
- ☰ 9.4. Visualization Attributes
- ☰ 9.5. Displaying Particle Tracks
-
- ☰ 10. Primary Particle Generation
- ☰ 10.1. PrimaryGeneratorAction
- ☰ 10.2. Particle Gun
- ☰ 10.3. Particle Energy
- ☰ 10.4. Particle Position
- ☰ 10.5. Particle Direction
- ☰ 10.6. Common Particle Sources
-
- ☰ 11. General Particle Source
- ☰ 11.1. Introduction to GPS
- ☰ 11.2. Position Distributions
- ☰ 11.3. Angular Distributions
- ☰ 11.4. Energy Distributions
- ☰ 11.5. Configuring Sources with Macros
-
- ☰ 12. Physics Lists
- ☰ 12.1. What Is a Physics List?
- ☰ 12.2. Reference Physics Lists
- ☰ 12.3. Electromagnetic Physics
- ☰ 12.4. Gamma Interactions
- ☰ 12.5. Positron Physics
- ☰ 12.6. Hadronic Physics
- ☰ 12.7. Choosing a Physics List
-
- ☰ 13. Particle Tracking
- ☰ 13.1. Tracks
- ☰ 13.2. Steps
- ☰ 13.3. Energy Deposition
- ☰ 13.4. Track Status
- ☰ 13.5. Parent and Secondary Particles
-
- ☰ 14. User Actions
- ☰ 14.1. RunAction
- ☰ 14.2. EventAction
- ☰ 14.3. SteppingAction
- ☰ 14.4. TrackingAction
- ☰ 14.5. StackingAction
- ☰ 14.6. ActionInitialization
-
- ☰ 15. Sensitive Detectors
- ☰ 15.1. What Is a Sensitive Detector?
- ☰ 15.2. Creating a Sensitive Detector
- ☰ 15.3. Hits
- ☰ 15.4. Hit Collections
- ☰ 15.5. Assigning Sensitive Detectors
-
- ☰ 16. Recording Energy Deposition
- ☰ 16.1. Energy Deposition
- ☰ 16.2. Energy per Event
- ☰ 16.3. Energy per Detector
- ☰ 16.4. Energy Spectra
- ☰ 16.5. Detector Efficiency
-
- ☰ 17. Particle Position and Timing
- ☰ 17.1. Particle Position
- ☰ 17.2. Interaction Position
- ☰ 17.3. Global Time
- ☰ 17.4. Time of Flight
- ☰ 17.5. Detector Timing
-
- ☰ 18. Geant4 Analysis System
- ☰ 18.1. Introduction to G4AnalysisManager
- ☰ 18.2. Histograms
- ☰ 18.3. Ntuples
- ☰ 18.4. Filling Ntuples
- ☰ 18.5. Writing Output Files
- ☰ 18.6. Closing Analysis Files
-
- ☰ 19. Geant4 and ROOT
- ☰ 19.1. ROOT Output from Geant4
- ☰ 19.2. Reading Geant4 Output with ROOT
- ☰ 19.3. Plotting Energy Spectra
- ☰ 19.4. Event Analysis
- ☰ 19.5. Simulation-to-Analysis Workflow
-
- ☰ 20. Geant4 Macro Commands
- ☰ 20.1. Macro Files
- ☰ 20.2. Run Commands
- ☰ 20.3. Particle Source Commands
- ☰ 20.4. Visualization Commands
- ☰ 20.5. Controlling Simulations Without Recompiling
-
- ☰ 21. Random Numbers and Reproducibility
- ☰ 21.1. Monte Carlo Random Numbers
- ☰ 21.2. Setting Random Seeds
- ☰ 21.3. Running Independent Simulations
- ☰ 21.4. Reproducing an Event
-
- ☰ 22. Multithreading
- ☰ 22.1. Geant4 Multithreading
- ☰ 22.2. Running with Multiple Threads
- ☰ 22.3. Thread-Safe User Code
- ☰ 22.4. Analysis with Multithreading
- ☰ 22.5. Performance Considerations
-
- ☰ 23. Practical Example: Gamma-Ray Detector
- ☰ 23.1. Project Overview
- ☰ 23.2. Creating the World
- ☰ 23.3. Creating the Detector
- ☰ 23.4. Adding the Material
- ☰ 23.5. Creating a Gamma Source
- ☰ 23.6. Selecting Electromagnetic Physics
- ☰ 23.7. Recording Energy Deposition
- ☰ 23.8. Creating an Energy Spectrum
- ☰ 23.9. Simulating Detector Resolution
- ☰ 23.10. Analyzing the Spectrum with ROOT
-
- ☰ 24. Practical Example: Radiation Shielding
- ☰ 24.1. Project Overview
- ☰ 24.2. Creating the Source
- ☰ 24.3. Creating the Shield
- ☰ 24.4. Comparing Shielding Materials
- ☰ 24.5. Varying Shield Thickness
- ☰ 24.6. Recording Transmitted Particles
- ☰ 24.7. Calculating Transmission
- ☰ 24.8. Calculating Attenuation
- ☰ 24.9. Comparing Simulation Results
-
- ☰ 25. Practical Example: PET Scanner
- ☰ 25.1. Introduction to PET Simulation
- ☰ 25.2. Creating a PET Detector Ring
- ☰ 25.3. Creating Detector Crystals
- ☰ 25.4. Assigning Detector IDs
- ☰ 25.5. Creating a Positron Source
- ☰ 25.6. Simulating Positron Annihilation
- ☰ 25.7. Recording Detector Hits
- ☰ 25.8. Applying an Energy Window
- ☰ 25.9. Finding Coincidence Events
- ☰ 25.10. Recording Detector Positions
- ☰ 25.11. Creating Lines of Response
- ☰ 25.12. Saving PET Events to ROOT
- ☰ 25.13. Analyzing PET Data with ROOT
-
- ☰ 26. Practical Example: Proton Beam in Water
- ☰ 26.1. Project Overview
- ☰ 26.2. Creating the Water Phantom
- ☰ 26.3. Creating a Proton Beam
- ☰ 26.4. Selecting the Physics List
- ☰ 26.5. Recording Energy Deposition
- ☰ 26.6. Dividing the Phantom into Slices
- ☰ 26.7. Calculating Depth Dose
- ☰ 26.8. Observing the Bragg Peak
- ☰ 26.9. Plotting the Depth-Dose Curve
-
- ☰ 27. Detector Resolution and Smearing
- ☰ 27.1. Ideal vs Realistic Detector Response
- ☰ 27.2. Energy Resolution
- ☰ 27.3. Position Resolution
- ☰ 27.4. Time Resolution
- ☰ 27.5. Applying Detector Effects
- ☰ 27.6. Comparing Ideal and Smeared Results
-
- ☰ 28. Simulation Validation
- ☰ 28.1. Why Validate a Simulation?
- ☰ 28.2. Checking Geometry
- ☰ 28.3. Checking Energy Conservation
- ☰ 28.4. Comparing with Analytical Calculations
- ☰ 28.5. Comparing with Reference Data
- ☰ 28.6. Statistical Uncertainties
- ☰ 28.7. Number of Simulated Events
-
- ☰ 29. Improving Simulation Performance
- ☰ 29.1. Geometry Performance
- ☰ 29.2. Physics List Performance
- ☰ 29.3. Production Cuts
- ☰ 29.4. Reducing Unnecessary Output
- ☰ 29.5. Multithreading
- ☰ 29.6. Running Large Simulations
- ☰ 29.7. Parameter Scans
-
- ☰ 30. Debugging Geant4 Simulations
- ☰ 30.1. Compilation Errors
- ☰ 30.2. Geometry Errors
- ☰ 30.3. Overlapping Volumes
- ☰ 30.4. Missing Particles
- ☰ 30.5. Missing Energy Deposition
- ☰ 30.6. Physics List Problems
- ☰ 30.7. Sensitive Detector Problems
- ☰ 30.8. Empty Output Files
- ☰ 30.9. Segmentation Faults
- ☰ 30.10. Using Geant4 Verbose Output
-
- ☰ 31. Writing Better Geant4 Applications
- ☰ 31.1. Organizing Source Code
- ☰ 31.2. Separating Geometry and Analysis
- ☰ 31.3. Using Configuration Parameters
- ☰ 31.4. Avoiding Hard-Coded Values
- ☰ 31.5. Creating Reusable Detector Components
- ☰ 31.6. Naming Conventions
- ☰ 31.7. Documentation
- ☰ 31.8. Version Control with Git
-
- ☰ 32. Advanced Geometry
- ☰ 32.1. Parameterized Geometry
- ☰ 32.2. Replica Volumes
- ☰ 32.3. Nested Geometry
- ☰ 32.4. Complex Detector Arrays
- ☰ 32.5. Importing CAD Geometry
- ☰ 32.6. Exporting Geometry with GDML
-
- ☰ 33. Optical Photons
- ☰ 33.1. Introduction to Optical Physics
- ☰ 33.2. Optical Photons
- ☰ 33.3. Material Optical Properties
- ☰ 33.4. Scintillation Light
- ☰ 33.5. Optical Surfaces
- ☰ 33.6. Photodetectors
- ☰ 33.7. Counting Optical Photons
-
- ☰ 34. Medical Physics Applications
- ☰ 34.1. Geant4 in Medical Physics
- ☰ 34.2. Radiation Dose Simulation
- ☰ 34.3. PET Simulation
- ☰ 34.4. SPECT Simulation
- ☰ 34.5. Radiotherapy Simulation
- ☰ 34.6. Proton Therapy Simulation
- ☰ 34.7. Biological Tissue Materials
-
- ☰ 35. Final Project
- ☰ 35.1. Project Overview
- ☰ 35.2. Define the Simulation Goal
- ☰ 35.3. Create the Geometry
- ☰ 35.4. Define Materials
- ☰ 35.5. Configure the Particle Source
- ☰ 35.6. Select the Physics List
- ☰ 35.7. Implement Sensitive Detectors
- ☰ 35.8. Record Simulation Data
- ☰ 35.9. Run the Simulation
- ☰ 35.10. Analyze the Results with ROOT
- ☰ 35.11. Validate the Simulation
- ☰ 35.12. Create Scientific Figures
- ☰ 35.13. Document the Simulation
-
- ☰ 36. Appendices
- ☰ 36.1. Geant4 Class Cheat Sheet
- ☰ 36.2. Geant4 Units Cheat Sheet
- ☰ 36.3. Common Geant4 Macro Commands
- ☰ 36.4. Common Geometry Classes
- ☰ 36.5. Common Particle Definitions
- ☰ 36.6. Common Physics Lists
- ☰ 36.7. G4AnalysisManager Cheat Sheet
- ☰ 36.8. Common Visualization Commands
- ☰ 36.9. Common Geant4 Errors and Solutions
- ☰ 36.10. Recommended Geant4 Project Structure
- ☰ 36.11. Recommended Geant4 Simulation Workflow
-
Comments
Please login to add a comment.
Don't have an account? Register now!