plot_nf_vs_ff_beam.py

#!/usr/bin/env python3
"""
Near-field vs far-field beamforming comparison.

Near-field user at 8 m (well within Fresnel distance) → focused SPOT
Far-field  user at 500 m (beyond Fresnel distance)    → STRIP along angle

Each beamformer uses the appropriate steering model for its user.
Beam patterns are evaluated on a polar (range, azimuth) grid.

Usage:
    python plot_nf_vs_ff_beam.py
    python plot_nf_vs_ff_beam.py --Nh 128 --Nv 64 --fc 12e9
"""

import argparse
import math

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


# ──────────────────────────────────────────────
# UPA geometry
# ──────────────────────────────────────────────

def make_upa(Nh, Nv, dx, dy):
    """Uniform Planar Array in x-z plane, centered at origin."""
    x = (torch.arange(Nh, dtype=torch.float32) - (Nh - 1) / 2) * dx
    z = (torch.arange(Nv, dtype=torch.float32) - (Nv - 1) / 2) * dy
    X, Z = torch.meshgrid(x, z, indexing="ij")
    return torch.stack([X, torch.zeros_like(X), Z], dim=-1).reshape(-1, 3)


# ──────────────────────────────────────────────
# Steering vectors
# ──────────────────────────────────────────────

def nf_steering(p, r, az, k):
    """Near-field: a_n = exp(jk ‖p_target − p_n‖)  (spherical wave)"""
    px = r * torch.sin(az)
    py = -r * torch.cos(az)
    dist = torch.sqrt(
        (px.unsqueeze(-1) - p[:, 0]) ** 2
        + py.unsqueeze(-1) ** 2
        + p[:, 2] ** 2
    )
    return torch.exp(1j * k * dist)


def ff_steering(p, az, k):
    """Far-field: a_n = exp(−jk x_n sinθ)  (planar wave, angle only)"""
    return torch.exp(-1j * k * p[:, 0] * torch.sin(az).unsqueeze(-1))


# ──────────────────────────────────────────────
# Beam pattern on polar (range, azimuth) grid
# ──────────────────────────────────────────────

@torch.no_grad()
def beam_pattern_polar(w, p, r_grid, az_grid, k, batch=2000):
    """P(r, θ) = |w^H a_nf(r, θ)|²  normalised to peak = 1."""
    R, AZ = torch.meshgrid(r_grid, az_grid, indexing="ij")
    Rf, AZf = R.reshape(-1), AZ.reshape(-1)

    wc = w.conj()
    parts = []
    for i in range(0, Rf.shape[0], batch):
        a = nf_steering(p, Rf[i:i + batch], AZf[i:i + batch], k)
        parts.append((a @ wc).abs().square().cpu())
    P = torch.cat(parts).reshape(len(r_grid), len(az_grid))
    return P / P.max()


# ──────────────────────────────────────────────
# Plot: 2D heatmaps + 1D cuts + phase profiles
# ──────────────────────────────────────────────

def plot_comparison(P_nf_db, P_ff_db,
                    r_nf, az_nf, r0_nf, az0_nf_deg,
                    r_ff, az_ff, r0_ff, az0_ff_deg,
                    w_nf, w_ff, p, info, path):
    """3-row figure: heatmaps, range cuts, phase profiles."""
    fig, axes = plt.subplots(3, 2, figsize=(14, 15))
    vmin = -40

    # ── Row 1: 2D heatmaps ──
    for col, (Z, r_ax, az_ax, r0, az0, label) in enumerate([
        (P_nf_db, r_nf, az_nf, r0_nf, az0_nf_deg,
         f"Near-Field BF → SPOT\n(target r={r0_nf:.0f} m, θ={az0_nf_deg}°)"),
        (P_ff_db, r_ff, az_ff, r0_ff, az0_ff_deg,
         f"Far-Field BF → STRIP\n(target r={r0_ff:.0f} m, θ={az0_ff_deg}°)"),
    ]):
        ax = axes[0, col]
        pcm = ax.pcolormesh(
            az_ax, r_ax, np.clip(Z, vmin, 0),
            cmap="jet", shading="auto", vmin=vmin, vmax=0)
        fig.colorbar(pcm, ax=ax, label="dB")
        ax.axhline(r0, color="w", ls="--", lw=0.8, alpha=0.7)
        ax.axvline(az0, color="w", ls="--", lw=0.8, alpha=0.7)
        ax.plot(az0, r0, "r*", ms=14, mec="white", mew=0.6)
        ax.set_xlabel("Azimuth (°)")
        ax.set_ylabel("Range (m)")
        ax.set_title(label, fontsize=11)

    # ── Row 2: range cuts at target azimuth ──
    az_nf_np = az_nf.numpy() if isinstance(az_nf, torch.Tensor) else az_nf
    az_ff_np = az_ff.numpy() if isinstance(az_ff, torch.Tensor) else az_ff
    r_nf_np = r_nf.numpy() if isinstance(r_nf, torch.Tensor) else r_nf
    r_ff_np = r_ff.numpy() if isinstance(r_ff, torch.Tensor) else r_ff

    idx_nf = np.argmin(np.abs(az_nf_np - az0_nf_deg))
    idx_ff = np.argmin(np.abs(az_ff_np - az0_ff_deg))

    for col, (Z, r_ax, idx, r0, label) in enumerate([
        (P_nf_db, r_nf_np, idx_nf, r0_nf,
         f"NF range cut at θ={az0_nf_deg}°"),
        (P_ff_db, r_ff_np, idx_ff, r0_ff,
         f"FF range cut at θ={az0_ff_deg}°"),
    ]):
        ax = axes[1, col]
        ax.plot(r_ax, Z[:, idx], "b-", lw=1.5)
        ax.axvline(r0, color="r", ls="--", lw=1, label=f"target r={r0:.0f} m")
        ax.set_xlabel("Range (m)")
        ax.set_ylabel("Power (dB)")
        ax.set_title(label, fontsize=11)
        ax.set_ylim(vmin, 3)
        ax.legend(fontsize=9)
        ax.grid(True, ls=":", alpha=0.3)

    # ── Row 3: weight phase profiles ──
    p_np = p.numpy()
    x_elem = p_np[:, 0]
    sort_idx = np.argsort(x_elem)

    for col, (w, label) in enumerate([
        (w_nf, "NF weight phase (curved = spherical)"),
        (w_ff, "FF weight phase (linear = planar)"),
    ]):
        ax = axes[2, col]
        phase = np.angle(w.numpy())[sort_idx]
        phase_unwrap = np.unwrap(phase)
        ax.plot(x_elem[sort_idx] * 1e3, phase_unwrap, "g-", lw=1)
        ax.set_xlabel("Element x-position (mm)")
        ax.set_ylabel("Phase (rad)")
        ax.set_title(label, fontsize=11)
        ax.grid(True, ls=":", alpha=0.3)

    fig.suptitle(info, fontsize=13, fontweight="bold")
    plt.tight_layout()
    plt.savefig(path, dpi=150, bbox_inches="tight")
    plt.close()
    print(f"Saved → {path}")


# ──────────────────────────────────────────────
# 3D surface plots
# ──────────────────────────────────────────────

def plot_3d(P_nf_db, P_ff_db,
            r_nf, az_nf, r0_nf, az0_nf_deg,
            r_ff, az_ff, r0_ff, az0_ff_deg,
            info, path):
    fig = plt.figure(figsize=(18, 8))
    vmin = -40

    for col, (Z, r_ax, az_ax, r0, az0, label) in enumerate([
        (P_nf_db, r_nf, az_nf, r0_nf, az0_nf_deg,
         f"(a) Near-Field BF  (target {r0_nf:.0f} m, {az0_nf_deg}°)"),
        (P_ff_db, r_ff, az_ff, r0_ff, az0_ff_deg,
         f"(b) Far-Field BF  (target {r0_ff:.0f} m, {az0_ff_deg}°)"),
    ]):
        ax = fig.add_subplot(1, 2, col + 1, projection="3d")
        R, AZ = np.meshgrid(r_ax, az_ax, indexing="ij")
        Z_clip = np.clip(Z, vmin, 0)

        ax.plot_surface(
            AZ, R, Z_clip,
            cmap="jet", vmin=vmin, vmax=0,
            rstride=2, cstride=2,
            linewidth=0, antialiased=True, alpha=0.9,
        )
        ax.scatter([az0], [r0], [3],
                   color="red", marker="*", s=300,
                   zorder=10, depthshade=False)
        ax.set_xlabel("Azimuth (°)", fontsize=10, labelpad=8)
        ax.set_ylabel("Range (m)", fontsize=10, labelpad=8)
        ax.set_zlabel("Power (dB)", fontsize=10, labelpad=6)
        ax.set_zlim(vmin, 5)
        ax.set_title(label, fontsize=12, fontweight="bold", y=-0.02)
        ax.view_init(elev=30, azim=-60)

    plt.tight_layout()
    plt.savefig(path, dpi=150, bbox_inches="tight")
    plt.close()
    print(f"Saved → {path}")


# ──────────────────────────────────────────────
# Main
# ──────────────────────────────────────────────

def run(args):
    lam = 3e8 / args.fc
    k = 2 * math.pi / lam
    dx = dy = lam / 2

    # If physical aperture is specified, override Nh/Nv to keep aperture fixed
    if args.aperture_h > 0:
        args.Nh = max(2, round(args.aperture_h / dx))
    if args.aperture_v > 0:
        args.Nv = max(2, round(args.aperture_v / dy))

    N = args.Nh * args.Nv
    D_h, D_v = args.Nh * dx, args.Nv * dy
    D = math.sqrt(D_h ** 2 + D_v ** 2)
    fresnel = 2 * D ** 2 / lam

    # NF user: well inside Fresnel distance
    r0_nf, az0_nf_deg = 3.0, 45.0
    # FF user: beyond Fresnel distance
    r0_ff, az0_ff_deg = 500.0, 30.0
    az0_nf_rad = az0_nf_deg * math.pi / 180
    az0_ff_rad = az0_ff_deg * math.pi / 180

    print(f"UPA {args.Nh}×{args.Nv} = {N} elements")
    print(f"λ = {lam * 1e3:.1f} mm  |  dx = dy = {dx * 1e3:.2f} mm")
    print(f"Aperture {D_h:.3f} × {D_v:.3f} m  |  Fresnel {fresnel:.0f} m")
    print(f"NF user: r = {r0_nf} m, θ = {az0_nf_deg}°  "
          f"(r/Fresnel = {r0_nf / fresnel:.4f})")
    print(f"FF user: r = {r0_ff} m, θ = {az0_ff_deg}°  "
          f"(r/Fresnel = {r0_ff / fresnel:.2f})")

    p = make_upa(args.Nh, args.Nv, dx, dy)

    # Beamforming weights
    w_nf = nf_steering(p, torch.tensor([r0_nf]),
                       torch.tensor([az0_nf_rad]), k).squeeze(0)
    w_ff = ff_steering(p, torch.tensor([az0_ff_rad]), k).squeeze(0)

    # Evaluation grids (polar: range × azimuth)
    ng = args.grid
    r_nf_grid = torch.linspace(0.5, 15.0, ng)
    az_nf_grid = torch.linspace(0.0, 90.0, ng)  # degrees for display
    az_nf_rad_grid = az_nf_grid * math.pi / 180

    r_ff_grid = torch.linspace(50.0, 1000.0, ng)
    az_ff_grid = torch.linspace(0.0, 90.0, ng)
    az_ff_rad_grid = az_ff_grid * math.pi / 180

    # Smaller batches for large arrays
    bsz = max(200, 2000 // max(1, N // 8192))
    print(f"\nComputing beam patterns ({ng}×{ng} polar grid, batch={bsz}) ...")
    P_nf = beam_pattern_polar(w_nf, p, r_nf_grid, az_nf_rad_grid, k, batch=bsz)
    print("  Near-field ✓")
    P_ff = beam_pattern_polar(w_ff, p, r_ff_grid, az_ff_rad_grid, k, batch=bsz)
    print("  Far-field  ✓")

    P_nf_db = 10 * np.log10(P_nf.numpy() + 1e-15)
    P_ff_db = 10 * np.log10(P_ff.numpy() + 1e-15)

    info = (f"UPA {args.Nh}×{args.Nv} @ {args.fc / 1e9:.0f} GHz  |  "
            f"Fresnel = {fresnel:.0f} m")

    # 2D heatmaps + range cuts + phase profiles
    plot_comparison(
        P_nf_db, P_ff_db,
        r_nf_grid.numpy(), az_nf_grid.numpy(), r0_nf, az0_nf_deg,
        r_ff_grid.numpy(), az_ff_grid.numpy(), r0_ff, az0_ff_deg,
        w_nf, w_ff, p, info, args.output)

    # 3D surface plots
    path_3d = args.output.replace(".png", "_3d.png")
    plot_3d(
        P_nf_db, P_ff_db,
        r_nf_grid.numpy(), az_nf_grid.numpy(), r0_nf, az0_nf_deg,
        r_ff_grid.numpy(), az_ff_grid.numpy(), r0_ff, az0_ff_deg,
        info, path_3d)


def main():
    pa = argparse.ArgumentParser(description="NF vs FF beam comparison")
    pa.add_argument("--Nh", type=int, default=128)
    pa.add_argument("--Nv", type=int, default=64)
    pa.add_argument("--fc", type=float, default=12e9, help="Carrier freq (Hz)")
    pa.add_argument("--aperture_h", type=float, default=0,
                    help="Fixed horizontal aperture (m). Overrides Nh.")
    pa.add_argument("--aperture_v", type=float, default=0,
                    help="Fixed vertical aperture (m). Overrides Nv.")
    pa.add_argument("--grid", type=int, default=200, help="Grid points per axis")
    pa.add_argument("-o", "--output", default="nf_vs_ff_beam.png")
    args = pa.parse_args()
    run(args)


if __name__ == "__main__":
    main()