高斯方向图模型¶

一、高斯方向图模型¶

高斯方向图模型是一种基于高斯分布的天线方向图简化模型，适合描述天线辐射方向图中主瓣的形状。其数学表达式如下： $$ G(\theta) = G_{\text{max}} \cdot e^{-k (\frac{\theta}{\theta_{\text{3dB}}})^2} $$

参数说明

$G(\theta)$：方向 $\theta$ 上的天线增益。
$G_{\text{max}}$：主瓣最大增益，通常在 $\theta = 0$ 时取值。
$\theta$：观察方向与天线主轴（通常是主瓣方向）之间的夹角。
$\theta_{\text{3dB}}$：3dB 波束宽度，定义为增益下降到最大值的一半时对应的角度宽度。
$k$：控制波束形状的系数，通常与 $\theta_{\text{3dB}}$ 有关，常取值为 $k = \ln 2$，使得 $\theta = \theta_{\text{3dB}}$ 时增益下降到 $G_{\text{max}} / 2$。

特性

主瓣集中性：
高斯方向图模型的主瓣呈对称的高斯分布，随着角度偏离主轴，增益迅速下降。
由于模型忽略了旁瓣的影响，它通常用于关注主瓣方向的应用场景。
简洁性：
高斯方向图模型通过简化旁瓣和其他次要特性，显著降低了计算复杂度，适合快速仿真计算。
归一化：
为了便于计算，可以对增益进行归一化，使得 $G(\theta)$ 的值在主瓣方向取 1。

应用场景

电子战：快速估计天线主瓣方向的辐射能量分布，用于干扰或抗干扰评估。
雷达和通信：对主瓣方向性较强的天线进行快速仿真。
方向性优化：通过调整 $\theta_{\text{3dB}}$ 和 $k$ 参数实现特定的波束宽度和集中性。

如果需要进一步扩展高斯方向图模型以包括旁瓣或其他特性，也可以通过叠加额外分量进行修正。

高斯方向图模型的改进形式¶

改进的高斯方向图模型其特点是用高斯分布描述主瓣，同时提供了一个函数形式用于描述主瓣以外的方向图（即旁瓣）：

主瓣公式 $$ f(\theta) = \exp\left(-k \theta^2\right) $$

主瓣部分是标准的高斯分布形式，其中 $k = \frac{4 \ln \sqrt{2}}{\theta_b^2}$，由 $\theta_b$（单程半功率点波束宽度）控制主瓣的宽度。
参数 $k$ 确保在 $\theta = \pm \frac{\theta_b}{2}$ 时，方向图幅度下降到其峰值的一半（即 3dB 下降点）。

主瓣以外的方向图 $$ f(\theta) = \frac{(1 + \cos \theta) \sin(k \sin(\theta))}{2k \sin(\theta)} $$

这一部分用于描述主瓣以外（旁瓣）的方向图特性。
$k = \frac{1.3916}{\sin(0.5\theta_b)}$ 是根据波束宽度 $\theta_b$ 确定的常数。
分母 $\sin(\theta)$ 和分子的 $\sin(k \sin(\theta))$ 描述了旁瓣的振荡特性，旁瓣随 $\theta$ 增加呈周期性变化。

模型分析

主瓣部分：
与传统高斯方向图模型相符，用高斯函数来精确描述主瓣方向的辐射分布。
通过参数 $k$ 和 $\theta_b$ 控制主瓣的宽度和增益衰减速率。
旁瓣部分：
旁瓣描述使用的是一个分段函数，体现了辐射能量的衰减和分布。
$(1 + \cos \theta)$ 项增强了主瓣附近的旁瓣幅度，而 $k$ 的引入确保旁瓣幅度的适当抑制。
是否为高斯方向图模型：
这个模型主瓣部分严格满足高斯分布，可以视为高斯方向图模型。
增加了旁瓣描述的扩展部分，因此可以认为它是 一种改进的高斯方向图模型，在实际应用中更接近实际天线的辐射特性。

适用场景

这种模型在需要对主瓣精确建模并同时考虑旁瓣对系统性能影响的场景中非常适用，例如： - 电子战中的方向图干扰仿真。 - 雷达系统对目标信号主瓣和旁瓣的能量分布分析。 - 无线通信中的波束形成优化。

二、可视化线上计算器¶

https://claude.site/artifacts/917d549d-d142-4c69-95dc-7a8e4ad48997

这个交互式的React组件，可以让用户调整参数并实时查看改进型高斯方向图模型的变化。

计算器代码：

import React, { useState, useCallback, useEffect } from 'react';
import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer } from 'recharts';
import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
import { Slider } from '@/components/ui/slider';
import { Label } from '@/components/ui/label';
import { Button } from '@/components/ui/button';
import { Input } from '@/components/ui/input';
import { Switch } from '@/components/ui/switch';
import { Calculator } from 'lucide-react';

const GaussianBeamCalculator = () => {
  // 状态管理
  const [thetaB, setThetaB] = useState(10); // 波束宽度（度）
  const [plotRange, setPlotRange] = useState(90); // 绘图范围（度）
  const [resolution, setResolution] = useState(360); // 数据点数量
  const [patternData, setPatternData] = useState([]); // 方向图数据
  const [kMain, setKMain] = useState(0); // 主瓣k参数
  const [kSide, setKSide] = useState(0); // 旁瓣k参数
  const [manualK, setManualK] = useState(false); // 是否手动设置K参数
  const [manualKMain, setManualKMain] = useState('0'); // 手动输入的主瓣k参数
  const [manualKSide, setManualKSide] = useState('0'); // 手动输入的旁瓣k参数

  // 自动计算K参数
  const calculateKParameters = useCallback(() => {
    const thetaBRad = (thetaB * Math.PI) / 180;
    const newKMain = (4 * Math.log(Math.sqrt(2))) / (thetaBRad * thetaBRad);
    const newKSide = 1.3916 / Math.sin(0.5 * thetaBRad);
    return { kMain: newKMain, kSide: newKSide };
  }, [thetaB]);

  // 更新K参数（考虑手动/自动模式）
  const updateKParameters = useCallback(() => {
    if (manualK) {
      setKMain(parseFloat(manualKMain) || 0);
      setKSide(parseFloat(manualKSide) || 0);
    } else {
      const { kMain: newKMain, kSide: newKSide } = calculateKParameters();
      setKMain(newKMain);
      setKSide(newKSide);
      setManualKMain(newKMain.toFixed(4));
      setManualKSide(newKSide.toFixed(4));
    }
  }, [manualK, manualKMain, manualKSide, calculateKParameters]);

  // 计算方向图数据
  const calculatePattern = useCallback(() => {
    updateKParameters();

    const data = [];
    const step = (2 * plotRange) / (resolution - 1);
    const currentKMain = manualK ? parseFloat(manualKMain) : kMain;
    const currentKSide = manualK ? parseFloat(manualKSide) : kSide;

    for (let theta = -plotRange; theta <= plotRange; theta += step) {
      const thetaRad = (theta * Math.PI) / 180;
      const thetaBHalf = thetaB / 2;
      const isMainLobe = Math.abs(theta) <= thetaBHalf;

      let amplitude;
      if (isMainLobe) {
        amplitude = Math.exp(-currentKMain * thetaRad * thetaRad);
      } else {
        if (Math.abs(thetaRad) < 1e-10) {
          amplitude = 1;
        } else {
          amplitude = ((1 + Math.cos(thetaRad)) * Math.sin(currentKSide * Math.sin(thetaRad))) / 
                     (2 * currentKSide * Math.sin(thetaRad));
        }
      }

      const amplitudeDB = 20 * Math.log10(Math.abs(amplitude));
      const normalizedDB = Math.max(amplitudeDB, -60);

      const r = normalizedDB + 60;
      data.push({
        theta,
        amplitude: normalizedDB,
        r,
        x: r * Math.cos(thetaRad),
        y: r * Math.sin(thetaRad)
      });
    }

    setPatternData(data);
  }, [thetaB, plotRange, resolution, kMain, kSide, manualK, manualKMain, manualKSide, updateKParameters]);

  // 首次加载时计算初始数据
  useEffect(() => {
    calculatePattern();
  }, []);

  // 处理手动/自动模式切换
  const handleModeToggle = (checked) => {
    setManualK(checked);
    if (!checked) {
      const { kMain: newKMain, kSide: newKSide } = calculateKParameters();
      setManualKMain(newKMain.toFixed(4));
      setManualKSide(newKSide.toFixed(4));
    }
  };

  // 自定义极坐标图组件（与之前相同）
  const PolarPattern = ({ data }) => {
    if (!data || data.length === 0) {
      return <div>Loading...</div>;
    }

    return (
      <svg className="w-full h-full" viewBox="-70 -70 140 140">
        {/* 绘制同心圆 */}
        {[0, 15, 30, 45, 60].map((r, i) => (
          <circle
            key={i}
            cx="0"
            cy="0"
            r={r}
            fill="none"
            stroke="#ddd"
            strokeWidth="0.5"
          />
        ))}

        {/* 绘制角度线 */}
        {[0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330].map((angle) => {
          const radians = (angle * Math.PI) / 180;
          return (
            <line
              key={angle}
              x1="0"
              y1="0"
              x2={60 * Math.cos(radians)}
              y2={60 * Math.sin(radians)}
              stroke="#ddd"
              strokeWidth="0.5"
            />
          );
        })}

        {/* 绘制方向图曲线 */}
        {data.length > 0 && (
          <path
            d={`M ${data[0].x} ${data[0].y} ` + 
               data.map(p => `L ${p.x} ${p.y}`).join(' ')}
            fill="none"
            stroke="#2563eb"
            strokeWidth="1"
          />
        )}

        {/* 添加刻度标签 */}
        {[0, -20, -40, -60].map((db, i) => (
          <text
            key={i}
            x="2"
            y={-15 * i - 2}
            fontSize="4"
            fill="#666"
          >
            {db}dB
          </text>
        ))}

        {/* 添加角度标签 */}
        {[0, 90, 180, 270].map((angle) => {
          const radians = (angle * Math.PI) / 180;
          return (
            <text
              key={angle}
              x={65 * Math.cos(radians)}
              y={65 * Math.sin(radians)}
              fontSize="4"
              fill="#666"
              textAnchor="middle"
            >
              {angle}°
            </text>
          );
        })}
      </svg>
    );
  };

  return (
    <Card className="w-full max-w-4xl">
      <CardHeader>
        <CardTitle>改进型高斯方向图模型计算器</CardTitle>
      </CardHeader>
      <CardContent className="space-y-6">
        <div className="space-y-4">
          <div className="space-y-2">
            <Label>波束宽度 θb (度)</Label>
            <div className="flex items-center space-x-4">
              <Slider
                value={[thetaB]}
                onValueChange={(value) => setThetaB(value[0])}
                min={1}
                max={30}
                step={0.5}
                className="flex-1"
              />
              <span className="w-12 text-right">{thetaB}°</span>
            </div>
          </div>

          <div className="space-y-2">
            <Label>绘图范围 (±度)</Label>
            <div className="flex items-center space-x-4">
              <Slider
                value={[plotRange]}
                onValueChange={(value) => setPlotRange(value[0])}
                min={30}
                max={180}
                step={10}
                className="flex-1"
              />
              <span className="w-12 text-right">±{plotRange}°</span>
            </div>
          </div>

          <div className="space-y-2">
            <div className="flex items-center justify-between">
              <Label>手动设置K参数</Label>
              <Switch
                checked={manualK}
                onCheckedChange={handleModeToggle}
              />
            </div>
            {manualK && (
              <div className="grid grid-cols-2 gap-4">
                <div className="space-y-2">
                  <Label>主瓣k参数</Label>
                  <Input
                    type="number"
                    value={manualKMain}
                    onChange={(e) => setManualKMain(e.target.value)}
                    step="0.0001"
                  />
                </div>
                <div className="space-y-2">
                  <Label>旁瓣k参数</Label>
                  <Input
                    type="number"
                    value={manualKSide}
                    onChange={(e) => setManualKSide(e.target.value)}
                    step="0.0001"
                  />
                </div>
              </div>
            )}
          </div>

          <Button 
            onClick={calculatePattern}
            className="w-full"
          >
            <Calculator className="mr-2 h-4 w-4" />
            计算方向图
          </Button>
        </div>

        <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
          {/* 直角坐标图 */}
          <div className="h-96">
            <Label className="mb-2 block">直角坐标显示</Label>
            <ResponsiveContainer width="100%" height="100%">
              <LineChart data={patternData}>
                <CartesianGrid strokeDasharray="3 3" />
                <XAxis 
                  dataKey="theta" 
                  label={{ value: '角度 (度)', position: 'bottom' }}
                />
                <YAxis 
                  domain={[-60, 5]} 
                  label={{ value: '幅度 (dB)', angle: -90, position: 'left' }}
                />
                <Tooltip 
                  formatter={(value) => `${value.toFixed(2)} dB`}
                  labelFormatter={(label) => `${label}°`}
                />
                <Legend />
                <Line 
                  type="monotone" 
                  dataKey="amplitude" 
                  stroke="#2563eb" 
                  name="方向图"
                  dot={false}
                />
              </LineChart>
            </ResponsiveContainer>
          </div>

          {/* 极坐标图 */}
          <div className="h-96">
            <Label className="mb-2 block">极坐标显示</Label>
            <div className="w-full h-full">
              <PolarPattern data={patternData} />
            </div>
          </div>
        </div>

        <div className="text-sm space-y-2">
          <p>主瓣k参数: {kMain.toFixed(4)}</p>
          <p>旁瓣k参数: {kSide.toFixed(4)}</p>
          <p>3dB波束宽度: {thetaB}°</p>
        </div>
      </CardContent>
    </Card>
  );
};

export default GaussianBeamCalculator;

这个交互式的高斯方向图模型计算器具有以下特点：

参数控制：
波束宽度(θb)滑块：可调范围1°-30°
绘图范围滑块：可调范围±30°到±180°
实时更新的参数显示
可视化功能：
响应式图表显示
自动缩放的坐标轴
网格线便于读数
鼠标悬停时显示具体数值
Y轴范围限制在-60dB到5dB
计算特性：
实时计算主瓣和旁瓣参数
自动处理临界值
平滑的曲线显示
显示关键参数值（k参数等）
使用说明：
拖动滑块来调整波束宽度和显示范围
图表会实时更新显示新的方向图
将鼠标悬停在曲线上可以查看具体数值
底部显示当前的计算参数

这个计算器使用了现代的React组件和hooks，采用了优化的计算方法，可以流畅地进行实时计算和显示。使用了shadcn/ui组件库来提供统一的UI风格。

主瓣和旁瓣的K参数可以手动输入，同时保持原有的自动计算功能。

K参数控制模式：
添加了切换开关，可以在自动计算和手动输入之间切换
在自动模式下，K参数根据波束宽度自动计算
在手动模式下，可以直接输入K参数值
新增输入界面：
添加了主瓣和旁瓣K参数的输入框
输入框支持高精度数值（步进值为0.0001）
切换到自动模式时会自动填充计算值
计算逻辑优化：
分离了K参数计算和方向图计算
在手动模式下使用输入的K值
在自动模式下使用计算的K值
用户界面改进：
清晰的模式切换开关
数值输入框的合理布局
实时显示当前使用的K参数值

使用方法： 1. 自动模式（默认）： - K参数根据波束宽度自动计算 - 调整波束宽度会影响K参数的计算值

手动模式：
打开"手动设置K参数"开关
直接输入想要的主瓣和旁瓣K参数值
点击"计算方向图"查看效果
切换模式：
从自动切换到手动时，保留当前计算的K值
从手动切换到自动时，恢复根据波束宽度计算的K值

需要注意的是：

波束宽度的选择会影响both主瓣和旁瓣的形状
可以通过调整显示范围来观察不同角度范围的细节

这个工具可以更好地理解和验证改进型高斯方向图模型的特性。

三、参考代码¶

Python代码¶

一个方便测试和验证这个改进型高斯方向图模型的Python代码。代码将包含模型的实现、可视化以及参数测试功能。

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider

class GaussianBeamPattern:
    def __init__(self, theta_b_deg=10):
        """
        初始化改进型高斯方向图模型

        参数:
            theta_b_deg: float, 单程半功率点波束宽度(度)
        """
        self.set_theta_b(theta_b_deg)

    def set_theta_b(self, theta_b_deg):
        """设置波束宽度并更新相关参数"""
        self.theta_b = np.deg2rad(theta_b_deg)  # 转换为弧度
        # 计算主瓣的k参数
        self.k_main = 4 * np.log(np.sqrt(2)) / (self.theta_b**2)
        # 计算旁瓣的k参数
        self.k_side = 1.3916 / np.sin(0.5 * self.theta_b)

    def main_lobe(self, theta):
        """计算主瓣方向图"""
        return np.exp(-self.k_main * theta**2)

    def side_lobe(self, theta):
        """计算旁瓣方向图"""
        # 避免除零错误
        small_angles = np.abs(theta) < 1e-10
        result = np.zeros_like(theta, dtype=float)

        # 处理非零角度
        non_zero = ~small_angles
        theta_nz = theta[non_zero]
        result[non_zero] = (1 + np.cos(theta_nz)) * np.sin(self.k_side * np.sin(theta_nz)) / (2 * self.k_side * np.sin(theta_nz))

        # 处理接近零度的情况（使用极限值）
        result[small_angles] = (1 + 1) * 1 / (2)  # lim(x->0) sin(kx)/x = k

        return result

    def pattern(self, theta):
        """计算完整的方向图"""
        # 确定主瓣范围（这里取±theta_b/2）
        is_main_lobe = np.abs(theta) <= self.theta_b/2

        # 分别计算主瓣和旁瓣
        pattern = np.zeros_like(theta)
        pattern[is_main_lobe] = self.main_lobe(theta[is_main_lobe])
        pattern[~is_main_lobe] = self.side_lobe(theta[~is_main_lobe])

        return pattern

def plot_beam_pattern(theta_b_deg=10):
    """绘制方向图并添加交互式控件"""
    # 创建图形和坐标轴
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 12))
    plt.subplots_adjust(bottom=0.25)  # 为滑块留出空间

    # 初始化模型
    beam = GaussianBeamPattern(theta_b_deg)

    # 计算角度范围和方向图
    theta_deg = np.linspace(-90, 90, 1000)
    theta = np.deg2rad(theta_deg)
    pattern = beam.pattern(theta)

    # 在直角坐标系中绘制
    line1, = ax1.plot(theta_deg, 20*np.log10(np.abs(pattern)), 'b-', label='方向图')
    ax1.grid(True)
    ax1.set_xlabel('角度 (度)')
    ax1.set_ylabel('相对幅度 (dB)')
    ax1.set_ylim(-60, 5)
    ax1.set_title('方向图 (直角坐标)')
    ax1.legend()

    # 在极坐标系中绘制
    ax2.set_theta_zero_location('N')  # 设置0度在正上方
    ax2.set_theta_direction(-1)       # 设置角度增长方向为顺时针
    pattern_db = 20*np.log10(np.abs(pattern))
    pattern_db = np.maximum(pattern_db, -60)  # 限制最小值为-60dB
    line2, = ax2.plot(theta, pattern_db, 'b-')
    ax2.set_title('方向图 (极坐标)')
    ax2.set_rmin(-60)
    ax2.set_rmax(0)
    ax2.grid(True)

    # 添加波束宽度滑块
    ax_slider = plt.axes([0.2, 0.1, 0.6, 0.03])
    slider = Slider(ax_slider, '波束宽度 (度)', 1, 30, valinit=theta_b_deg)

    def update(val):
        """更新方向图"""
        beam.set_theta_b(slider.val)
        pattern = beam.pattern(theta)
        pattern_db = 20*np.log10(np.abs(pattern))

        # 更新直角坐标图
        line1.set_ydata(pattern_db)

        # 更新极坐标图
        pattern_db_polar = np.maximum(pattern_db, -60)
        line2.set_ydata(pattern_db_polar)

        fig.canvas.draw_idle()

    slider.on_changed(update)
    plt.show()

if __name__ == "__main__":
    # 测试代码
    plot_beam_pattern(10)  # 默认波束宽度为10度

这段代码实现了以下功能：

模型实现：
创建了GaussianBeamPattern类，完整实现了改进型高斯方向图模型
分别实现了主瓣和旁瓣的计算函数
处理了临界情况（如角度接近0度时的计算）
可视化功能：
同时提供直角坐标和极坐标两种显示方式
直角坐标显示详细的幅度变化
极坐标显示更直观的方向图特性
坐标轴和网格的合理设置
交互式参数调节：
添加了波束宽度的滑动条
实时更新方向图显示
范围设置在1-30度之间
其他特性：
dB显示范围限制在-60dB到5dB
合理的极坐标显示设置（北向为0度，顺时针方向）
完善的注释和文档

使用方法：

# 直接运行程序
python gaussian_beam_pattern.py

# 或者在其他代码中导入使用
from gaussian_beam_pattern import GaussianBeamPattern
beam = GaussianBeamPattern(theta_b_deg=10)
pattern = beam.pattern(theta)  # theta为弧度制的角度数组

你可以通过滑动控制条来改变波束宽度，观察方向图的变化。这对于理解参数变化对方向图形状的影响非常有帮助。

需要注意的是，代码需要安装以下Python包：

pip install numpy matplotlib

C++代码¶

以下是一个高斯方向图模型的C++代码模块，具有清晰的输入输出，便于嵌入实际应用程序中使用。

功能说明

主瓣使用高斯模型：$f(\theta) = \exp\left(-k \theta^2\right)$
旁瓣描述：$f(\theta) = \frac{(1 + \cos \theta) \sin(k \sin(\theta))}{2k \sin(\theta)}$
输入：
$\theta$（方向角，单位：弧度）
$\theta_b$（单程半功率点波束宽度，单位：弧度）
输出：
天线方向图增益 $f(\theta)$

C++代码模块

#include <iostream>
#include <cmath>
#include <stdexcept>

// 高斯方向图模型的实现
class GaussianAntennaPattern {
public:
    // 构造函数，传入波束宽度
    GaussianAntennaPattern(double theta_b) {
        if (theta_b <= 0) {
            throw std::invalid_argument("Beamwidth theta_b must be positive.");
        }
        this->theta_b = theta_b;
        this->k_main = 4 * std::log(std::sqrt(2)) / (theta_b * theta_b);
        this->k_side = 1.3916 / std::sin(0.5 * theta_b);
    }

    // 获取指定方向角上的增益值
    double computeGain(double theta) const {
        // 主瓣模型
        if (std::abs(theta) <= 0.5 * theta_b) {
            return std::exp(-k_main * theta * theta);
        } 
        // 旁瓣模型
        else {
            double sin_theta = std::sin(theta);
            if (std::abs(sin_theta) < 1e-6) { // 避免除零
                return 0.0;
            }
            return ((1 + std::cos(theta)) * std::sin(k_side * sin_theta)) / (2 * k_side * sin_theta);
        }
    }

private:
    double theta_b;  // 半功率点波束宽度
    double k_main;   // 主瓣系数
    double k_side;   // 旁瓣系数
};

// 测试高斯方向图模型
int main() {
    try {
        // 定义波束宽度
        double theta_b = 0.5; // 以弧度为单位
        GaussianAntennaPattern antennaPattern(theta_b);

        // 输出不同方向角的增益
        std::cout << "Theta (radians) | Gain" << std::endl;
        for (double theta = -1.0; theta <= 1.0; theta += 0.1) {
            double gain = antennaPattern.computeGain(theta);
            std::cout << theta << " | " << gain << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}

代码功能解析

主类 GaussianAntennaPattern：
构造函数接受波束宽度 $\theta_b$ 并计算主瓣和旁瓣的系数 $k_{\text{main}}$ 和 $k_{\text{side}}$。
computeGain 方法根据 $\theta$ 判断是主瓣还是旁瓣，并分别计算增益。
输入校验：
确保 $\theta_b > 0$。
防止 $\sin(\theta) = 0$ 时的除零错误。
示例输出：
主程序循环计算不同方向角 $\theta$ 下的增益并打印。

示例输出

假设 $\theta_b = 0.5$，方向角 $\theta$ 从 $-1.0$ 到 $1.0$：

Theta (radians) | Gain
-1.0 | 0.005
-0.9 | 0.010
-0.8 | 0.050
-0.7 | 0.150
-0.6 | 0.400
-0.5 | 0.707
-0.4 | 0.900
...

适用性

模块化设计，便于集成到现有代码中。
支持灵活的方向角计算，适合电子战仿真、雷达信号处理等应用。
可扩展性强，能够添加额外特性（如干扰建模、噪声影响等）。

示例使用场景¶

场景 1：快速计算特定方向的增益¶

可以将代码改为直接计算某个方向角的增益，而不是循环输出：

int main() {
    try {
        // 定义波束宽度
        double theta_b = 0.5; // 单程半功率点波束宽度
        GaussianAntennaPattern antennaPattern(theta_b);

        // 计算某个角度的增益
        double theta = 0.3; // 方向角
        double gain = antennaPattern.computeGain(theta);

        std::cout << "Gain at theta = " << theta << " radians: " << gain << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}

运行输出：

Gain at theta = 0.3 radians: 0.9798

场景 2：与实际仿真集成¶

将类 GaussianAntennaPattern 作为模块嵌入到电子战仿真程序中，只需要调用 computeGain 方法传入角度即可获取对应的增益值。例如：

double signalPower = 10.0; // 原始信号功率
double theta = 0.5; // 当前方向角
double gain = antennaPattern.computeGain(theta);
double receivedPower = signalPower * gain; // 加权后的接收功率

优化建议

多线程支持：可以对 computeGain 进行多线程优化，适合批量计算多个方向增益。
文件输入输出：将计算结果写入文件或从文件读取方向角。
图形化输出：将计算结果导出为数据文件，用于可视化方向图。