空对地雷达对抗侦察效能模型

#include <iostream>
#include <string>
#include <map>
#include <cmath>

//-----------------------------------------
// 枚举和结构定义
//-----------------------------------------
enum class RadarBand {
    INVALID,
    V_UHF,
    L,
    S,
    C,
    X,
    KU
};

struct BandParameters {
    double freqMin;          // 频段最小频率 (GHz)
    double freqMax;          // 频段最大频率 (GHz)
    double freqStd;          // 标准频率 (GHz)
    double attenuation;      // 大气衰减系数 (dB/km)
    double cableLoss;        // 电缆损耗系数 (dB/m)
    double bandwidth;        // 接收机带宽 (MHz)
    double sensitivity;      // 接收机灵敏度 (dBm)
    bool hasPolarLoss;       // 是否有极化损失 (true表示有3dB极化损失)
};

//-----------------------------------------
// 雷达频段判断类
//-----------------------------------------
class RadarBandDetector {
private:
    std::map<RadarBand, BandParameters> bandParams;
    
public:
    RadarBandDetector() {
        // 初始化频段参数表
        bandParams = {
            {RadarBand::V_UHF, {0.2, 1.0, 0.5, 0.003, 0.1, 1, -115, false}},
            {RadarBand::L,     {1.0, 2.0, 1.3, 0.006, 0.3, 2, -110, true}},
            {RadarBand::S,     {2.0, 4.0, 3.0, 0.0075,0.4, 5, -105, true}},
            {RadarBand::C,     {4.0, 8.0, 5.5, 0.0085,0.6, 10,-100, true}},
            {RadarBand::X,     {8.0, 12.0,10.0,0.012, 0.8, 20,-95,  true}},
            {RadarBand::KU,    {12.0,18.0,15.0,0.0275,1.1, 30,-90,  true}}
        };
    }
    
    RadarBand detectBand(double frequency_GHz) {
        if (frequency_GHz <= 0) return RadarBand::INVALID;
        
        for (const auto& pair : bandParams) {
            if (frequency_GHz >= pair.second.freqMin && frequency_GHz < pair.second.freqMax) {
                return pair.first;
            }
        }
        return RadarBand::INVALID;
    }
    
    const BandParameters* getBandParameters(RadarBand band) {
        auto it = bandParams.find(band);
        if (it != bandParams.end()) {
            return &(it->second);
        }
        return nullptr;
    }
    
    std::string getBandName(RadarBand band) {
        switch (band) {
            case RadarBand::V_UHF: return "V/UHF";
            case RadarBand::L: return "L";
            case RadarBand::S: return "S";
            case RadarBand::C: return "C";
            case RadarBand::X: return "X";
            case RadarBand::KU: return "Ku";
            default: return "Invalid";
        }
    }
};

//-----------------------------------------
// 单位转换和dB转换函数
//-----------------------------------------
double dB_to_linear(double dB) {
    return std::pow(10.0, dB / 10.0);
}

double dBm_to_W(double dBm) {
    double mW = std::pow(10.0, dBm / 10.0);
    return mW / 1000.0;
}

//-----------------------------------------
// 模型计算函数
//-----------------------------------------

// 步骤1：计算最大通视距离 R_max (km)
// 输入高度为m，结果为km
double compute_line_of_sight_range(double h1_m, double h2_m) {
    return 4.12 * (std::sqrt(h1_m) + std::sqrt(h2_m));
}

// 步骤2：计算 R_max' (m)
// R_max' = sqrt( (Pt * Gt/(4π)) * (Gr * λ²/(4π)) * 1/(L_s * L_r * L_l * S_min) )
//
// 参数说明：
// Pt(W), Gt(线性值), Gr(线性值), λ(m)
// L_s, L_r, L_l(线性值), S_min(W)
double compute_detection_range_prime(
    double Pt_W,
    double Gt_linear,
    double Gr_linear,
    double lambda_m,
    double L_s_linear,
    double L_r_linear,
    double L_l_linear,
    double S_min_W
) {
    double numerator = Pt_W * Gt_linear * Gr_linear * (lambda_m * lambda_m);
    double denominator = (16.0 * M_PI * M_PI) * L_s_linear * L_r_linear * L_l_linear * S_min_W;
    double R_max_prime_m = std::sqrt(numerator / denominator); 
    return R_max_prime_m;
}

int main() {
    RadarBandDetector detector;
    double frequency_GHz;
    std::cout << "请输入雷达工作频率(GHz): ";
    std::cin >> frequency_GHz;

    RadarBand band = detector.detectBand(frequency_GHz);
    if (band == RadarBand::INVALID) {
        std::cout << "\n输入频率 " << frequency_GHz << " GHz 超出有效范围!" << std::endl;
        std::cout << "有效频率范围: 0.2 - 18.0 GHz" << std::endl;
        return 0;
    }

    const BandParameters* params = detector.getBandParameters(band);
    if (!params) {
        std::cout << "无效频段参数!" << std::endl;
        return 0;
    }

    std::cout << "\n已识别频段: " << detector.getBandName(band) << std::endl;
    // 可根据需要打印频段参数进行检查
    // 此处不再详列，可使用print函数或自行输出

    // 以下为计算所需示例参数设定：
    // 目标雷达参数
    double h1 = 20.0;       // 目标雷达天线高度(m)
    double Pt_W = 1000.0;   // 目标雷达发射功率(W)
    double Gt_dB = -30.0;    // 目标雷达天线增益(dB)
    double Gt_linear = dB_to_linear(Gt_dB);

    // 侦察机参数
    double h2 = 3000.0;     // 接收机天线高度(m)
    double Gr_dB = 10.0;    // 接收机天线增益(dB)
    double Gr_linear = dB_to_linear(Gr_dB);

    // 根据输入频率计算波长
    double f_Hz = frequency_GHz * 1e9; 
    double c = 3e8; // m/s
    double lambda_m = c / f_Hz;

    // 极化损失（线性值）
    double L_r_dB = params->hasPolarLoss ? 3.0 : 0.0;
    double L_r_linear = dB_to_linear(L_r_dB);

    // 大气衰减(线性值)
    // 需根据R_max'距离估计，简化：先用一个参考距离假设，如50km计算
    // 本例直接使用最终距离时再统一考虑，这里演示简单处理：
    // 我们将大气衰减和电缆损耗视为与距离无关的平均值，以示范用法。
    double L_s_dB_per_km = params->attenuation; // dB/km
    // 假设侦察距离为R(未知)，大气衰减 = 10^(L_s_dB_per_km * R/10)
    // 无法直接求解，这里为了演示，仅以侦察距离为R_max’计算后再调试。
    // 为演示简化，设参考距离：R_ref = 50 km
    double R_ref = 50.0;
    double L_s_dB = L_s_dB_per_km * R_ref; 
    double L_s_linear = dB_to_linear(L_s_dB);

    // 电缆损耗(线性值)
    // 假设电缆长度8m：
    double cable_length_m = 8.0;
    double L_l_dB = params->cableLoss * cable_length_m;
    double L_l_linear = dB_to_linear(L_l_dB);

    // 接收机灵敏度
    double S_min_dBm = params->sensitivity;
    double S_min_W = dBm_to_W(S_min_dBm);

    // 步骤1：计算R_max (km)
    double R_max_km = compute_line_of_sight_range(h1, h2);

    // 步骤2：计算R_max' (m)
    double R_max_prime_m = compute_detection_range_prime(
        Pt_W,
        Gt_linear,
        Gr_linear,
        lambda_m,
        L_s_linear,
        L_r_linear,
        L_l_linear,
        S_min_W
    );
    double R_max_prime_km = R_max_prime_m / 1000.0;

    // 步骤3：取两者较小值为最终侦察距离
    double R_final_km = std::min(R_max_km, R_max_prime_km);

    std::cout << "\n计算结果:" << std::endl;
    std::cout << "最大通视距离 R_max: " << R_max_km << " km" << std::endl;
    std::cout << "侦察距离 R_max': " << R_max_prime_km << " km (基于灵敏度和参数计算)" << std::endl;
    std::cout << "最终侦察距离: " << R_final_km << " km" << std::endl;

    return 0;
}