import argparse import math import os from pathlib import Path from types import SimpleNamespace os.environ.setdefault("MPLCONFIGDIR", "/tmp/matplotlib") import matplotlib.pyplot as plt import numpy as np import torch from updated_SIM_0410_add_library import make_layer_points from updated_SIM_0413_multi_user import Config, MultiUserDownlinkOptimizer, build_point_propagation_vector def default_user_positions(cfg: Config, device): az_deg = torch.tensor([-38.0, -12.0, 18.0, 43.0], device=device) r = torch.tensor([5.0, 9.0, 13.0, 17.0], device=device) if cfg.n_users != 4: az_deg = torch.linspace(cfg.az_min_deg + 12.0, cfg.az_max_deg - 12.0, cfg.n_users, device=device) r = torch.linspace(cfg.r_min + 3.0, cfg.r_max - 3.0, cfg.n_users, device=device) return r, az_deg * math.pi / 180.0 def propagate_to_last_layer(optimizer: MultiUserDownlinkOptimizer, theta, a_raw, b_raw, device): cfg = optimizer.cfg pt_w = 10.0 ** (cfg.Pt_dBm / 10.0) / 1000.0 u = optimizer.feeders.to(device) * math.sqrt(pt_w / optimizer.num_users) for l_idx, layer_type in enumerate(optimizer.layout): if layer_type == "L": u = u * torch.exp(1j * theta[l_idx]).unsqueeze(0) else: u = optimizer.apply_nonlinear(u, a_raw[l_idx], b_raw[l_idx]) if l_idx < optimizer.num_layers - 1: h_mat = getattr(optimizer, f"H_{l_idx}").to(device) u = torch.matmul(u, h_mat.T) return u def ideal_focus_to_targets(cfg: Config, geometry, r_users, az_users, device): pt_w = 10.0 ** (cfg.Pt_dBm / 10.0) / 1000.0 p_last = make_layer_points(cfg, geometry.num_layers, device) p_users = torch.stack( [ r_users * torch.sin(az_users), -r_users * torch.cos(az_users), torch.zeros_like(r_users), ], dim=-1, ) h_targets = build_point_propagation_vector(cfg, p_last, p_users) u = h_targets.conj() u = u / u.norm(dim=1, keepdim=True).clamp_min(1e-30) return u * math.sqrt(pt_w / geometry.num_users) @torch.no_grad() def beam_power_map( cfg: Config, geometry, u_last, n_r: int, n_az: int, chunk_size: int, device, plot_mode: str, ): # 定义 Range 和 Azimuth 扫描轴 r_axis = torch.linspace(cfg.r_min, cfg.r_max, n_r, device=device) az_axis = torch.linspace(cfg.az_min_deg, cfg.az_max_deg, n_az, device=device) * math.pi / 180.0 # 生成网格 r_grid, az_grid = torch.meshgrid(r_axis, az_axis, indexing="ij") points = torch.stack( [ r_grid.reshape(-1) * torch.sin(az_grid.reshape(-1)), -r_grid.reshape(-1) * torch.cos(az_grid.reshape(-1)), torch.zeros_like(r_grid.reshape(-1)), ], dim=-1, ) p_last = make_layer_points(cfg, geometry.num_layers, device) powers = [] for start in range(0, points.shape[0], chunk_size): # Same physical last-layer-to-user channel used by propagate_streams. h = build_point_propagation_vector(cfg, p_last, points[start : start + chunk_size]) # Received field at every scan point for every stream: # h: (chunk, N), u_last.T: (N, n_users), rx: (chunk, n_users) rx = torch.matmul(h, u_last.T) power = rx.abs().square() if plot_mode == "focus": # Remove range-dependent free-space/channel strength so the map shows # where the aperture is phase-focused instead of just the closest points. channel_power = h.abs().square().sum(dim=1, keepdim=True).clamp_min(1e-30) power = power / channel_power powers.append(power.cpu()) # 调整形状为 (n_r, n_az, n_users) power_map = torch.cat(powers, dim=0).reshape(n_r, n_az, cfg.n_users) return r_axis.cpu(), az_axis.cpu() * 180.0 / math.pi, power_map def to_relative_db(power: torch.Tensor): return 10.0 * torch.log10(power / power.max().clamp_min(1e-30) + 1e-12) def plot_beams(cfg, r_axis, az_axis_deg, powers, r_users, az_users, rates, output_path: Path, plot_mode: str, db_floor: float): n_cols = min(3, cfg.n_users + 1) n_rows = math.ceil((cfg.n_users + 1) / n_cols) fig, axes = plt.subplots(n_rows, n_cols, figsize=(5.5 * n_cols, 4.5 * n_rows), constrained_layout=True) axes = np.asarray(axes).reshape(-1).tolist() az_np = az_axis_deg.numpy() r_np = r_axis.numpy() target_az = az_users.detach().cpu().numpy() * 180.0 / math.pi target_r = r_users.detach().cpu().numpy() # 准备画图面板 metric_name = "Focus Gain" if plot_mode == "focus" else "Received Power" panels = [(f"Max {metric_name}", powers.max(dim=-1).values)] panels.extend((f"Stream {idx + 1} {metric_name}", powers[:, :, idx]) for idx in range(cfg.n_users)) for ax, (title, panel_power) in zip(axes, panels): # --- 核心修改：转置矩阵以实现横轴为 Range, 纵轴为 Angle --- db = to_relative_db(panel_power).numpy() image = ax.imshow( db.T, # 转置：行变 Angle, 列变 Range origin="lower", aspect="auto", extent=[r_np.min(), r_np.max(), az_np.min(), az_np.max()], vmin=db_floor, vmax=0.0, cmap="magma", # 使用这种色图更容易观察对比度 ) ax.contour(r_np, az_np, db.T, levels=[-10.0, -3.0], colors=["white", "cyan"], linewidths=[0.8, 1.0]) # 标注用户真实坐标 (注意：x=Range, y=Azimuth) ax.scatter(target_r, target_az, c="cyan", s=60, edgecolors="white", marker='x', linewidths=1.5, label='GT Positions') for user_idx, (az, rr) in enumerate(zip(target_az, target_r), start=1): ax.text(rr + 0.2, az + 1.0, f"U{user_idx}", color="white", fontsize=10, weight="bold") ax.set_title(title) ax.set_xlabel("Range (m)") ax.set_ylabel("Azimuth (deg)") fig.colorbar(image, ax=ax, label=f"Normalized {metric_name.lower()} (dB)") for ax in axes[len(panels) :]: ax.axis("off") fig.suptitle(f"SIM Near-Field {metric_name}, Avg Rate: {rates.mean().item():.2f} bps/Hz/user", fontsize=14) fig.savefig(output_path, dpi=200) plt.close(fig) def parse_args(): parser = argparse.ArgumentParser() parser.add_argument("--n-users", type=int, default=4) parser.add_argument("--nh", type=int, default=None, help="Override horizontal SIM elements for plotting.") parser.add_argument("--nv", type=int, default=None, help="Override vertical SIM elements for plotting.") parser.add_argument("--iters", type=int, default=60) # 建议稍高一点以获得更尖锐的焦点 parser.add_argument("--lr", type=float, default=5e-2) parser.add_argument("--n-r", type=int, default=200) # 提高分辨率 parser.add_argument("--n-az", type=int, default=200) # 提高分辨率 parser.add_argument("--chunk-size", type=int, default=1024) parser.add_argument("--db-floor", type=float, default=-20.0, help="Lower dB limit for the plotted color scale.") parser.add_argument( "--plot-mode", type=str, default="focus", choices=["focus", "received"], help="focus removes channel/path-loss strength; received plots absolute received power.", ) parser.add_argument( "--beam-source", type=str, default="ideal", choices=["ideal", "optimizer"], help="ideal uses conjugate near-field focusing weights; optimizer plots the current SIM optimizer output.", ) parser.add_argument("--device", type=str, default=None) parser.add_argument("--output", type=str, default="sim_focusing_spectrum.png") return parser.parse_args() def main(): args = parse_args() cfg = Config() cfg.n_users = args.n_users if args.nh is not None: cfg.Nh = args.nh if args.nv is not None: cfg.Nv = args.nv cfg.group_opt_iters = args.iters cfg.group_opt_lr = args.lr if args.device is not None: cfg.device = args.device device = torch.device(cfg.device) geometry = SimpleNamespace(num_layers=4, num_users=cfg.n_users) optimizer = None if args.beam_source == "optimizer": optimizer = MultiUserDownlinkOptimizer(cfg).to(device) geometry = optimizer r_users, az_users = default_user_positions(cfg, device) pt_w = 10.0 ** (cfg.Pt_dBm / 10.0) / 1000.0 noise_power = pt_w / (10.0 ** (cfg.snr_db / 10.0)) if args.beam_source == "optimizer": print(f"Optimizing SIM Focal Points for {cfg.n_users} users...") theta, a_raw, b_raw = optimizer.optimize_group_action(r_users, az_users) u_last = propagate_to_last_layer(optimizer, theta, a_raw, b_raw, device) with torch.no_grad(): gains = optimizer.propagate_streams(theta, a_raw, b_raw, r_users, az_users) rates = optimizer.rates_from_gains(gains, noise_power) else: print(f"Drawing ideal near-field focal points for {cfg.n_users} users...") u_last = ideal_focus_to_targets(cfg, geometry, r_users, az_users, device) with torch.no_grad(): p_last = make_layer_points(cfg, geometry.num_layers, device) p_users = torch.stack( [ r_users * torch.sin(az_users), -r_users * torch.cos(az_users), torch.zeros_like(r_users), ], dim=-1, ) h_users = build_point_propagation_vector(cfg, p_last, p_users) gains = torch.matmul(h_users, u_last.T).abs().square() desired = torch.diagonal(gains) interference = gains.sum(dim=1) - desired rates = torch.log2(1.0 + desired / (interference + noise_power)) print(f"Mean rate achieved: {rates.mean().item():.4f} bps/Hz/user") # 生成参数谱图数据 r_axis, az_axis_deg, powers = beam_power_map( cfg, geometry, u_last, args.n_r, args.n_az, args.chunk_size, device, args.plot_mode ) output_path = Path(args.output).resolve() plot_beams(cfg, r_axis, az_axis_deg, powers, r_users, az_users, rates, output_path, args.plot_mode, args.db_floor) print(f"Saved near-field spectrum plot to {output_path}") if __name__ == "__main__": main()