KAHIBARO Bookshelves
Discord Login Register

35.10. Analyze the Results with ROOT

Preparing ROOT for Final Project Analysis

For the final project, you already have a Geant4 simulation that writes output in a ROOT compatible format using G4AnalysisManager. This chapter focuses only on what you do after the simulation has finished: how to open the ROOT file, inspect its contents, make plots, apply cuts, and extract physics results.

You will work mainly inside a ROOT session or a small ROOT macro, not inside Geant4.

Inspecting the Output ROOT File

Once your Geant4 run is complete, you should have one or more ROOT files, for example finalProject.root. Start an interactive ROOT session from the command line:

bash
root finalProject.root

ROOT automatically opens a prompt where you can inspect the file content.

Use TFile::ls() to see what objects are stored:

cpp
TFile *f = (TFile*)gROOT->GetListOfFiles()->At(0);
f->ls();

If you used G4AnalysisManager to create histograms and ntuples, you will typically see:

  • One or more TH1 or TH2 objects, such as hEdep.
  • One TTree or TNtuple, such as ntuple or Ntuple0.

To explore the branches of a TTree, for example:

cpp
TTree *t = (TTree*)f->Get("ntuple");
t->Print();

This prints branch names and types, such as Edep, x, y, z, time, eventID, detID and any other columns you defined.

Always verify branch names and types in the ROOT file before writing analysis code. Using a wrong branch name or assuming a wrong type often leads to silent mistakes in your results.

If you used G4AnalysisManager’s default naming, ntuples may be called "ntuple0", "ntuple1", and histograms "h0", "h1", and so on. Check your Geant4 code or the ROOT file listing to find the exact identifiers.

Plotting Basic Distributions

ROOT can quickly plot histograms and tree variables. If your Geant4 application created a histogram, such as an energy spectrum called Edep, you can draw it directly:

cpp
TH1D *hEdep = (TH1D*)f->Get("Edep");
hEdep->Draw();

If you only stored an ntuple (tree) with columns, use the ROOT Draw method:

cpp
TTree *t = (TTree*)f->Get("ntuple");
t->Draw("Edep");

ROOT automatically creates a histogram of the variable Edep using default binning. To specify the number of bins and range:

cpp
t->Draw("Edep>>hE(200, 0, 2.0)"); // 200 bins from 0 to 2.0 (e.g. MeV)
TH1D *hE = (TH1D*)gDirectory->Get("hE");

You can set axis titles and style for clearer plots:

cpp
hE->GetXaxis()->SetTitle("Deposited energy [MeV]");
hE->GetYaxis()->SetTitle("Counts");
gStyle->SetOptStat(1110); // Show entries, mean, RMS
hE->Draw();

Use logy for spectra that span several orders of magnitude:

cpp
gPad->SetLogy();
hE->Draw();

You can quickly check other distributions in the same way, for example position or time:

cpp
t->Draw("x");                 // X position distribution
t->Draw("time");              // Time distribution
t->Draw("y:x>>hXY(100, -50, 50, 100, -50, 50)"); // 2D hit map

For 2D histograms, choose a color representation:

cpp
TH2D *hXY = (TH2D*)gDirectory->Get("hXY");
hXY->Draw("COLZ");

These quick plots help you visually confirm that your Geant4 output is reasonable before doing more detailed analysis.

Always start with simple sanity checks: total entries, typical energy scale, and basic shapes. This often reveals unit mistakes or incorrect cuts very early.

Applying Cuts and Selections

To extract physics quantities such as detector efficiency or background rejection, you usually need to apply selections on the recorded variables. ROOT lets you express cuts as simple C-like strings.

For example, to plot energy only in the central detector, assuming a branch detID:

cpp
t->Draw("Edep>>hCenter(200,0,2.0)", "detID == 0");

To select events above a threshold, for example only hits with Edep > 0.1 MeV:

cpp
t->Draw("Edep>>hAbove(200,0,2.0)", "Edep > 0.1");

To combine cuts:

cpp
t->Draw("Edep>>hSel(200,0,2.0)",
        "detID == 0 && Edep > 0.1 && time < 50");

For coincidence-like conditions that depend on multiple hits in the same event, you often need a more detailed analysis loop, but you can still use ROOT selections to inspect subsets first.

A very useful feature is to compute statistics with cuts using TTree::Draw and TTree::GetSelectedRows. For example, to count the number of hits above a threshold:

cpp
Long64_t nAll  = t->GetEntries();
Long64_t nPass = t->Draw("Edep", "Edep > 0.1", "goff");
double efficiency = double(nPass) / double(nAll);

The "goff" option tells ROOT not to draw a histogram, only to use the selection internally.

When computing quantities like efficiency or transmission, always use the same definition consistently: clearly separate total incident events, detected events, and any energy or timing thresholds used in the selection.

Extracting Physics Quantities

The main goal of your final project analysis is to turn raw simulation output into physical results that answer your project’s scientific question. Typical quantities include energy spectra, efficiencies, depth dose curves, or spatial distributions.

Energy spectra and peak analysis

To analyze an energy spectrum, first create a clean histogram, then extract basic statistics and, if needed, fit peaks.

Assume you have a histogram hE with the total deposited energy per event in a detector. You can retrieve useful quantities:

cpp
int    entries = hE->GetEntries();
double mean    = hE->GetMean();
double rms     = hE->GetRMS();

To focus on a particular energy region, for example near a gamma peak, you can restrict the fit range and use a Gaussian model:

cpp
TF1 *gaus = new TF1("gaus", "gaus", 0.4, 0.6); // fit 0.4–0.6 MeV region
hE->Fit(gaus, "R");

After the fit, you can access fitted parameters:

cpp
double peakE   = gaus->GetParameter(1); // mean
double sigmaE  = gaus->GetParameter(2); // sigma
double fwhm    = 2.355 * sigmaE;
double res     = fwhm / peakE;          // relative energy resolution

You can then report energy resolution, compare to expectations, or compare between different detector configurations.

Efficiencies and probabilities

If you stored one entry per event with a total deposited energy EdepTotal, you can estimate the detection efficiency above some threshold:

cpp
TTree *tEvent = (TTree*)f->Get("eventNtuple");
Long64_t nTotal = tEvent->GetEntries();
Long64_t nDet   = tEvent->Draw("EdepTotal",
                               "EdepTotal > 0.2", "goff");
double eff      = double(nDet) / double(nTotal);
double sigmaEff = std::sqrt(eff * (1.0 - eff) / nTotal);

This efficiency with statistical uncertainty is usually a key result when comparing detector designs or materials.

Depth dose or spatial distributions

If your project involves a phantom or detector divided into bins (for example voxel ID or slice index), you probably stored an index and an energy per hit. To obtain a depth dose curve, you can accumulate energy as a function of bin index with a TProfile or histogram.

For example, suppose you have branches sliceID and Edep for each step or hit:

cpp
TTree *tHit = (TTree*)f->Get("hits");
TProfile *pDose = new TProfile("pDose","Depth dose",
                               100, 0, 100, 0, 1e6); // slice 0–99
tHit->Draw("Edep:sliceID>>pDose", "", "prof");
pDose->GetXaxis()->SetTitle("Slice index");
pDose->GetYaxis()->SetTitle("Mean deposited energy [MeV]");
pDose->Draw();

You can convert slice index to depth in mm or cm by setting custom axis labels or by using a histogram with an appropriate binning that reflects real distances.

Coincidences and correlations

If your final project involves coincidence detection or correlations between two detectors, you may have ntuples with one entry per hit and fields like eventID, detID, Edep, and time. In this case, a straightforward analysis is often easier with a small ROOT macro that loops over the tree, groups hits by event, and applies coincidence criteria.

For example, a simplified outline in a macro:

cpp
void analyzeCoincidences() {
  TFile *f = TFile::Open("finalProject.root");
  TTree *t = (TTree*)f->Get("hits");
  int eventID, detID;
  double Edep, time;
  t->SetBranchAddress("eventID", &eventID);
  t->SetBranchAddress("detID",   &detID);
  t->SetBranchAddress("Edep",    &Edep);
  t->SetBranchAddress("time",    &time);
  const double Ecut = 0.3;
  const double dtMax = 5.0; // time window, for example ns
  Long64_t nEntries = t->GetEntries();
  int currentEvent = -1;
  std::vector<int>    dets;
  std::vector<double> times;
  std::vector<double> edeps;
  int nCoinc = 0;
  for (Long64_t i = 0; i < nEntries; ++i) {
    t->GetEntry(i);
    if (eventID != currentEvent && currentEvent != -1) {
      // Analyze hits of the previous event
      for (size_t a = 0; a < dets.size(); ++a) {
        if (edeps[a] < Ecut) continue;
        for (size_t b = a+1; b < dets.size(); ++b) {
          if (edeps[b] < Ecut) continue;
          if (std::fabs(times[a] - times[b]) < dtMax) {
            ++nCoinc;
          }
        }
      }
      dets.clear();
      times.clear();
      edeps.clear();
    }
    currentEvent = eventID;
    dets.push_back(detID);
    times.push_back(time);
    edeps.push_back(Edep);
  }
  // Analyze last event
  // (repeat coincidence check here if needed)
  std::cout << "Total coincidences: " << nCoinc << std::endl;
}

You can adapt this structure to your final project needs, such as storing coincidence energy sums, line of response information, or other derived quantities.

When performing event-based analyses such as coincidences or track reconstruction, always make sure your tree is properly sorted by eventID. If not, group hits using both eventID and entry index, or sort them explicitly inside your macro.

Producing Publication-Quality Plots and Tables

For the final project report, you will likely need high quality figures and numerical summaries of your results. ROOT allows you to customize plots and export them to vector or bitmap formats.

To improve the appearance of a canvas:

cpp
TCanvas *c1 = new TCanvas("c1","Energy spectrum",800,600);
c1->SetGrid();
hE->SetLineColor(kBlue+1);
hE->SetLineWidth(2);
hE->SetTitle("Detector energy spectrum;Energy [MeV];Counts");
hE->Draw();
c1->SaveAs("energy_spectrum.pdf");
c1->SaveAs("energy_spectrum.png");

You can also combine multiple histograms in one plot to compare configurations, for example different materials or thicknesses:

cpp
TH1D *hLead  = (TH1D*)f->Get("Edep_lead");
TH1D *hAl    = (TH1D*)f->Get("Edep_aluminum");
hLead->SetLineColor(kRed);
hAl->SetLineColor(kBlue);
hLead->SetTitle("Energy spectra;Energy [MeV];Counts");
hLead->Draw();
hAl->Draw("SAME");
TLegend *leg = new TLegend(0.6,0.7,0.88,0.88);
leg->AddEntry(hLead, "Lead", "l");
leg->AddEntry(hAl,   "Aluminum", "l");
leg->Draw();
c1->SaveAs("comparison_materials.pdf");

To summarize key numerical results, you can print them directly from ROOT:

cpp
std::cout << "Detection efficiency: " << eff*100.0
          << " % ± " << sigmaEff*100.0 << " %" << std::endl;

You can copy these values into your report, or export them to a CSV file by writing them out yourself or using ROOT’s TTree::Scan or TTree::Draw("var >> file.csv") features.

Use consistent units and labels in all plots and tables, and explicitly state thresholds, cuts, and normalization choices. This is essential for others to interpret your final project results correctly.

Connecting Simulation and Analysis

At this stage of the course you should see a full chain:

  1. Geant4 simulation produces ROOT data (ntuples, histograms).
  2. ROOT is used to visualize the raw distributions.
  3. Cuts and selections are applied to extract physically meaningful observables.
  4. Fits, integrals, and counting give quantitative results with uncertainties.
  5. Plots and tables summarize these results in a clear, reproducible way.

If you find during ROOT analysis that you are missing an important variable, or that your ntuple structure makes some analysis difficult, note this for later improvement of your Geant4 application. A well designed output format simplifies ROOT analysis, especially in larger projects.

For the final project, your goal is to demonstrate that you can complete this whole cycle: use simulation output, analyze it in ROOT, and present results that directly answer your chosen scientific question.

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