32.2. Replica Volumes
Table of Contents
Why Use Replica Volumes
Replica volumes are a way to divide a larger volume into many identical, regularly arranged subvolumes without placing each copy by hand. In Geant4 this is done with the class G4PVReplica.
A replica is not an independent physical volume created with G4PVPlacement. Instead, a single logical volume is replicated many times along one coordinate or around a circle, and Geant4 automatically handles the positions and boundaries of all the copies.
Replica volumes are particularly useful when you have a detector made of many identical strips, layers, or slices, such as a calorimeter segmented in depth, a stack of thin detectors, or a regular grid in one dimension. Using replicas reduces the amount of code you need to write and often improves performance, because the geometry is highly regular and Geant4 can navigate it efficiently.
There are two key points you should always remember about replicas. First, they always fill their mother volume exactly, with no gaps. Second, all replicas share the same logical volume, so they all have the same material and size, except for the dimension along which the replication is performed.
Replica volumes fill their mother volume completely with identical copies of a single logical volume, and all replicas must have the same material and dimensions (except along the replication axis).
The Concept of G4PVReplica
G4PVReplica is the class that defines a replicated physical volume. It tells Geant4 how to divide a mother logical volume into many identical daughters.
The constructor of G4PVReplica connects three main pieces:
- The name of the replicated volume.
- The logical volume that will be replicated.
- The mother logical volume that will contain all the replicas.
It also defines along which axis the replication happens, how many replicas there are, and how thick each one is. In C++, this looks like
auto replicaPhys = new G4PVReplica("MyReplica",
replicaLogical, // logical volume to replicate
motherLogical, // mother logical volume
axis, // replication axis
nReplicas, // number of replicas
width, // width along axis
offset); // optional offsetThe position of each individual replica is not something you compute directly. Geant4 derives the location and the bounding surfaces of each copy based on the replication parameters you pass to the constructor.
Internally, Geant4 assigns a copy number to each replica. For a given particle step inside a replica, you can query this copy number with
auto copyNo = step->GetPreStepPoint()
->GetTouchableHandle()
->GetCopyNumber();This is very important when you want to know in which segment, strip, or slice a hit occurred. You will use the copy number to index arrays, histograms, or hit collections in other parts of your application.
The copy number of a replica volume is the main way to identify which instance of a repeated detector element has been hit.
Types of Replication
Geant4 supports three basic ways to replicate a volume with G4PVReplica. These correspond to the three possible choices for the axis argument in the constructor.
The three replication modes are summarized in the following table:
| Axis value | Replication type | Typical use case |
|---|---|---|
kXAxis, kYAxis, kZAxis | Linear replication along a Cartesian axis | Calorimeter slices, layered detectors |
kRho | Radial replication | Cylindrical shells, radial segments |
kPhi | Angular (phi) replication | Detector wedges around a ring |
Each type has specific geometry requirements and is best suited for particular solids and layouts.
Linear replication along x, y, or z
Linear replication is the most commonly used form. You divide a box or a cylinder into equal slices along one Cartesian axis. For example, you can split a G4Box into many thin slabs along the z axis to create a set of depth segments in a calorimeter.
For linear replication you choose axis as one of kXAxis, kYAxis, or kZAxis. The width parameter is the size of each replica along that axis. The total length of the mother volume along that axis must be exactly nReplicas * width.
If the mother is a G4Box, its half-length along the replication axis must match half of this total length. Geant4 then places the first replica at one end of the mother and the last replica at the other end, so that they just touch with no overlap.
Radial replication with kRho
Radial replication is used with cylindrical solids such as G4Tubs, in order to create concentric cylindrical layers. You choose axis = kRho, and Geant4 divides the radial extent of the mother solid into several cylindrical shells.
Each replica is then a ring of constant thickness in radius. This is useful for modeling radial segmentation in cylindrical detectors such as some calorimeters or shielding layers.
The number of replicas and the radial thickness must be consistent with the inner and outer radius of the mother cylindrical solid. Geant4 ensures that the replicas fill the mother volume between its inner and outer radii.
Angular replication with kPhi
Angular replication is used to divide a ring or cylindrical shell into wedges in the azimuthal direction. You choose axis = kPhi, and Geant4 subdivides the total phi range of the mother volume into nReplicas identical slices.
This is often used to build detector rings from identical sectors, such as a PET ring made of multiple identical modules or a cylindrical tracker divided into sectors.
The mother volume must have a nonzero angular span in phi. The angular width of each replica is determined by dividing the phi range by the number of replicas. The replicas are arranged around the axis of the cylinder so that their angular boundaries exactly coincide.
Setting Up a Replica
To set up a replica volume, you must already have a mother logical volume and a logical volume that describes the shape and material of a single replica. The key point is that the replica logical volume must be consistent with the shape of the mother and the chosen replication axis.
For example, suppose you want to divide a calorimeter into 100 slices along the z axis. You might first define the mother solid and its logical volume:
auto caloSolid = new G4Box("CaloSolid",
10.0*cm, 10.0*cm, 50.0*cm); // half-lengths
auto caloLogical = new G4LogicalVolume(caloSolid, caloMaterial, "CaloLogical");
The full length of this box along z is 100.0*cm. If you want 100 slices, each slice will be 1.0 cm thick. The replica solid must have a half-length of 0.5 cm along z:
auto sliceSolid = new G4Box("SliceSolid",
10.0*cm, 10.0*cm, 0.5*cm); // half-lengths
auto sliceLogical = new G4LogicalVolume(sliceSolid, caloMaterial, "SliceLogical");You then create the replicas with:
auto slicePhys = new G4PVReplica("SlicePhys",
sliceLogical,
caloLogical,
kZAxis,
100, // number of replicas
1.0*cm, // slice thickness along z
0.0*cm); // offset
After this, you usually place caloLogical as a single volume inside the world using G4PVPlacement. The many slices are created implicitly inside it and do not require individual placements.
When you set up a replica, keep the following practical rules in mind.
First, the shape of the daughter logical volume must match the subdivision of the mother. For linear replication, both are usually the same class of solid, such as G4Box inside G4Box, with only one dimension scaled. For radial and angular replication, solids like G4Tubs are required.
Second, the product of the number of replicas and the width must match the available extent in the mother. If this is inconsistent, the geometry will be ill defined.
Third, you cannot apply an arbitrary rotation or translation to each replica. They are fully defined by the replication parameters, so G4PVReplica does not take a rotation matrix or translation vector.
For a valid replica, the size of the mother volume along the replication axis must equal the number of replicas multiplied by the width, and the replica placement is entirely controlled by G4PVReplica, not by manual translations or rotations.
Differences Between Replicas and Parameterized Volumes
Replica volumes are one of two main approaches in Geant4 for repeated geometry, the other being parameterized volumes. Both can create many similar subvolumes, but they are designed for different situations.
The key differences can be summarized as follows:
| Aspect | Replica volumes | Parameterized volumes |
|---|---|---|
| Geometry variation | All replicas identical | Shape, size, and material may vary |
| Placement | Fixed, regular subdivision | Arbitrary, defined by a parameterization |
| Supported solids | Limited, mainly boxes and cylinders | Many solids supported |
| Navigation performance | Very efficient in regular geometries | Good, but depends on complexity |
| Use case | Uniform segmentation, fixed grid | Non uniform layouts, complex arrays |
Replica volumes are best when the segmentation is uniform and strictly regular, such as equal thickness slices or equal angular wedges. If you want to gradually change the thickness of layers, or if some detector elements are missing, you must use a parameterized volume instead.
In code, a replica is defined with G4PVReplica and does not need a user defined class for the placement. A parameterized volume uses G4PVParameterised together with a user class that computes the dimensions and positions of each copy.
Conceptually, you can think of replicas as cutting a loaf of bread into equal slices, while parameterized volumes let you cut slices of different thickness or shapes. As soon as you need that flexibility, replication is no longer suitable and parameterization becomes necessary.
Limitations and Practical Tips
Replica volumes have several important limitations that you must respect in order to avoid geometry errors and hard to debug problems.
First, you cannot assign a different material or different solid to individual replicas of the same logical volume. All replicas share exactly the same G4LogicalVolume, so they all have the same material, field, and user information.
Second, you cannot place additional daughter volumes inside some replicas and not others. If you place a daughter inside the replica logical volume, it will appear in every replica instance. There is no way with simple replication to put a daughter in only one specific copy.
Third, you cannot apply rotations or translations instance by instance. The positions of replicas are derived from the replication axis, width, and offset. If you need arbitrary individual rotations or positions, you must use multiple placements or parameterized volumes.
Fourth, certain solids and orientations are not supported. For example, you cannot usually replicate a spherical solid along z with kZAxis. Radial and angular replications are tied to cylindrical coordinates and require appropriate mother shapes.
Fifth, placing a replica volume inside another replica is very restricted and easy to misuse. For beginners, it is often safer to avoid deep hierarchies of replicas and instead use a simple structure, for example a mother segmented in one direction, and then possibly daughters placed inside each segment with usual placements.
In practice, when you use replicas to segment a detector, you will often combine them with sensitive detectors and hit collections. You assign a sensitive detector to the replica logical volume. During the simulation, when a step happens in one slice or segment, you access the copy number to know which replica generated that hit. This lets you build energy profiles, depth dose curves, or detector maps with very little geometry code.
For example, in a calorimeter divided into 100 slices along z, you can accumulate energy deposition per slice by using the copy number from the touchable. This is much simpler than creating and naming 100 separate logical or physical volumes.
Use replica volumes only for strictly regular, identical segmentation. If you need different shapes, materials, or a more complex layout per copy, switch to parameterized volumes or explicit placements instead of forcing replicas to do something they are not designed for.
By understanding these constraints and strengths, you can decide when replica volumes are the right tool and use them effectively for segmented detectors and regular geometries in your Geant4 applications.
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!