Domain: Physics — Quantum Mechanics

Problem:
The fission degree of freedom of \(^{240}\mathrm{Pu}\) is described by a one-dimensional collective coordinate \(q\) with an effective potential energy surface:

\[
V(q) = V_{\text{base}}(q) + V_{\text{inner}}(q) + V_{\text{outer}}(q)
       + V_{\text{shell}}(q) + V_{\text{fall}}(q),
\]

where
\[
V_{\text{base}}(q) = a(q^2 - b^2)^2 e^{-(q/q_f)^2}, \quad
V_{\text{inner}}(q) = c_1 e^{-((q-d_1)^2/s_1^2)}, 
\]

\[
V_{\text{outer}}(q) = c_2 e^{-((q-d_2)^2/s_2^2)}, \quad
V_{\text{shell}}(q) = A_{\mathrm{sh}} e^{-(q/\lambda)^2}\cos(\kappa q^3 + \phi),
\]

\[
V_{\text{fall}}(q) = -V_{\text{drop}}
\left[\frac{1}{1 + e^{-(q-q_{\text{drop}})/\Delta_H}}\right].
\]

The coordinate-dependent collective inertia is specified in  \(\hbar^2/\mathrm{MeV}\); to keep the WKB action dimensionless, we write the inertia explicitly as
\[
M(q) = M_0\bigl[1 + \alpha e^{-(q-q_m)^2/w^2}\bigr]
\left[1 + \frac{\beta}{1 + e^{(q-q_c)/\gamma}}\right].
\]

The numerical parameters are:

\[
a = 4.6,\quad b = 0.9,\quad q_f = 2.10.
\]

\[
c_1 = 7.2,\quad d_1 = 1.40,\quad s_1 = 0.35.
\]

\[
c_2 = 4.0,\quad d_2 = 2.10,\quad s_2 = 0.25.
\]

\[
A_{\mathrm{sh}} = 0.40,\quad \lambda = 1.20,\quad \kappa = 2.30,\quad \phi = 0.40.
\]

\[
V_{\text{drop}} = 9.0,\quad q_{\text{drop}} = 2.40,\quad \Delta_H = 0.06.
\]

\[
M_0 = 4.0,\quad \alpha = 0.60,\quad q_m = 1.15,\quad w = 0.30.
\]

\[
\beta = 0.80,\quad q_c = 1.80,\quad \gamma = 0.12.
\]

\[
E_g = 2.1~\mathrm{MeV},\quad \nu = 10^{20}~\mathrm{s}^{-1},\quad q \in [0,6.5].
\]


For each forbidden region where \(V(q)>E_g\), the semiclassical (dimensionless) WKB action is:

\[
S_i = \frac{1}{\hbar}\int_{q_{L,i}}^{q_{R,i}}
\sqrt{2\,M(q)\,[V(q)-E_g]}\,dq,
\qquad
S=\sum_i S_i.
\]

We use the WKB approximation for a multi-humped barrier in the opaque limit, neglecting intermediate-well resonances. In this approximation the transmission probability is:

\[
P \approx \exp\!\left[-2\sum_i S_i\right].
\]

The fission-decay probability and the spontaneous-fission half-life are therefore
\[
P=e^{-2S}, \quad
T_{1/2} = \frac{\ln 2}{\nu P}.
\]

Compute the spontaneous-fission half-life \(T_{1/2}\) in seconds, rounded to three significant digits.

Answer: \(1.87\times10^{21}\)

Solution code:
import math
import numpy as np
a, b, qf = 4.6, 0.9, 2.10
c1, d1, s1 = 7.2, 1.40, 0.35   # inner hump
c2, d2, s2 = 4.0, 2.10, 0.25   # outer hump
A_sh, lam, kappa, phi = 0.40, 1.20, 2.30, 0.40
Vdrop, q_drop, delta_H = 9.0, 2.40, 0.06

M0 = 4.0
alpha, qm, w = 0.60, 1.15, 0.30
beta,  qc, gamma = 0.80, 1.80, 0.12

Eg  = 2.1        # MeV
nu  = 1.0e20     # s^-1
qmin, qmax = 0.0, 6.5

HBAR = 1.0      

N_GRID     = 260_001
SAFETY_EPS = 1.0e-10
TOL        = 1e-9
MAX_DEPTH  = 32

def V_base_damped(q):
    return a * (q*q - b*b)**2 * math.exp(- (q/qf)**2)

def V_inner(q):
    return c1 * math.exp(- ((q - d1)**2) / (s1*s1))

def V_outer(q):
    return c2 * math.exp(- ((q - d2)**2) / (s2*s2))

def V_shell(q):
    return A_sh * math.exp(-(q/lam)**2) * math.cos(kappa*q**3 + phi)

def smooth_step(q):
    return 1.0 / (1.0 + math.exp(-(q - q_drop)/delta_H))

def V_fall(q):
    return -Vdrop * smooth_step(q)

def V(q):
    return V_base_damped(q) + V_inner(q) + V_outer(q) + V_shell(q) + V_fall(q)

def M_of_q(q):
    term1 = 1.0 + alpha * math.exp(- ((q - qm)**2) / (w*w))
    term2 = 1.0 + beta  / (1.0 + math.exp((q - qc)/gamma))
    return M0 * term1 * term2  # units: ħ^2 / MeV

def bisection_root(f, a, b, itmax=80):
    """Sign-preserving bisection root of f in [a,b] (requires a sign change)."""
    fa, fb = f(a), f(b)
    if fa == 0.0: return a
    if fb == 0.0: return b
    if fa * fb > 0.0:
        raise ValueError("Bisection requires a sign change on [a,b].")
    lo, hi = a, b
    flo, fhi = fa, fb
    for _ in range(itmax):
        mid = 0.5 * (lo + hi)
        fm  = f(mid)
        if flo * fm <= 0.0:
            hi, fhi = mid, fm
        else:
            lo, flo = mid, fm
    return 0.5 * (lo + hi)

def build_forbidden_intervals(Eg, qmin, qmax):
    g = lambda x: V(x) - Eg
    qq = np.linspace(qmin, qmax, N_GRID)
    Vv = np.array([V(float(x)) for x in qq], dtype=np.float64)
    mask = (Vv > Eg).astype(np.int8)
    edges = np.where(np.diff(mask) != 0)[0]

    intervals = []
    if mask[0] == 1:
        q_cross = None
        for k in range(len(qq) - 1):
            if g(qq[k]) * g(qq[k + 1]) <= 0.0:
                q_cross = bisection_root(g, float(qq[k]), float(qq[k + 1]))
                break
        intervals.append([qmin, q_cross if q_cross is not None else float(qq[-1])])

    qL = None
    for idx in edges:
        a_i, b_i = float(qq[idx]), float(qq[idx + 1])
        if g(a_i) * g(b_i) == 0.0:
            eps = 1e-14 * (1.0 + abs(a_i) + abs(b_i))
            a_i -= eps
            b_i += eps
        try:
            q_cross = bisection_root(g, a_i, b_i)
        except ValueError:
            continue
        if mask[idx] == 0 and mask[idx + 1] == 1:
            qL = q_cross
        elif mask[idx] == 1 and mask[idx + 1] == 0:
            if qL is not None and q_cross > qL:
                intervals.append([qL, q_cross])
            qL = None

    if qL is not None and mask[-1] == 1:
        intervals.append([qL, qmax])

    intervals.sort(key=lambda p: p[0])
    return intervals
def adaptive_simpson(f, a, b, tol=TOL, depth=MAX_DEPTH):
    def S(f, a, b):
        c = 0.5 * (a + b)
        return (b - a) * (f(a) + 4.0 * f(c) + f(b)) / 6.0
    def rec(f, a, b, Sab, tol, depth):
        c = 0.5 * (a + b)
        Sa = S(f, a, c)
        Sb = S(f, c, b)
        if depth == 0 or abs(Sa + Sb - Sab) < 15.0 * tol:
            return Sa + Sb + (Sa + Sb - Sab) / 15.0
        return rec(f, a, c, Sa, tol / 2.0, depth - 1) + rec(f, c, b, Sb, tol / 2.0, depth - 1)
    Sab = S(f, a, b)
    return rec(f, a, b, Sab, tol, depth)

def integrand(q):
    dv = V(q) - Eg
    return 0.0 if dv <= 0.0 else (math.sqrt(2.0 * M_of_q(q) * dv) / HBAR)

def action_on_interval(qL, qR):
    a = max(qmin, qL) + SAFETY_EPS
    b = min(qmax, qR) - SAFETY_EPS
    if b <= a:
        return 0.0
    return adaptive_simpson(integrand, a, b, tol=TOL, depth=MAX_DEPTH)

intervals = build_forbidden_intervals(Eg, qmin, qmax)
S_total = sum(action_on_interval(L, R) for (L, R) in intervals)   

logP = -2.0 * S_total
T12 = (math.log(2.0) / nu) * math.exp(-logP)

print(f"{T12:.2e}")