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.