23.10. Analyzing the Spectrum with ROOT
Table of Contents
Preparing the ROOT Environment
To analyze the gamma ray detector spectrum, you will use the ROOT framework to read and plot the data that your Geant4 application produced. At this stage, you should already have a ROOT file created by G4AnalysisManager that contains at least one 1D histogram of deposited energy in the scintillator.
Start by launching ROOT from a terminal using the root command. You can work either in the interactive C++ prompt (the ROOT shell, called CINT or Cling in recent ROOT versions) or by writing short macros in .C files. For beginners, the interactive prompt is usually more convenient.
Once ROOT is open, you will load your output file with the TFile class. ROOT works with objects stored in files, and you can list the contents, retrieve histograms, and immediately draw them on a canvas for inspection.
It is good practice to know the exact names of your histograms and ntuples from your Geant4 code. The names you pass to CreateH1, CreateNtuple, and similar methods in G4AnalysisManager will appear as object names in the ROOT file.
Always make sure that the ROOT file you want to analyze is closed properly by Geant4 before opening it in ROOT. Opening a file that is still being written can lead to corrupted or incomplete data.
Opening Geant4 Output in ROOT
Assume that in your gamma ray detector example, you configured the analysis manager to write a file such as gammaDetector.root and created a 1D histogram of energy deposition called "Edep" in a directory called "h1".
To open the file in ROOT, start ROOT and run:
TFile *f = TFile::Open("gammaDetector.root");You can check what is inside by listing the top level content:
f->ls();
If you used the default G4AnalysisManager convention with one dimensional histograms, you may see an object directory named "h1" that contains your histograms. You can navigate into it:
f->cd("h1");
gDirectory->ls();
Now you should see your histogram, for example "Edep". Retrieve it as a TH1 object:
TH1D *hE = (TH1D*)gDirectory->Get("Edep");
If you are not sure about the type, you can use TH1 *:
TH1 *hE = (TH1*)gDirectory->Get("Edep");
At this point, hE contains your energy spectrum and is ready to be drawn, rebinned, fitted, or otherwise processed.
If your Geant4 application wrote ntuples instead of or in addition to histograms, you will also see TTree objects in the ROOT file, often named "ntuple" or similar. You can list them with:
f->ls();and then:
TTree *t = (TTree*)f->Get("ntuple");
t->Print();This prints the branches and their types. For a gamma ray detector, you might have branches like energy deposition, detector ID, or event ID.
When you use Get to retrieve objects from a ROOT file, always check that the returned pointer is not nullptr before using it. A null pointer indicates that the object name or path is wrong.
Drawing and Inspecting the Spectrum
Once you have the histogram in memory, you can inspect the gamma ray energy spectrum visually. ROOT uses a TCanvas to display graphics.
Create a new canvas and draw the histogram:
TCanvas *c1 = new TCanvas("c1", "Gamma-ray energy spectrum", 800, 600);
hE->Draw();By default, ROOT draws a step-like histogram. You can change the draw option, for example:
hE->Draw("HIST");
hE->SetLineColor(kBlue);
hE->SetLineWidth(2);You can also change axis titles so that the plot is physically meaningful:
hE->GetXaxis()->SetTitle("Deposited energy [MeV]");
hE->GetYaxis()->SetTitle("Counts");
c1->Update();Zooming into a region of interest can be done interactively with the mouse, or programmatically by setting axis ranges:
hE->GetXaxis()->SetRangeUser(0.0, 2.0); // example: 0 to 2 MeV
c1->Modified();
c1->Update();
If your Geant4 histogram was created with units in mind (for example, filling with edep / MeV), then the x axis is already in MeV. Double check the filling code so that your axis labels correspond to the correct units.
You may find that the statistics box in the top right corner shows total entries, mean, and RMS of the energy distribution. To make it visible or adjust options:
gStyle->SetOptStat(1110); // show entries, mean, RMS
c1->Modified();
c1->Update();Always confirm that the units used to fill the histogram in Geant4 match the units you display in ROOT. A common mistake is to fill energies in keV but label the axis as MeV, which leads to misinterpretation of spectral features.
Basic Statistical Quantities
ROOT can provide basic statistical information about your gamma ray spectrum through methods of TH1. For instance, you can quickly inspect global properties:
Int_t entries = hE->GetEntries();
Double_t mean = hE->GetMean();
Double_t rms = hE->GetRMS();
GetMean and GetRMS operate in the x variable, so here they represent the mean deposited energy and the width of the distribution. These global values are useful for a quick check, but for gamma spectroscopy you are usually more interested in specific peaks rather than the entire distribution.
You can also compute integrals over selected ranges in order to count events in particular energy windows. If you know the bin numbers that correspond to a range, use:
Int_t bin_low = hE->FindBin(0.45); // example: lower energy in MeV
Int_t bin_high = hE->FindBin(0.55); // example: upper energy in MeV
Double_t counts = hE->Integral(bin_low, bin_high);
Integral returns the number of entries in that bin range without any corrections. You can divide this by the total number of simulated primary particles to estimate detection probabilities or efficiencies.
When you work with histograms that have variable bin widths, be aware that Integral can be normalized by bin width. For a uniform binning in this simple example, a plain integral is enough.
When interpreting counts in a given peak or energy region, always normalize by the number of primary gammas simulated if you want to compare simulations that have different event counts or if you compare with experimental efficiencies.
Identifying and Fitting Photopeaks
A central goal of analyzing a gamma ray detector spectrum is to identify characteristic features such as photopeaks, Compton edges, and backscatter peaks. In a simple example with a monoenergetic gamma source, the main visible structure is typically the photopeak at or near the input gamma energy.
To identify the photopeak, visually inspect the spectrum in ROOT and locate the bin corresponding to the maximum of the peak:
Int_t maxBin = hE->GetMaximumBin();
Double_t E_peak_estimate = hE->GetBinCenter(maxBin);
This gives an approximate peak position. To obtain a more precise value and an estimate of the detector energy resolution, you can fit the peak with a Gaussian function. In ROOT, use TF1 to define a Gaussian and fit it to a selected energy range around the peak.
For example, suppose you expect a photopeak around 0.662 MeV (from a Cs-137 source). You can define a fit range around that energy:
TF1 *gaus = new TF1("gaus", "gaus", 0.5, 0.8); // fit between 0.5 and 0.8 MeV
hE->Fit(gaus, "R"); // "R" means use the defined rangeThe Gaussian function in ROOT has three parameters. After the fit, you can access them:
Double_t norm = gaus->GetParameter(0); // amplitude
Double_t mean = gaus->GetParameter(1); // peak position
Double_t sigma = gaus->GetParameter(2); // standard deviation
Double_t meanErr = gaus->GetParError(1);
Double_t sigmaErr = gaus->GetParError(2);
The standard deviation is related to the full width at half maximum by:
$$ \text{FWHM} = 2.355 \, \sigma $$
You can compute it in ROOT:
Double_t fwhm = 2.355 * sigma;
Double_t resolution = fwhm / mean; // relative energy resolution
Remember the relation between Gaussian width and resolution:
$$ \boxed{\text{FWHM} = 2.355 \, \sigma} $$
and energy resolution at energy $E$ is often expressed as:
$$ \boxed{R = \frac{\text{FWHM}}{E}} $$
where $R$ is the relative resolution.
You can print or store these values for later comparison with experimental data or with other simulations. This is the main bridge from raw simulation output to detector performance metrics.
If your spectrum shows more than one peak, you can restrict the fit range to each peak individually, or use more complex composite functions that sum several Gaussians plus a background term.
Comparing Ideal and Smeared Spectra
In a simple Geant4 gamma detector example, you might first record an "ideal" energy spectrum where the deposited energy is filled without any detector resolution effects. In a later step, you may apply energy smearing (for example, Gaussian smearing) either in Geant4 or in ROOT to simulate a realistic detector response.
To compare an ideal spectrum and a smeared one, open the ROOT file that contains both histograms. For example, you might have "Edep_ideal" and "Edep_smeared".
Retrieve both:
TH1 *hIdeal = (TH1*)gDirectory->Get("Edep_ideal");
TH1 *hSmeared = (TH1*)gDirectory->Get("Edep_smeared");Normalize them to the same area if they have different total entries, so that the shapes can be compared directly:
hIdeal->Scale(1.0 / hIdeal->Integral());
hSmeared->Scale(1.0 / hSmeared->Integral());Now draw them on the same canvas:
TCanvas *c2 = new TCanvas("c2", "Ideal vs smeared spectra", 800, 600);
hIdeal->SetLineColor(kBlack);
hIdeal->SetLineWidth(2);
hIdeal->Draw("HIST");
hSmeared->SetLineColor(kRed);
hSmeared->SetLineWidth(2);
hSmeared->Draw("HIST SAME");You should observe that in the smeared spectrum, photopeaks become broader and possibly lower in amplitude while the total area remains the same after normalization. This visual comparison helps you understand how detector resolution affects peak shapes and the ability to resolve nearby energy lines.
If you did not implement smearing inside Geant4, you can apply it in ROOT by creating a new histogram and filling it with smeared values. Loop over the original histogram bins and for each bin center and content, sample a Gaussian with given $\sigma$ and fill the new histogram. For many beginners, however, implementing smearing on the Geant4 side is simpler and more consistent with later analysis.
When comparing ideal and smeared spectra, always normalize the histograms before visually comparing shapes. Comparing raw counts can be misleading when the total number of events or binning differs between spectra.
Saving Plots and Results
Once you have an informative spectrum plot and fitted parameters, you will usually want to save the plot and possibly some numerical results.
To save the canvas as an image, use:
c1->SaveAs("gamma_spectrum.png"); // or ".pdf", ".eps", ".root"You can do the same for comparison plots:
c2->SaveAs("ideal_vs_smeared.pdf");If you want to preserve the ROOT objects for later, you can write them into a new ROOT file:
TFile *fout = TFile::Open("analysisResults.root", "RECREATE");
c1->Write("c_spectrum");
c2->Write("c_compare");
gaus->Write("fit_photopeak");
fout->Close();You can also save numerical values such as fitted peak position and resolution into a text file directly from ROOT:
std::ofstream txt("peak_results.txt");
txt << "Peak mean [MeV]: " << mean << "\n";
txt << "FWHM [MeV]: " << fwhm << "\n";
txt << "Resolution (FWHM/E): " << resolution << "\n";
txt.close();This gives you a compact record of your main analysis results that you can later use for reports or further comparison, for example when you change detector geometry or materials in the Geant4 simulation.
Always keep a clear link between the ROOT analysis and the Geant4 configuration that produced the data. Record the simulation version, geometry, materials, physics list, and source settings together with your analysis results to ensure that your findings can be reproduced.
By following these steps, you turn the raw energy deposition data from your Geant4 gamma ray detector simulation into interpretable spectra and quantitative measures of detector performance using ROOT.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to Geant4
- ☰ 1.1. What Is Geant4?
- ☰ 1.2. How Geant4 Works
- ☰ 1.3. Geant4 Simulation Structure
- ☰ 1.4. Geant4 and C++
-
- ☰ 2. Installing Geant4
- ☰ 2.1. Geant4 Requirements
- ☰ 2.2. Installing Geant4 on Linux
- ☰ 2.3. Installing Visualization Libraries
- ☰ 2.4. Verifying the Installation
- ☰ 2.5. Geant4 Example Applications
-
- ☰ 3. C++ Basics for Geant4
- ☰ 3.1. Classes and Objects
- ☰ 3.2. Inheritance
- ☰ 3.3. Pointers and References
- ☰ 3.4. Header and Source Files
- ☰ 3.5. Standard Library Containers
-
- ☰ 4. Creating Your First Geant4 Project
- ☰ 4.1. Project Structure
- ☰ 4.2. CMake Configuration
- ☰ 4.3. The Main Program
- ☰ 4.4. User Initialization Classes
- ☰ 4.5. Building and Running
-
- ☰ 5. Geant4 Units and Constants
- ☰ 5.1. Geant4 Unit System
- ☰ 5.2. Using Units in C++
- ☰ 5.3. Physical Constants
- ☰ 5.4. Printing Values with Units
-
- ☰ 6. Creating the Simulation World
- ☰ 6.1. DetectorConstruction
- ☰ 6.2. Solids
- ☰ 6.3. Logical Volumes
- ☰ 6.4. Physical Volumes
- ☰ 6.5. Creating the World Volume
-
- ☰ 7. Materials
- ☰ 7.1. Geant4 Materials
- ☰ 7.2. NIST Material Database
- ☰ 7.3. Common Materials
- ☰ 7.4. Creating Custom Materials
- ☰ 7.5. Detector Materials
-
- ☰ 8. Building Detector Geometry
- ☰ 8.1. Basic Geometrical Shapes
- ☰ 8.2. Boolean Solids
- ☰ 8.3. Positioning Volumes
- ☰ 8.4. Repeated Geometry
- ☰ 8.5. Detector Arrays
- ☰ 8.6. Geometry Overlap Checking
-
- ☰ 9. Geometry Visualization
- ☰ 9.1. Visualization in Geant4
- ☰ 9.2. Starting the Visualization System
- ☰ 9.3. Changing the View
- ☰ 9.4. Visualization Attributes
- ☰ 9.5. Displaying Particle Tracks
-
- ☰ 10. Primary Particle Generation
- ☰ 10.1. PrimaryGeneratorAction
- ☰ 10.2. Particle Gun
- ☰ 10.3. Particle Energy
- ☰ 10.4. Particle Position
- ☰ 10.5. Particle Direction
- ☰ 10.6. Common Particle Sources
-
- ☰ 11. General Particle Source
- ☰ 11.1. Introduction to GPS
- ☰ 11.2. Position Distributions
- ☰ 11.3. Angular Distributions
- ☰ 11.4. Energy Distributions
- ☰ 11.5. Configuring Sources with Macros
-
- ☰ 12. Physics Lists
- ☰ 12.1. What Is a Physics List?
- ☰ 12.2. Reference Physics Lists
- ☰ 12.3. Electromagnetic Physics
- ☰ 12.4. Gamma Interactions
- ☰ 12.5. Positron Physics
- ☰ 12.6. Hadronic Physics
- ☰ 12.7. Choosing a Physics List
-
- ☰ 13. Particle Tracking
- ☰ 13.1. Tracks
- ☰ 13.2. Steps
- ☰ 13.3. Energy Deposition
- ☰ 13.4. Track Status
- ☰ 13.5. Parent and Secondary Particles
-
- ☰ 14. User Actions
- ☰ 14.1. RunAction
- ☰ 14.2. EventAction
- ☰ 14.3. SteppingAction
- ☰ 14.4. TrackingAction
- ☰ 14.5. StackingAction
- ☰ 14.6. ActionInitialization
-
- ☰ 15. Sensitive Detectors
- ☰ 15.1. What Is a Sensitive Detector?
- ☰ 15.2. Creating a Sensitive Detector
- ☰ 15.3. Hits
- ☰ 15.4. Hit Collections
- ☰ 15.5. Assigning Sensitive Detectors
-
- ☰ 16. Recording Energy Deposition
- ☰ 16.1. Energy Deposition
- ☰ 16.2. Energy per Event
- ☰ 16.3. Energy per Detector
- ☰ 16.4. Energy Spectra
- ☰ 16.5. Detector Efficiency
-
- ☰ 17. Particle Position and Timing
- ☰ 17.1. Particle Position
- ☰ 17.2. Interaction Position
- ☰ 17.3. Global Time
- ☰ 17.4. Time of Flight
- ☰ 17.5. Detector Timing
-
- ☰ 18. Geant4 Analysis System
- ☰ 18.1. Introduction to G4AnalysisManager
- ☰ 18.2. Histograms
- ☰ 18.3. Ntuples
- ☰ 18.4. Filling Ntuples
- ☰ 18.5. Writing Output Files
- ☰ 18.6. Closing Analysis Files
-
- ☰ 19. Geant4 and ROOT
- ☰ 19.1. ROOT Output from Geant4
- ☰ 19.2. Reading Geant4 Output with ROOT
- ☰ 19.3. Plotting Energy Spectra
- ☰ 19.4. Event Analysis
- ☰ 19.5. Simulation-to-Analysis Workflow
-
- ☰ 20. Geant4 Macro Commands
- ☰ 20.1. Macro Files
- ☰ 20.2. Run Commands
- ☰ 20.3. Particle Source Commands
- ☰ 20.4. Visualization Commands
- ☰ 20.5. Controlling Simulations Without Recompiling
-
- ☰ 21. Random Numbers and Reproducibility
- ☰ 21.1. Monte Carlo Random Numbers
- ☰ 21.2. Setting Random Seeds
- ☰ 21.3. Running Independent Simulations
- ☰ 21.4. Reproducing an Event
-
- ☰ 22. Multithreading
- ☰ 22.1. Geant4 Multithreading
- ☰ 22.2. Running with Multiple Threads
- ☰ 22.3. Thread-Safe User Code
- ☰ 22.4. Analysis with Multithreading
- ☰ 22.5. Performance Considerations
-
- ☰ 23. Practical Example: Gamma-Ray Detector
- ☰ 23.1. Project Overview
- ☰ 23.2. Creating the World
- ☰ 23.3. Creating the Detector
- ☰ 23.4. Adding the Material
- ☰ 23.5. Creating a Gamma Source
- ☰ 23.6. Selecting Electromagnetic Physics
- ☰ 23.7. Recording Energy Deposition
- ☰ 23.8. Creating an Energy Spectrum
- ☰ 23.9. Simulating Detector Resolution
- ☰ 23.10. Analyzing the Spectrum with ROOT
-
- ☰ 24. Practical Example: Radiation Shielding
- ☰ 24.1. Project Overview
- ☰ 24.2. Creating the Source
- ☰ 24.3. Creating the Shield
- ☰ 24.4. Comparing Shielding Materials
- ☰ 24.5. Varying Shield Thickness
- ☰ 24.6. Recording Transmitted Particles
- ☰ 24.7. Calculating Transmission
- ☰ 24.8. Calculating Attenuation
- ☰ 24.9. Comparing Simulation Results
-
- ☰ 25. Practical Example: PET Scanner
- ☰ 25.1. Introduction to PET Simulation
- ☰ 25.2. Creating a PET Detector Ring
- ☰ 25.3. Creating Detector Crystals
- ☰ 25.4. Assigning Detector IDs
- ☰ 25.5. Creating a Positron Source
- ☰ 25.6. Simulating Positron Annihilation
- ☰ 25.7. Recording Detector Hits
- ☰ 25.8. Applying an Energy Window
- ☰ 25.9. Finding Coincidence Events
- ☰ 25.10. Recording Detector Positions
- ☰ 25.11. Creating Lines of Response
- ☰ 25.12. Saving PET Events to ROOT
- ☰ 25.13. Analyzing PET Data with ROOT
-
- ☰ 26. Practical Example: Proton Beam in Water
- ☰ 26.1. Project Overview
- ☰ 26.2. Creating the Water Phantom
- ☰ 26.3. Creating a Proton Beam
- ☰ 26.4. Selecting the Physics List
- ☰ 26.5. Recording Energy Deposition
- ☰ 26.6. Dividing the Phantom into Slices
- ☰ 26.7. Calculating Depth Dose
- ☰ 26.8. Observing the Bragg Peak
- ☰ 26.9. Plotting the Depth-Dose Curve
-
- ☰ 27. Detector Resolution and Smearing
- ☰ 27.1. Ideal vs Realistic Detector Response
- ☰ 27.2. Energy Resolution
- ☰ 27.3. Position Resolution
- ☰ 27.4. Time Resolution
- ☰ 27.5. Applying Detector Effects
- ☰ 27.6. Comparing Ideal and Smeared Results
-
- ☰ 28. Simulation Validation
- ☰ 28.1. Why Validate a Simulation?
- ☰ 28.2. Checking Geometry
- ☰ 28.3. Checking Energy Conservation
- ☰ 28.4. Comparing with Analytical Calculations
- ☰ 28.5. Comparing with Reference Data
- ☰ 28.6. Statistical Uncertainties
- ☰ 28.7. Number of Simulated Events
-
- ☰ 29. Improving Simulation Performance
- ☰ 29.1. Geometry Performance
- ☰ 29.2. Physics List Performance
- ☰ 29.3. Production Cuts
- ☰ 29.4. Reducing Unnecessary Output
- ☰ 29.5. Multithreading
- ☰ 29.6. Running Large Simulations
- ☰ 29.7. Parameter Scans
-
- ☰ 30. Debugging Geant4 Simulations
- ☰ 30.1. Compilation Errors
- ☰ 30.2. Geometry Errors
- ☰ 30.3. Overlapping Volumes
- ☰ 30.4. Missing Particles
- ☰ 30.5. Missing Energy Deposition
- ☰ 30.6. Physics List Problems
- ☰ 30.7. Sensitive Detector Problems
- ☰ 30.8. Empty Output Files
- ☰ 30.9. Segmentation Faults
- ☰ 30.10. Using Geant4 Verbose Output
-
- ☰ 31. Writing Better Geant4 Applications
- ☰ 31.1. Organizing Source Code
- ☰ 31.2. Separating Geometry and Analysis
- ☰ 31.3. Using Configuration Parameters
- ☰ 31.4. Avoiding Hard-Coded Values
- ☰ 31.5. Creating Reusable Detector Components
- ☰ 31.6. Naming Conventions
- ☰ 31.7. Documentation
- ☰ 31.8. Version Control with Git
-
- ☰ 32. Advanced Geometry
- ☰ 32.1. Parameterized Geometry
- ☰ 32.2. Replica Volumes
- ☰ 32.3. Nested Geometry
- ☰ 32.4. Complex Detector Arrays
- ☰ 32.5. Importing CAD Geometry
- ☰ 32.6. Exporting Geometry with GDML
-
- ☰ 33. Optical Photons
- ☰ 33.1. Introduction to Optical Physics
- ☰ 33.2. Optical Photons
- ☰ 33.3. Material Optical Properties
- ☰ 33.4. Scintillation Light
- ☰ 33.5. Optical Surfaces
- ☰ 33.6. Photodetectors
- ☰ 33.7. Counting Optical Photons
-
- ☰ 34. Medical Physics Applications
- ☰ 34.1. Geant4 in Medical Physics
- ☰ 34.2. Radiation Dose Simulation
- ☰ 34.3. PET Simulation
- ☰ 34.4. SPECT Simulation
- ☰ 34.5. Radiotherapy Simulation
- ☰ 34.6. Proton Therapy Simulation
- ☰ 34.7. Biological Tissue Materials
-
- ☰ 35. Final Project
- ☰ 35.1. Project Overview
- ☰ 35.2. Define the Simulation Goal
- ☰ 35.3. Create the Geometry
- ☰ 35.4. Define Materials
- ☰ 35.5. Configure the Particle Source
- ☰ 35.6. Select the Physics List
- ☰ 35.7. Implement Sensitive Detectors
- ☰ 35.8. Record Simulation Data
- ☰ 35.9. Run the Simulation
- ☰ 35.10. Analyze the Results with ROOT
- ☰ 35.11. Validate the Simulation
- ☰ 35.12. Create Scientific Figures
- ☰ 35.13. Document the Simulation
-
- ☰ 36. Appendices
- ☰ 36.1. Geant4 Class Cheat Sheet
- ☰ 36.2. Geant4 Units Cheat Sheet
- ☰ 36.3. Common Geant4 Macro Commands
- ☰ 36.4. Common Geometry Classes
- ☰ 36.5. Common Particle Definitions
- ☰ 36.6. Common Physics Lists
- ☰ 36.7. G4AnalysisManager Cheat Sheet
- ☰ 36.8. Common Visualization Commands
- ☰ 36.9. Common Geant4 Errors and Solutions
- ☰ 36.10. Recommended Geant4 Project Structure
- ☰ 36.11. Recommended Geant4 Simulation Workflow
-
Comments
Please login to add a comment.
Don't have an account? Register now!