Chapter 6

Gamma Decay

Electromagnetic Transitions

Gamma decay is the emission of a photon from an excited nuclear state. Unlike alpha and beta decay, which change the nuclear composition, gamma decay only changes the energy state of the nucleus:

$$^A_Z X^* \to ^A_Z X + \gamma$$

Gamma-ray energies typically range from tens of keV to several MeV, corresponding to the energy spacing between nuclear levels. The emitted photon carries angular momentum $L$ and parity $(-1)^L$ (electric) or $(-1)^{L+1}$ (magnetic).

Selection Rules

The multipolarity of the transition is determined by angular momentum and parity conservation:

$$|J_i - J_f| \leq L \leq J_i + J_f, \quad L \geq 1$$

Type	Notation	Parity Change	$\Delta J$
Electric dipole	E1	Yes	0, 1
Magnetic dipole	M1	No	0, 1
Electric quadrupole	E2	No	0, 1, 2
Magnetic quadrupole	M2	Yes	0, 1, 2
Electric octupole	E3	Yes	0, 1, 2, 3

Note: $0 \to 0$ transitions are strictly forbidden by single-photon emission (a photon must carry at least $L = 1$ unit of angular momentum).

Weisskopf Estimates

Weisskopf single-particle estimates provide order-of-magnitude transition rates assuming the transition involves a single nucleon changing its state:

$$T(EL) \approx \frac{4.4(L+1)}{L[(2L+1)!!]^2}\left(\frac{3}{L+3}\right)^2 \left(\frac{E_\gamma}{\hbar c}\right)^{2L+1} \left(\frac{R}{\hbar c}\right)^{2L} \cdot c$$

Key scaling relations:

- Rate scales as $E_\gamma^{2L+1}$: higher-energy transitions are much faster
- Each increase in $L$ suppresses the rate by roughly $10^5$-$10^7$
- Electric transitions are typically ~100x faster than magnetic of same $L$
- The lowest allowed multipolarity dominates

Internal Conversion

Internal conversion is a competing de-excitation process where the nuclear excitation energy is transferred directly to an atomic electron (usually K or L shell), which is ejected from the atom:

$$T_e = E^* - B_e$$

where $E^*$ is the excitation energy and $B_e$ is the electron binding energy. The internal conversion coefficient is:

$$\alpha_{\text{IC}} = \frac{\lambda_{\text{IC}}}{\lambda_\gamma}$$

Internal conversion is enhanced for low-energy transitions, high-Z nuclei, and higher multipolarities. It is the only de-excitation mechanism for E0 ($0^+ \to 0^+$) transitions.

Isomeric States

Nuclear isomers are long-lived excited states that decay slowly because the available transitions require high multipolarity. They occur when there is a large spin difference between the isomeric state and lower-lying states. Famous examples:

- $^{180m}$Ta: $J^\pi = 9^-$, the only naturally occurring nuclear isomer (stable for practical purposes)
- $^{99m}$Tc: $t_{1/2} = 6$ hours, widely used in medical imaging (SPECT)
- $^{178m2}$Hf: $J^\pi = 16^+$, $t_{1/2} = 31$ years, stores 2.4 MeV of energy

Python Simulation: Transition Rates

Weisskopf single-particle estimates for electric and magnetic transition rates as a function of gamma-ray energy and multipolarity.

Gamma Transition Rates vs Multipolarity

Python

Weisskopf estimates showing hierarchy of electric and magnetic multipole transition rates

script.py97 lines

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

# ──────────────────────────────────────────────
# Gamma Decay: Weisskopf Estimates
# Transition rates vs multipolarity and energy
# ──────────────────────────────────────────────

# Weisskopf single-particle estimates (in s^-1)
# Electric: T(EL) = C_E(L) * A^(2L/3) * E_gamma^(2L+1)
# Magnetic: T(ML) = C_M(L) * A^((2L-2)/3) * E_gamma^(2L+1)
# where E_gamma in MeV, A = mass number

def weisskopf_electric(L, E_gamma, A):
    """Weisskopf estimate for electric transition rate (s^-1)"""
    r0 = 1.2  # fm
    # Formula from Krane Table 10.1
    prefactors = {
        1: 1.0e14,   # E1
        2: 7.3e7,    # E2
        3: 3.4e1,    # E3
        4: 1.1e-5,   # E4
    }
    if L not in prefactors:
        return 0
    return prefactors[L] * A**(2*L/3.0) * E_gamma**(2*L+1)

def weisskopf_magnetic(L, E_gamma, A):
    """Weisskopf estimate for magnetic transition rate (s^-1)"""
    prefactors = {
        1: 3.1e13,   # M1
        2: 2.2e7,    # M2
        3: 1.0e1,    # M3
        4: 3.3e-6,   # M4
    }
    if L not in prefactors:
        return 0
    return prefactors[L] * A**((2*L-2)/3.0) * E_gamma**(2*L+1)

A = 150  # typical medium-heavy nucleus
E_range = np.linspace(0.1, 5.0, 200)  # MeV

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: Electric transitions
colors_E = ['#ef4444', '#f59e0b', '#22c55e', '#3b82f6']
for L in [1, 2, 3, 4]:
    rates = [weisskopf_electric(L, E, A) for E in E_range]
    axes[0].semilogy(E_range, rates, color=colors_E[L-1], linewidth=2.5,
                     label=f'E{L}')

axes[0].set_xlabel('E_gamma [MeV]', color='#94a3b8', fontsize=12)
axes[0].set_ylabel('Transition Rate [s^-1]', color='#94a3b8', fontsize=12)
axes[0].set_title(f'Electric Transitions (A={A})', color='white', fontsize=14)
axes[0].legend(fontsize=11, facecolor='#1a1a2e', edgecolor='#334155', labelcolor='white')
axes[0].tick_params(colors='#94a3b8')
axes[0].set_ylim(1e-5, 1e20)
axes[0].grid(True, alpha=0.15, color='#334155')

# Right: E vs M comparison
colors_EM = ['#ef4444', '#f59e0b', '#22c55e', '#3b82f6', '#a855f7', '#ec4899']
labels = ['E1', 'M1', 'E2', 'M2', 'E3', 'M3']
for i, (L, typ) in enumerate([(1,'E'), (1,'M'), (2,'E'), (2,'M'), (3,'E'), (3,'M')]):
    if typ == 'E':
        rates = [weisskopf_electric(L, E, A) for E in E_range]
    else:
        rates = [weisskopf_magnetic(L, E, A) for E in E_range]
    axes[1].semilogy(E_range, rates, color=colors_EM[i], linewidth=2,
                     label=labels[i], linestyle='-' if typ=='E' else '--')

axes[1].set_xlabel('E_gamma [MeV]', color='#94a3b8', fontsize=12)
axes[1].set_ylabel('Transition Rate [s^-1]', color='#94a3b8', fontsize=12)
axes[1].set_title(f'Electric vs Magnetic (A={A})', color='white', fontsize=14)
axes[1].legend(fontsize=10, facecolor='#1a1a2e', edgecolor='#334155', labelcolor='white', ncol=2)
axes[1].tick_params(colors='#94a3b8')
axes[1].set_ylim(1e-5, 1e20)
axes[1].grid(True, alpha=0.15, color='#334155')

plt.tight_layout()
plt.savefig('gamma_rates.png', dpi=130, bbox_inches='tight',
            facecolor=fig.get_facecolor())

print(f"Weisskopf estimates for A={A}, E_gamma=1 MeV:")
for L in [1,2,3]:
    print(f"  E{L}: {weisskopf_electric(L, 1.0, A):.3e} s^-1")
    print(f"  M{L}: {weisskopf_magnetic(L, 1.0, A):.3e} s^-1")
print(f"\nE1 is ~100x faster than M1 (same energy)")
print(f"Each increase in L suppresses rate by ~5-7 orders of magnitude")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran Implementation

Comprehensive Weisskopf estimate calculator for electric and magnetic transitions.

Weisskopf Estimate Calculator

Fortran

Computes electromagnetic transition rates for electric and magnetic multipoles

weisskopf_estimates.f9098 lines

program weisskopf_estimates
  implicit none
  integer, parameter :: dp = selected_real_kind(15)
  real(dp), parameter :: pi = 3.14159265358979_dp
  real(dp), parameter :: hbar_c = 197.3_dp    ! MeV fm
  real(dp), parameter :: r0 = 1.2_dp          ! fm
  real(dp), parameter :: c_light = 3.0d23     ! fm/s

integer :: L, A
  real(dp) :: R, E_gamma, rate_E, rate_M
  real(dp) :: double_fact

write(*,'(A)') '=== Weisskopf Single-Particle Estimates ==='
  write(*,'(A)') ''

! Table for A=150, E_gamma = 1 MeV
  A = 150
  R = r0 * real(A, dp)**(1.0_dp/3.0_dp)
  E_gamma = 1.0_dp  ! MeV

write(*,'(A,I4,A,F6.2,A)') 'A = ', A, ', E_gamma = ', E_gamma, ' MeV'
  write(*,'(A,F6.2,A)') 'Nuclear radius R = ', R, ' fm'
  write(*,'(A)') ''
  write(*,'(A)') 'Type   Rate (s^-1)    Half-life'
  write(*,'(A)') '----   -----------    ---------'

do L = 1, 4
    ! Electric
    call calc_weisskopf_E(L, E_gamma, A, rate_E)
    write(*,'(A,I1,A,ES13.3,A,ES10.3,A)') '  E', L, '  ', rate_E, '    ', &
      0.6931_dp/rate_E, ' s'

! Magnetic
    call calc_weisskopf_M(L, E_gamma, A, rate_M)
    write(*,'(A,I1,A,ES13.3,A,ES10.3,A)') '  M', L, '  ', rate_M, '    ', &
      0.6931_dp/rate_M, ' s'
    write(*,'(A)') ''
  end do

! Show energy dependence for E2
  write(*,'(A)') ''
  write(*,'(A)') '--- E2 transition rate vs energy (A=150) ---'
  write(*,'(A)') 'E_gamma(MeV)   Rate(s^-1)     t_1/2'
  do L = 1, 10
    E_gamma = 0.5_dp * L
    call calc_weisskopf_E(2, E_gamma, A, rate_E)
    write(*,'(F8.1, ES16.3, ES14.3, A)') E_gamma, rate_E, 0.6931_dp/rate_E, ' s'
  end do

contains

subroutine calc_weisskopf_E(L, Eg, A, rate)
    integer, intent(in) :: L, A
    real(dp), intent(in) :: Eg
    real(dp), intent(out) :: rate
    real(dp) :: R_nuc, prefactor
    real(dp), parameter :: e2_4pi = 1.44_dp  ! MeV fm

R_nuc = r0 * real(A, dp)**(1.0_dp/3.0_dp)

! Approximate Weisskopf formula
    prefactor = 4.4_dp * (L + 1.0_dp) / (L * dfact(2*L+1)**2) &
                * (3.0_dp / (L + 3.0_dp))**2

rate = prefactor * (Eg / hbar_c)**(2*L+1) * (R_nuc)**( 2*L) * c_light / hbar_c
    ! Simplified using tabulated prefactors
    select case(L)
      case(1); rate = 1.0d14 * real(A,dp)**(2.0_dp/3.0_dp) * Eg**3
      case(2); rate = 7.3d7  * real(A,dp)**(4.0_dp/3.0_dp) * Eg**5
      case(3); rate = 3.4d1  * real(A,dp)**(2.0_dp)         * Eg**7
      case(4); rate = 1.1d-5 * real(A,dp)**(8.0_dp/3.0_dp)  * Eg**9
    end select
  end subroutine

subroutine calc_weisskopf_M(L, Eg, A, rate)
    integer, intent(in) :: L, A
    real(dp), intent(in) :: Eg
    real(dp), intent(out) :: rate

select case(L)
      case(1); rate = 3.1d13 * real(A,dp)**(0.0_dp)         * Eg**3
      case(2); rate = 2.2d7  * real(A,dp)**(2.0_dp/3.0_dp)  * Eg**5
      case(3); rate = 1.0d1  * real(A,dp)**(4.0_dp/3.0_dp)  * Eg**7
      case(4); rate = 3.3d-6 * real(A,dp)**(2.0_dp)          * Eg**9
    end select
  end subroutine

function dfact(n) result(res)
    integer, intent(in) :: n
    real(dp) :: res
    integer :: i
    res = 1.0_dp
    do i = n, 1, -2
      res = res * real(i, dp)
    end do
  end function

end program weisskopf_estimates

Click Run to execute the Fortran code

Code will be compiled with gfortran and executed on the server

← Beta Decay Part III: Nuclear Reactions →