35.7. Implement Sensitive Detectors
Table of Contents
Connecting Physics to Readout
In the final project, sensitive detectors are the bridge between the physics happening in your geometry and the data you will analyze. Geometry alone only describes where materials are. A sensitive detector turns specific volumes into “measurement devices” that can react to energy deposition, count particles, or record timing information.
In Geant4, this is done by assigning a sensitive detector object to one or more logical volumes. Whenever a step occurs in one of those volumes, your sensitive detector code has the opportunity to create a hit and store whatever information you consider relevant.
In the context of the final project, you will already have defined your detector geometry, materials, and physics list. Implementing sensitive detectors is the step where you design how your virtual detector “responds” and what quantities you will write out for analysis.
A volume is only “detected” if you assign a sensitive detector to its logical volume. Without this assignment, no hits or detector signals are recorded, even if energy deposition takes place.
Designing What You Want to Record
Before you write any code, decide what a “measurement” in your final project should look like. Different projects require different hit information:
For a calorimeter-like detector you often need total energy deposited per detector element per event, and maybe the position of the energy deposit to reconstruct shower shapes.
For a tracking detector you are usually interested in the position of each crossing, the time, and sometimes the momentum or particle type.
For a PET or gamma detector project you may care about deposited energy, time, and which crystal (ID) was hit, so you can build energy spectra and coincidence events.
For the final project, write down a minimal set of quantities such as energy, time, detector ID and position, that you will store for each interaction or for each detector element per event. This design choice will guide your hit class and sensitive detector implementation. Collecting too much detail can slow the simulation and produce unnecessarily large output. Collecting too little can make later analysis impossible.
Decide your hit content before coding. Changing the hit structure later usually means changing your analysis code and may invalidate data you already produced.
Creating a Hit Class for Your Detector
A hit represents the response of a single detector element or channel during an event. In Geant4, a hit is an object derived from a hit base class such as G4VHit. For the final project you will typically create one hit class per detector type, for example MyDetectorHit for a generic detector, CalorimeterHit for a calorimeter, or CrystalHit for scintillator crystals.
A minimal hit class usually contains:
An identifier of the detector element, like copy number or channel ID.
Measured (or simulated) energy $E_{\text{dep}}$ in that element.
Time information, for example the earliest time or the time of the energy deposit.
Position, such as the step position or the center of the detector element.
Optionally, particle or track information, for example PDG code or track ID, useful for debugging or detailed studies.
In C++ terms, your hit class is a small data container with member variables, setters and getters, and the methods required by Geant4, such as a constructor, destructor, and potentially Draw() or Print() methods. For large simulations you usually do not draw hits but having a Print() method can be helpful when debugging your final project.
Even if in your analysis you plan to use summed quantities per event, it is still useful to record step-level hits during early development, then later simplify or aggregate them once you know exactly what you need.
Implementing a Sensitive Detector Class
The core of the detector response is your sensitive detector class, derived from G4VSensitiveDetector. In the final project it will be one of your main user-defined classes, for example MyDetectorSD or CrystalSD. This class defines how each step inside a sensitive volume is translated into hits.
A typical sensitive detector needs to:
Declare the name of its hit collection.
Create the collection at the beginning of each event.
Respond to each step inside its attached volumes via the ProcessHits method.
Store hits into the collection for later access by your event or run actions.
The key method is usually
G4bool ProcessHits(G4Step step, G4TouchableHistory history);
Inside ProcessHits, you will extract information from the step such as total energy deposited, global time or position, then either create a new hit object or update an existing hit for that detector element.
For a calorimetric detector you often sum all energy in a cell, so ProcessHits will look up if a hit for that cell already exists in the current event and add the new step’s energy. For a tracker-style detector you may create a separate hit per step or per crossing.
Even though the detailed C++ code belongs to other chapters, conceptually your sensitive detector is where physics events become detector signals that you will later convert into histograms and ntuples.
ProcessHits is called for every step in your sensitive volume. Unnecessary complex logic inside this method can strongly affect performance, especially in large final project runs.
Attaching Sensitive Detectors to Logical Volumes
Once you have a sensitive detector class, you must attach instances of it to the logical volumes that represent the active parts of your detector. This is usually done in your detector construction class or in a dedicated geometry setup method.
You normally:
Create an instance of your sensitive detector, often via the Geant4 SD manager.
Register that sensitive detector with the SD manager.
Assign it to the logical volume that should be sensitive.
If you have many identical detector elements such as an array of crystals or layers, you typically assign one sensitive detector instance to the logical volume that is replicated or parameterized. Geant4 then uses the copy number of the physical volume to distinguish which element was hit. This avoids creating thousands of sensitive detector objects.
In the final project, ensure that only the appropriate volumes are marked as sensitive. Support structures, shielding or world volumes should remain non sensitive to avoid useless hits and slower simulations. The boundary between sensitive and non sensitive volumes should match the conceptual “active area” of your detector.
Attaching a sensitive detector to a physical volume is not supported. Always attach to the corresponding logical volume so that all of its placements share the same sensitive behavior.
Managing Hit Collections per Event
Hits created by your sensitive detector are stored in hit collections. Each sensitive detector usually has one hit collection type, and each event has its own instance of that collection. This organization is important for your final project, because you will usually analyze or write out the data event by event.
Conceptually, the sequence is:
At the beginning of an event, your sensitive detector creates a fresh hit collection and registers it with the event’s collection of collections.
During the event, each call to ProcessHits creates or updates hits in that collection.
At the end of the event, your event action can retrieve the hit collection by its ID and process or copy the information into analysis structures such as histograms or ntuples.
For example, in a PET-like final project you might, at the end of each event, inspect the hit collection to find which crystals were hit and with what energy and time. You can then apply an energy window, build coincidence pairs, and fill your analysis output.
Pay attention to the mapping between collection names and IDs. Once initialized, these IDs stay constant within a run. It is good practice in your final project to obtain the IDs once during initialization of your event action and store them, instead of looking them up every event.
Never keep hit pointers from one event and use them in another. Hits are owned by the event’s hit collections and are only valid for the lifetime of that event.
Planning Data Flow into the Analysis Stage
Sensitive detectors are the first stage of your data pipeline. The information they produce must match what your analysis code expects. In the context of the final project, you already know that later you will:
Create histograms and ntuples.
Write output files for ROOT or other tools.
Validate detector performance and physics.
To make this smooth, design a clear mapping from hit information to analysis variables. For instance:
If your analysis will plot an energy spectrum per detector element, ensure that each hit carries a detector ID, and that you sum energy per detector element before filling the histogram.
If you need time versus energy information, your hits must carry both, not just one.
If you plan to calculate efficiency or spatial resolution, you will need counts of incident vs detected particles and accurate positions.
A simple and robust strategy for the final project is:
Keep sensitive detectors responsible only for collecting raw detector-like information, like energy deposits and times.
Use event and run actions to transform that raw information into higher level quantities and fill the analysis manager.
By keeping responsibilities separated, it is easier to adjust your analysis logic without touching the detector response implementation, and vice versa. This also improves clarity when you later document your final project.
Do not perform file I/O or heavy analysis directly inside ProcessHits. Use user actions and the Geant4 analysis system to write data in a controlled and efficient way.
Testing and Debugging Your Detector Response
After implementing sensitive detectors, you must verify that they behave as intended before running long final project simulations. A few targeted tests can save a lot of wasted computation time.
First, run with a small number of events and simple particle sources that hit a known part of your detector. Use verbose stepping or dedicated printouts to check that:
Steps in sensitive volumes produce hits.
Energy deposition values are non zero where expected and zero where not.
Detector IDs or copy numbers correspond to the physical locations you think they do.
Second, visualize your geometry and particle tracks, and compare with printed hit positions. This helps you confirm that the geometry, placement, and sensitive assignments are consistent.
Third, cross check energy conservation qualitatively. For example, if particles are stopped in your detector, the sum of energy deposited in the hits should be close to the initial particle energy (minus any escaping secondaries). This connects to later validation steps but can already reveal obvious bugs such as missing sensitive volumes or wrong unit usage.
Finally, once basic behavior is confirmed, remove or reduce debug printouts and move to using histograms and ntuples. This keeps your final project efficient and makes the analysis workflow more realistic.
By following this approach, your sensitive detector implementation becomes a reliable and well understood component in your complete Geant4 final project.
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!