Chapter 11

Collective Models

Nuclear Deformation

Many nuclei away from closed shells are permanently deformed. The nuclear shape is parameterized by the multipole expansion of the nuclear radius:

$$R(\theta, \phi) = R_0\left(1 + \sum_{\lambda \mu} \alpha_{\lambda\mu} Y_\lambda^\mu(\theta, \phi)\right)$$

The dominant deformation is quadrupole ($\lambda = 2$), characterized by the deformation parameters $\beta$ and $\gamma$:

$$\alpha_{20} = \beta\cos\gamma, \quad \alpha_{2\pm2} = \frac{1}{\sqrt{2}}\beta\sin\gamma$$

- $\gamma = 0$: Prolate (rugby ball) deformation
- $\gamma = 60°$: Oblate (disc) deformation
- $\beta \approx 0.2$-0.3: Typical for well-deformed nuclei (rare earths, actinides)

Rotational Spectra

A permanently deformed nucleus can rotate collectively. For an axially symmetric nucleus (prolate or oblate), the rotational energy is:

$$E_{\text{rot}}(J) = \frac{\hbar^2}{2\mathscr{I}}\,J(J+1)$$

where $\mathscr{I}$ is the moment of inertia. For even-even nuclei, the ground state band has $J^\pi = 0^+, 2^+, 4^+, 6^+, \ldots$ The characteristic energy ratios are:

$$\frac{E(4^+)}{E(2^+)} = \frac{4\times5}{2\times3} = \frac{10}{3} \approx 3.33$$

This ratio is a powerful diagnostic: values near 3.33 indicate a good rotor (e.g., $^{166}$Er: 3.31), while values near 2.0 indicate a vibrator, and values near 2.5 indicate transitional behavior.

Vibrational Spectra

Spherical nuclei near closed shells can undergo shape oscillations (vibrations) about the equilibrium shape. Quantizing these vibrations gives phonon excitations:

$$E(n) = n\hbar\omega_\lambda$$

For quadrupole vibrations ($\lambda = 2$), each phonon carries $J^\pi = 2^+$:

- 0 phonons: $0^+$ ground state
- 1 phonon: $2^+$ state at $E = \hbar\omega$
- 2 phonons: Triplet $0^+, 2^+, 4^+$ at $E = 2\hbar\omega$

The hallmark is $E(4^+)/E(2^+) = 2.0$ and a degenerate two-phonon triplet.

The Nilsson Diagram

The Nilsson diagram plots single-particle energy levels as a function of the deformation parameter $\delta$ (or $\epsilon_2$). Each spherical level splits into $(2j+1)/2$ levels labeled by the projection quantum number$\Omega = |m_j|$:

$$[Nn_z\Lambda]\Omega^\pi$$

where $N$ is the major shell, $n_z$ is the oscillator quantum number along the symmetry axis, $\Lambda$ is the orbital angular momentum projection, and$\Omega$ is the total angular momentum projection. The Nilsson diagram explains ground-state spins of odd-A deformed nuclei and predicts the onset of deformation as a function of nucleon number.

Python Simulation: Collective Spectra

Comparison of rotational and vibrational energy level patterns in collective nuclear models.

Rotational and Vibrational Energy Spectra

Python

Level schemes for ideal rotor and quadrupole vibrator nuclei

script.py91 lines

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

# ──────────────────────────────────────────────
# Collective Nuclear Models
# Rotational and Vibrational Energy Spectra
# ──────────────────────────────────────────────

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

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

# Left: Rotational spectrum
# E(J) = hbar^2/(2*I) * J(J+1), J = 0, 2, 4, 6, ... (ground state band, even-even)
hbar2_2I = 0.012  # MeV (typical for rare-earth deformed nucleus, e.g. Er-166)

J_values = [0, 2, 4, 6, 8, 10, 12]
E_rot = [hbar2_2I * J * (J + 1) for J in J_values]

# Plot as level diagram
for i, (J, E) in enumerate(zip(J_values, E_rot)):
    axes[0].plot([0.3, 0.7], [E, E], color='#ef4444', linewidth=3)
    axes[0].text(0.75, E, f'J = {J}+', color='#f59e0b', fontsize=11, va='center')
    axes[0].text(0.15, E, f'{E*1000:.0f}', color='#94a3b8', fontsize=9, va='center', ha='right')

# Add ratios
axes[0].text(1.2, E_rot[1], f'E(4)/E(2) = {E_rot[2]/E_rot[1]:.2f}', color='#22c55e', fontsize=10, va='center')
axes[0].text(1.2, E_rot[1] - 0.05, f'(Ideal rotor: 3.33)', color='#64748b', fontsize=9, va='center')
axes[0].text(1.2, E_rot[2], f'E(6)/E(2) = {E_rot[3]/E_rot[1]:.2f}', color='#22c55e', fontsize=10, va='center')
axes[0].text(1.2, E_rot[2] - 0.05, f'(Ideal: 7.00)', color='#64748b', fontsize=9, va='center')

axes[0].set_ylabel('Energy [MeV]', color='#94a3b8', fontsize=12)
axes[0].set_title('Rotational Band (Ground State)', color='white', fontsize=14)
axes[0].tick_params(colors='#94a3b8')
axes[0].set_xticks([])
axes[0].set_xlim(0, 2.0)

# Right: Vibrational spectrum
# E(n) = (n + 0) * hbar*omega, with phonon number n
# Quadrupole vibrations: 0+, 2+, (0+, 2+, 4+), ...
hw_vib = 0.8  # MeV (typical phonon energy)

# n=0: ground state 0+
# n=1: one phonon -> 2+
# n=2: two phonons -> 0+, 2+, 4+ (triplet)
# n=3: three phonons -> 0+, 2+, 3+, 4+, 6+

vib_levels = [
    (0, '0+', '#ef4444'),
    (hw_vib, '2+', '#f59e0b'),
    (2*hw_vib, '0+, 2+, 4+', '#22c55e'),
    (3*hw_vib, '0+, 2+, 3+, 4+, 6+', '#3b82f6'),
]

for E, label, color in vib_levels:
    axes[1].plot([0.3, 0.7], [E, E], color=color, linewidth=3)
    axes[1].text(0.75, E, label, color=color, fontsize=10, va='center')

axes[1].text(1.5, 0, 'n = 0', color='#94a3b8', fontsize=10, va='center')
axes[1].text(1.5, hw_vib, 'n = 1 (1 phonon)', color='#94a3b8', fontsize=10, va='center')
axes[1].text(1.5, 2*hw_vib, 'n = 2 (2 phonons)', color='#94a3b8', fontsize=10, va='center')
axes[1].text(1.5, 3*hw_vib, 'n = 3 (3 phonons)', color='#94a3b8', fontsize=10, va='center')

# Energy ratios
axes[1].text(0.05, hw_vib + 0.1, f'E(2+)/E(2+) = 1.0', color='#64748b', fontsize=8, va='center')
axes[1].text(0.05, 2*hw_vib + 0.1, f'E(triplet)/E(2+) = 2.0', color='#64748b', fontsize=8, va='center')

axes[1].set_ylabel('Energy [MeV]', color='#94a3b8', fontsize=12)
axes[1].set_title('Vibrational Spectrum (Quadrupole)', color='white', fontsize=14)
axes[1].tick_params(colors='#94a3b8')
axes[1].set_xticks([])
axes[1].set_xlim(0, 2.5)

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

print("Rotational spectrum: E(J) = hbar^2/(2I) * J(J+1)")
print(f"Moment of inertia parameter: hbar^2/(2I) = {hbar2_2I*1000:.1f} keV")
print(f"E(2+) = {E_rot[1]*1000:.0f} keV")
print(f"E(4+)/E(2+) = {E_rot[2]/E_rot[1]:.2f} (ideal rotor: 3.33)")
print(f"E(6+)/E(2+) = {E_rot[3]/E_rot[1]:.2f} (ideal rotor: 7.00)")
print(f"\nVibrational spectrum: E = n * hbar*omega = n * {hw_vib:.1f} MeV")
print(f"Ideal vibrator: E(4+)/E(2+) = 2.0, E(triplet)/E(2+) = 2.0")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran Implementation

Computes quadrupole deformation and moments for deformed nuclei.

Deformed Nucleus Quadrupole Moment

Fortran

Computes intrinsic quadrupole moments and deformation parameters

deformed_nucleus.f9059 lines

program deformed_nucleus
  implicit none
  integer, parameter :: dp = selected_real_kind(15)
  real(dp), parameter :: pi = 3.14159265358979_dp
  real(dp), parameter :: r0 = 1.2_dp  ! fm
  real(dp), parameter :: e_charge = 1.602d-19  ! C
  real(dp), parameter :: e_barn = 1.0d-24  ! cm^2

integer :: i
  real(dp) :: A, Z, beta, R0, Q0, Q_sp, B_E2
  real(dp) :: delta, a_perp, a_z, ratio

integer, parameter :: n_nuclei = 6
  character(len=10) :: names(n_nuclei)
  real(dp) :: A_list(n_nuclei), Z_list(n_nuclei), beta_list(n_nuclei)

names = (/ 'Sm-152    ', 'Gd-156    ', 'Er-166    ', 'Hf-178    ', 'U-238     ', 'Pu-240    ' /)
  A_list = (/ 152.0_dp, 156.0_dp, 166.0_dp, 178.0_dp, 238.0_dp, 240.0_dp /)
  Z_list = (/ 62.0_dp, 64.0_dp, 68.0_dp, 72.0_dp, 92.0_dp, 94.0_dp /)
  beta_list = (/ 0.29_dp, 0.32_dp, 0.27_dp, 0.24_dp, 0.28_dp, 0.29_dp /)

write(*,'(A)') '=== Deformed Nucleus Quadrupole Properties ==='
  write(*,'(A)') ''
  write(*,'(A)') 'Nucleus    beta    R0(fm)   Q0(e*fm^2)  Q0(e*b)   ratio'
  write(*,'(A)') '-------    ----    ------   ----------  -------   -----'

do i = 1, n_nuclei
    A = A_list(i)
    Z = Z_list(i)
    beta = beta_list(i)

R0 = r0 * A**(1.0_dp/3.0_dp)

! Intrinsic quadrupole moment
    ! Q0 = (2/5) * Z * R0^2 * beta * (1 + 0.36*beta)
    Q0 = (2.0_dp/5.0_dp) * Z * R0**2 * beta * (1.0_dp + 0.36_dp * beta)

! Semi-axis ratio for prolate deformation
    delta = beta * (4.0_dp/3.0_dp) * sqrt(5.0_dp/(16.0_dp*pi))
    a_z = R0 * (1.0_dp + delta)
    a_perp = R0 * (1.0_dp - 0.5_dp * delta)
    ratio = a_z / a_perp

write(*,'(A10, F7.2, F9.2, F12.1, F10.2, F9.3)') &
      names(i), beta, R0, Q0, Q0/100.0_dp, ratio
  end do

write(*,'(A)') ''
  write(*,'(A)') 'Notes:'
  write(*,'(A)') '- Q0 > 0: prolate (elongated along symmetry axis)'
  write(*,'(A)') '- Q0 < 0: oblate (flattened)'
  write(*,'(A)') '- Deformed regions: 150 < A < 190 and A > 220'
  write(*,'(A)') '- Spherical regions: near magic numbers (A ~ 208)'
  write(*,'(A)') ''
  write(*,'(A)') '--- Rotational Energy Ratios ---'
  write(*,'(A)') 'Ideal rotor:  E(4+)/E(2+) = 3.333'
  write(*,'(A)') 'Ideal vibrator: E(4+)/E(2+) = 2.000'
  write(*,'(A)') 'Gamma-soft:  E(4+)/E(2+) = 2.500'
end program deformed_nucleus

Click Run to execute the Fortran code

Code will be compiled with gfortran and executed on the server

← Shell Model Part V: Applications →