Chapter 4

Alpha Decay

Alpha Decay Fundamentals

Alpha decay is the emission of a helium-4 nucleus ($^4_2$He or alpha particle) from an unstable parent nucleus. It is the dominant decay mode for heavy nuclei with $Z > 82$:

$$^A_Z X \to ^{A-4}_{Z-2} Y + ^4_2\text{He}$$

The Q-value (kinetic energy released) is:

$$Q_\alpha = [M(A,Z) - M(A-4, Z-2) - M(^4\text{He})]c^2$$

Alpha decay is energetically possible when $Q_\alpha > 0$. The alpha particle carries most of the kinetic energy due to momentum conservation:

$$T_\alpha = Q_\alpha \frac{A - 4}{A}$$

The Geiger-Nuttall Law

Geiger and Nuttall (1911) empirically discovered that alpha-decay half-lives span an enormous range (from nanoseconds to billions of years) but correlate strongly with the decay energy:

$$\log_{10} t_{1/2} = a + \frac{b}{\sqrt{Q_\alpha}}$$

where $a$ and $b$ are constants that depend on the parent nucleus charge. A change in $Q_\alpha$ by a factor of 2 can change the half-life by 20 orders of magnitude! This extraordinary sensitivity is explained by quantum tunneling.

Gamow Theory of Alpha Decay

George Gamow (1928) provided the first successful quantum mechanical explanation of alpha decay using the WKB approximation for tunneling through the Coulomb barrier.

The Coulomb Barrier

Inside the nucleus ($r < R$), the alpha particle is bound by the nuclear potential. Outside, it sees the repulsive Coulomb barrier:

$$V(r) = \frac{2(Z-2)e^2}{4\pi\epsilon_0 r} = \frac{2(Z-2) \times 1.44 \text{ MeV}\cdot\text{fm}}{r} \quad \text{for } r > R$$

The barrier height at the nuclear surface is typically 25-30 MeV, while the alpha particle energy is only 4-9 MeV. Classically, escape is impossible.

WKB Tunneling Probability

The tunneling probability through the barrier using the WKB approximation is:

$$T = \exp\left(-\frac{2}{\hbar}\int_R^{r_{\text{tp}}} \sqrt{2\mu[V(r) - Q_\alpha]}\,dr\right)$$

where $r_{\text{tp}} = 2(Z-2)e^2/(4\pi\epsilon_0 Q_\alpha)$ is the classical turning point and $\mu$ is the reduced mass. Evaluating the integral analytically:

$$T = \exp\left(-\frac{2}{\hbar}\sqrt{2\mu Q_\alpha}\,r_{\text{tp}}\left[\arccos\sqrt{\rho} - \sqrt{\rho(1-\rho)}\right]\right)$$

where $\rho = R/r_{\text{tp}}$. The decay rate is then:

$$\lambda = f \cdot T, \quad f = \frac{v}{2R} \sim 10^{21} \text{ s}^{-1}$$

where $f$ is the assault frequency (how often the alpha particle hits the barrier).

Python Simulation: Gamow Tunneling

Calculates the Gamow tunneling probability and resulting half-lives as a function of alpha decay energy, demonstrating the Geiger-Nuttall relationship.

Gamow Tunneling Probability

Python

Tunneling probability and half-life vs alpha-decay energy for Z=82 daughter

script.py110 lines

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

# ──────────────────────────────────────────────
# Gamow Theory of Alpha Decay
# Tunneling probability vs energy
# ──────────────────────────────────────────────

# Constants
hbar = 1.0546e-34   # J s
e = 1.602e-19        # C
m_alpha = 4 * 1.6605e-27  # kg (alpha particle mass)
MeV = 1.602e-13     # J
fm = 1.0e-15         # m
k_e = 1.44           # MeV fm (e^2/4pi*eps0)

# Parent nucleus parameters
Z_daughter = 82      # Lead (Pb) daughter
A_daughter = 206
R = 1.2 * (A_daughter**(1.0/3.0) + 4**(1.0/3.0))  # fm, touching radius

# Coulomb barrier height
V_barrier = 2 * Z_daughter * k_e / R  # MeV
print(f"Coulomb barrier height: {V_barrier:.2f} MeV")
print(f"Nuclear touching radius: {R:.2f} fm")

# Gamow factor calculation
def gamow_factor(Q_alpha, Z_d, R_nuc):
    """Calculate Gamow penetration factor"""
    eta = 2 * Z_d * k_e / (2 * Q_alpha)  # Sommerfeld parameter * v/c stuff
    # Classical turning point
    r_turn = 2 * Z_d * k_e / Q_alpha  # fm
    # Gamow factor (WKB approximation)
    # G = exp(-2*integral from R to r_turn of sqrt(2m(V-E))/hbar dr)
    # Analytical result:
    rho = R_nuc / r_turn
    G_exponent = np.sqrt(2 * m_alpha * Q_alpha * MeV) / (hbar / fm) * r_turn * (np.arccos(np.sqrt(rho)) - np.sqrt(rho * (1 - rho)))
    return np.exp(-2 * G_exponent), r_turn

# Scan Q_alpha values
Q_values = np.linspace(3.0, 10.0, 200)  # MeV
T_values = []
r_turn_values = []

for Q in Q_values:
    T, r_t = gamow_factor(Q, Z_daughter, R)
    T_values.append(T)
    r_turn_values.append(r_t)

T_values = np.array(T_values)
r_turn_values = np.array(r_turn_values)

# Estimate half-lives: t_1/2 ~ hbar/(T * f), f ~ v/(2R) attempt frequency
v_alpha = np.sqrt(2 * Q_values * MeV / m_alpha)  # m/s
f_attempt = v_alpha / (2 * R * fm)  # Hz
lambda_decay = T_values * f_attempt  # decay rate
t_half = np.log(2) / (lambda_decay + 1e-300)  # seconds

fig, axes = plt.subplots(1, 2, figsize=(14, 6))
fig.patch.set_facecolor('#0a0a1a')

for ax in axes:
    ax.set_facecolor('#0a0a1a')
    for spine in ax.spines.values():
        spine.set_edgecolor('#334155')

# Left: tunneling probability
axes[0].semilogy(Q_values, T_values, color='#ef4444', linewidth=2.5)
axes[0].set_xlabel('Q_alpha [MeV]', color='#94a3b8', fontsize=12)
axes[0].set_ylabel('Tunneling Probability T', color='#94a3b8', fontsize=12)
axes[0].set_title('Gamow Tunneling Probability', color='white', fontsize=14)
axes[0].tick_params(colors='#94a3b8')
axes[0].grid(True, alpha=0.2, color='#334155')

# Mark some real nuclei
real_nuclei = [
    ('Po-212', 8.95, '#fbbf24'),
    ('Po-210', 5.41, '#22c55e'),
    ('U-238', 4.27, '#3b82f6'),
    ('Th-232', 4.08, '#a855f7'),
]
for name, Q, color in real_nuclei:
    if 3.0 <= Q <= 10.0:
        T_nuc, _ = gamow_factor(Q, Z_daughter, R)
        axes[0].axvline(x=Q, color=color, linestyle='--', alpha=0.5)
        axes[0].text(Q, T_nuc * 10, name, color=color, fontsize=9, ha='center')

# Right: half-life vs Q_alpha (Geiger-Nuttall)
valid = t_half > 0
axes[1].semilogy(Q_values[valid], t_half[valid], color='#f59e0b', linewidth=2.5)
axes[1].set_xlabel('Q_alpha [MeV]', color='#94a3b8', fontsize=12)
axes[1].set_ylabel('Half-life [seconds]', color='#94a3b8', fontsize=12)
axes[1].set_title('Geiger-Nuttall Relation', color='white', fontsize=14)
axes[1].tick_params(colors='#94a3b8')
axes[1].grid(True, alpha=0.2, color='#334155')

# Reference lines
axes[1].axhline(y=3.156e7, color='#64748b', linestyle=':', alpha=0.5)
axes[1].text(9.5, 3.156e7 * 3, '1 year', color='#64748b', fontsize=8, ha='right')
axes[1].axhline(y=3.156e16, color='#64748b', linestyle=':', alpha=0.5)
axes[1].text(9.5, 3.156e16 * 3, '1 Gyr', color='#64748b', fontsize=8, ha='right')

plt.tight_layout()
plt.savefig('gamow_tunneling.png', dpi=130, bbox_inches='tight',
            facecolor=fig.get_facecolor())
print(f"T at Q=5 MeV: {T_values[np.argmin(np.abs(Q_values-5.0))]:.4e}")
print(f"T at Q=9 MeV: {T_values[np.argmin(np.abs(Q_values-9.0))]:.4e}")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran Implementation

Calculates alpha-decay half-lives for specific nuclei using the Gamow tunneling formula.

Alpha Decay Half-Life Calculator

Fortran

Computes Gamow tunneling half-lives for various alpha-emitting nuclei

alpha_decay_halflife.f9073 lines

program alpha_decay_halflife
  implicit none
  integer, parameter :: dp = selected_real_kind(15)
  real(dp), parameter :: pi = 3.14159265358979_dp
  real(dp), parameter :: hbar = 1.0546d-34   ! J s
  real(dp), parameter :: e_charge = 1.602d-19 ! C
  real(dp), parameter :: amu = 1.6605d-27    ! kg
  real(dp), parameter :: MeV = 1.602d-13     ! J
  real(dp), parameter :: fm = 1.0d-15        ! m
  real(dp), parameter :: k_e = 1.44_dp       ! MeV fm
  real(dp), parameter :: ln2 = 0.6931471805599_dp

integer, parameter :: n_nuclei = 6
  character(len=8) :: names(n_nuclei)
  real(dp) :: A_par(n_nuclei), Z_par(n_nuclei), Q_alpha(n_nuclei)
  real(dp) :: R, r_tp, rho, G_exp, T_prob, m_red, v_alpha, f_att, lambda, t_half
  integer :: i

! Parent nuclei data (A, Z, Q_alpha in MeV)
  names   = (/ 'Th-232  ', 'U-235   ', 'U-238   ', 'Pu-239  ', 'Po-210  ', 'Po-212  ' /)
  A_par   = (/ 232.0_dp, 235.0_dp, 238.0_dp, 239.0_dp, 210.0_dp, 212.0_dp /)
  Z_par   = (/  90.0_dp,  92.0_dp,  92.0_dp,  94.0_dp,  84.0_dp,  84.0_dp /)
  Q_alpha = (/ 4.08_dp,  4.68_dp,  4.27_dp,  5.24_dp,  5.41_dp,  8.95_dp  /)

write(*,'(A)') '=== Alpha Decay Half-Life Calculator ==='
  write(*,'(A)') '(Gamow tunneling model)'
  write(*,'(A)') ''
  write(*,'(A)') 'Nucleus   Q(MeV)  Barrier(MeV)  log10(T)    t_1/2'
  write(*,'(A)') '-------   ------  ------------  --------    -----'

do i = 1, n_nuclei
    ! Nuclear radius (touching configuration)
    R = 1.2_dp * ((A_par(i)-4.0_dp)**(1.0_dp/3.0_dp) + 4.0_dp**(1.0_dp/3.0_dp))

! Coulomb barrier at surface
    ! V_barrier = 2*(Z-2)*k_e/R

! Classical turning point
    r_tp = 2.0_dp * (Z_par(i) - 2.0_dp) * k_e / Q_alpha(i)

rho = R / r_tp

! Reduced mass in kg
    m_red = 4.0_dp * (A_par(i) - 4.0_dp) / A_par(i) * amu

! Gamow exponent
    G_exp = sqrt(2.0_dp * m_red * Q_alpha(i) * MeV) / (hbar / fm) * r_tp &
            * (acos(sqrt(rho)) - sqrt(rho * (1.0_dp - rho)))

T_prob = exp(-2.0_dp * G_exp)

! Attempt frequency
    v_alpha = sqrt(2.0_dp * Q_alpha(i) * MeV / m_red)
    f_att = v_alpha / (2.0_dp * R * fm)

! Half-life
    lambda = T_prob * f_att
    if (lambda > 0.0_dp) then
      t_half = ln2 / lambda
    else
      t_half = 1.0d99
    end if

write(*,'(A8, F8.2, F12.2, ES14.3, ES14.3, A)') &
      names(i), Q_alpha(i), 2.0_dp*(Z_par(i)-2.0_dp)*k_e/R, &
      T_prob, t_half, ' s'
  end do

write(*,'(A)') ''
  write(*,'(A)') 'Note: Simple Gamow model gives order-of-magnitude estimates.'
  write(*,'(A)') 'Refinements include angular momentum barrier, preformation'
  write(*,'(A)') 'probability, and nuclear structure effects.'
end program alpha_decay_halflife

Click Run to execute the Fortran code

Code will be compiled with gfortran and executed on the server

← Nuclear Models Beta Decay →