KAHIBARO Bookshelves
Discord Login Register

25.13. Analyzing PET Data with ROOT

Preparing to Analyze PET Data

In a PET simulation you typically end with a ROOT file that contains event-level information from Geant4, such as detector IDs, times, energies, and line of response parameters. This chapter focuses on how to work with that ROOT output, not on how to generate it in Geant4. The goal is to go from a collection of coincidence events to physics and imaging quantities that you can inspect, plot, and understand.

Although PET analysis can become very sophisticated, you can already learn a lot from simple ROOT macros that read your trees, apply basic cuts, and fill histograms.

Exploring the ROOT File

Start by opening your PET ROOT file with the ROOT browser. If your Geant4 analysis used G4AnalysisManager to create an ntuple called for example "PET", you will usually find a TTree like "PET" or "PET_ntuple" inside the file.

In a ROOT session, open the file and list its contents:

cpp
TFile *f = TFile::Open("pet_output.root");
f->ls();

Look for a TTree that contains one entry per coincidence event or per detected hit, depending on how you set up your Geant4 output. For PET analysis it is convenient to have a tree where each entry corresponds to one coincidence event, with both hits stored in the same row. A simple structure could be:

Branch nameTypeMeaning
E1DoubleEnergy in detector 1
E2DoubleEnergy in detector 2
t1DoubleTime of detector 1 hit
t2DoubleTime of detector 2 hit
detID1IntID of detector 1
detID2IntID of detector 2
x1, y1, z1DoublePosition of detector 1 hit
x2, y2, z2DoublePosition of detector 2 hit
LORx, LORy, LORzDoubleDerived line of response parameters

The exact branch names and structure depend on your Geant4 implementation, but the analysis ideas are the same. Use the TBrowser in ROOT to inspect branches interactively:

cpp
TBrowser *b = new TBrowser();

Then double click on your TTree and explore the branches to confirm what is stored.

Basic Quality and Sanity Checks

Before doing detailed analysis, check that the data are sensible. Plot simple 1D and 2D distributions directly with ROOT.

For example, inspect the energy deposited in one crystal:

cpp
TTree *t = (TTree*)f->Get("PET");
t->Draw("E1");

You should see a distribution reflecting the gamma interaction spectrum in a single crystal. If you are simulating 511 keV photons, the spectrum will show a Compton continuum and maybe a visible photopeak if your geometry and materials allow.

Check correlations between the energies in the two detectors:

cpp
t->Draw("E2:E1","","colz");

You expect a band roughly centered around the 511 keV line if you performed coincidence selection already, with events where both energies are around the photopeak and many with one or both energies lower due to partial energy deposition.

Perform similar sanity checks for hit positions and times:

cpp
t->Draw("t2-t1");
t->Draw("z1");
t->Draw("z2");

These quick checks often reveal obvious problems like uninitialized branches, units misunderstandings, or missing cuts in your simulation output.

Always confirm units and coordinate conventions before interpreting PET results. Check that energies are in keV or MeV as expected, times are in ns or ps consistently, and positions are in mm or cm in agreement with your Geant4 geometry.

Energy Windowing in ROOT

PET relies on selecting gamma interactions that are likely to correspond to true 511 keV annihilation photons. This is done with an energy window around the photopeak. Even if you applied an energy window in Geant4, it is useful to be able to change or refine that window in ROOT.

A typical PET energy window might be something like 350 keV to 650 keV around the 511 keV line. In ROOT you can apply this window dynamically using TTree::Draw.

For a symmetric window on both detectors you could write:

cpp
double Emin = 350.0; // keV
double Emax = 650.0; // keV
TString cut = Form("E1>%f && E1<%f && E2>%f && E2<%f", Emin, Emax, Emin, Emax);
t->Draw("E1", cut);

You can then overlay distributions for different window choices to study the effect of tightening or loosening the energy selection. For example, compare two windows:

cpp
t->Draw("E1", "E1>400 && E1<600", "");
t->Draw("E1", "E1>450 && E1<550", "same");

The narrower window will reduce scatter events but also reduce statistics. You can quantify the fraction of events that pass the window by using TTree::GetEntries:

cpp
Long64_t total = t->GetEntries();
Long64_t passed = t->GetEntries(cut);
double efficiency = double(passed) / double(total);

This gives a simple measure of the detection efficiency versus energy window width, which is often interesting when you study trade-offs in PET system design.

Coincidence and Time-of-Flight Analysis

If you stored event-level coincidence information in your ROOT TTree, you can analyze the timing difference between the two detectors in a coincidence pair. This is important both for validating the coincidence selection and for exploring time-of-flight capabilities.

Compute the time difference:

cpp
t->Draw("t2 - t1", cut);

where cut is the energy window condition you defined earlier. The resulting histogram should show a peak centered around zero if your time stamps are correctly referenced. The width of this peak is related to the time resolution of your detector system.

You can fit this peak with a Gaussian:

cpp
TH1F *hDT = new TH1F("hDT","Time difference; t2-t1 [ns]; Counts",200,-5,5);
t->Draw("t2-t1 >> hDT", cut);
hDT->Fit("gaus");

The Gaussian sigma gives a simple estimate of the coincidence timing resolution. If you are simulating time-of-flight PET, you can then relate time difference to position along the line of response. For annihilation photons traveling at speed of light $c$, the position offset $\Delta x$ from the middle of the detector pair satisfies:

$$
\Delta x = \frac{c \Delta t}{2}
$$

where $\Delta t = t_2 - t_1$.

The relation between time difference and position along the line of response is
$$
\Delta x = \frac{c \Delta t}{2}
$$
Make sure your time units and $c$ units are consistent, for example $\Delta t$ in ns and $c \approx 0.3\ \text{mm}/\text{ps} = 300\ \text{mm}/\text{ns}$.

In ROOT you can create a histogram of the inferred position along the LOR from the time difference:

cpp
const double c_mm_per_ns = 299.792458; // mm/ns
t->Draw(Form("0.5*%f*(t2-t1)", c_mm_per_ns), cut);

This type of plot is mainly useful to understand the intrinsic timing spread and how it would translate into spatial uncertainty along the LOR.

Simple Image Reconstruction Plots

A full PET image reconstruction algorithm is beyond the scope of a beginner course. However, you can still create intuitive 2D maps that show where coincidence events are likely to originate in space.

For a simple ring PET geometry with detectors around the origin in the transverse plane, and a small object placed near the center, you can approximate the event origin as the midpoint of the two detector hit positions. This is a rough backprojection method, but it helps visualize the emission distribution.

For each coincidence event compute the midpoint coordinates:

$$
x_{\text{mid}} = \frac{x_1 + x_2}{2},\quad
y_{\text{mid}} = \frac{y_1 + y_2}{2}
$$

You can fill these directly in ROOT:

cpp
TString cut = "E1>350 && E1<650 && E2>350 && E2<650";
t->Draw("(y1+y2)/2.0:(x1+x2)/2.0", cut, "colz");

The resulting 2D histogram shows a simple backprojected activity map. For a point source at the center of the ring you should see a localized region of higher counts around the center. For an extended phantom the pattern will approximate its shape.

You can also restrict the analysis to a specific axial slice if you stored z1 and z2. For example, select only events where both detectors are in a central slice:

cpp
cut += " && abs(z1) < 5 && abs(z2) < 5";
t->Draw("(y1+y2)/2.0:(x1+x2)/2.0", cut, "colz");

This demonstrates the connection between detector hits and reconstructed image space, even if it is not a proper tomographic reconstruction.

Evaluating PET Performance Metrics

With your ROOT data you can estimate basic performance quantities of your simulated PET system. These include simple count-based measures like true, scatter, and random coincident event fractions, and geometric relationships such as sinograms.

If you tagged events in Geant4 with information about whether they are true, scattered, or random coincidences, you can store a classification branch, for example:

BranchTypeMeaning
typeInt0 true, 1 scatter, 2 random, etc.

Then in ROOT you can count how many events of each type pass your energy and timing cuts:

cpp
TString commonCut = "E1>350 && E1<650 && E2>350 && E2<650";
Long64_t nTrue = t->GetEntries(commonCut + " && type==0");
Long64_t nScatter = t->GetEntries(commonCut + " && type==1");
Long64_t nRandom = t->GetEntries(commonCut + " && type==2");
double total = double(nTrue + nScatter + nRandom);
double fTrue = nTrue / total;
double fScatter = nScatter / total;
double fRandom = nRandom / total;

You can then print and compare these fractions for different choices of energy windows, timing windows, or geometry configurations.

Another important PET concept is the sinogram, which represents the number of events as a function of LOR projection angle and radial offset. If your detectors are arranged in a simple ring and you stored detector IDs that map to angular positions, you can try a basic sinogram creation.

Assume that each detector ID corresponds to angle $\phi_i$ around the ring, and you have a mapping array:

cpp
const int nDet = 64;
double angle[nDet];
for (int i = 0; i < nDet; ++i) {
  angle[i] = 2.0*TMath::Pi()*i/nDet; // simple ring
}

In a ROOT macro, you can loop over entries and fill a 2D histogram for sinogram bins. A very simple geometry might use the angle of the LOR and a crude radial coordinate, although full sinogram definition can be more detailed.

Even without full sinogram reconstruction, counting coincidences as a function of detector pair angle is informative:

cpp
TH1F *hAngle = new TH1F("hAngle","LOR angle; angle [rad]; Counts", 64, 0, 2*TMath::Pi());
int det1, det2;
t->SetBranchAddress("detID1", &det1);
t->SetBranchAddress("detID2", &det2);
Long64_t nEntries = t->GetEntries();
for (Long64_t i = 0; i < nEntries; ++i) {
  t->GetEntry(i);
  double phi1 = angle[det1];
  double phi2 = angle[det2];
  double lorAngle = 0.5*(phi1 + phi2);
  if (lorAngle < 0) lorAngle += 2.0*TMath::Pi();
  if (lorAngle >= 2.0*TMath::Pi()) lorAngle -= 2.0*TMath::Pi();
  hAngle->Fill(lorAngle);
}
hAngle->Draw();

For a symmetric central point source you expect a flat distribution in angle. Deviations from flatness can indicate nonuniform detection efficiency, geometric effects, or simulation issues.

Writing Simple ROOT Macros for PET

Rather than issuing many TTree::Draw commands interactively, it is convenient to encapsulate your analysis steps in simple ROOT macros. This also improves reproducibility and makes it easier to share your analysis with others.

A minimal PET analysis macro might follow this pattern:

cpp
void analyze_pet(const char* filename="pet_output.root") {
  TFile *f = TFile::Open(filename);
  if (!f || f->IsZombie()) {
    printf("Cannot open file %s\n", filename);
    return;
  }
  TTree *t = (TTree*)f->Get("PET");
  if (!t) {
    printf("Cannot find tree PET\n");
    return;
  }
  // Define cuts
  TString cutEnergy = "E1>350 && E1<650 && E2>350 && E2<650";
  // Energy spectra
  TCanvas *c1 = new TCanvas("c1","Energy spectra",800,600);
  t->Draw("E1>>hE1(200,0,700)", cutEnergy);
  t->Draw("E2>>hE2(200,0,700)", cutEnergy, "same");
  // Time difference
  TCanvas *c2 = new TCanvas("c2","Time difference",800,600);
  t->Draw("t2-t1>>hDT(200,-5,5)", cutEnergy);
  hDT->Fit("gaus");
  // Simple backprojection
  TCanvas *c3 = new TCanvas("c3","Backprojection",800,600);
  t->Draw("(y1+y2)/2.0:(x1+x2)/2.0>>hXY(200,-100,100,200,-100,100)",
          cutEnergy, "colz");
  // Save canvases
  c1->SaveAs("pet_energy.png");
  c2->SaveAs("pet_timing.png");
  c3->SaveAs("pet_backprojection.png");
}

Running:

cpp
root -l -q 'analyze_pet.C("pet_output.root")'

creates and saves the key plots in one step. You can then iterate on this macro to add more performance metrics, such as efficiency curves, scatter fractions, or angle distributions.

Keep your PET analysis macros under version control and document the branches and cuts they use. This ensures that you can reproduce figures, track changes, and avoid silent mismatches between simulation versions and analysis code.

By combining these ROOT techniques with the PET-specific information you already recorded in your Geant4 simulation, you gain a flexible environment for exploring detector performance, event selection strategies, and basic imaging properties.

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

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