25.11. Creating Lines of Response
Table of Contents
Concept of a Line of Response
In a PET scanner, each valid coincidence event corresponds to the (approximate) detection of two annihilation photons that were emitted back to back. Each photon is detected in a different detector crystal. If you know the positions of these two detector elements, you can construct the straight line that connects them. This line is called a line of response, often abbreviated as LOR.
In your Geant4 simulation, creating LORs means transforming the information you already have for coincidence events into a simple geometric description: for each coincidence, you store the coordinates of the two detector hits and treat the line between them as one measured LOR. Later, reconstruction code can use these LORs to estimate the spatial distribution of activity in the field of view.
For the purpose of this beginner example, an LOR will usually be represented in the simplest possible way, by the two 3D points where the photons were detected. More compact parameterizations are possible, but the two end points are straightforward to compute and easy to write to an output file.
An LOR in this context is defined by two distinct detector hit positions that belong to the same coincidence event and are not located in the same detector element.
Choosing an LOR Representation
The simplest representation of a line of response uses two global position vectors, one for each detector hit. In Geant4, these positions are typically stored as $G4ThreeVector$ objects in your hit class or in your coincidence event class.
A basic representation in C++ might conceptually look like this:
class PetLOR {
public:
G4ThreeVector p1; // first detector hit position, global coordinates
G4ThreeVector p2; // second detector hit position, global coordinates
G4double t1; // detection time of first hit
G4double t2; // detection time of second hit
G4double e1; // deposited energy in first detector
G4double e2; // deposited energy in second detector
};You do not have to create a dedicated C++ class if you prefer to write values directly into an ntuple, but it is often clearer to think in terms of an object like this. The essential part of the LOR is the pair of positions $(\mathbf{p}_1, \mathbf{p}_2)$. Time and energy can be stored with the LOR for later use, for example for time of flight analysis or for applying additional energy cuts offline.
It is useful to emphasize that you do not need to compute a unit direction vector or parametric form of the line unless you specifically need it. The reconstruction software can always compute such derived quantities from the two endpoints:
$$
\mathbf{d} = \mathbf{p}_2 - \mathbf{p}_1, \quad
\hat{\mathbf{u}} = \frac{\mathbf{d}}{|\mathbf{d}|}.
$$
The minimal LOR data that you must store is:
- Position of hit 1, $\mathbf{p}_1 = (x_1, y_1, z_1)$.
- Position of hit 2, $\mathbf{p}_2 = (x_2, y_2, z_2)$.
Both positions should be in a consistent coordinate system, usually the global coordinates of the simulation.
Extracting Detector Positions from Hits
Before you can form an LOR, you must extract the positions of the two detector hits that form a coincidence. Earlier in the PET example, you recorded detector hits and then selected coincidence events. At the stage where you know which two hits belong to a coincidence, you already have access to each hit’s position, time, energy, and detector ID.
A typical PET hit class will have at least the following members:
class PetHit : public G4VHit {
public:
G4ThreeVector fPosition;
G4double fTime;
G4double fEnergy;
G4int fDetectorID;
// ...
};
When coincidence finding logic has identified two hits, say hitA and hitB, you obtain the positions like this:
G4ThreeVector p1 = hitA->GetPosition();
G4ThreeVector p2 = hitB->GetPosition();These positions should already be in global coordinates if they were recorded that way in the hit. If you stored local coordinates instead, you must convert them to global coordinates by applying the relevant transform for the detector volume, but for a beginner PET example it is usually simpler to store global positions from the beginning.
It is also common to read out associated information at the same time:
G4double t1 = hitA->GetTime();
G4double t2 = hitB->GetTime();
G4double e1 = hitA->GetEnergy();
G4double e2 = hitB->GetEnergy();
G4int detID1 = hitA->GetDetectorID();
G4int detID2 = hitB->GetDetectorID();You can optionally apply final checks here, for example to ensure that the two hits are not in the same detector crystal, and that they satisfy any time and energy conditions you require.
Always verify that:
- The two hits belong to the same PET event,
- They passed your energy window and timing criteria,
- Their detector IDs are different.
Only then should you construct an LOR.
Building the LOR from Coincidence Hits
Once you have two valid hits, the next step is to build the LOR and prepare it for output. Conceptually, you take the two global positions and store them together as one line of response.
If you use a dedicated LOR object, the creation is straightforward:
PetLOR lor;
lor.p1 = p1;
lor.p2 = p2;
lor.t1 = t1;
lor.t2 = t2;
lor.e1 = e1;
lor.e2 = e2;If your focus is on simple PET without time of flight, you can already use this. If you plan to explore time of flight PET, you may also want to compute time and position along the line, but that can be done later in the analysis code.
A useful derived quantity is the midpoint of the LOR, which is often used for simple backprojection methods:
$$
\mathbf{m} = \frac{\mathbf{p}_1 + \mathbf{p}_2}{2}.
$$
In C++ this is:
G4ThreeVector mid = 0.5 * (p1 + p2);Storing this midpoint along with the endpoints can simplify very basic reconstruction demonstrations, because you can, for example, fill a 2D histogram of $(x_{\text{mid}}, y_{\text{mid}})$ to visualize where events concentrate.
Another useful derived quantity, especially for a symmetric ring, is the LOR length:
$$
L = |\mathbf{p}_2 - \mathbf{p}_1|.
$$
You can use this to perform sanity checks, for instance by comparing $L$ to the expected diameter of your detector ring.
The LOR direction and midpoint follow directly from the endpoints:
\[
\mathbf{d} = \mathbf{p}_2 - \mathbf{p}_1,\quad
L = |\mathbf{d}|,\quad
\hat{\mathbf{u}} = \frac{\mathbf{d}}{L},\quad
\mathbf{m} = \frac{\mathbf{p}_1 + \mathbf{p}_2}{2}.
\]
You do not need to store all of these if storage space is limited. The endpoints are sufficient.
Storing LORs with G4AnalysisManager
To use the LORs outside Geant4, for example in ROOT-based reconstruction, you must write their information to an output file. In this course, the Geant4 analysis system with G4AnalysisManager is used to record such data. You have already used it for energies and positions. Now you extend your ntuple or histograms to include LOR information.
A convenient way is to create an ntuple dedicated to LORs, with one row per coincidence event. A minimal structure might look like the following table.
| Column name | Content |
|---|---|
| eventID | Event ID in the Geant4 simulation |
| x1, y1, z1 | Coordinates of hit 1 |
| x2, y2, z2 | Coordinates of hit 2 |
| t1, t2 | Times of hit 1 and hit 2 |
| e1, e2 | Deposited energies in each detector |
In your analysis initialization you define this ntuple:
auto analysisManager = G4AnalysisManager::Instance();
analysisManager->CreateNtuple("LOR", "PET lines of response");
analysisManager->CreateNtupleIColumn("eventID");
analysisManager->CreateNtupleDColumn("x1");
analysisManager->CreateNtupleDColumn("y1");
analysisManager->CreateNtupleDColumn("z1");
analysisManager->CreateNtupleDColumn("x2");
analysisManager->CreateNtupleDColumn("y2");
analysisManager->CreateNtupleDColumn("z2");
analysisManager->CreateNtupleDColumn("t1");
analysisManager->CreateNtupleDColumn("t2");
analysisManager->CreateNtupleDColumn("e1");
analysisManager->CreateNtupleDColumn("e2");
analysisManager->FinishNtuple();Then, when your PET coincidence code has just created an LOR, you fill these columns. This usually takes place in an event or run action, after you have performed coincidence sorting for the event:
G4int eventID = G4RunManager::GetRunManager()->GetCurrentEvent()->GetEventID();
analysisManager->FillNtupleIColumn(0, eventID);
analysisManager->FillNtupleDColumn(1, lor.p1.x());
analysisManager->FillNtupleDColumn(2, lor.p1.y());
analysisManager->FillNtupleDColumn(3, lor.p1.z());
analysisManager->FillNtupleDColumn(4, lor.p2.x());
analysisManager->FillNtupleDColumn(5, lor.p2.y());
analysisManager->FillNtupleDColumn(6, lor.p2.z());
analysisManager->FillNtupleDColumn(7, lor.t1);
analysisManager->FillNtupleDColumn(8, lor.t2);
analysisManager->FillNtupleDColumn(9, lor.e1);
analysisManager->FillNtupleDColumn(10, lor.e2);
analysisManager->AddNtupleRow();The exact column indices depend on the order in which you defined them, so make sure they are consistent. Once the run finishes, the analysis manager will write these LOR entries to a file format of your choice, for example a ROOT file. Later chapters will show how to open this file with ROOT and perform LOR based reconstruction steps.
When using G4AnalysisManager to record LORs:
- Create a dedicated ntuple for LORs.
- Call
FillNtuple*Columnonly after you have confirmed a valid coincidence. - Call
AddNtupleRow()once for each LOR you create.
Sanity Checks and Simple Diagnostics
Before relying on your LOR data for reconstruction, it is important to confirm that your simulation is writing reasonable information. A few simple diagnostics can be applied directly to the stored LORs.
You can check that the LOR endpoints lie on the detector ring by plotting their radius in ROOT. If your detector ring is centered at the origin and lies in the $x$-$y$ plane, the transverse radius of a point is
$$
r = \sqrt{x^2 + y^2}.
$$
If the crystals are arranged at radius $R$, most endpoints should cluster near $R$.
You can also inspect the distribution of LOR midpoints. For a point-like positron source at the center, the midpoint distribution should cluster near the origin. If you move the source in the simulation, you should see the cluster follow the source position.
Finally, you can check that the LOR directions look isotropic as seen from the source. For example, you can plot the polar angle and azimuthal angle of the vector $\mathbf{d} = \mathbf{p}_2 - \mathbf{p}_1$.
Performing these simple plots on the LOR file is an effective way to verify that your coincidence selection and LOR construction are correct before you proceed to more complex PET image reconstruction.
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!