5.1. Geant4 Unit System
Table of Contents
Length
Geant4 uses its own internal system of units to avoid ambiguity in physics calculations. Every physical quantity must carry an explicit unit, and you combine values with units directly in your C++ code.
Internally, Geant4 uses millimeters as the base length unit. The constant mm is defined to have the numerical value 1. Other length units are defined relative to mm. For example, centimeters and meters are just multiples of millimeters. When you write code, you always multiply a plain number by a unit constant, such as 10cm or 1m.
The most commonly used length units in Geant4 include millimeter, centimeter, meter, and micrometer. These are defined in the Geant4 headers so you can use them directly without redefining anything. You must include the appropriate unit header, which is covered in a later chapter, but the idea remains the same: always attach a unit.
A few typical examples are a detector thickness of 5mm, a world dimension of 1m, or a pixel size of 300*um. Inside Geant4, all of these are converted to millimeters automatically. You never have to do that conversion by hand.
The table below shows some standard length units and their relation to the internal base unit.
| Unit symbol | Meaning | Relation to internal unit |
|---|---|---|
mm | millimeter | $1$ |
cm | centimeter | $1\,\text{cm} = 10\,\text{mm}$ |
m | meter | $1\,\text{m} = 1000\,\text{mm}$ |
um | micrometer | $1\,\mu\text{m} = 10^{-3}\,\text{mm}$ |
nm | nanometer | $1\,\text{nm} = 10^{-6}\,\text{mm}$ |
Geant4 does not guess your intention. The number 10 is just 10 and has no length until you multiply it by a unit such as mm or cm. If you forget to attach a unit, you get inconsistent dimensions and unphysical geometry. The compiler will not always warn you, so you must get into the habit of always including units.
Always multiply numerical values by a Geant4 unit constant, for example 10cm or 1m, never use a bare number for a physical length.
Geant4 also provides units for areas such as mm2 and cm2 and volumes such as mm3 and cm3. These are built from the same base unit, so 1*cm3 is automatically interpreted as $(10\,\text{mm})^3$ internally.
Energy
Geant4 uses megaelectronvolts as the internal base unit of energy. The constant MeV is defined to be 1, so when you write 1*MeV you are giving a value equal to the internal unit. Other units such as eV, keV, and GeV are defined relative to MeV.
Just as with length, you specify energy by multiplying a number with a unit constant. For example, you assign a primary particle energy as 1GeV or define a threshold as 100keV. Geant4 then converts everything to the internal MeV representation.
The most common energy units and their relation to the internal unit are:
| Unit symbol | Meaning | Relation to internal unit |
|---|---|---|
eV | electronvolt | $1\,\text{eV} = 10^{-6}\,\text{MeV}$ |
keV | kiloelectronvolt | $1\,\text{keV} = 10^{-3}\,\text{MeV}$ |
MeV | megaelectronvolt | $1$ |
GeV | gigaelectronvolt | $1\,\text{GeV} = 10^{3}\,\text{MeV}$ |
TeV | teraelectronvolt | $1\,\text{TeV} = 10^{6}\,\text{MeV}$ |
For beginners it is useful to remember that Geant4 is designed primarily for particle physics, so MeV and GeV are the natural scales. If you want to simulate very low energy processes in the eV or keV range, it is still fine, because the conversion is handled automatically.
When you compare Geant4 results with experimental data or analytical formulas, check the energy units carefully. If your experiment reports 511 keV and you set 511MeV instead of 511keV, you introduce a factor of 1000 error that can be difficult to spot just by looking at plots.
Geant4 uses MeV as the internal energy unit. Always specify energies using explicit unit constants like keV, MeV, or GeV, and double check they match your intended physical scale.
Many physics quantities involve both energy and other dimensions, such as stopping power in units like MeV/mm, or cross sections in units like barn. These compound units are built by combining basic units. For instance, you can write 1*MeV/mm and Geant4 will interpret it correctly.
Time
In the Geant4 unit system, nanosecond is the base unit of time. The constant ns is defined as 1, and other time units such as s, ms, us, and ps are defined relative to ns. Any time quantity that you pass to Geant4, for example a time window in a detector or a decay time, must be given as a number multiplied by one of these time constants.
Typical uses of time in Geant4 include the global time of a track, the time of a hit, and the duration of a run or a beam pulse. These are all handled in nanoseconds internally, even if you specify them differently in your code.
Some common time units and their relation to the internal unit are:
| Unit symbol | Meaning | Relation to internal unit |
|---|---|---|
s | second | $1\,\text{s} = 10^{9}\,\text{ns}$ |
ms | millisecond | $1\,\text{ms} = 10^{6}\,\text{ns}$ |
us | microsecond | $1\,\mu\text{s} = 10^{3}\,\text{ns}$ |
ns | nanosecond | $1$ |
ps | picosecond | $1\,\text{ps} = 10^{-3}\,\text{ns}$ |
If you read timing information from Geant4, for example using GetGlobalTime(), you get a value in internal units. That value is in nanoseconds, so if you want to print it in microseconds you must divide by us. The details of printing are discussed in a later chapter, but the important point here is that the same unit constants are used for both input and output.
When you simulate fast detectors like scintillators or silicon photomultipliers, the relevant timescale is often in nanoseconds or picoseconds. If you simulate biological processes or accelerator cycles, you may work in microseconds or longer. In all cases, Geant4 keeps everything consistent by converting to nanoseconds internally.
Geant4 uses nanoseconds as the internal time unit. Use explicit time constants such as ns, ps, us, ms, or s whenever you set or interpret any time quantity in your simulation.
Because the speed of light is defined consistently with this unit system, operations that combine distance and time, such as time of flight, give results with the correct dimensions as long as you consistently apply units.
Mass
Geant4 commonly expresses mass in units derived from the internal system where energy is in MeV and time is in nanoseconds. For many particle properties, Geant4 uses energy units to represent mass through the relation $E = mc^2$. For example, particle masses are often given in MeV, which actually means MeV divided by $c^2$.
For macroscopic materials, such as a block of lead or a water phantom, you usually work with mass density in units like grams per cubic centimeter or kilograms per cubic meter. Geant4 defines mass units like kg, g, and also combined units for density such as g/cm3 and kg/m3. Internally, these are all converted consistently to the base units of the system.
Some basic mass units and their relation to each other are:
| Unit symbol | Meaning | Example usage |
|---|---|---|
kg | kilogram | Large macroscopic masses |
g | gram | Material density, 1.0*g/cm3 |
mg | milligram | Small samples or thin foils |
In practice, you most often meet mass when you define materials. There you specify the density using a value multiplied by a density unit. For example, the density of water is written as 1.0g/cm3, and the density of lead is about 11.34g/cm3. Geant4 then converts these into internal units that are consistent with the rest of the system.
On the particle level, you rarely set a mass yourself. Geant4 already knows the masses of standard particles and stores them in its particle definition tables, typically in units of MeV. This is convenient because you can compare energies and rest masses directly without additional conversion.
Use explicit mass or density units such as g/cm3 or kg/m3 when defining materials, and remember that particle masses in Geant4 are expressed in energy units through $E = mc^2$.
When you compute derived quantities that involve mass, such as stopping power per unit mass or dose in units of gray, the consistent use of units ensures that your results are dimensionally correct. The gray, for example, is expressed in Geant4 as joule/kg, using the same unit system.
Angle
Geant4 uses radians as the internal unit for angles. The constant rad is equal to 1, so any angle quantity inside Geant4 is stored in radians. To help with human readable values, Geant4 also defines the constant deg for degrees. Both can be used directly in C++ code.
If you want to specify a rotation of 90 degrees, you write 90deg, not M_PI/2. Geant4 converts 90deg into the corresponding number of radians internally. This keeps your code clearer and reduces the chance of mixing degrees and radians by mistake.
Some angle related units and their relations are:
| Unit symbol | Meaning | Relation to internal unit |
|---|---|---|
rad | radian | $1$ |
deg | degree | $1\,\text{deg} = \pi / 180\,\text{rad}$ |
You will use angles frequently for particle directions and for rotations of volumes in the geometry. For example, you might want to aim a beam in the positive x direction by specifying polar and azimuthal angles in radians, or rotate a detector around the z axis by 45*deg. All these operations rely on the same angle units.
When you print or analyze angular quantities, remember that Geant4 reports them in radians unless you explicitly convert by dividing by deg. If your plots or tables use degrees, you must perform that conversion yourself, using the same constants.
Geant4 uses radians internally for all angular quantities. Always attach rad or deg when specifying or interpreting angles, for example theta = 45*deg.
Angles also appear in trigonometric functions from the C++ standard library, which always expect and return values in radians. Because Geant4 also uses radians internally, you can pass these values directly to std::sin, std::cos, and similar functions without additional conversion, as long as you stay consistent with the unit system.
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!