32.1. Parameterized Geometry
Table of Contents
Motivation for Parameterized Geometry
Geant4 often needs many repeated detector elements, for example long calorimeter stacks, pixel or strip detectors, or voxelized phantoms. Creating a separate volume and placement for every single copy is possible, but it becomes hard to maintain and slow to initialize when you have thousands or millions of elements.
Parameterized geometry offers a compact way to describe such repeated structures with a small amount of C++ code. Instead of explicitly placing every copy, you define a single logical volume and a parameterization class that tells Geant4 how to position and shape each copy when needed.
Using parameterized geometry can reduce memory usage, simplify your geometry description, and speed up navigation in large regular structures.
Basic Idea of Parameterized Volumes
In a parameterized geometry, you have three key ingredients. First, a logical volume that describes the basic type of object you are repeating, including its material and its solid class. Second, a placement volume that contains an arbitrary number of copies of that logical volume. Third, a parameterization class that, for each copy number, defines the solid dimensions, the transformation, and possibly the material.
Geant4 then treats each copy as an independent physical volume for tracking purposes, but you do not create them one by one. Instead, the geometry system queries the parameterization when it needs information about a specific copy, identified by its copy number.
Important rule: In a parameterized geometry, all copies share the same G4LogicalVolume object, but they can differ in size, position, and even material if your parameterization defines these quantities per copy.
The copy number is an integer index assigned by Geant4, usually from 0 up to the number of parameterized placements minus 1. Your parameterization class uses this index to compute the properties of that copy.
The G4VPVParameterisation Class
Parameterized geometry in Geant4 is controlled by user classes derived from G4VPVParameterisation. This is an abstract base class that defines the interface that Geant4 calls when it needs information about a particular copy.
You typically subclass G4VPVParameterisation and implement methods such as:
ComputeTransformation(G4int copyNo, G4VPhysicalVolume* physVol)to set the translation and rotation for each copy.ComputeDimensions(...)to set the size of the solid for a given copy.- Optionally,
ComputeMaterial(G4int copyNo, G4VPhysicalVolume physVol, const G4VTouchable parentTouch)if you want different materials for different copies.
Your parameterization object is then passed to a special placement class, G4PVParameterised, which uses it to create a family of parameterized volumes inside a mother volume.
Important rule: Any class derived from G4VPVParameterisation must correctly implement ComputeTransformation and at least one appropriate ComputeDimensions method that matches the solid type used in the logical volume.
If you mismatch the solid type and the ComputeDimensions function, Geant4 will either report errors at initialization or misinterpret your geometry.
Defining Dimensions of Parameterized Solids
In a parameterized geometry, the same logical volume can represent elements of different sizes. For example, a sampling calorimeter might have absorber plates that get thicker with depth, or a voxelized phantom might have different slice thicknesses.
To describe this, you implement ComputeDimensions in your parameterization class. The exact signature of this function depends on the solid type of your logical volume. For instance:
- For
G4Box:void ComputeDimensions(G4Box& box, const G4int copyNo, const G4VPhysicalVolume* physVol) const; - For
G4Tubs:void ComputeDimensions(G4Tubs& tubs, const G4int copyNo, const G4VPhysicalVolume* physVol) const; - For
G4Sphere:void ComputeDimensions(G4Sphere& sphere, const G4int copyNo, const G4VPhysicalVolume* physVol) const;
Inside this method, you typically compute the half lengths or radii based on the copy number. Geant4 calls ComputeDimensions during geometry setup, so you must not rely on event dependent information here.
For example, consider a stack of boxes whose thickness in $z$ increases linearly with copy number. If $t_0$ is the base half thickness for copy 0, and $\Delta t$ is the increment per copy, you might implement:
$$
t_z(\text{copyNo}) = t_0 + \text{copyNo} \cdot \Delta t
$$
and then set box.SetZHalfLength(t_z(copyNo)); inside ComputeDimensions.
Important rule: ComputeDimensions must be deterministic and must not depend on random numbers or run, event, or track state. The geometry must be fixed before the run starts.
As long as the volume type and the ComputeDimensions method match, you can achieve a wide variety of shapes that vary from copy to copy.
Positioning Parameterized Volumes
While ComputeDimensions defines the shape, ComputeTransformation sets the position and orientation of each copy. Geant4 calls this method with the copy number and a pointer to the physical volume. Inside, you typically compute a translation and rotation based on the index and apply them to physVol.
A simple and common example is a linear array or a stack. For instance, to place $N$ identical detector strips of width $w$ along the $x$ axis, with their centers separated by $d = w + g$, where $g$ is a gap:
$$
x(\text{copyNo}) = \left(\text{copyNo} - \frac{N - 1}{2}\right) \cdot d
$$
You would then call physVol->SetTranslation(G4ThreeVector(x(copyNo), 0, 0)); in ComputeTransformation.
You can create 2D or 3D grids similarly. For a 2D grid with indices $(i,j)$, you convert from the linear copyNo to two indices by:
$$
i = \text{copyNo} \bmod N_x, \quad j = \left\lfloor \frac{\text{copyNo}}{N_x} \right\rfloor
$$
Then you can compute positions $x(i)$ and $y(j)$ and set the translation accordingly.
Rotations are handled by constructing a G4RotationMatrix, setting the desired angles, and then calling physVol->SetRotation(&rotationMatrix); or using a precomputed matrix.
Important rule: ComputeTransformation defines the position and rotation of the copy relative to the mother volume, not in global coordinates.
The center of each parameterized volume must lie entirely inside its mother volume and must not overlap other volumes in an inconsistent way. If you get the positioning wrong, you can create overlaps that are difficult to debug.
Material and Copy Number Handling
In many applications, all elements in a parameterized family share the same material. In that case, you simply assign the material once when creating the logical volume and do nothing else. However, parameterized geometry also allows you to vary material by copy if necessary.
You can override ComputeMaterial in your parameterization class to return a different G4Material pointer for each copy based on its copy number or position. This is useful when building complex phantoms where different regions represent different tissues, or for layered detectors with alternating materials.
Even if you do not vary the material, the copy number is valuable. Each physical step in a parameterized volume carries a copy number, which you can access in sensitive detectors or user actions through the touchable history or directly from the step. This allows you to identify which element has been hit and associate it with an index in an array or an external file.
For example, for a 1D stack along $z$ you might define the copy number as an index $k$ that maps to a depth:
$$
z_k = z_0 + k \cdot \Delta z
$$
When you record energy deposition, you can fill a depth dose or profile histogram at bin $k$ based on the copy number, instead of computing the position directly from coordinates.
Important rule: The copy number is the primary way to distinguish individual elements within a parameterized family when you process hits and energy deposition.
Using copy numbers consistently simplifies analysis, since you can map from a single integer index to geometry properties or detector calibration information stored in arrays or external configuration.
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!