Range-Doppler Processing

A pulsed radar transmits $M$ pulses and forms a range-Doppler map:

1. Fast time (within each pulse): matched filtering for range
2. Slow time (across pulses): FFT for Doppler velocity

$$\text{RD}[r, v] = \left|\sum_{m=0}^{M-1} y_m[r]\,e^{-j2\pi vm/M}\right|^2$$

def range_doppler_map(rx_pulses, tx_chirp):
    M, N = rx_pulses.shape
    rd = np.zeros((N, M), dtype=complex)
    for m in range(M):
        rd[:, m] = pulse_compress(rx_pulses[m], tx_chirp)[:N]
    rd = np.fft.fftshift(np.fft.fft(rd, axis=1), axes=1)
    return np.abs(rd)**2

CFAR (Constant False Alarm Rate) sets an adaptive threshold based on the local noise level:

1. For each cell under test (CUT), average the power in surrounding training cells (excluding guard cells)
2. Multiply by a threshold factor $\alpha$ set from the desired $P_{\text{fa}}$
3. Declare detection if CUT power exceeds the threshold

$$\alpha = N_{\text{train}} \left(P_{\text{fa}}^{-1/N_{\text{train}}} - 1\right)$$

def cfar_1d(signal, n_train, n_guard, pfa):
    N = len(signal)
    n_train_total = 2 * n_train
    alpha = n_train_total * (pfa**(-1/n_train_total) - 1)
    detections = np.zeros(N, dtype=bool)
    for i in range(n_guard + n_train, N - n_guard - n_train):
        train_cells = np.concatenate([
            signal[i-n_guard-n_train:i-n_guard],
            signal[i+n_guard+1:i+n_guard+n_train+1]
        ])
        threshold = alpha * np.mean(train_cells)
        if signal[i] > threshold:
            detections[i] = True
    return detections

The velocity resolution from $M$ pulses with PRI $T_s$ is:

$$\Delta v = \frac{\lambda}{2MT_s} = \frac{c}{2f_cMT_s}$$

The maximum unambiguous velocity is:

$$v_{\max} = \frac{\lambda}{4T_s}$$