{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cf181941",
   "metadata": {},
   "source": [
    "# TX signal generator for lunar / planetary delay-Doppler mapping\n",
    "\n",
    "Generates a CW or Zadoff-Chu (ZC) transmit signal and writes it as a SigMF recording (`ci16_le`).\n",
    "\n",
    "Select the signal with `signal_type`, the radar target with `target`, and run all cells top to bottom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e5c5a787",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import datetime\n",
    "\n",
    "import sympy\n",
    "\n",
    "import sigmf\n",
    "from sigmf import SigMFFile"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "665193e4",
   "metadata": {},
   "source": [
    "## Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ba77388c",
   "metadata": {},
   "outputs": [],
   "source": [
    "signal_type = \"zc\"          # \"zc\" or \"cw\"\n",
    "\n",
    "sample_rate = 250e3         # SDR sample rate (Hz)\n",
    "duration = 10           # length of one period (s)\n",
    "repeats = 27                 # number of periods in the file (only file length; same signal if the TX loops the file)\n",
    "coherent_periods = 1        # periods integrated coherently at the receiver (independent of repeats)\n",
    "\n",
    "center_freq = 1299650000    # Hz\n",
    "tx_gain = 10                # stored as vrt:tx_gain\n",
    "\n",
    "backoff_db = 1.0            # peak level below int16 full scale, headroom for SDR interpolation filters\n",
    "\n",
    "# pulse shaping when upsampling chips to samples:\n",
    "#   \"rect\" - repeat each chip (constant envelope, 0 dB PAPR, sinc^2 spectrum with wide sidelobes)\n",
    "#   \"fft\"  - exact periodic band-limited interpolation, band limit set by pulse_bw\n",
    "pulse_shape = \"rect\"\n",
    "# bandwidth for \"fft\" (Hz, two-sided):\n",
    "#   None   - chip rate only (flat spectrum, no out-of-band power, ~2.7 dB PAPR)\n",
    "#   number - rect chips band-limited to +-pulse_bw/2 (keeps the sinc^2 sidelobes up to there, e.g. 150e3)\n",
    "pulse_bw = 150e3\n",
    "\n",
    "# radar target\n",
    "target = \"venus\"             # \"moon\" or \"venus\"\n",
    "\n",
    "# radius (m), max Doppler offset from the echo center at 23 cm (Hz), delay depth to map (s, None = full sphere 2R/c)\n",
    "# Venus: ~2.6 m/s apparent equatorial velocity near inferior conjunction -> +-22 Hz at 1.3 GHz.\n",
    "# Its full depth (40 ms) is overspread for a periodic code (2*max_doppler*depth > 1), so map only the front 18 ms\n",
    "# (use 10e-3 with block processing, which needs 4*max_doppler*depth <= 1).\n",
    "targets = {\n",
    "    \"moon\":  {\"radius\": 1737.4e3, \"max_doppler\": 12, \"max_delay\": None},\n",
    "    \"venus\": {\"radius\": 6051.8e3, \"max_doppler\": 9, \"max_delay\": 18e-3},\n",
    "    \"local\": {\"radius\": 2000e3, \"max_doppler\": 120, \"max_delay\": 10e-3},\n",
    "}\n",
    "\n",
    "max_doppler = targets[target][\"max_doppler\"]\n",
    "delay_depth = targets[target][\"max_delay\"] or 2 * targets[target][\"radius\"] / 299792458\n",
    "\n",
    "# Zadoff-Chu\n",
    "zc_bw = int(10e3)           # chip rate (Hz)\n",
    "use_prime_length = False    # False: N = duration*zc_bw exactly; True: N = next prime (period becomes N/zc_bw)\n",
    "\n",
    "# echo processing, sets how the root q is chosen:\n",
    "#   \"full_period\" - correlate the whole period against Doppler-shifted replicas; q only has to keep the ghost\n",
    "#                   lattice outside the echo, any q in 2..N/2 is searched (limit: 2*max_doppler*depth <= 1)\n",
    "#   \"block\"       - correlate short blocks and FFT across blocks (ZC acts as a chirp); q also has to keep the\n",
    "#                   Doppler-induced delay shift <= 1/4 chip and the ridge wrap beyond the depth (4*max_doppler*depth <= 1)\n",
    "processing = \"full_period\"\n",
    "\n",
    "path = \"/Users/telkamp/data/eve2026/test/\"\n",
    "\n",
    "author = \"Thomas Telkamp\"\n",
    "\n",
    "fs = sample_rate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed9de4f4",
   "metadata": {},
   "source": [
    "## Signal generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "256e8e7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_zadoff_chu(N, q):\n",
    "    \"\"\"\n",
    "    Generate a Zadoff-Chu sequence of length N with root index q.\n",
    "\n",
    "    Ideal (zero-sidelobe) periodic autocorrelation holds for any N as long as\n",
    "    gcd(N, q) == 1. A prime N is only needed for good cross-correlation between\n",
    "    different roots.\n",
    "\n",
    "    Parameters:\n",
    "        N (int): Length of the sequence.\n",
    "        q (int): Root index (must be coprime with N).\n",
    "\n",
    "    Returns:\n",
    "        np.ndarray: Complex Zadoff-Chu sequence.\n",
    "    \"\"\"\n",
    "    if np.gcd(N, q) != 1:\n",
    "        raise ValueError(\"Root index q must be coprime with N.\")\n",
    "\n",
    "    n = np.arange(N, dtype=np.int64)\n",
    "    cf = N % 2  # n(n+1) for odd N, n^2 for even N\n",
    "\n",
    "    # the phase is periodic in q*n*(n+cf) with period 2N; reduce in integers to keep full float precision\n",
    "    phase = (n * (n + cf) % (2 * N)) * (q % (2 * N)) % (2 * N)\n",
    "\n",
    "    return np.exp(-1j * np.pi * phase / N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0af1894b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def upsample(seq, sps, method=\"rect\", bw=None):\n",
    "    \"\"\"\n",
    "    Upsample a periodic chip sequence by an integer factor sps.\n",
    "\n",
    "    For \"fft\", bw is the two-sided bandwidth in units of the chip rate: None keeps only the chip-rate\n",
    "    band with a flat spectrum, otherwise the rect waveform is band-limited to +-bw/2 (bw >= sps is rect).\n",
    "    \"\"\"\n",
    "    if method == \"rect\":\n",
    "        return np.repeat(seq, sps)\n",
    "    if method == \"fft\" and bw is not None:\n",
    "        x = np.repeat(seq, sps)\n",
    "        X = np.fft.fft(x)\n",
    "        f = np.fft.fftfreq(len(x), 1 / sps)  # in units of the chip rate\n",
    "        X[np.abs(f) > bw / 2] = 0\n",
    "        return np.fft.ifft(X)\n",
    "    if method == \"fft\":\n",
    "        # zero-pad the spectrum; exact for periodic signals\n",
    "        N = len(seq)\n",
    "        X = np.fft.fft(seq)\n",
    "        Y = np.zeros(N * sps, dtype=complex)\n",
    "        h = N // 2\n",
    "        Y[:h] = X[:h]\n",
    "        Y[-h:] = X[-h:]\n",
    "        if N % 2:\n",
    "            Y[h] = X[h]\n",
    "        else:\n",
    "            # split the Nyquist bin between +fs/2 and -fs/2\n",
    "            Y[h] = X[h] / 2\n",
    "            Y[-h - 1] += X[h] / 2\n",
    "        return np.fft.ifft(Y) * sps\n",
    "    raise ValueError(\"Unknown pulse shape: \" + method)\n",
    "\n",
    "\n",
    "def check_sps(sample_rate, chip_rate):\n",
    "    sps = sample_rate / chip_rate\n",
    "    assert sps == int(sps), \"sample_rate must be an integer multiple of the chip rate\"\n",
    "    return int(sps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "180e1563",
   "metadata": {},
   "outputs": [],
   "source": [
    "def choose_q(N, M, K, q_range):\n",
    "    \"\"\"\n",
    "    Pick the root q that keeps the ghost peaks furthest outside the echo-difference region.\n",
    "\n",
    "    A Doppler shift of k bins equals a cyclic delay of m chips when k = q*m mod N, so every\n",
    "    (m, k) on that lattice is a full-strength ghost. Two echo points differ by at most M chips\n",
    "    and K bins; margin = min over ghosts of max(|m|/M, |k|/K). Margin > 1 means no aliasing.\n",
    "    Returns the smallest q within 1% of the best margin (small q also suits block processing).\n",
    "    \"\"\"\n",
    "    m = np.arange(1, int(3 * M) + 2)  # ghosts beyond 3*M chips cannot bring the margin below 3\n",
    "    qs = np.array([q for q in q_range if np.gcd(N, q) == 1])\n",
    "    if len(qs) == 0:\n",
    "        raise ValueError(\"No q in range is coprime with N\")\n",
    "    margins = []\n",
    "    for chunk in np.array_split(qs, max(1, len(qs) * len(m) // 20_000_000)):\n",
    "        k = np.outer(chunk, m) % N\n",
    "        k = np.minimum(k, N - k)\n",
    "        margins.append(np.minimum(np.maximum(m / M, k / K).min(axis=1), 3))\n",
    "    margins = np.concatenate(margins)\n",
    "    i = np.argmax(margins >= 0.99 * margins.max())\n",
    "    return int(qs[i]), float(margins[i])\n",
    "\n",
    "\n",
    "def make_cw():\n",
    "    data = np.ones(int(duration * sample_rate), dtype=complex)\n",
    "    name = \"cw-fs\" + str(int(sample_rate)) + \"-\" + str(duration) + \"sec-\" + str(repeats) + \"x\"\n",
    "    params = {}\n",
    "    return data, name, params\n",
    "\n",
    "\n",
    "def make_zc():\n",
    "    sps = check_sps(sample_rate, zc_bw)\n",
    "\n",
    "    N = int(duration * zc_bw)\n",
    "    if use_prime_length:\n",
    "        N = int(sympy.nextprime(N - 1))\n",
    "\n",
    "    M = delay_depth * zc_bw                  # max delay difference between echo points (chips)\n",
    "    K = 2 * max_doppler * N / zc_bw          # max Doppler difference between echo points (bins of zc_bw/N Hz)\n",
    "\n",
    "    if processing == \"full_period\":\n",
    "        spread = 2 * max_doppler * delay_depth\n",
    "        q_range = range(2, N // 2 + 1)\n",
    "    elif processing == \"block\":\n",
    "        spread = 4 * max_doppler * delay_depth\n",
    "        # Doppler f shifts the correlation peak by f*N/(q*zc_bw) chips; keep that <= 1/4 chip at max_doppler\n",
    "        q_lo = int(np.ceil(4 * max_doppler * N / zc_bw))\n",
    "        # the chirp wraps every N/q chips; keep that beyond the target delay depth\n",
    "        q_hi = int(N / M)\n",
    "        if q_hi < q_lo:\n",
    "            print(\"WARNING: no q satisfies both block-processing limits, using q >= %d\" % q_lo)\n",
    "            q_hi = q_lo + 100\n",
    "        q_range = range(q_lo, q_hi + 1)\n",
    "    else:\n",
    "        raise ValueError(\"Unknown processing: \" + processing)\n",
    "\n",
    "    q, margin = choose_q(N, M, K, q_range)\n",
    "\n",
    "    print(\"ZC length N:\", N, \"(prime)\" if sympy.isprime(N) else \"\")\n",
    "    print(\"Target:\", target, \" max Doppler (Hz):\", max_doppler, \" delay depth (ms): %.1f\" % (delay_depth * 1e3))\n",
    "    print(\"Processing:\", processing, \" spread factor: %.2f (must be <= 1)\" % spread)\n",
    "    print(\"Root q:\", q, \" ghost margin: %.2f (must be > 1)\" % margin)\n",
    "    print(\"Delay shift at max Doppler (chips): %.3f\" % (max_doppler * N / (q * zc_bw)))\n",
    "    if margin <= 1:\n",
    "        print(\"WARNING: ghost peaks fall inside the echo, reduce the delay depth to map or the Doppler range\")\n",
    "\n",
    "    seq = generate_zadoff_chu(N, q)\n",
    "    data = upsample(seq, sps, pulse_shape, None if pulse_bw is None else pulse_bw / zc_bw)\n",
    "\n",
    "    name = (\"zadoff-chu-fs\" + str(int(sample_rate)) + \"-fzc\" + str(zc_bw) + \"-l\" + str(N) + \"-q\" + str(q)\n",
    "            + \"-\" + str(duration) + \"sec-\" + str(repeats) + \"x\")\n",
    "    if pulse_shape != \"rect\":\n",
    "        name += \"-\" + pulse_shape\n",
    "        if pulse_shape == \"fft\" and pulse_bw is not None:\n",
    "            name += str(int(pulse_bw))\n",
    "\n",
    "    params = {\n",
    "        \"zc:length\": N,\n",
    "        \"zc:root\": q,\n",
    "        \"zc:chip_rate\": zc_bw,\n",
    "        \"zc:samples_per_chip\": sps,\n",
    "        \"zc:pulse_shape\": pulse_shape,\n",
    "        \"zc:max_doppler\": max_doppler,\n",
    "        \"zc:delay_depth\": delay_depth,\n",
    "        \"zc:processing\": processing,\n",
    "        \"zc:ghost_margin\": margin,\n",
    "    }\n",
    "    if pulse_shape == \"fft\" and pulse_bw is not None:\n",
    "        params[\"zc:pulse_bw\"] = pulse_bw\n",
    "    return data, name, params, seq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c5c47dbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ZC length N: 100000 \n",
      "Target: venus  max Doppler (Hz): 9  delay depth (ms): 18.0\n",
      "Processing: full_period  spread factor: 0.32 (must be <= 1)\n",
      "Root q: 313  ghost margin: 1.74 (must be > 1)\n",
      "Delay shift at max Doppler (chips): 0.288\n",
      "Samples: 67500000  PAPR (dB): 0.00\n",
      "/Users/telkamp/data/eve2026/test/zadoff-chu-fs250000-fzc10000-l100000-q313-10sec-27x.sigmf-data\n"
     ]
    }
   ],
   "source": [
    "if signal_type == \"zc\":\n",
    "    data, name, params, seq = make_zc()\n",
    "elif signal_type == \"cw\":\n",
    "    data, name, params = make_cw()\n",
    "    seq = None\n",
    "else:\n",
    "    raise ValueError(\"Unknown signal_type: \" + signal_type)\n",
    "\n",
    "period_samples = len(data)\n",
    "data = np.tile(data, repeats)\n",
    "params[\"tx:target\"] = target\n",
    "params[\"tx:repeats\"] = repeats\n",
    "params[\"tx:period_samples\"] = period_samples\n",
    "\n",
    "data_file = path + name + \".sigmf-data\"\n",
    "meta_file = path + name + \".sigmf-meta\"\n",
    "\n",
    "papr = 10 * np.log10(np.max(np.abs(data)**2) / np.mean(np.abs(data)**2))\n",
    "print(\"Samples:\", len(data), \" PAPR (dB): %.2f\" % papr)\n",
    "print(data_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a1bcabc8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coherent integration: 1 period(s), 10.00 s\n",
      "Delay resolution:     100.00 us  (range 14.99 km)\n",
      "Doppler resolution:   0.1000 Hz  (surface 67.24 km)\n",
      "Delay cells over mapped depth (18.0 ms): 180\n",
      "Doppler cells over +-9 Hz: 180\n",
      "Grid cells (delay x Doppler): 32400\n",
      "Cells covered by the echo: 18972\n"
     ]
    }
   ],
   "source": [
    "# delay-Doppler resolution and number of cells, for coherent processing of coherent_periods periods.\n",
    "# Integrating K periods gives K times finer Doppler bins; the ghost lattice (spacing 1/period) is unchanged.\n",
    "if signal_type == \"zc\":\n",
    "    c = 299792458\n",
    "    R = targets[target][\"radius\"]\n",
    "    full_depth = 2 * R / c\n",
    "    period = params[\"zc:length\"] / zc_bw\n",
    "    t_coh = coherent_periods * period\n",
    "\n",
    "    delay_res = 1 / zc_bw                     # s, one chip\n",
    "    doppler_res = 1 / t_coh                   # Hz, one bin\n",
    "    range_res = c * delay_res / 2             # m\n",
    "    cross_res = R * doppler_res / max_doppler # m, Doppler bin projected on the surface (f = max_doppler * x / R)\n",
    "\n",
    "    delay_cells = delay_depth / delay_res\n",
    "    doppler_cells = 2 * max_doppler / doppler_res\n",
    "\n",
    "    # cells covered by the echo: area of the footprint (up to the mapped depth) in the delay-Doppler plane\n",
    "    tau = np.linspace(0, delay_depth, 10001)\n",
    "    width = 2 * max_doppler * np.sqrt(1 - (1 - tau / full_depth)**2)\n",
    "    footprint_cells = np.mean(width) * delay_depth / (delay_res * doppler_res)\n",
    "\n",
    "    print(\"Coherent integration: %d period(s), %.2f s\" % (coherent_periods, t_coh))\n",
    "    print(\"Delay resolution:   %8.2f us  (range %.2f km)\" % (delay_res * 1e6, range_res / 1e3))\n",
    "    print(\"Doppler resolution: %8.4f Hz  (surface %.2f km)\" % (doppler_res, cross_res / 1e3))\n",
    "    print(\"Delay cells over mapped depth (%.1f ms): %d\" % (delay_depth * 1e3, round(delay_cells)))\n",
    "    print(\"Doppler cells over +-%g Hz: %d\" % (max_doppler, round(doppler_cells)))\n",
    "    print(\"Grid cells (delay x Doppler): %d\" % round(delay_cells * doppler_cells))\n",
    "    print(\"Cells covered by the echo: %d\" % round(footprint_cells))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d920d474",
   "metadata": {},
   "source": [
    "## Checks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d6ce9db4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import mlab\n",
    "\n",
    "pxx, freqs = mlab.psd(data, NFFT=64*1024, Fs=fs, window=mlab.window_hanning)\n",
    "psd_db = 10 * np.log10(np.maximum(pxx / pxx.max(), 1e-20))\n",
    "\n",
    "fig, ax0 = plt.subplots(figsize=(8, 5))\n",
    "ax0.plot(freqs, psd_db)\n",
    "ax0.set_xlabel(\"Frequency (Hz)\")\n",
    "ax0.set_ylabel(\"Relative PSD (dB)\")\n",
    "ax0.set_ylim(max(psd_db.min(), -120) - 5, 5)\n",
    "ax0.grid(True)\n",
    "if signal_type == \"zc\":\n",
    "    ax0.axvline(-zc_bw / 2, color='black', ls=':')\n",
    "    ax0.axvline(zc_bw / 2, color='black', ls=':')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b8465134",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Peak periodic autocorrelation sidelobe: -326.6 dB\n",
      "Full-strength ghost peaks in window (delay ms, Doppler Hz):\n",
      "   -32.00 ms  -16.00 Hz\n",
      "   -31.90 ms   15.30 Hz\n",
      "    31.90 ms  -15.30 Hz\n",
      "    32.00 ms   16.00 Hz\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# periodic autocorrelation of the chip sequence, and delay-Doppler ambiguity over the full target\n",
    "if seq is not None:\n",
    "    N = len(seq)\n",
    "    S = np.fft.fft(seq)\n",
    "    r = np.abs(np.fft.ifft(S * np.conj(S)))\n",
    "    r /= r[0]\n",
    "    print(\"Peak periodic autocorrelation sidelobe: %.1f dB\" % (20 * np.log10(r[1:].max() + 1e-300)))\n",
    "\n",
    "    # window: +-full sphere depth in delay, +-2*max_doppler (largest Doppler difference between echo points)\n",
    "    full_depth = 2 * targets[target][\"radius\"] / 299792458\n",
    "    max_lag = int(np.ceil(1.1 * full_depth * zc_bw))\n",
    "    # Doppler grid in half-bin steps (shows leakage from non-integer Doppler), at most ~200 rows\n",
    "    half_bin = zc_bw / N / 2\n",
    "    step = max(1, int(np.ceil(4 * max_doppler / half_bin / 200))) * half_bin\n",
    "    n_step = int(2 * max_doppler / step)\n",
    "    dopplers = np.arange(-n_step, n_step + 1) * step  # Hz\n",
    "    t = np.arange(N) / zc_bw\n",
    "    lags = np.r_[N - max_lag:N, 0:max_lag + 1]\n",
    "    lag_chips = np.where(lags > N // 2, lags - N, lags)\n",
    "    amb = np.empty((len(dopplers), len(lags)))\n",
    "    for i, f in enumerate(dopplers):\n",
    "        R = np.fft.fft(seq * np.exp(2j * np.pi * f * t))\n",
    "        amb[i] = np.abs(np.fft.ifft(R * np.conj(S)))[lags] / N\n",
    "\n",
    "    # ghost peaks: a Doppler shift of k bins (zc_bw/N Hz) is identical to a delay of m chips when k = q*m mod N\n",
    "    q = params[\"zc:root\"]\n",
    "    ghosts = []\n",
    "    for m in range(-max_lag, max_lag + 1):\n",
    "        k = (q * m) % N\n",
    "        k = k - N if k > N // 2 else k\n",
    "        f = k * zc_bw / N\n",
    "        if m != 0 and abs(f) <= dopplers[-1]:\n",
    "            ghosts.append((m / zc_bw, f))\n",
    "    print(\"Full-strength ghost peaks in window (delay ms, Doppler Hz):\")\n",
    "    for d, f in ghosts:\n",
    "        inside = abs(d) <= delay_depth and abs(f) <= 2 * max_doppler\n",
    "        print(\"  %7.2f ms  %6.2f Hz%s\" % (d * 1e3, f, \"   <-- inside mapped region\" if inside else \"\"))\n",
    "\n",
    "    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))\n",
    "    ax1.plot(np.fft.fftshift(np.fft.fftfreq(N, 1 / N)).astype(int),\n",
    "             20 * np.log10(np.fft.fftshift(r) + 1e-12))\n",
    "    ax1.set_xlabel(\"lag (chips)\")\n",
    "    ax1.set_ylabel(\"dB\")\n",
    "    ax1.set_title(\"Periodic autocorrelation\")\n",
    "    ax1.set_ylim(-200, 5)\n",
    "\n",
    "    # max-pool for display, otherwise the 1 chip x 0.5 Hz peaks disappear when the image is scaled down\n",
    "    pd, pl = max(1, len(dopplers) // 80), max(1, len(lags) // 300)\n",
    "    a = amb[:len(dopplers) // pd * pd, :len(lags) // pl * pl]\n",
    "    amb_disp = a.reshape(a.shape[0] // pd, pd, a.shape[1] // pl, pl).max(axis=(1, 3))\n",
    "\n",
    "    im = ax2.imshow(20 * np.log10(amb_disp + 1e-12), aspect='auto', origin='lower', vmin=-80, vmax=0,\n",
    "                    extent=[lag_chips[0] / zc_bw * 1e3, lag_chips[-1] / zc_bw * 1e3, dopplers[0], dopplers[-1]])\n",
    "\n",
    "    # echo footprint of the target (leading edge at 0), and the mapped delay depth\n",
    "    theta = np.linspace(0, np.pi / 2, 200)\n",
    "    fp_delay = full_depth * (1 - np.cos(theta)) * 1e3\n",
    "    fp_dopp = max_doppler * np.sin(theta)\n",
    "    ax2.plot(np.r_[fp_delay, fp_delay[::-1]], np.r_[fp_dopp, -fp_dopp[::-1]], color='white', lw=1)\n",
    "    if ghosts:\n",
    "        g = np.array(ghosts)\n",
    "        ax2.plot(g[:, 0] * 1e3, g[:, 1], 'o', mfc='none', mec='red', ms=8)\n",
    "    ax2.axvline(delay_depth * 1e3, color='white', ls='--', lw=1)\n",
    "    ax2.axvline(-delay_depth * 1e3, color='white', ls='--', lw=1)\n",
    "\n",
    "    ax2.set_xlabel(\"delay (ms)\")\n",
    "    ax2.set_ylabel(\"Doppler (Hz)\")\n",
    "    ax2.set_title(\"Ambiguity (dB), %s: echo footprint (white), mapped depth (dashed), ghosts (red)\" % target)\n",
    "    fig.colorbar(im, ax=ax2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14039b29",
   "metadata": {},
   "source": [
    "## Write SigMF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4322fd8c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Peak int16: 29204\n",
      "/Users/telkamp/data/eve2026/test/zadoff-chu-fs250000-fzc10000-l100000-q313-10sec-27x.sigmf-meta\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/z4/dvccn8pj2hgf0vx73t6yw4xm0000gn/T/ipykernel_70906/1272221697.py:18: DeprecationWarning: SigMFFile.DATATYPE_KEY is deprecated and will be removed in a future version, use sigmf.DATATYPE_KEY\n",
      "  SigMFFile.DATATYPE_KEY: 'ci16_le',\n",
      "/var/folders/z4/dvccn8pj2hgf0vx73t6yw4xm0000gn/T/ipykernel_70906/1272221697.py:19: DeprecationWarning: SigMFFile.SAMPLE_RATE_KEY is deprecated and will be removed in a future version, use sigmf.SAMPLE_RATE_KEY\n",
      "  SigMFFile.SAMPLE_RATE_KEY: sample_rate,\n",
      "/var/folders/z4/dvccn8pj2hgf0vx73t6yw4xm0000gn/T/ipykernel_70906/1272221697.py:20: DeprecationWarning: SigMFFile.AUTHOR_KEY is deprecated and will be removed in a future version, use sigmf.AUTHOR_KEY\n",
      "  SigMFFile.AUTHOR_KEY: author,\n",
      "/var/folders/z4/dvccn8pj2hgf0vx73t6yw4xm0000gn/T/ipykernel_70906/1272221697.py:21: DeprecationWarning: SigMFFile.DESCRIPTION_KEY is deprecated and will be removed in a future version, use sigmf.DESCRIPTION_KEY\n",
      "  SigMFFile.DESCRIPTION_KEY: name,\n",
      "/var/folders/z4/dvccn8pj2hgf0vx73t6yw4xm0000gn/T/ipykernel_70906/1272221697.py:22: DeprecationWarning: SigMFFile.EXTENSIONS_KEY is deprecated and will be removed in a future version, use sigmf.EXTENSIONS_KEY\n",
      "  SigMFFile.EXTENSIONS_KEY: extensions,\n",
      "/var/folders/z4/dvccn8pj2hgf0vx73t6yw4xm0000gn/T/ipykernel_70906/1272221697.py:30: DeprecationWarning: SigMFFile.FREQUENCY_KEY is deprecated and will be removed in a future version, use sigmf.FREQUENCY_KEY\n",
      "  SigMFFile.FREQUENCY_KEY: center_freq,\n",
      "/var/folders/z4/dvccn8pj2hgf0vx73t6yw4xm0000gn/T/ipykernel_70906/1272221697.py:31: DeprecationWarning: SigMFFile.DATETIME_KEY is deprecated and will be removed in a future version, use sigmf.DATETIME_KEY\n",
      "  SigMFFile.DATETIME_KEY: datetime.datetime.now(datetime.timezone.utc).strftime(\"%Y-%m-%dT%H:%M:%S.%fZ\"),\n"
     ]
    }
   ],
   "source": [
    "def write_sigmf(data, name, params):\n",
    "    # scale to int16 with backoff, round, write interleaved I/Q\n",
    "    scale = (2**15 - 1) * 10**(-backoff_db / 20) / np.max(np.abs(data))\n",
    "    iq = np.empty(2 * len(data), dtype=np.int16)\n",
    "    iq[0::2] = np.round(data.real * scale)\n",
    "    iq[1::2] = np.round(data.imag * scale)\n",
    "    iq.tofile(data_file)\n",
    "    print(\"Peak int16:\", np.max(np.abs(iq)))\n",
    "\n",
    "    extensions = [{\"name\": \"vrt\", \"version\": \"1.0.0\", \"optional\": True}]\n",
    "    if any(k.startswith(\"zc:\") for k in params):\n",
    "        extensions.append({\"name\": \"zc\", \"version\": \"1.0.0\", \"optional\": True})\n",
    "    extensions.append({\"name\": \"tx\", \"version\": \"1.0.0\", \"optional\": True})\n",
    "\n",
    "    meta = SigMFFile(\n",
    "        data_file=data_file,\n",
    "        global_info={\n",
    "            SigMFFile.DATATYPE_KEY: 'ci16_le',\n",
    "            SigMFFile.SAMPLE_RATE_KEY: sample_rate,\n",
    "            SigMFFile.AUTHOR_KEY: author,\n",
    "            SigMFFile.DESCRIPTION_KEY: name,\n",
    "            SigMFFile.EXTENSIONS_KEY: extensions,\n",
    "            \"vrt:tx_gain\": tx_gain,\n",
    "            \"tx:backoff_db\": backoff_db,\n",
    "            **params,\n",
    "        }\n",
    "    )\n",
    "\n",
    "    meta.add_capture(0, metadata={\n",
    "        SigMFFile.FREQUENCY_KEY: center_freq,\n",
    "        SigMFFile.DATETIME_KEY: datetime.datetime.now(datetime.timezone.utc).strftime(\"%Y-%m-%dT%H:%M:%S.%fZ\"),\n",
    "    })\n",
    "\n",
    "    meta.tofile(meta_file)\n",
    "    print(meta_file)\n",
    "\n",
    "\n",
    "write_sigmf(data, name, params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b98f0f0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a3ec8b3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1adee95-4dfe-40c7-8bf0-1a4ad34684c7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4eb37b03-7188-46fc-94d0-ac61e873770d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.14.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
