从零搭建光电仿真引擎（三）：大气与热特性系统

从零搭建光电仿真引擎（三）：大气与热特性系统

一位架构师视角下的光电仿真引擎从零构建实战指南

---

前言

在国防军工、航空航天、安防监控、自动驾驶等领域，光电场景仿真技术扮演着越来越重要的角色。从红外制导系统的算法验证，到无人机光电载荷的性能评估，再到自动驾驶可见光/红外融合感知算法的训练与测试------高质量的光电仿真引擎能够大幅降低实物试验成本、缩短研发周期、提升系统可靠性。

然而，与游戏引擎、通用渲染引擎不同，光电仿真引擎有其独特的技术挑战：它不仅要生成"看起来像"的图像，更要保证图像在物理上的准确性------光谱分布、辐射强度、热特性、大气传输效应、探测器响应等每一个环节都需要基于物理原理精确建模。

本文将以架构师的视角，从零开始系统性地讲解如何构建一个支持可见光与红外双波段的光电场景仿真引擎。我们将从最基础的架构设计出发，逐层深入场景建模、材质光谱、大气传输、热特性求解、辐射传输、探测器成像等核心模块，每一个模块都将深入探讨其物理原理、算法选型、架构设计与工程实现。

目标读者

本文主要面向以下读者群体：

• 光电仿真工程师：正在或有志于从事光电场景仿真系统开发
• 系统架构师/技术负责人：需要对光电仿真系统有全局性理解，以做出正确的技术选型
• 红外/可见光成像算法工程师：希望理解成像链路的完整物理过程
• 国防军工/安防领域的技术人员：需要评估或构建光电仿真验证系统

阅读本文需要具备以下基础：

• 扎实的C/C++编程基础
• 基本的计算机图形学知识
• 一定的物理光学和辐射度学基础
• 基本的热传导理论知识

本册为《从零搭建光电仿真引擎》第三册，涵盖第三篇：大气与热特性系统，聚焦大气传输模型、热特性求解与环境背景辐射。

---

目录

第三篇：大气与热特性系统

• [第7章 大气传输模型与计算](#第7章 大气传输模型与计算 "#%E7%AC%AC7%E7%AB%A0-%E5%A4%A7%E6%B0%94%E4%BC%A0%E8%BE%93%E6%A8%A1%E5%9E%8B%E4%B8%8E%E8%AE%A1%E7%AE%97")
• [第8章 热特性求解系统架构](#第8章 热特性求解系统架构 "#%E7%AC%AC8%E7%AB%A0-%E7%83%AD%E7%89%B9%E6%80%A7%E6%B1%82%E8%A7%A3%E7%B3%BB%E7%BB%9F%E6%9E%B6%E6%9E%84")
• [第9章 环境与背景辐射建模](#第9章 环境与背景辐射建模 "#%E7%AC%AC9%E7%AB%A0-%E7%8E%AF%E5%A2%83%E4%B8%8E%E8%83%8C%E6%99%AF%E8%BE%90%E5%B0%84%E5%BB%BA%E6%A8%A1")

---

第三篇：大气与热特性系统

---

第7章 大气传输模型与计算

7.1 大气辐射传输基础：吸收、散射、发射

大气辐射传输是光电仿真中连接目标辐射与传感器入瞳的核心环节。任何从目标表面发出的辐射，在到达探测器之前，都必须穿过一段或长或短的大气路径。在这段路径中，大气分子、气溶胶粒子以及各种痕量气体会与辐射发生复杂的相互作用，最终改变到达传感器的辐射强度、光谱分布乃至偏振状态。

从物理机制上看，大气与辐射的相互作用可以归纳为三个基本过程：吸收（Absorption） 、散射（Scattering） 和 发射（Emission） 。这三个过程共同决定了大气的光谱透过率、路径辐射强度以及太阳/天空散射光的贡献。

吸收过程是指大气中的分子和气溶胶将入射辐射的能量转化为内能（热能）的过程。吸收具有强烈的波长选择性------某些波长的辐射几乎可以不受阻碍地穿过大气（称为"大气窗口"），而另一些波长则会被完全吸收。这种选择性源于分子能级的量子化特性：只有当入射光子的能量恰好等于分子两个能级之间的能量差时，吸收才会发生。

对于光电仿真工程师而言，最关心的大气窗口包括：

• 可见光/近红外窗口（0.4~2.5 μm）：主要受水蒸气和二氧化碳吸收带的限制
• 中波红外窗口（3~5 μm）：位于CO₂吸收带与水蒸气吸收带之间
• 长波红外窗口（8~14 μm）：受水蒸气连续吸收和臭氧吸收的限制

散射过程是指辐射与大气粒子相互作用后改变传播方向的现象。散射不改变辐射的总能量（理想弹性散射下），但会将部分辐射从原传播路径中移除，同时也会将其他方向的辐射（如太阳光）散射到观测路径中。散射的强度和角分布取决于粒子尺寸参数 x = 2πr/λ（r 为粒子半径，λ 为波长）：

• 当 x << 1 时，为瑞利散射（Rayleigh Scattering），散射截面与 λ⁻⁴ 成正比，这就是天空呈现蓝色的原因
• 当 x ≈ 1 时，为米氏散射（Mie Scattering），适用于气溶胶粒子，散射方向性更强
• 当 x >> 1 时，为几何光学散射，适用于云滴、雨滴等大粒子

散射相函数 P(θ) 描述了散射能量在空间角度上的分布。瑞利散射的相函数为：

P(\theta) = \frac{3}{4}(1 + \cos^2\theta)

而米氏散射的相函数则要复杂得多，通常需要用勒让德多项式展开来表示：

P(\cos\theta) = \sum_{l=0}^{L} (2l+1) \omega_l P_l(\cos\theta)

其中 ω_l 是展开系数，P_l 是 l 阶勒让德多项式。在实际工程实现中，常用 Henyey-Greenstein 相函数作为近似：

P_{HG}(\cos\theta) = \frac{1 - g^2}{(1 + g^2 - 2g\cos\theta)^{3/2}}

其中 g 是不对称因子，取值范围为 -1, 1，g > 0 表示前向散射为主，g < 0 表示后向散射为主。对于大气气溶胶，典型的 g 值在 0.6~0.85 之间。

发射过程是大气自身作为热辐射源向外辐射能量的过程。根据基尔霍夫定律，在局地热平衡条件下，大气的发射率等于其吸收率。大气发射是红外波段（尤其是热红外波段）路径辐射的主要来源。对于波长 λ，厚度为 dz 的气层的热辐射亮度为：

dL_{\lambda,emission} = \alpha_\lambda(z) B_\lambda(T(z)) dz

其中 αλ(z) 是高度 z 处的光谱吸收系数，Bλ(T) 是温度 T 下的普朗克函数：

B_\lambda(T) = \frac{2hc^2}{\lambda^5} \frac{1}{e^{hc/(\lambda k_B T)} - 1}

将吸收、散射和发射结合起来，就得到了大气辐射传输方程（Radiative Transfer Equation, RTE）：

\mu \frac{dL_\lambda(z, \mu, \phi)}{dz} = -\alpha_\lambda(z) L_\lambda(z, \mu, \phi) + \frac{\omega_\lambda(z)}{4\pi} \int_0^{2\pi} \int_{-1}^{1} P_\lambda(z, \cos\Theta) L_\lambda(z, \mu', \phi') d\mu' d\phi' + \alpha_\lambda(z)(1 - \omega_\lambda(z)) B_\lambda(T(z))

其中 μ = cosθ 是天顶角余弦，ωλ = σ s,λ / (σa,λ + σs,λ) 是单次散射反照率，Θ 是入射方向与出射方向之间的夹角。

这个方程的物理含义很明确：沿传播方向的辐射亮度变化等于三项之和------吸收和散射造成的衰减（第一项为负）、其他方向散射进来的辐射（第二项，称为源函数的散射部分）、以及大气自身的热发射（第三项，称为源函数的热发射部分）。

在实际工程实现中，直接求解完整的辐射传输方程计算量巨大。因此，光电仿真引擎通常根据具体的应用场景和精度需求，选择不同的近似方法：

0. 比尔-朗伯定律（Beer-Lambert Law） ：仅考虑吸收和消光散射，忽略多次散射和大气发射。适用于可见光/近红外的短程路径、或者精度要求不高的快速估算场景。透过率计算简单：

   \tau_\lambda = \exp\left(-\int_0^R \beta_{e,\lambda}(s) ds\right)

   其中 β {e,λ} = β{a,λ} + β_{s,λ} 是消光系数。

1. 二流近似（Two-Stream Approximation） ：将辐射场分解为向上和向下两个半球，适用于计算漫射辐射的总通量，在太阳辐射和天空背景计算中常用。

2. 离散纵标法（Discrete Ordinates Method, DISORT） ：将角度空间离散化为有限个方向，对每个方向独立求解传输方程。这是中等精度模型（如MODTRAN）的核心算法。

3. 逐线积分法（Line-by-Line, LBL） ：对每一条分子吸收线进行精确积分，精度最高但计算量最大，通常用于生成数据库或验证低阶模型。

在引擎架构设计中，我们通常将辐射传输计算封装为独立的模块，提供统一的接口。以下是一个典型的大气传输计算模块的接口设计：

// atmosphere_transmission.h
#pragma once
#include <vector>
#include <string>
#include <memory>

namespace opto_engine {
namespace atmosphere {

// 光谱采样结构
struct SpectrumSample {
    double wavelength_um;   // 波长，单位微米
    double value;           // 采样值（透过率、辐射亮度等）
};

// 大气路径几何参数
struct PathGeometry {
    double observer_altitude_km;   // 观测点海拔高度 (km)
    double target_altitude_km;     // 目标海拔高度 (km)
    double zenith_angle_deg;       // 观测天顶角 (度)
    double azimuth_angle_deg;      // 方位角 (度)
    double range_km;               // 斜距 (km)，可选，为0则自动计算
};

// 大气计算结果
struct AtmosphereResult {
    std::vector<double> wavelengths;       // 波长数组 (μm)
    std::vector<double> transmittance;     // 光谱透过率
    std::vector<double> path_radiance;     // 路径辐射亮度 (W/(m²·sr·μm))
    std::vector<double> solar_scatter;     // 太阳散射贡献 (W/(m²·sr·μm))
    std::vector<double> thermal_emission;  // 大气热发射贡献 (W/(m²·sr·μm))
};

// 大气模型类型枚举
enum class AtmosphereModelType {
    STANDARD_US_1976,      // 美国标准大气 1976
    MIDLATITUDE_SUMMER,    // 中纬度夏季
    MIDLATITUDE_WINTER,    // 中纬度冬季
    TROPICAL,              // 热带大气
    POLAR_SUMMER,          // 极地夏季
    POLAR_WINTER,          // 极地冬季
    CUSTOM                 // 自定义大气廓线
};

// 气溶胶模型类型
enum class AerosolModelType {
    RURAL,      // 乡村型
    URBAN,      // 城市型
    MARITIME,   // 海洋型
    DESERT,     // 沙漠型
    TROPOSPHERIC, // 对流层型
    FOG,        // 雾
    CUSTOM      // 自定义
};

// 大气传输计算器基类（策略模式）
class IAtmosphereCalculator {
public:
    virtual ~IAtmosphereCalculator() = default;
    
    // 计算大气路径的光谱透过率和路径辐射
    virtual AtmosphereResult computePath(
        const PathGeometry& path,
        const std::vector<double>& wavelengths,
        AtmosphereModelType model = AtmosphereModelType::MIDLATITUDE_SUMMER,
        AerosolModelType aerosol = AerosolModelType::RURAL,
        double visibility_km = 23.0
    ) const = 0;
    
    // 获取模型名称
    virtual std::string name() const = 0;
    
    // 获取单次计算的预估耗时（毫秒），用于调度决策
    virtual double estimatedCostMs() const = 0;
};

// 工厂类：创建不同精度等级的大气计算器
class AtmosphereCalculatorFactory {
public:
    // 精度等级
    enum class PrecisionLevel {
        LOW,        // 低精度：宽带透过率，适用于实时仿真
        MEDIUM,     // 中等精度：MODTRAN级别，适用于离线仿真
        HIGH        // 高精度：逐线积分级别，适用于验证与标定
    };
    
    static std::unique_ptr<IAtmosphereCalculator> create(PrecisionLevel level);
};

} // namespace atmosphere
} // namespace opto_engine

这个设计采用了策略模式（Strategy Pattern），将不同精度的大气传输计算方法封装为统一接口的实现类。这样做的好处是，上层的仿真场景代码不需要关心底层使用的是哪种大气模型，只需要通过工厂获取合适精度的计算器即可。当需要切换模型精度时，只需修改工厂的配置，而不需要改动调用方代码。

7.2 大气模型：标准大气、中纬度夏季/冬季、热带、极地等

大气模型是大气传输计算的基础输入，它描述了大气温度、压力、密度以及各种成分浓度随高度的分布廓线。不同地区、不同季节的大气状态差异很大，因此需要建立多种标准大气模型来覆盖典型的使用场景。

美国标准大气（US Standard Atmosphere 1976） 是最广为人知的大气模型，它基于中纬度地区的年平均状况构建。该模型将大气分为若干层：对流层（012 km，温度递减率 -6.5 K/km）、平流层下部（12 20 km，等温 216.65 K）、平流层上部（2047 km，温度递增）、中间层（4786 km，温度递减）等。

标准大气的温度廓线可以用分段函数表示：

T(h) = T_0 + L \cdot (h - h_0)

其中 T₀ 是参考高度 h₀ 处的温度，L 是该层的温度递减率。

压力分布则可以通过流体静力学方程和理想气体状态方程推导得到：

P(h) = P_0 \left( \frac{T(h)}{T_0} \right)^{-gM/(RL)}

对于等温层（L = 0），压力分布为指数衰减：

P(h) = P_0 \exp\left( -\frac{gM(h - h_0)}{RT_0} \right)

其中 g 是重力加速度，M 是空气摩尔质量，R 是气体常数。

在实际的光电仿真中，标准大气模型往往不够用。因为仿真场景可能位于热带、极地，或者是特定的季节。为此，国际上发展了多种区域大气模型，其中最著名的是 AFGL（Air Force Geophysics Laboratory）大气模型系列，它们也是 MODTRAN 等辐射传输代码的内置模型。

AFGL 大气模型包括六种参考大气：

0. 热带（Tropical, 15°N）：地面温度 299.7 K，水汽含量高
1. 中纬度夏季（Midlatitude Summer, 45°N, 7月）：地面温度 294.2 K
2. 中纬度冬季（Midlatitude Winter, 45°N, 1月）：地面温度 272.2 K
3. 副极地夏季（Subarctic Summer, 60°N, 7月）：地面温度 287.2 K
4. 副极地冬季（Subarctic Winter, 60°N, 1月）：地面温度 257.2 K
5. 美国标准大气 1976

每种模型都提供了从地面到 100 km 高度的温度、压力、密度，以及 H₂O、CO₂、O₃、N₂O、CO、CH₄、O₂ 等主要吸收气体的数密度廓线。

以下是大气廓线数据结构的C++实现示例：

// atmosphere_profile.h
#pragma once
#include <vector>
#include <array>
#include <string>

namespace opto_engine {
namespace atmosphere {

// 大气成分枚举
enum class GasSpecies {
    H2O,    // 水蒸气
    CO2,    // 二氧化碳
    O3,     // 臭氧
    N2O,    // 一氧化二氮
    CO,     // 一氧化碳
    CH4,    // 甲烷
    O2,     // 氧气
    NO2,    // 二氧化氮
    SO2,    // 二氧化硫
    NH3,    // 氨
    HNO3,   // 硝酸
    COUNT   // 成分数量
};

// 单一层的大气参数
struct AtmosphereLayer {
    double altitude_km;        // 层底高度 (km)
    double temperature_K;      // 温度 (K)
    double pressure_hPa;       // 气压 (hPa)
    double air_density_cm3;    // 空气分子数密度 (cm⁻³)
    // 各气体成分的数密度 (cm⁻³)
    std::array<double, static_cast<int>(GasSpecies::COUNT)> number_density;
    // 气溶胶消光系数 (km⁻¹)，按波长采样存储
    std::vector<double> aerosol_extinction;
    std::vector<double> aerosol_wavelengths;
};

// 大气廓线：多层结构
struct AtmosphereProfile {
    std::string name;
    std::vector<AtmosphereLayer> layers;
    
    // 获取指定高度的温度（线性插值）
    double temperatureAt(double altitude_km) const {
        if (layers.empty()) return 288.15;
        if (altitude_km <= layers.front().altitude_km)
            return layers.front().temperature_K;
        if (altitude_km >= layers.back().altitude_km)
            return layers.back().temperature_K;
        
        for (size_t i = 0; i < layers.size() - 1; ++i) {
            if (altitude_km >= layers[i].altitude_km && 
                altitude_km < layers[i+1].altitude_km) {
                double frac = (altitude_km - layers[i].altitude_km) /
                              (layers[i+1].altitude_km - layers[i].altitude_km);
                return layers[i].temperature_K + 
                       frac * (layers[i+1].temperature_K - layers[i].temperature_K);
            }
        }
        return 288.15;
    }
    
    // 类似地，可以实现 pressureAt、numberDensityAt 等插值方法
};

// 标准大气廓线库
class StandardAtmosphereLibrary {
public:
    // 获取单例实例
    static StandardAtmosphereLibrary& instance();
    
    // 根据模型类型获取大气廓线
    const AtmosphereProfile& getProfile(AtmosphereModelType type) const;
    
    // 加载自定义廓线文件
    bool loadCustomProfile(const std::string& filepath);
    
private:
    StandardAtmosphereLibrary();
    void buildStandardProfiles();
    
    std::array<AtmosphereProfile, 
        static_cast<int>(AtmosphereModelType::CUSTOM) + 1> profiles_;
    bool custom_loaded_ = false;
};

} // namespace atmosphere
} // namespace opto_engine

在架构设计上，我们将大气廓线数据与传输计算解耦。廓线库是一个单例对象，负责管理所有预定义的大气模型数据。传输计算器在需要时从廓线库获取数据，而不是自己存储数据。这样做有两个好处：一是节省内存（多个计算器共享同一份廓线数据），二是便于扩展（新增大气模型只需修改廓线库，不需要改动计算器代码）。

除了这些标准模型，在实际工程中我们还经常需要处理实时气象数据的输入。比如，用户可能希望用当时当地的探空数据或气象站观测数据来驱动仿真。这就要求大气廓线模块支持自定义数据的导入和插值。一个完善的大气系统应当支持以下几种数据输入方式：

0. 内置标准模型：快速选择，适用于没有实测数据的场景
1. 气象参数修正：用户提供地面温度、湿度、气压等参数，系统自动对标准廓线进行缩放修正
2. 探空数据导入：支持通用的探空数据格式（如BUFR、ASCII表格等）
3. 数值天气预报数据接入：对接 WRF、MM5 等中尺度气象模式的输出结果

7.3 大气成分：水蒸气、二氧化碳、臭氧、气溶胶的光谱特性

大气中的各种成分对辐射的吸收和散射具有强烈的光谱选择性，这是大气窗口形成的根本原因。理解主要大气成分的光谱特性，对于正确选择工作波段、评估探测距离、设计目标识别算法都至关重要。

水蒸气（H₂O） 是大气中最重要的吸收气体之一，其浓度变化范围极大（从极地冬季的不足 0.1 g/m³ 到热带夏季的 40 g/m³ 以上）。水蒸气在红外波段有大量的吸收线，主要分布在：

• 0.94 μm、1.1 μm、1.38 μm、1.87 μm、2.7 μm 附近的近红外吸收带
• 6.3 μm 附近的中红外强吸收带（振动基频）
• 10~200 μm 的远红外转动吸收带（连续吸收）

水蒸气的吸收线非常密集，形成了所谓的"线森林"。在长波红外窗口（8~14 μm），水蒸气的连续吸收是主要的衰减机制之一。连续吸收与谱线吸收不同，它没有明显的线结构，而是随波长缓慢变化，主要来自于水蒸气分子的远翼吸收和二聚体（H₂O）₂的吸收。

二氧化碳（CO₂） 是大气中含量稳定的微量气体（约 415 ppm，且逐年增长）。CO₂ 的主要吸收带包括：

• 1.4 μm、1.6 μm、2.0 μm、2.7 μm 附近的近红外吸收带
• 4.3 μm 的强吸收带（不对称伸缩振动基频）
• 15 μm 的强吸收带（弯曲振动基频）

CO₂ 在 15 μm 的吸收带非常强，几乎完全阻挡了地表向上的热辐射，这是温室效应的主要来源之一。在中波红外（35 μm）窗口的短波端（4.3 μm 附近），CO₂ 的吸收也很强，因此实际的中波窗口通常只利用 3.54.1 μm 和 4.55.0 μm 两个子窗口。

臭氧（O₃） 主要集中在平流层（20~30 km 高度的臭氧层），但对流层也有少量分布。臭氧的吸收特征包括：

• 0.2~0.3 μm 的哈特莱（Hartley）带（强紫外吸收）
• 0.3~0.36 μm 的哈金斯（Huggins）带
• 0.4~0.7 μm 的沙普伊（Chappuis）带（可见光弱吸收）
• 9.6 μm 的中红外强吸收带（振动基频）

臭氧在 9.6 μm 的吸收带位于长波红外窗口（8~14 μm）内，是该窗口内的重要吸收成分。对于高空平台或星载传感器，臭氧的影响尤为显著。

气溶胶（Aerosol） 是悬浮在大气中的固体或液体微粒，尺寸范围从几纳米到几十微米。气溶胶对辐射的影响包括散射和吸收两部分，其特性高度依赖于粒子的尺寸分布、化学成分和形状。

气溶胶的消光特性通常用 Angström 公式来近似描述：

\tau_{aero}(\lambda) = \beta \lambda^{-\alpha}

其中 α 是 Angström 指数，与粒子尺寸有关：粒子越小，α 值越大。对于纯瑞利散射（分子散射），α = 4；对于典型的大陆性气溶胶，α ≈ 1~1.5；对于大颗粒（如沙尘、雾），α 可以接近 0。

气溶胶的单次散射反照率 ω₀ = σs / (σs + σ_a) 也是一个重要参数，它决定了气溶胶是偏散射型还是偏吸收型。比如，硫酸盐气溶胶主要是散射型（ω₀ > 0.95），而黑碳气溶胶则是强吸收型（ω₀ < 0.5）。

在引擎实现中，我们通常将气体吸收和散射的光谱数据以查找表（Lookup Table, LUT）的形式存储。以下是光谱数据库模块的设计示例：

// spectral_database.h
#pragma once
#include <vector>
#include <unordered_map>
#include <string>
#include <mutex>

namespace opto_engine {
namespace atmosphere {

// 分子吸收截面数据（单条谱线或连续吸收系数）
struct AbsorptionCrossSection {
    double wavelength_um;      // 波长 (μm)
    double cross_section_cm2;  // 吸收截面 (cm²)
};

// 分子吸收数据库
class MolecularAbsorptionDB {
public:
    static MolecularAbsorptionDB& instance();
    
    // 加载某气体的吸收截面数据
    bool loadGasData(GasSpecies species, const std::string& filepath);
    
    // 获取指定气体在指定波长处的吸收截面
    double getCrossSection(GasSpecies species, double wavelength_um, 
                           double temperature_K, double pressure_hPa) const;
    
    // 获取指定波段范围内的吸收截面数组
    std::vector<double> getCrossSectionArray(
        GasSpecies species,
        const std::vector<double>& wavelengths,
        double temperature_K,
        double pressure_hPa) const;
    
private:
    MolecularAbsorptionDB() = default;
    
    mutable std::mutex mutex_;
    std::unordered_map<int, std::vector<AbsorptionCrossSection>> gas_data_;
    
    // 线宽计算（多普勒加宽 + 洛伦兹加宽 → 沃伊特线型）
    double dopplerWidth(double wavelength_um, double temperature_K, 
                        double molar_mass_gmol) const;
    double lorentzWidth(double pressure_hPa, double temperature_K) const;
    double voigtProfile(double x, double y) const;  // 沃伊特函数
};

// 气溶胶光学特性数据库
class AerosolOpticsDB {
public:
    static AerosolOpticsDB& instance();
    
    // 加载气溶胶模型数据
    bool loadAerosolData(AerosolModelType type, const std::string& filepath);
    
    // 获取气溶胶消光系数（单位：km⁻¹，归一化到 550nm = 1.0）
    double getExtinction(AerosolModelType type, double wavelength_um) const;
    
    // 获取气溶胶单次散射反照率
    double getSingleScatterAlbedo(AerosolModelType type, double wavelength_um) const;
    
    // 获取气溶胶不对称因子 g
    double getAsymmetryFactor(AerosolModelType type, double wavelength_um) const;
    
    // 获取气溶胶相函数（按角度采样）
    std::vector<double> getPhaseFunction(AerosolModelType type, 
                                          double wavelength_um,
                                          const std::vector<double>& angles_deg) const;
    
private:
    AerosolOpticsDB() = default;
    
    struct AerosolSpectralData {
        std::vector<double> wavelengths;
        std::vector<double> extinction;       // 消光效率因子
        std::vector<double> scattering;       // 散射效率因子
        std::vector<double> absorption;       // 吸收效率因子
        std::vector<double> asymmetry_g;      // 不对称因子
        // 相函数展开系数（勒让德多项式）
        std::vector<std::vector<double>> phase_moments;
    };
    
    std::unordered_map<int, AerosolSpectralData> aerosol_data_;
    mutable std::mutex mutex_;
};

} // namespace atmosphere
} // namespace opto_engine

这个数据库设计有几个值得注意的特点。首先，它使用了单例模式，确保全局只有一份光谱数据的拷贝，避免重复加载和内存浪费。其次，吸收截面的计算考虑了温度和压力对谱线形状的影响------这是因为分子吸收线的宽度会随温度（多普勒加宽）和压力（洛伦兹加宽）变化，进而影响给定波长处的吸收系数。

在实际的高精度计算中，我们通常不直接存储截面值，而是存储谱线参数（线强度、线中心位置、空气加宽系数、自加宽系数等），然后在运行时根据温压条件计算实际的吸收截面。但这会大幅增加计算量。因此，在工程实现中，往往采用折衷方案：预先生成不同温压条件下的吸收截面查找表，运行时通过多维插值获取结果。

比如，可以建立一个三维查找表：温度（T）× 压力（P）× 波长（λ）→ 吸收截面 k(T,P,λ)。运行时根据当前层的温压条件，通过双线性插值（在 T-P 平面上）得到该层的光谱吸收系数。这种方法在保证精度的同时，计算效率可以提高几个数量级。

7.4 大气传输计算方法：MODTRAN、CART、LOWTRAN等模型介绍

在光电仿真领域，有几个经典的大气辐射传输模型被广泛使用。了解这些模型的特点和适用范围，对于正确选择和集成大气计算模块至关重要。

LOWTRAN（Low Resolution Transmission） 是美国空军地球物理实验室（AFGL）开发的低分辨率大气传输模型，最早发布于 1970 年代。LOWTRAN 的光谱分辨率较低（约 20 cm⁻¹），使用 2 cm⁻¹ 间隔的吸收系数查找表。它采用了单参数带模型（即把每个光谱区间的吸收用一个等效的指数透过率来表示），计算速度非常快。

LOWTRAN 包含以下主要功能：

• 0.25 μm ~ 28500 μm（约 35 cm⁻¹）的光谱范围
• 六种标准大气模型
• 多种气溶胶模型（乡村、城市、海洋、沙漠等）
• 支持雾、雨、云的消光计算
• 支持太阳/月亮散射、热辐射计算

尽管 LOWTRAN 的精度不高，但由于其计算速度快、使用简单，在很多对精度要求不高的工程估算和实时仿真中仍有应用。

MODTRAN（Moderate Resolution Transmission） 是 LOWTRAN 的升级版，也是目前应用最广泛的大气辐射传输模型之一。MODTRAN 将光谱分辨率提高到了 2 cm⁻¹，采用了更精确的带模型算法（CKD，即 Correlated-K Distribution 方法）。

MODTRAN 的核心改进包括：

• 更高的光谱分辨率（2 cm⁻¹）
• 相关 k 分布（CKD）方法处理气体吸收，比 LOWTRAN 的单参数带模型精确得多
• 更多的吸收气体种类（包含 H₂O、CO₂、O₃、N₂O、CO、CH₄、O₂、NO、SO₂、NO₂、NH₃、HNO₃ 等）
• 更精确的气溶胶模型和多次散射计算
• 支持离散纵标法（DISORT）求解多次散射
• 支持气球、飞机、卫星等多种观测几何

MODTRAN 的典型计算速度是：每条路径、每个光谱区间约几毫秒。对于一个完整的 0.4~15 μm 光谱范围（约 7000 个 2 cm⁻¹ 间隔的点），单次路径计算大约需要几秒到几十秒的时间。

CART（Combined Atmospheric Radiative Transfer） 是国内自主研发的大气辐射传输模型，由中科院安徽光学精密机械研究所开发。CART 在算法上与 MODTRAN 类似，但在数据和模型上更贴合国内的大气条件。CART 支持从紫外到远红外的宽光谱范围，包含多种中国典型地区的大气模型。

FASCODE（Fast Atmospheric Signature Code） 是高精度的大气传输模型，采用逐线积分（LBL）方法，光谱分辨率可以达到 0.001 cm⁻¹ 甚至更高。FASCODE 的精度最高，但计算量也最大，通常用于验证低分辨率模型或者对精度要求极高的特种应用。

6S（Second Simulation of the Satellite Signal in the Solar Spectrum） 是专门针对太阳反射波段（0.25~4.0 μm）的辐射传输模型，由法国气象局开发。6S 采用逐次散射近似方法，计算速度较快，在遥感大气校正领域应用广泛。

SHARM（Successive Orders of Scattering with Radiative Transfer Matrix） 是另一个常用的矢量辐射传输模型，支持偏振计算，适用于偏振遥感和偏振成像仿真。

在引擎架构设计中，我们面临一个关键的选择：是直接集成现有的大气传输模型（如 MODTRAN），还是自己实现一套大气传输计算模块？这个选择涉及多方面的权衡，我们将在 7.6 节详细讨论。这里先给出一个典型的集成方案------将 MODTRAN 作为外部计算引擎，通过封装调用的方式集成到仿真系统中：

// modtran_adapter.h
#pragma once
#include "atmosphere_transmission.h"
#include <string>
#include <vector>
#include <memory>

namespace opto_engine {
namespace atmosphere {

// MODTRAN 适配器：封装 MODTRAN 外部程序的调用
class ModtranAdapter : public IAtmosphereCalculator {
public:
    ModtranAdapter(const std::string& modtran_path = "");
    ~ModtranAdapter() override;
    
    AtmosphereResult computePath(
        const PathGeometry& path,
        const std::vector<double>& wavelengths,
        AtmosphereModelType model = AtmosphereModelType::MIDLATITUDE_SUMMER,
        AerosolModelType aerosol = AerosolModelType::RURAL,
        double visibility_km = 23.0
    ) const override;
    
    std::string name() const override { return "MODTRAN6"; }
    double estimatedCostMs() const override { return 5000.0; } // 预估5秒
    
    // 设置 MODTRAN 可执行文件路径
    void setModtranPath(const std::string& path) { modtran_path_ = path; }
    
    // 设置光谱分辨率（cm⁻¹）
    void setSpectralResolution(double resolution_cm1) { 
        spectral_resolution_cm1_ = resolution_cm1; 
    }
    
private:
    // 生成 MODTRAN 输入文件（tape5 格式）
    std::string generateInputFile(
        const PathGeometry& path,
        AtmosphereModelType model,
        AerosolModelType aerosol,
        double visibility_km,
        double wavenumber_min,
        double wavenumber_max
    ) const;
    
    // 解析 MODTRAN 输出文件（tape6 格式）
    bool parseOutputFile(const std::string& filepath,
                         AtmosphereResult& result) const;
    
    // 执行 MODTRAN 进程
    bool runModtran(const std::string& input_file, 
                    const std::string& output_file) const;
    
    std::string modtran_path_;
    double spectral_resolution_cm1_ = 2.0;
    
    // 结果缓存：避免重复计算相同路径
    mutable struct Cache {
        size_t hits = 0;
        size_t misses = 0;
        std::unordered_map<size_t, AtmosphereResult> data;
    } cache_;
    
    size_t computeCacheKey(const PathGeometry& path,
                           AtmosphereModelType model,
                           AerosolModelType aerosol,
                           double visibility) const;
};

} // namespace atmosphere
} // namespace opto_engine

这个适配器模式（Adapter Pattern）的设计有几个优点。第一，它将 MODTRAN 的调用细节（输入文件格式、输出解析、进程管理）封装在内部，对外提供统一的 IAtmosphereCalculator 接口。这样，如果将来需要切换到其他大气模型（比如 CART 或自己实现的模型），只需要新增一个适配器类即可，上层代码无需改动。

第二，适配器内部实现了结果缓存机制。由于大气传输计算相对耗时，而仿真场景中很多路径的大气条件是相同的（比如同一帧图像中的不同像素可能对应相似的观测路径），通过缓存可以大幅减少重复计算。缓存的 key 可以由路径几何参数、大气模型、气溶胶类型、能见度等参数的哈希值构成。

第三，适配器支持对 MODTRAN 的参数进行精细化控制，比如光谱分辨率、多次散射次数、云层参数等。这些可以通过配置文件或运行时接口来设置。

7.5 大气传输计算的引擎集成：离线预计算 vs 在线计算

大气传输计算是光电仿真中计算量最大的环节之一。如何将大气传输计算高效地集成到仿真引擎中，直接影响着整个系统的性能和用户体验。这里有两种基本的集成策略：离线预计算（Offline Precomputation） 和 在线计算（Online Computation） 。

离线预计算是指在仿真运行之前，预先计算好各种大气条件下的传输数据，存储为查找表（LUT）。仿真运行时，只需要通过查表和插值来获取结果，计算量极小。

离线预计算的典型做法是构建一个多维查找表，维度可能包括：

• 观测高度（或路径长度）
• 天顶角
• 波长
• 大气模型类型
• 能见度（或气溶胶光学厚度）
• 地面/目标高度

比如，一个典型的大气透过率 LUT 可能是 4 维的：transmittance[altitude][zenith][wavelength][visibility]。在运行时，根据当前的路径参数，通过多维线性插值（或更精确的样条插值）得到实际的透过率值。

离线预计算的优点很明显：

0. 运行速度极快：一次查表插值只需微秒级，完全可以满足实时仿真的需求
1. 计算资源消耗低：运行时不占用 CPU 核心，可以将资源让给其他仿真模块
2. 结果稳定可重复：预计算结果是确定的，不会因为运行时环境变化而不同

但缺点也同样明显：

0. 内存占用大：高维 LUT 可能需要几百 MB 甚至几 GB 的内存
1. 精度受限于采样密度：对于参数空间中的非线性区域（如吸收带边缘），需要更密的采样才能保证精度
2. 灵活性差：一旦 LUT 生成，就难以支持自定义大气廓线、特殊气溶胶模型等非标准情况
3. 预计算时间长：生成高维、高精度的 LUT 可能需要数小时甚至数天

在线计算是指在仿真运行过程中，实时调用大气传输模型来计算每条路径的传输特性。在线计算的优缺点与离线预计算正好相反：精度高、灵活性好，但计算量大。

在线计算有几种不同的实现方式：

0. 每帧计算一次：对于静态场景或慢速变化的场景，只在仿真开始时或大气参数变化时计算一次，结果缓存起来供整帧或多帧使用
1. 每像素计算：对于复杂场景（如三维地形、三维大气），每个像素对应不同的路径，需要独立计算。这种方式计算量最大，通常需要 GPU 加速或简化模型
2. 自适应采样：在图像空间进行稀疏采样，然后通过插值得到全分辨率结果。比如，只在图像的关键位置（如边缘、目标区域）计算大气传输，其他位置用插值填充

在实际的光电仿真引擎中，最常见的做法是混合策略：对于那些变化缓慢、可以预先枚举的参数（如大气模型、波长响应），采用离线预计算；对于那些变化频繁、难以枚举的参数（如路径几何、目标高度），采用在线计算。

以下是一个混合策略的大气传输管理器的实现框架：

// atmosphere_manager.h
#pragma once
#include "atmosphere_transmission.h"
#include <memory>
#include <vector>
#include <functional>

namespace opto_engine {
namespace atmosphere {

// 大气传输管理器：协调离线LUT与在线计算
class AtmosphereManager {
public:
    enum class ComputeMode {
        AUTO,           // 自动选择：优先LUT，LUT不覆盖则回退到在线计算
        LUT_ONLY,       // 仅使用离线LUT
        ONLINE_ONLY,    // 仅使用在线计算
        HYBRID          // 显式混合模式
    };
    
    AtmosphereManager();
    ~AtmosphereManager();
    
    // 初始化：加载LUT、创建在线计算器
    bool initialize(const std::string& config_file);
    
    // 核心计算接口
    AtmosphereResult compute(
        const PathGeometry& path,
        const std::vector<double>& wavelengths,
        AtmosphereModelType model = AtmosphereModelType::MIDLATITUDE_SUMMER,
        AerosolModelType aerosol = AerosolModelType::RURAL,
        double visibility_km = 23.0
    );
    
    // 设置计算模式
    void setComputeMode(ComputeMode mode) { mode_ = mode; }
    ComputeMode getComputeMode() const { return mode_; }
    
    // 预计算指定参数范围的LUT
    bool precomputeLUT(
        const std::string& output_file,
        const std::vector<double>& altitudes,
        const std::vector<double>& zenith_angles,
        const std::vector<double>& wavelengths,
        const std::vector<double>& visibilities,
        AtmosphereModelType model,
        AerosolModelType aerosol,
        std::function<void(int progress)> progress_callback = nullptr
    );
    
    // 加载预计算的LUT
    bool loadLUT(const std::string& lut_file);
    
    // 批量计算优化：一次计算多条路径（利用向量化/并行化）
    std::vector<AtmosphereResult> computeBatch(
        const std::vector<PathGeometry>& paths,
        const std::vector<double>& wavelengths,
        AtmosphereModelType model,
        AerosolModelType aerosol,
        double visibility_km
    );
    
private:
    ComputeMode mode_ = ComputeMode::AUTO;
    
    // 离线LUT计算器
    struct LUTCalculator {
        // 多维查找表数据（简化为示意）
        std::vector<double> altitude_axis;
        std::vector<double> zenith_axis;
        std::vector<double> wavelength_axis;
        std::vector<double> visibility_axis;
        std::vector<float> transmittance_data;  // 4D数组展平
        
        bool isInRange(const PathGeometry& path, double visibility) const;
        double interpolate(double alt, double zen, double wl, double vis) const;
    };
    
    std::unique_ptr<LUTCalculator> lut_calculator_;
    std::unique_ptr<IAtmosphereCalculator> online_calculator_;
    
    // 线程池：用于批量并行计算
    class ThreadPool;
    std::unique_ptr<ThreadPool> thread_pool_;
    
    // 判断是否应该使用LUT
    bool shouldUseLUT(const PathGeometry& path, double visibility) const;
};

} // namespace atmosphere
} // namespace opto_engine

这个管理器设计体现了几个重要的架构思想。首先是优雅降级（Graceful Degradation） ：当请求的参数在 LUT 覆盖范围内时，使用快速的 LUT 插值；当参数超出范围时，自动回退到在线计算模式。这样既保证了常见场景的性能，又保留了极端场景的正确性。

其次是批量计算优化。大气传输计算通常是高度可并行的------不同路径之间没有数据依赖。通过线程池将多条路径的计算分配到多个 CPU 核心上，可以获得接近线性的加速比。更进一步，如果使用 GPU 加速，可以将成千上万条路径的计算并行化，实现实时甚至超实时的大气传输计算。

另外一个值得考虑的优化是增量计算。在连续仿真中，相邻两帧之间的大气条件和路径几何可能变化很小。如果能够检测到这种变化，并且只计算变化的部分，就可以进一步提高效率。比如，当大气模型和能见度没有变化，只有观测角度轻微变化时，可以利用上一帧的结果作为初值，通过少量迭代得到新的结果。

7.6 架构师视角：大气模型精度与计算效率的权衡

作为光电仿真引擎的架构师，在大气传输系统的设计中，我们面临着一系列艰难的权衡。这些权衡不仅关乎技术选型，更直接影响着产品的定位、目标用户群体和市场竞争力。

第一个权衡：自研 vs 集成第三方模型。

自研大气传输模型的优势在于：完全可控，可以根据需求进行深度优化和定制；没有授权费用和法律风险；可以与引擎的其他模块（如 GPU 渲染管线）深度集成。但劣势也很明显：开发周期长（一个可用的 MODTRAN 级别的模型可能需要数十人年的工作量）；需要深厚的大气光学专业知识；验证和标定工作繁重。

集成第三方模型（如 MODTRAN、CART）的优势是：精度有保障，经过了学术界和工业界几十年的验证；开发成本低，可以快速出成果。劣势在于：授权问题（MODTRAN 受美国出口管制，商业使用需要申请授权）；难以进行深度优化（作为黑盒调用，无法利用 GPU 加速或向量化）；与系统其他模块的耦合度低，数据转换开销大。

架构师的建议是：对于大多数商业仿真引擎，采用"核心自研 + 高端模型可选集成"的策略。也就是说，引擎内置一套中等精度的自研发大气传输模型（基于带模型或相关 k 分布方法），满足 80% 的常规应用需求；同时提供 MODTRAN/FASCODE 等高端模型的可选集成接口，供对精度要求极高的用户选用。这样既保证了产品的自主性和性能，又为高端用户提供了精度升级的路径。

第二个权衡：光谱分辨率与计算量的矛盾。

光谱分辨率越高，计算精度越高，但计算量也越大。LOWTRAN 的 20 cm⁻¹ 分辨率计算很快但精度有限；MODTRAN 的 2 cm⁻¹ 分辨率精度不错但计算量增加了一个数量级；逐线积分的 0.001 cm⁻¹ 分辨率精度最高但计算量巨大。

在实际工程中，我们发现很多用户并不需要全波段、高分辨率的光谱数据。比如，一个工作在 8~14 μm 的长波红外成像仪，其探测器的光谱响应可能很宽（整个窗口都响应），此时用 20 cm⁻¹ 甚至更粗的分辨率计算宽带透过率，精度可能已经足够。而对于高光谱成像仪，可能需要 cm⁻¹ 甚至亚 cm⁻¹ 级的分辨率。

架构师的建议是 ：采用多分辨率光谱数据库设计。底层存储高分辨率的光谱数据（如 0.1 cm⁻¹），上层根据应用需求动态选择计算分辨率。对于宽带成像仿真，使用低分辨率（如 20 cm⁻¹）快速计算；对于高光谱仿真，自动切换到高分辨率计算。这种设计可以通过光谱重采样（spectral resampling）技术来实现，在保证精度的同时最大化计算效率。

第三个权衡：物理完备性与工程可用性的平衡。

从物理上讲，大气辐射传输是一个极其复杂的过程，涉及偏振、非线性、非局地热平衡、三维非均匀大气等诸多效应。如果追求物理上的绝对完备，计算量将是不可承受的。

工程上，我们需要做合理的近似。比如：

• 假设大气是水平均匀的（平面平行大气近似），忽略水平变化
• 假设局地热平衡（LTE），忽略荧光等非热效应
• 忽略偏振（标量近似），或者只在需要时才考虑
• 用二流近似或四流近似代替精确的多次散射计算

这些近似引入的误差有多大？在什么情况下这些误差是可以接受的？这是架构师必须回答的问题。

架构师的建议是 ：建立误差预算（Error Budget） 管理制度。对仿真链路中的每个环节（目标辐射、大气传输、传感器响应、噪声等）分配误差容限，大气传输模块的误差必须控制在分配的容限以内。如果某个近似引入的误差超出了预算，就需要提高模型精度；反之，如果预算有富余，就可以进一步简化模型以提高效率。

比如，对于一个总误差容限为 10% 的仿真系统，可能给大气传输分配 3% 的误差预算。然后通过与高精度模型（如 FASCODE）的对比来验证低阶模型的误差是否在 3% 以内。如果是，就可以放心使用低阶模型；如果不是，就需要调整模型参数或升级模型等级。

第四个权衡：内存占用与计算速度的权衡。

这主要体现在 LUT 的设计上。LUT 的采样越密，插值精度越高，但内存占用也越大。一个 4 维的 LUT，如果每个维度采样 100 个点，总数据量就是 100⁴ = 1 亿个点。每个点如果存储 4 字节的 float 数据，就是 400 MB。如果再加一个维度（比如目标高度），数据量就会膨胀到 40 GB，这在普通工作站上是无法接受的。

架构师的建议是 ：采用自适应采样 + 分层 LUT 的策略。对于非线性程度高的区域（如吸收带边缘、低能见度、大天顶角），采用较密的采样；对于线性程度好的区域（如大气窗口中心、高能见度、小天顶角），采用较稀的采样。同时，将 LUT 分层存储：基础层（低分辨率）常驻内存，精细层（高分辨率）按需从磁盘加载。这种方式可以在保证精度的前提下，将内存占用降低一个数量级以上。

另外，还可以考虑函数拟合的方法。对于某些具有明确函数形式的物理量（如瑞利散射的 λ⁻⁴ 依赖），不需要存储完整的 LUT，只需要存储少量拟合参数即可。这可以进一步减少内存占用。

最后，作为架构师，我们还要考虑系统的可扩展性和可维护性。大气科学在不断发展，新的观测数据和模型不断涌现。我们的设计必须能够方便地吸纳这些新成果，而不至于每次更新都伤筋动骨。这就是为什么我们强调接口抽象、策略模式、数据库与计算分离等设计原则的原因------它们为系统的长期演进留下了空间。

---

第8章 热特性求解系统架构

8.1 热特性求解的物理基础：热传导、热对流、热辐射

在光电仿真中，目标的红外辐射特性直接取决于其表面温度分布。要准确计算目标的红外图像，首先必须准确计算目标的温度场。而温度场的求解，正是热特性求解系统的核心任务。

热传递有三种基本方式：热传导（Heat Conduction） 、热对流（Heat Convection） 和 热辐射（Thermal Radiation） 。这三种方式在实际问题中往往同时存在、相互耦合，共同决定了物体的温度分布。

热传导是指物质内部或相互接触的物质之间，由于微观粒子的热运动而产生的热量传递现象。热传导的基本定律是傅里叶定律（Fourier's Law）：

\vec{q} = -k \nabla T

其中 \vec{q} 是热流密度矢量（单位：W/m²），k 是热导率（单位：W/(m·K)），∇T 是温度梯度。负号表示热量从高温区域流向低温区域。

将傅里叶定律代入能量守恒方程，可以得到热传导方程：

\rho c_p \frac{\partial T}{\partial t} = \nabla \cdot (k \nabla T) + q_v

其中 ρ 是密度（kg/m³），c_p 是定压比热容（J/(kg·K)），q_v 是内热源强度（W/m³），比如材料内部的焦耳热、化学反应热等。

对于稳态问题（温度不随时间变化），方程简化为：

\nabla \cdot (k \nabla T) + q_v = 0

如果热导率 k 是常数且没有内热源，则进一步简化为拉普拉斯方程：

\nabla^2 T = 0

热对流是指流体与固体表面之间，由于流体的宏观运动而产生的热量传递。对流换热的基本计算公式是牛顿冷却定律（Newton's Law of Cooling）：

q = h(T_s - T_f)

其中 h 是对流换热系数（单位：W/(m²·K)），T_s 是固体表面温度，T_f 是流体温度。

对流换热系数 h 并不是一个物性参数，它受到多种因素的影响：流体的物性（密度、粘度、热导率、比热容）、流动状态（层流还是湍流）、流动速度、表面几何形状等。在工程上，h 通常通过无量纲数（如努塞尔数 Nu、雷诺数 Re、普朗特数 Pr、格拉晓夫数 Gr 等）的经验关联式来计算。

对流可以分为自然对流和强制对流两大类：

• 自然对流：流体运动是由温度差引起的密度差（浮力）驱动的。努塞尔数的一般形式为 Nu = C(Gr·Pr)^n，其中 Gr 是格拉晓夫数（表征浮力与粘性力之比），C 和 n 是与几何形状和流动状态有关的常数。
• 强制对流：流体运动是由外部动力（如风机、泵）驱动的。努塞尔数的一般形式为 Nu = C·Re^m·Pr^n，其中 Re 是雷诺数（表征惯性力与粘性力之比）。

对于光电仿真中最常见的外部绕流问题（如风从目标表面吹过），常用的对流换热关联式包括平板层流（Nu = 0.664·Re^0.5·Pr^(1/3)）、平板湍流（Nu = 0.037·Re^0.8·Pr^(1/3)）、圆柱绕流、球体绕流等。

热辐射是物体由于自身温度而以电磁波形式向外发射能量的现象。与传导和对流不同，热辐射不需要介质，可以在真空中传播。热辐射的基本定律包括：

• 普朗克定律：描述黑体光谱辐射出射度与波长和温度的关系（公式见第7章）。
• 斯蒂芬-玻尔兹曼定律：黑体总辐射出射度与温度的四次方成正比： M_b = \sigma T^4 其中 σ = 5.670×10⁻⁸ W/(m²·K⁴) 是斯蒂芬-玻尔兹曼常数。
• 基尔霍夫定律：在热平衡条件下，物体的发射率等于其吸收率，即 ε = α。
• 朗伯余弦定律：漫射表面的辐射强度在各个方向上相等，辐射出射度随观察角的余弦变化：L(θ) = L_n·cosθ。

在热特性求解中，辐射换热通常以边界条件的形式出现。物体表面的净辐射热流密度等于自身发射的辐射减去吸收的入射辐射：

q_{rad} = \varepsilon \sigma T_s^4 - \alpha G

其中 G 是表面的入射辐射照度（irradiation），包括来自环境的辐射、其他表面的辐射以及太阳辐射等。对于灰体假设（ε = α），可以简化为：

q_{rad} = \varepsilon (\sigma T_s^4 - G)

当考虑两个表面之间的辐射换热时，需要引入角系数（View Factor）F_ij 的概念，它表示表面 i 发出的辐射中直接到达表面 j 的比例。角系数仅与几何形状和相对位置有关，与表面温度和物性无关。角系数满足互换性（A_i F_ij = A_j F_ji）和完整性（Σ_j F_ij = 1）。

以下是热物性参数和换热边界条件的C++数据结构设计：

// thermal_properties.h
#pragma once
#include <vector>
#include <functional>
#include <string>

namespace opto_engine {
namespace thermal {

// 热物性参数（温度相关）
struct ThermalMaterialProperties {
    std::string material_name;
    
    // 密度 (kg/m³)，通常视为常数
    double density = 7850.0;
    
    // 比热容 J/(kg·K)，可以是温度的函数
    std::function<double(double T)> specific_heat = 
        [](double T) { return 470.0; };  // 默认钢的比热
    
    // 热导率 W/(m·K)，可以是温度的函数
    std::function<double(double T)> thermal_conductivity = 
        [](double T) { return 50.0; };   // 默认钢的热导率
    
    // 表面发射率（红外波段平均）
    double emissivity = 0.85;
    
    // 表面吸收率（太阳波段）
    double solar_absorptivity = 0.6;
    
    // 是否为半透明材料（考虑体内辐射）
    bool is_semitransparent = false;
};

// 热边界条件类型
enum class BoundaryConditionType {
    FIXED_TEMPERATURE,    // 第一类边界条件：给定温度
    FIXED_HEAT_FLUX,      // 第二类边界条件：给定热流密度
    CONVECTION,           // 第三类边界条件：对流换热
    RADIATION,            // 辐射换热边界
    CONVECTION_RADIATION, // 对流 + 辐射 耦合边界
    SYMMETRY,             // 对称边界（绝热）
    INTERFACE             // 接触面（两固体之间）
};

// 热边界条件
struct ThermalBoundaryCondition {
    BoundaryConditionType type;
    
    // 固定温度 (K)
    double temperature = 300.0;
    
    // 固定热流密度 (W/m²)，正值表示流入
    double heat_flux = 0.0;
    
    // 对流换热参数
    double convection_coeff = 10.0;     // h, W/(m²·K)
    double fluid_temperature = 300.0;   // T_inf, K
    
    // 辐射换热参数
    double emissivity = 0.85;
    double ambient_temperature = 300.0; // 环境等效辐射温度 (K)
    double solar_irradiance = 0.0;      // 太阳辐照度 (W/m²)
    double solar_absorptivity = 0.6;
    double sky_temperature = 230.0;     // 天空有效温度 (K)
    double sky_view_factor = 0.5;       // 天空角系数
    double ground_temperature = 290.0;  // 地表温度 (K)
    double ground_view_factor = 0.5;    // 地面角系数
};

// 内热源
struct InternalHeatSource {
    double power_density = 0.0;  // 体功率密度 (W/m³)
    // 也可以是面热源或点热源，这里简化为体热源
};

} // namespace thermal
} // namespace opto_engine

在热特性求解系统中，材料物性的温度依赖性是一个需要特别关注的问题。对于大多数金属材料，热导率和比热容随温度的变化在常温范围内可能不超过 10%，可以近似为常数。但在高温（如 > 500°C）或低温（如 < -100°C）场景下，温度依赖性就不能忽略了。在代码设计中，我们使用 std::function 来表示温度相关的物性，这样既支持简单的常数形式，也支持复杂的函数形式（如多项式拟合、查表插值等），具有很好的灵活性。

8.2 热边界条件：环境温度、风速、太阳辐射、地表辐射

热边界条件是连接目标热特性与环境的桥梁。光电仿真中的目标热特性计算，本质上就是在给定环境条件下求解目标的温度场。因此，热边界条件的准确性直接决定了温度场计算的精度，进而影响整个红外仿真的可信度。

最常见的热边界条件是对流-辐射耦合边界，即物体外表面同时与环境发生对流换热和辐射换热。这种边界条件的数学表达为：

-k \frac{\partial T}{\partial n} \bigg|{surface} = h(T_s - T{amb}) + \varepsilon \sigma T_s^4 - \alpha_{solar} q_{solar} - \varepsilon \sigma T_{sky}^4 F_{sky} - \varepsilon \sigma T_{ground}^4 F_{ground}

左边是固体内部通过热传导到达表面的热流（傅里叶定律），右边各项分别是：

0. 对流换热损失（牛顿冷却定律）
1. 表面自身的热辐射发射（斯蒂芬-玻尔兹曼定律）
2. 吸收的太阳辐射
3. 吸收的天空辐射
4. 吸收的地面辐射

这里我们做了一个简化：假设天空和地面都可以等效为朗伯黑体（或灰体），其辐射可以用等效温度来表示。实际情况要复杂得多------天空的红外辐射亮度随天顶角、波长、大气条件而变化，地面的辐射也与地表类型、温度分布有关。但在工程精度范围内，用等效温度和角系数来近似是完全可行的。

环境温度（Ambient Temperature） 是最基本的气象参数，它直接影响对流换热的方向和强度。环境温度通常指离地面 1.5~2 m 高度处的空气温度。在一天之中，环境温度随时间变化，通常凌晨最低、下午最高。这种日变化是导致目标温度日波动的主要驱动因素之一。

风速（Wind Speed） 决定了对流换热系数的大小。对于自然对流，风速为零，换热系数较小（通常 5~25 W/(m²·K)）。对于强制对流，风速越大，对流换热系数越高。在工程上，常用以下经验公式估算平板的对流换热系数：

h = 2.5 + 4.0 \cdot v^{0.8}

其中 v 是风速（m/s），h 的单位是 W/(m²·K)。这个公式适用于风速 0~20 m/s 的范围，在 v = 0 时给出 2.5 W/(m²·K) 的自然对流近似值。

更精确的计算需要根据雷诺数判断流态（层流/湍流），然后选用相应的努塞尔数关联式。在热求解器中，我们通常将对流换热系数的计算封装为独立的函数模块：

// convection_calculator.h
#pragma once

namespace opto_engine {
namespace thermal {

// 对流换热计算器
class ConvectionCalculator {
public:
    // 计算外部强制对流换热系数（平板）
    static double flatPlateForcedConvection(
        double velocity_m_s,    // 来流速度 (m/s)
        double length_m,        // 平板沿流动方向的长度 (m)
        double T_surface_K,     // 表面温度 (K)
        double T_fluid_K,       // 流体温度 (K)
        double pressure_kPa = 101.325  // 环境气压 (kPa)
    );
    
    // 计算自然对流换热系数（垂直平板）
    static double verticalPlateNaturalConvection(
        double T_surface_K,     // 表面温度 (K)
        double T_fluid_K,       // 流体温度 (K)
        double height_m,        // 平板高度 (m)
        double pressure_kPa = 101.325
    );
    
    // 计算自然对流换热系数（水平平板，热面朝上）
    static double horizontalPlateNaturalConvection_Up(
        double T_surface_K,
        double T_fluid_K,
        double characteristic_length_m,
        double pressure_kPa = 101.325
    );
    
    // 圆柱绕流对流换热系数
    static double cylinderCrossFlowConvection(
        double velocity_m_s,
        double diameter_m,
        double T_surface_K,
        double T_fluid_K,
        double pressure_kPa = 101.325
    );
    
    // 综合估算：根据风速和几何特征长度估算对流换热系数
    static double estimateConvectionCoeff(
        double wind_speed_m_s,
        double characteristic_length_m,
        double T_surface_K = 300.0,
        double T_ambient_K = 290.0
    );
    
private:
    // 空气物性参数计算
    struct AirProperties {
        double density;            // kg/m³
        double dynamic_viscosity;  // Pa·s
        double thermal_conductivity; // W/(m·K)
        double specific_heat;      // J/(kg·K)
        double prandtl_number;     // Pr
    };
    
    static AirProperties airProperties(double T_K, double p_kPa);
};

} // namespace thermal
} // namespace opto_engine

太阳辐射（Solar Radiation） 是白天目标加热的主要能量来源。太阳辐照度的大小取决于地理位置、时间、天气条件以及表面的朝向。在标准大气条件下，垂直于太阳光的海平面处的太阳辐照度（太阳常数）约为 1361 W/m²。但由于大气的吸收和散射，到达地面的太阳辐照度通常在 800~1100 W/m² 之间（晴朗白天）。

到达表面的太阳辐射包括三个部分：

0. 直接辐射（Direct Normal Irradiance, DNI） ：来自太阳圆盘的平行光
1. 散射辐射（Diffuse Horizontal Irradiance, DHI） ：被大气散射后从整个天空半球到达的辐射
2. 反射辐射：经过地面或周围环境反射后到达的辐射

表面接收到的总太阳辐照度可以表示为：

G_{solar} = DNI \cdot \cos\theta + DHI + G_{ground} \cdot \rho_{ground}

其中 θ 是太阳入射角（太阳光与表面法线的夹角），ρ_ground 是地面的太阳反射率（即反照率 albedo）。

太阳辐射的光谱分布与 5800 K 黑体辐射类似，主要集中在 0.33 μm 的短波范围。因此，表面对太阳辐射的吸收率（α*solar）与其对红外辐射的发射率（ε）可能不同。比如，白色涂料的太阳吸收率很低（α ≈ 0.10.2），但红外发射率很高（ε ≈ 0.9）。这种选择性涂层在实际工程中非常常见，也是热计算中必须区分 α*solar 和 ε 的原因。

天空辐射（Sky Radiation） 是指天空作为一个大的热辐射源，向下发射的长波红外辐射。天空辐射的强度主要取决于大气温度、湿度和云量。晴朗夜晚，天空的有效辐射温度可以比环境温度低 2030 K（即 250270 K），这就是为什么晴朗夜晚地面会降温很快（辐射冷却效应）。阴天时，云层的温度较高且发射率接近 1，天空有效温度接近环境温度。

天空辐射的经验计算公式有很多，其中常用的是 Swinbank 公式：

T_{sky} = 0.0552 \cdot T_{amb}^{1.5}

以及 Brutsaert 公式：

\varepsilon_{sky} = 1.24 \left( \frac{e_a}{T_{amb}} \right)^{1/7}

其中 e_a 是水汽压（kPa），T_amb 是环境温度（K）。

地表辐射（Ground Radiation） 是来自地面的长波红外辐射。地表温度与环境温度接近，但由于地表的热惯性，其日变化幅度通常比气温小，且相位滞后。地表发射率通常较高（0.85~0.95），因此地表的红外辐射可以近似为 ε_ground · σ · T_ground⁴。

在热求解器的架构设计中，我们将环境边界条件封装为一个独立的环境管理器，负责管理所有与环境相关的参数计算。这样做的好处是，热求解器只需要关注热传导方程的求解，而把复杂的环境参数计算（太阳角度、天空辐射、风速影响等）交给专门的模块处理。

8.3 稳态求解 vs 瞬态求解：选型与适用场景

热特性求解可以分为稳态（Steady-State） 和 瞬态（Transient） 两大类。选择哪种求解方式，取决于仿真的目标和场景。

稳态热求解是求解温度场不随时间变化的情况，即 ∂T/∂t = 0。此时热传导方程简化为：

\nabla \cdot (k \nabla T) + q_v = 0

稳态求解的特点是：计算量相对较小，结果只取决于边界条件和物性参数，与初始条件无关。稳态求解适用于以下场景：

0. 长时间工作后的热平衡状态：比如目标在环境中放置了足够长的时间，温度分布已经稳定，不再随时间变化。
1. 平均温度估算：当我们只关心目标的平均温度或最高/最低温度，而不关心温度随时间的变化过程时，可以用稳态求解快速估算。
2. 设计优化：在产品设计阶段，比较不同材料、不同结构方案的稳态温度分布，可以快速评估热设计的优劣。
3. 长波红外成像仿真（昼/夜稳态） ：对于某些场景，比如正午或午夜的热成像，目标温度接近稳态，可以用稳态计算结果来生成红外图像。

瞬态热求解是求解温度场随时间变化的过程，即 ∂T/∂t ≠ 0。瞬态求解需要考虑物体的热惯性（热容），计算量更大，但能提供更丰富的时间信息。瞬态求解的热传导方程为：

\rho c_p \frac{\partial T}{\partial t} = \nabla \cdot (k \nabla T) + q_v

瞬态求解适用于以下场景：

0. 日变化温度场计算：目标温度随太阳辐射、环境温度的日变化而波动，这是红外目标特性的核心内容。没有瞬态求解，就无法准确模拟日出、日落、正午、午夜等不同时刻的目标红外特征。
1. 动态过程仿真：比如飞机起飞后蒙皮温度的变化、设备开机后的升温过程、导弹发射后的气动加热过程等。
2. 热冲击和热疲劳分析：快速温度变化引起的热应力和材料疲劳。
3. 相变问题：熔化、凝固等伴随潜热的相变过程。

在瞬态求解中，时间步长的选择是一个关键问题。时间步长太大，可能导致数值不稳定或精度不足；时间步长太小，计算量又太大。对于显式时间积分方法（如显式有限差分），时间步长受到稳定性条件的严格限制：

\Delta t \leq \frac{\rho c_p (\Delta x)^2}{2k}

这就是著名的傅里叶数稳定性判据（Fo ≤ 0.5，对一维问题）。其中 Δx 是空间网格尺寸。可以看到，网格越细，允许的时间步长越小。对于三维问题，稳定性条件更加严格。这也是为什么显式方法虽然每步计算简单，但总体效率不一定高的原因------它需要的时间步数太多了。

对于隐式时间积分方法（如隐式有限差分、有限元），时间步长没有稳定性限制（无条件稳定），可以取较大的时间步长。但每步需要求解一个线性方程组，单步计算量更大。隐式方法是工程热分析中更常用的方法。

以下是瞬态热求解器的时间积分方案枚举和接口设计：

// thermal_solver.h
#pragma once
#include "thermal_properties.h"
#include "thermal_mesh.h"
#include <vector>
#include <functional>
#include <memory>

namespace opto_engine {
namespace thermal {

// 求解类型
enum class SolverType {
    STEADY_STATE,    // 稳态求解
    TRANSIENT        // 瞬态求解
};

// 时间积分方法（瞬态求解）
enum class TimeIntegrationMethod {
    EXPLICIT_EULER,       // 显式欧拉（条件稳定）
    IMPLICIT_EULER,       // 隐式欧拉（无条件稳定，一阶精度）
    CRANK_NICOLSON,       // 克兰克-尼科尔森（无条件稳定，二阶精度）
    BACKWARD_DIFFERENCE   // 向后差分公式（BDF，高阶精度）
};

// 线性方程组求解器类型
enum class LinearSolverType {
    DIRECT_LU,        // 直接LU分解（小规模问题）
    CONJUGATE_GRADIENT, // 共轭梯度法（对称正定矩阵）
    GMRES,            // 广义最小残差法（非对称矩阵）
    MULTIGRID,        // 多重网格法（大规模问题）
    ICCG              // 不完全乔列斯基共轭梯度
};

// 求解器配置
struct ThermalSolverConfig {
    SolverType solver_type = SolverType::TRANSIENT;
    TimeIntegrationMethod time_method = TimeIntegrationMethod::IMPLICIT_EULER;
    LinearSolverType linear_solver = LinearSolverType::GMRES;
    
    // 瞬态参数
    double time_start = 0.0;       // 起始时间 (s)
    double time_end = 86400.0;     // 结束时间 (s)，默认24小时
    double time_step = 60.0;       // 时间步长 (s)，默认1分钟
    double adaptive_time_step = true;  // 自适应时间步长
    double max_time_step = 300.0;  // 最大时间步长 (s)
    double min_time_step = 1.0;    // 最小时间步长 (s)
    
    // 收敛判据
    double temperature_tolerance = 0.01;  // 温度收敛容差 (K)
    int max_iterations = 1000;            // 最大迭代次数
    double relative_tolerance = 1e-6;     // 相对残差容差
};

// 求解结果
struct ThermalSolution {
    std::vector<double> node_temperatures;  // 节点温度 (K)
    double current_time = 0.0;              // 当前时间 (s)
    bool converged = false;                 // 是否收敛
    int iterations = 0;                     // 迭代次数
    double residual_norm = 0.0;             // 残差范数
};

// 热求解器基类
class IThermalSolver {
public:
    virtual ~IThermalSolver() = default;
    
    // 设置网格
    virtual void setMesh(std::shared_ptr<ThermalMesh> mesh) = 0;
    
    // 设置材料属性
    virtual void setMaterials(
        const std::vector<ThermalMaterialProperties>& materials) = 0;
    
    // 设置边界条件
    virtual void setBoundaryConditions(
        const std::vector<ThermalBoundaryCondition>& bc_list) = 0;
    
    // 设置内热源
    virtual void setInternalHeatSources(
        const std::vector<InternalHeatSource>& sources) = 0;
    
    // 设置初始温度场（瞬态求解）
    virtual void setInitialTemperature(double T0) = 0;
    virtual void setInitialTemperatureField(
        const std::vector<double>& T_field) = 0;
    
    // 求解
    virtual bool solve(const ThermalSolverConfig& config) = 0;
    
    // 获取结果
    virtual ThermalSolution getSolution() const = 0;
    
    // 步进求解（用于瞬态耦合，每一步外部可以干预边界条件）
    virtual bool step(double dt) = 0;
    
    // 获取当前时间
    virtual double getCurrentTime() const = 0;
};

} // namespace thermal
} // namespace opto_engine

这个求解器接口设计有几个值得注意的特点。首先，它同时支持稳态和瞬态两种求解模式，通过配置参数来切换。其次，它提供了 step() 方法------这是为热-光耦合、热-结构耦合等多物理场耦合场景设计的。在耦合仿真中，每推进一个时间步，可能需要先调用热求解器计算温度场，然后将温度场传递给光学求解器计算辐射特性，再将光学求解的结果（如辐射加热/冷却效应）反馈回热求解器作为边界条件的修正。没有 step() 方法，这种紧耦合的仿真就难以实现。

在实际的光电仿真工程中，我们发现日变化瞬态求解 是最常用的场景。用户通常希望知道目标在一天 24 小时内不同时刻的温度分布和红外特征。对于这种周期性边界条件的瞬态问题，有一些特殊的优化技巧。比如，可以先从一个估计的初始温度场开始，计算若干个周期（通常 2~3 天），直到温度场的周期性稳定下来（即第 n 天和第 n+1 天同一时刻的温度差小于收敛容差）。这种方法称为周期稳态求解，它本质上仍然是瞬态求解，但目标是获得周期性变化的稳态解。

8.4 有限差分法（FDM）与有限元法（FEM）对比

热传导方程的数值求解方法有很多种，其中最常用的是有限差分法（Finite Difference Method, FDM） 和 有限元法（Finite Element Method, FEM） 。这两种方法各有优缺点，适用于不同的场景。

有限差分法是最早发展起来的数值方法，其基本思想是将求解域离散为规则的网格（如矩形网格、立方体网格），用差商代替微商，将微分方程转化为代数方程组。

有限差分法的优点：

0. 原理简单，易于理解和实现：对于规则网格，差分格式的推导非常直接，代码编写相对简单。
1. 计算效率高：规则网格导致的系数矩阵具有非常规整的结构（如三对角、块三对角），可以用专门的高效算法求解（如 Thomas 算法、ADI 方法等）。
2. 内存占用小：不需要存储复杂的网格拓扑信息，只需要存储节点温度和少量系数。

有限差分法的缺点：

0. 复杂几何适应性差：对于不规则的几何形状（曲线边界、斜面、孔洞等），规则网格难以精确拟合，需要用阶梯近似或特殊的边界处理方法，这会引入额外的误差。
1. 材料界面处理复杂：当不同材料的分界面与网格线不重合时，需要特殊处理（如调和平均热导率），精度会受到影响。
2. 局部加密困难：FDM 的网格通常是均匀的（或分块均匀的），难以对局部区域进行精细化加密。虽然有自适应网格细化（AMR）技术，但实现起来比较复杂。

有限元法是另一种广泛使用的数值方法，其基本思想是将求解域离散为若干个有限大小的单元（如三角形、四边形、四面体、六面体等），在每个单元内假设温度的插值函数，通过变分原理或加权余量法将微分方程转化为代数方程组。

有限元法的优点：

0. 几何适应性强：可以用任意形状的单元来拟合复杂的几何边界，精度高。
1. 材料界面处理自然：材料分界面可以与单元边界重合，不需要特殊处理。
2. 局部加密方便：可以在温度梯度大的区域（如热源附近、尖角处）加密网格，在温度平缓的区域使用粗网格，实现计算资源的优化配置。
3. 数学基础严谨：有限元法有坚实的数学理论基础，收敛性和误差分析都比较完善。

有限元法的缺点：

0. 实现复杂：有限元程序的开发难度远大于有限差分，需要处理单元积分、矩阵组装、边界条件施加等诸多细节。
1. 计算开销大：有限元的系数矩阵通常是稀疏的，但不如 FDM 的矩阵规整，求解效率相对较低。另外，有限元需要存储网格拓扑、单元形状函数等信息，内存占用也更大。
2. 网格生成是瓶颈：对于复杂三维模型，生成高质量的有限元网格本身就是一项困难的任务，可能需要专业的网格生成工具和大量的人工干预。

在光电仿真的热特性计算中，应该选择 FDM 还是 FEM 呢？这取决于具体的应用场景：

• 如果目标是简单的几何形状（如平板、圆柱、球体等可以用规则网格表示的结构），且对计算速度要求高（如实时仿真），FDM 是更好的选择。
• 如果目标是复杂的三维结构（如飞机、车辆、建筑物等），且对几何精度要求高，FEM 是不二之选。
• 如果需要多物理场耦合（如热-结构耦合、热-流体耦合），FEM 通常更方便，因为其他物理场（结构、流体）也大多采用有限元或有限体积法，数据交换更容易。

在实际的工程实践中，还有一种折衷方案：有限体积法（Finite Volume Method, FVM） 。FVM 兼具 FDM 的计算效率和 FEM 的几何灵活性，在计算流体力学（CFD）中应用非常广泛。对于热传导问题，FVM 也是一个很好的选择，尤其是当热求解需要与流体求解耦合时（共轭传热问题）。

以下是一个基于有限差分法的一维瞬态热求解器的核心实现，展示了FDM的基本思路：

// fdm_thermal_solver.cpp
// 一维瞬态热传导有限差分解法（隐式欧拉）

#include <vector>
#include <cmath>

namespace opto_engine {
namespace thermal {

class FDM1DThermalSolver {
public:
    FDM1DThermalSolver(int num_nodes, double thickness_m)
        : nx_(num_nodes), dx_(thickness_m / (num_nodes - 1)) {
        T_.resize(nx_, 300.0);  // 初始温度
        T_new_.resize(nx_);
        k_.resize(nx_, 50.0);   // 默认热导率
        rho_cp_.resize(nx_, 7850.0 * 470.0);  // 默认ρ*cp
    }
    
    void setInitialTemperature(double T0) {
        std::fill(T_.begin(), T_.end(), T0);
    }
    
    void setMaterialProperties(
        const std::vector<double>& k,
        const std::vector<double>& rho_cp) {
        k_ = k;
        rho_cp_ = rho_cp;
    }
    
    // 设置左边界（x=0）：对流换热
    void setLeftConvectionBC(double h, double T_ambient) {
        left_h_ = h;
        left_T_amb_ = T_ambient;
        left_bc_type_ = CONVECTION;
    }
    
    // 设置右边界（x=L）：对流 + 辐射 + 太阳
    void setRightMixedBC(double h, double T_ambient, 
                         double emissivity, double solar_flux,
                         double solar_absorptivity) {
        right_h_ = h;
        right_T_amb_ = T_ambient;
        right_eps_ = emissivity;
        right_solar_ = solar_flux;
        right_alpha_s_ = solar_absorptivity;
        right_bc_type_ = MIXED;
    }
    
    // 推进一个时间步（隐式欧拉 + 牛顿迭代处理辐射非线性）
    bool step(double dt) {
        const int max_newton_iter = 20;
        const double tol = 0.01;  // 温度收敛容差 0.01 K
        
        std::vector<double> T_guess = T_;
        
        for (int iter = 0; iter < max_newton_iter; ++iter) {
            // 构建三对角方程组：a*T[i-1] + b*T[i] + c*T[i+1] = d
            std::vector<double> a(nx_, 0.0);  // 下对角线
            std::vector<double> b(nx_, 0.0);  // 主对角线
            std::vector<double> c(nx_, 0.0);  // 上对角线
            std::vector<double> d(nx_, 0.0);  // 右端项
            
            // 内部节点
            for (int i = 1; i < nx_ - 1; ++i) {
                // 界面热导率（调和平均）
                double k_left = 2.0 * k_[i] * k_[i-1] / (k_[i] + k_[i-1]);
                double k_right = 2.0 * k_[i] * k_[i+1] / (k_[i] + k_[i+1]);
                
                a[i] = -k_left / dx_;
                c[i] = -k_right / dx_;
                b[i] = rho_cp_[i] * dx_ / dt + k_left / dx_ + k_right / dx_;
                d[i] = rho_cp_[i] * dx_ / dt * T_[i];
            }
            
            // 左边界：对流换热（第三类边界条件，能量平衡）
            applyLeftBoundary(a, b, c, d, T_guess, dt);
            
            // 右边界：对流 + 辐射 + 太阳（非线性，用牛顿法线性化）
            applyRightBoundary(a, b, c, d, T_guess, dt);
            
            // 求解三对角方程组（Thomas算法）
            thomasAlgorithm(a, b, c, d, T_new_);
            
            // 检查收敛
            double max_delta = 0.0;
            for (int i = 0; i < nx_; ++i) {
                max_delta = std::max(max_delta, std::abs(T_new_[i] - T_guess[i]));
            }
            
            T_guess = T_new_;
            
            if (max_delta < tol) {
                T_ = T_new_;
                return true;
            }
        }
        
        T_ = T_new_;
        return false;  // 未收敛
    }
    
    double getTemperature(int node) const { return T_[node]; }
    const std::vector<double>& getTemperatureField() const { return T_; }
    
private:
    enum BCType { CONVECTION, MIXED };
    
    int nx_;
    double dx_;
    std::vector<double> T_;       // 当前温度场
    std::vector<double> T_new_;   // 新温度场
    std::vector<double> k_;       // 热导率
    std::vector<double> rho_cp_;  // 密度×比热容
    
    // 左边界参数
    BCType left_bc_type_ = CONVECTION;
    double left_h_ = 10.0;
    double left_T_amb_ = 300.0;
    
    // 右边界参数
    BCType right_bc_type_ = MIXED;
    double right_h_ = 10.0;
    double right_T_amb_ = 300.0;
    double right_eps_ = 0.85;
    double right_solar_ = 0.0;
    double right_alpha_s_ = 0.6;
    static constexpr double sigma_ = 5.670374419e-8;  // 斯蒂芬-玻尔兹曼常数
    
    void applyLeftBoundary(std::vector<double>& a, 
                           std::vector<double>& b,
                           std::vector<double>& c, 
                           std::vector<double>& d,
                           const std::vector<double>& T_guess,
                           double dt) {
        int i = 0;  // 左边界节点
        // 能量平衡：内部导热 + 对流换热 = 内能变化
        // 使用边界节点法（控制体法），左边界的控制体厚度为 dx_/2
        double k_right = (k_[0] + k_[1]) / 2.0;  // 界面热导率
        
        b[i] = rho_cp_[i] * dx_ / (2.0 * dt) + left_h_ + k_right / dx_;
        c[i] = -k_right / dx_;
        d[i] = rho_cp_[i] * dx_ / (2.0 * dt) * T_[i] + left_h_ * left_T_amb_;
    }
    
    void applyRightBoundary(std::vector<double>& a, 
                            std::vector<double>& b,
                            std::vector<double>& c, 
                            std::vector<double>& d,
                            const std::vector<double>& T_guess,
                            double dt) {
        int i = nx_ - 1;  // 右边界节点
        
        double k_left = (k_[nx_-2] + k_[nx_-1]) / 2.0;
        
        // 辐射项线性化：εσT⁴ ≈ εσ(4T_guess³·T - 3T_guess⁴)
        double Tg = T_guess[i];
        double Tg3 = Tg * Tg * Tg;
        double Tg4 = Tg3 * Tg;
        double rad_coeff = right_eps_ * sigma_ * 4.0 * Tg3;  // 线性化系数
        double rad_const = right_eps_ * sigma_ * (-3.0 * Tg4); // 常数项
        
        b[i] = rho_cp_[i] * dx_ / (2.0 * dt) + right_h_ + k_left / dx_ + rad_coeff;
        a[i] = -k_left / dx_;
        d[i] = rho_cp_[i] * dx_ / (2.0 * dt) * T_[i] 
             + right_h_ * right_T_amb_ 
             + right_alpha_s_ * right_solar_
             - rad_const;  // 注意符号
    }
    
    // 三对角方程组求解（Thomas算法）
    void thomasAlgorithm(const std::vector<double>& a,
                         const std::vector<double>& b,
                         const std::vector<double>& c,
                         const std::vector<double>& d,
                         std::vector<double>& x) {
        int n = d.size();
        std::vector<double> c_prime(n);
        std::vector<double> d_prime(n);
        
        c_prime[0] = c[0] / b[0];
        d_prime[0] = d[0] / b[0];
        
        for (int i = 1; i < n; ++i) {
            double m = a[i] / (b[i] - a[i] * c_prime[i-1]);
            c_prime[i] = c[i] * m;  // 注意：这里需要修正
            d_prime[i] = (d[i] - a[i] * d_prime[i-1]) / (b[i] - a[i] * c_prime[i-1]);
        }
        // 修正：c_prime[i] = c[i] / (b[i] - a[i]*c_prime[i-1])
        // 上面的计算顺序需要调整，此处为示意代码
        
        x[n-1] = d_prime[n-1];
        for (int i = n - 2; i >= 0; --i) {
            x[i] = d_prime[i] - c_prime[i] * x[i+1];
        }
    }
};

} // namespace thermal
} // namespace opto_engine

这段代码展示了一维有限差分热求解器的核心架构。几个关键点值得关注：

0. 控制体法（Finite Volume 思想在 FDM 中的应用） ：边界节点的处理采用了能量平衡的控制体方法，而不是简单的差分近似。这样可以更好地保证能量守恒，尤其是在边界条件复杂时。
1. 隐式时间积分：采用隐式欧拉方法，时间步长不受稳定性限制，可以根据精度需求灵活选择。
2. 辐射非线性处理 ：由于辐射换热与温度的四次方成正比，是一个强非线性项。代码中使用了牛顿迭代法来处理这个非线性------每次迭代中，将辐射项在当前温度估计值处线性化，然后求解线性方程组。迭代直到温度变化小于收敛容差。
3. 调和平均界面热导率：在材料界面处，热导率不连续，此时使用调和平均值（而不是算术平均值）来计算界面的等效热导率，可以保证热流的连续性，提高计算精度。

8.5 热求解器架构设计：网格生成、求解器、结果可视化

一个完整的热特性求解系统不仅仅是一个求解器，它包含了从几何建模到结果后处理的完整流程。从架构的角度看，热求解系统可以划分为三个主要模块：网格生成模块 、求解器核心模块 和结果后处理与可视化模块。

网格生成模块负责将几何模型转换为数值计算所需的离散网格。网格的质量直接影响求解的精度和效率。对于 FDM，网格生成相对简单------只需要根据几何尺寸和分辨率要求生成规则的笛卡尔网格即可。对于 FEM，网格生成则复杂得多，通常需要专业的网格生成算法和工具。

网格生成的主要步骤包括：

0. 几何输入：读取 CAD 模型（如 STEP、IGES 格式）或用户定义的几何参数。
1. 几何清理与修复：CAD 模型中常常存在小面、缝隙、重叠等缺陷，需要先进行清理。
2. 面网格生成：在模型表面生成三角形或四边形面网格。
3. 体网格生成：在实体内部生成四面体、六面体或混合体网格。
4. 边界层网格：对于对流换热问题，在壁面附近生成加密的边界层网格，以准确捕捉温度梯度。
5. 网格质量检查与优化：检查单元的长宽比、歪斜度、雅可比等质量指标，对差质量单元进行优化。
6. 区域与边界标记：给不同的材料区域和边界条件区域打上标签，方便后续赋值。

在工程实践中，我们通常不会从零开始实现网格生成算法，而是集成开源或商业的网格生成库。常用的开源网格生成库包括：

• Gmsh：功能强大的三维有限元网格生成器，支持参数化建模、自适应网格生成等。
• TetGen：高质量的四面体网格生成库。
• Triangle：二维三角形网格生成器。
• Netgen：另一个开源的自动三维网格生成器。

以下是热求解系统的整体架构图（以代码接口的形式展示）：

// thermal_system.h
#pragma once
#include "thermal_mesh.h"
#include "thermal_solver.h"
#include "thermal_result.h"
#include <memory>
#include <string>
#include <vector>

namespace opto_engine {
namespace thermal {

// 热分析系统：整合网格、求解、后处理
class ThermalAnalysisSystem {
public:
    ThermalAnalysisSystem();
    ~ThermalAnalysisSystem();
    
    // ========== 阶段1：几何与网格 ==========
    
    // 从CAD文件导入几何模型
    bool importGeometry(const std::string& cad_file);
    
    // 定义简单几何（盒体、圆柱、球体等）
    bool addBox(double x, double y, double z, 
                double l, double w, double h,
                const std::string& material_name);
    
    bool addCylinder(double x, double y, double z,
                     double radius, double height,
                     const std::string& material_name);
    
    // 执行网格生成
    bool generateMesh(double max_element_size = -1.0, 
                      double min_element_size = -1.0);
    
    // 导入外部生成的网格（如Gmsh的.msh文件）
    bool importMesh(const std::string& mesh_file);
    
    // 获取网格信息
    size_t getNodeCount() const;
    size_t getElementCount() const;
    
    // ========== 阶段2：条件设置与求解 ==========
    
    // 设置材料库
    void setMaterialLibrary(
        const std::vector<ThermalMaterialProperties>& materials);
    
    // 给区域分配材料
    bool assignMaterial(const std::string& region_name,
                        const std::string& material_name);
    
    // 设置边界条件
    bool addBoundaryCondition(const std::string& boundary_name,
                              const ThermalBoundaryCondition& bc);
    
    // 设置内热源
    bool addHeatSource(const std::string& region_name,
                       double power_density);
    
    // 设置环境条件
    void setEnvironment(double ambient_temp, double wind_speed,
                        double solar_irradiance, double sky_temperature);
    
    // 执行求解
    bool solve(const ThermalSolverConfig& config);
    
    // 执行日变化循环求解
    bool solveDailyCycle(double latitude, double longitude,
                         int day_of_year, 
                         const ThermalSolverConfig& config);
    
    // ========== 阶段3：结果后处理 ==========
    
    // 获取节点温度场
    std::vector<double> getNodeTemperatures() const;
    
    // 获取表面温度分布
    std::vector<double> getSurfaceTemperatures(
        const std::string& boundary_name) const;
    
    // 获取最高/最低温度
    double getMaxTemperature() const;
    double getMinTemperature() const;
    
    // 计算表面热流密度
    std::vector<double> getSurfaceHeatFlux(
        const std::string& boundary_name) const;
    
    // 计算温度分布的统计量（均值、方差、直方图等）
    TemperatureStatistics getTemperatureStatistics() const;
    
    // 导出结果文件（VTK、CSV等格式）
    bool exportResults(const std::string& filepath, 
                       ResultFormat format = ResultFormat::VTK) const;
    
    // 获取某时刻的解（瞬态求解时，保存了多个时间步的结果）
    ThermalSolution getSolutionAtTime(double time_s) const;
    
    // 获取表面温度随时间变化的曲线
    std::vector<std::pair<double, double>> getSurfaceTemperatureHistory(
        int surface_node_index) const;
    
private:
    // 网格数据
    std::shared_ptr<ThermalMesh> mesh_;
    
    // 求解器
    std::unique_ptr<IThermalSolver> solver_;
    
    // 材料库
    std::vector<ThermalMaterialProperties> material_library_;
    
    // 边界条件列表
    std::vector<ThermalBoundaryCondition> boundary_conditions_;
    
    // 求解结果（瞬态时保存多个时间步）
    std::vector<ThermalSolution> solutions_;
    std::vector<double> time_points_;
    
    // 环境参数
    double ambient_temp_ = 290.0;
    double wind_speed_ = 2.0;
    double solar_irradiance_ = 0.0;
    double sky_temperature_ = 240.0;
};

} // namespace thermal
} // namespace opto_engine

这个系统设计体现了流水线（Pipeline）架构风格：几何输入 → 网格生成 → 条件设置 → 求解 → 后处理，每个阶段有明确的输入输出，阶段之间通过标准化的数据结构（网格、解向量等）连接。这种架构的好处是：

0. 模块解耦：每个模块可以独立开发、测试和升级。比如，更换网格生成算法不会影响求解器和后处理模块。
1. 可替换性强：用户可以用自己的网格工具生成网格，然后导入系统进行求解；也可以用第三方后处理工具（如 ParaView）来可视化结果。
2. 易于调试：当结果有问题时，可以分别检查每个阶段的输出，快速定位问题所在。

结果后处理与可视化模块虽然不直接参与求解计算，但它是用户与系统交互的主要界面。一个好的后处理模块应该具备以下功能：

0. 温度场可视化：云图（contour plot）、等温面、切片图等，可以直观展示温度分布。
1. 时间历程曲线：对于瞬态问题，展示关键点温度随时间的变化。
2. 数据探针：用户可以在模型上点击任意位置，查看该点的温度、热流等数据。
3. 统计分析：最大/最小温度、平均温度、温度直方图、温度梯度分布等。
4. 结果导出：支持多种格式的导出（VTK、CSV、图像、视频等），方便用户进行后续分析或报告制作。

在光电仿真的上下文中，热求解结果的后处理还有一个特殊的功能------生成红外辐射特性数据。也就是说，将温度场转化为表面的光谱辐射出射度，然后提供给光学仿真模块使用。这是热-光耦合的关键接口，我们将在下一节详细讨论。

8.6 架构设计：热求解与光学求解的耦合方式

热特性求解和光学仿真是光电仿真链条中两个紧密相关的环节。热求解得到的温度场是光学仿真的输入（决定目标的红外辐射强度），而光学仿真的结果（如表面吸收的辐射能量）又可能反过来影响温度场。因此，热求解与光学求解的耦合方式是光电仿真引擎架构设计中的一个重要问题。

根据耦合的紧密程度，可以分为三种模式：单向耦合（One-Way Coupling） 、迭代耦合（Iterative Coupling） 和 全耦合（Full Coupling） 。

单向耦合是最简单的耦合方式。其流程是：先独立完成热求解，得到目标的温度场分布；然后将温度场作为已知条件输入光学求解器，计算目标的红外辐射和成像效果。两个求解过程依次进行，中间只有一次数据传递。

单向耦合的适用场景：

• 热辐射对温度场的影响可以忽略时。比如，目标温度主要由内热源和对流决定，辐射换热的比例很小。
• 太阳辐射的加热效应已经在热边界条件中用简化方法（如直接给定太阳辐照度）考虑了，不需要光学求解器来计算。
• 精度要求不高的快速仿真。

单向耦合的优点是实现简单、计算效率高。缺点是没有考虑光学效应对温度的反馈，在某些情况下可能引入明显的误差。比如，当目标表面有强反射/强吸收的涂层时，表面对太阳辐射和环境辐射的吸收分布需要通过光线追踪才能精确计算，而用均匀的辐照度假设就不够准确了。

迭代耦合是指热求解和光学求解交替进行，直到两者的结果都收敛。具体流程是：

0. 给定初始温度场 T₀
1. 用当前温度场 T_k 进行光学求解，得到表面的辐射加热/冷却分布 q_k
2. 将 q_k 作为热边界条件，进行热求解，得到新的温度场 T_{k+1}
3. 检查温度变化是否小于收敛容差，如果是则结束，否则返回步骤 2

迭代耦合考虑了热-光之间的相互影响，精度比单向耦合高。它适用于以下场景：

• 辐射换热占主导地位的场景（如真空环境、高温场景）。
• 表面辐射特性空间分布不均匀，需要通过光学计算来精确获取表面的入射辐射分布。
• 存在多次反射、聚焦等复杂辐射效应的场景。

迭代耦合的收敛速度取决于两个场之间的耦合强度。对于弱耦合问题，可能只需要 2~3 次迭代就能收敛；对于强耦合问题，可能需要更多次迭代。为了加速收敛，可以采用亚松弛（under-relaxation）或艾特肯加速（Aitken acceleration）等技术。

全耦合是指将热传导方程和辐射传输方程组合成一个统一的方程组，同时求解。全耦合的精度最高，但实现难度也最大，计算量也最大。在工程实践中，全耦合的应用相对较少，大多数情况下迭代耦合已经足够精确。

在光电仿真引擎的架构设计中，我们通常采用迭代耦合 作为标准方案，同时支持单向耦合作为快速模式。以下是耦合管理器的设计框架：

// thermal_optical_coupler.h
#pragma once
#include <memory>
#include <functional>

namespace opto_engine {

// 前向声明
namespace thermal { class ThermalAnalysisSystem; }
namespace optical { class OpticalRadiationSolver; }

namespace coupling {

// 耦合模式
enum class CouplingMode {
    ONE_WAY,         // 单向耦合：热 → 光
    ITERATIVE,       // 迭代耦合：热 ↔ 光
    FULL             // 全耦合（预留接口）
};

// 耦合收敛参数
struct CouplingConvergence {
    double temperature_tolerance = 0.1;  // 温度收敛容差 (K)
    double radiance_tolerance = 0.5;     // 辐射亮度收敛容差 (%)
    int max_iterations = 10;             // 最大耦合迭代次数
};

// 热-光耦合管理器
class ThermalOpticalCoupler {
public:
    ThermalOpticalCoupler(
        std::shared_ptr<thermal::ThermalAnalysisSystem> thermal_sys,
        std::shared_ptr<optical::OpticalRadiationSolver> optical_solver
    );
    
    ~ThermalOpticalCoupler();
    
    // 设置耦合模式
    void setMode(CouplingMode mode) { mode_ = mode; }
    CouplingMode getMode() const { return mode_; }
    
    // 设置收敛参数
    void setConvergenceParams(const CouplingConvergence& params) {
        convergence_ = params;
    }
    
    // 执行耦合求解
    bool solve();
    
    // 获取耦合迭代历史（用于分析收敛行为）
    const std::vector<double>& getIterationMaxDeltaT() const {
        return delta_T_history_;
    }
    
    // 耦合迭代回调：每完成一次迭代调用一次
    using IterationCallback = std::function<void(int iter, double max_delta_T)>;
    void setIterationCallback(IterationCallback cb) { iteration_cb_ = cb; }
    
private:
    std::shared_ptr<thermal::ThermalAnalysisSystem> thermal_sys_;
    std::shared_ptr<optical::OpticalRadiationSolver> optical_solver_;
    
    CouplingMode mode_ = CouplingMode::ONE_WAY;
    CouplingConvergence convergence_;
    std::vector<double> delta_T_history_;
    IterationCallback iteration_cb_;
    
    // 单向耦合求解
    bool solveOneWay();
    
    // 迭代耦合求解
    bool solveIterative();
    
    // 数据传递：热 → 光（温度场 → 表面辐射发射）
    void transferThermalToOptical();
    
    // 数据传递：光 → 热（表面吸收辐射 → 热边界条件修正）
    void transferOpticalToThermal();
    
    // 计算两次迭代之间的最大温度差
    double computeMaxTemperatureDelta(
        const std::vector<double>& T_old,
        const std::vector<double>& T_new) const;
};

} // namespace coupling
} // namespace opto_engine

这个耦合管理器的设计体现了几个重要的架构原则。首先是松耦合（Loose Coupling） ：热求解系统和光学求解器通过耦合管理器进行交互，它们之间不直接依赖。也就是说，热求解系统不需要知道光学求解器的存在，光学求解器也不需要知道热求解系统的存在。两者都只依赖于标准的数据接口（温度场、表面热流等）。这种设计使得两个子系统可以独立开发和测试，也方便将来替换其中的任何一个。

其次是单一职责原则：耦合管理器只负责协调两个求解器的交互和数据传递，不涉及具体的求解算法。热怎么算、光怎么算，是各自子系统的事情。耦合管理器的核心职责是控制迭代流程和管理数据交换。

第三，可观测性：耦合管理器提供了迭代历史记录和回调接口，让用户可以监控耦合过程的收敛行为。这对于调试和性能优化非常重要。比如，如果发现迭代收敛很慢，用户可以通过观察 delta_T 的变化曲线来判断是否需要调整松弛因子或更换耦合策略。

在实际工程中，还有一个重要的问题需要考虑：数据映射（Data Mapping） 。热求解的网格和光学求解的网格通常是不一样的。热求解可能使用较粗的有限元网格（因为温度场变化相对平缓），而光学求解可能使用较密的曲面网格（因为需要精确计算辐射和几何细节）。因此，在数据传递时，需要进行网格之间的插值映射。

比如，从热到光的数据传递，需要将有限元节点上的温度值插值到光学曲面的顶点或面片上。从光到热的数据传递，需要将光学面元上的热流密度映射到热网格的边界节点上。这个映射过程必须保证能量守恒（至少近似守恒），否则可能引入额外的误差。

常用的数据映射方法包括：

0. 最近点映射：最简单，但不守恒，适用于精度要求不高的场景。
1. 投影插值：将源网格的面元投影到目标网格上，按面积加权分配。精度较高，也近似守恒。
2. 守恒映射：基于约束优化的方法，严格保证能量守恒，但计算量较大。

在架构设计上，我们将数据映射功能封装为独立的 DataMapper 组件，供耦合管理器调用。这样，映射算法的改进不会影响耦合流程的控制逻辑。

最后，从架构师的角度来看，热-光耦合系统的设计还要考虑可扩展性。未来可能需要加入更多的物理场（如结构应力、气动加热等），耦合管理器的设计应该能够方便地扩展到多物理场耦合的场景。这时候，采用更通用的耦合框架（如基于协同学的非线性耦合求解器、或者基于算子分裂的模块化耦合框架）可能是更好的选择。

---

第9章 环境与背景辐射建模

9.1 太阳辐射建模：太阳光谱、太阳辐照度、太阳角度计算

太阳是光电仿真中最重要的环境辐射源之一。在可见光和近红外波段，太阳辐射是场景照明的主要来源；在红外波段，太阳辐射是目标白天加热的主要能量输入。准确的太阳辐射建模，对于可见光/近红外场景的逼真度和红外场景的温度计算精度都至关重要。

太阳光谱是太阳辐射的基本属性。在大气上界（大气质量为0，即 AM0），太阳的光谱辐照度与 5777 K 黑体的辐射光谱非常接近。太阳常数（Solar Constant）定义为日地平均距离处，垂直于太阳光的单位面积上接收到的太阳总辐照度，其值约为 1361 W/m²（最近的卫星测量结果）。

太阳光谱的具体分布可以用多种模型来表示：

• 黑体近似：最简单的模型，用 5800 K 普朗克函数来近似太阳光谱。优点是计算简单，缺点是在某些波段（如紫外、可见光的精细结构）误差较大。
• ASTM G173 标准光谱：美国材料与试验协会发布的标准太阳光谱，包括 AM0（大气上界）和 AM1.5G（地面，空气质量 1.5，全球倾斜面）两种。这是光伏和太阳能领域最常用的标准光谱。
• MODTRAN 内置太阳光谱：MODTRAN 等辐射传输模型内置了高分辨率的太阳光谱，包括夫琅禾费吸收线的精细结构。
• LOWTRAN 太阳光谱：低分辨率的太阳光谱，适用于宽带计算。

在光电仿真引擎中，太阳光谱通常以查找表的形式存储------波长与对应辐照度的一一对应关系。使用时，根据需要的波长范围和分辨率进行插值。以下是太阳光谱模块的设计：

// solar_spectrum.h
#pragma once
#include <vector>
#include <string>

namespace opto_engine {
namespace environment {

// 太阳光谱类型
enum class SolarSpectrumType {
    BLACKBODY_5800K,      // 5800K黑体近似
    ASTM_G173_AM0,        // ASTM G173 AM0（大气上界）
    ASTM_G173_AM15G,      // ASTM G173 AM1.5 Global
    MODTRAN_HIGH_RES,     // MODTRAN高分辨率太阳光谱
    LOWTRAN_LOW_RES       // LOWTRAN低分辨率太阳光谱
};

// 太阳光谱数据库
class SolarSpectrumDB {
public:
    static SolarSpectrumDB& instance();
    
    // 获取指定类型的太阳光谱
    const std::vector<std::pair<double, double>>& 
        getSpectrum(SolarSpectrumType type) const;
    
    // 获取指定波长处的光谱辐照度（AM0，单位：W/(m²·μm)）
    double getIrradiance(double wavelength_um, 
                         SolarSpectrumType type = SolarSpectrumType::ASTM_G173_AM0) const;
    
    // 获取指定波段内的积分辐照度（W/m²）
    double getIntegratedIrradiance(double wl_min_um, double wl_max_um,
                                    SolarSpectrumType type = SolarSpectrumType::ASTM_G173_AM0) const;
    
    // 加载自定义太阳光谱文件
    bool loadCustomSpectrum(const std::string& filepath);
    
private:
    SolarSpectrumDB();
    void buildBuiltInSpectra();
    
    // 内置光谱数据
    std::vector<std::pair<double, double>> blackbody_5800k_;
    std::vector<std::pair<double, double>> astm_am0_;
    std::vector<std::pair<double, double>> astm_am15g_;
    std::vector<std::pair<double, double>> modtran_highres_;
    std::vector<std::pair<double, double>> lowtran_lowres_;
};

} // namespace environment
} // namespace opto_engine

太阳角度计算是太阳辐射建模的另一个核心内容。太阳在天空中的位置决定了：

• 表面接收到的太阳直接辐照度（入射角余弦效应）
• 阴影的方向和长度
• 大气质量（太阳天顶角越大，光穿过的大气路径越长）
• 场景的光照方向和光影效果

太阳位置的计算需要以下输入参数：

• 地理纬度（Latitude）
• 地理经度（Longitude）
• 日期（年积日 Day of Year 或 具体日期）
• 时间（地方时或世界时）

太阳位置的计算涉及几个天文学参数：

0. 赤纬角（Declination, δ） ：太阳光线与地球赤道面的夹角，在一年中在 ±23.45° 之间变化。常用 Cooper 公式计算：

   \delta = 23.45^\circ \cdot \sin\left( \frac{360^\circ}{365} (284 + N) \right)

   其中 N 是年积日（1月1日 N=1）。

1. 时角（Hour Angle, ω） ：当前时间与正午的时间差对应的角度，每小时 15°。上午为负，下午为正。

   \omega = 15^\circ \cdot (ST - 12)

   其中 ST 是真太阳时。

2. 太阳天顶角（Solar Zenith Angle, θ_z） ：太阳方向与天顶方向的夹角。

   \cos\theta_z = \sin\phi \sin\delta + \cos\phi \cos\delta \cos\omega

   其中 φ 是地理纬度。

3. 太阳方位角（Solar Azimuth Angle, γ_s） ：太阳在水平面上的投影与正南方向的夹角（从正南向西为正，或从北向东为正，不同定义需注意区分）。

   \cos\gamma_s = \frac{\sin\delta - \sin\phi \cos\theta_z}{\cos\phi \sin\theta_z}

更精确的太阳位置计算还需要考虑：

• 时差（Equation of Time, EOT） ：由于地球轨道偏心率和黄赤交角的影响，真太阳时与平太阳时之间存在偏差，最大可达约 16 分钟。
• 大气折射修正：在地平线附近，大气折射会使太阳的视位置比实际位置高约 0.5°。
• 日地距离修正：地球轨道是椭圆，日地距离在一年中变化约 3.3%，因此太阳常数也有相应的变化。

以下是太阳位置计算器的实现框架：

// solar_position.h
#pragma once

namespace opto_engine {
namespace environment {

// 太阳位置结果
struct SolarPosition {
    double zenith_angle_deg;    // 天顶角 (度)，0=天顶，90=地平线
    double azimuth_angle_deg;   // 方位角 (度)，0=正北，顺时针增加
    double elevation_deg;       // 高度角 (度)，90-天顶角
    double air_mass;            // 大气质量（相对大气质量）
    
    double declination_deg;     // 赤纬角 (度)
    double hour_angle_deg;      // 时角 (度)
    double equation_of_time_min; // 时差 (分钟)
    double earth_sun_distance_ratio; // 日地距离与平均距离之比
};

// 太阳位置计算器
class SolarPositionCalculator {
public:
    // 计算太阳位置
    // year: 年份，month: 月份 (1-12)，day: 日期 (1-31)
    // hour: 小时 (0-23，世界时UTC)，minute: 分钟，second: 秒
    // latitude_deg: 纬度 (度，北正南负)
    // longitude_deg: 经度 (度，东正西负)
    static SolarPosition compute(
        int year, int month, int day,
        double hour_utc, double minute, double second,
        double latitude_deg, double longitude_deg
    );
    
    // 简化版：用年积日和小时计算
    static SolarPosition computeSimple(
        int day_of_year,
        double hour_local,
        double latitude_deg,
        double longitude_deg
    );
    
    // 计算日出日落时间（地方时）
    static void computeSunriseSunset(
        int day_of_year,
        double latitude_deg,
        double& sunrise_hour,
        double& sunset_hour
    );
    
    // 计算大气质量（相对值，天顶方向为1）
    // 使用 Kasten-Young 公式
    static double computeAirMass(double zenith_angle_deg);
    
private:
    // 计算年积日
    static int dayOfYear(int year, int month, int day);
    
    // 计算赤纬角（Cooper公式）
    static double declination(int day_of_year);
    
    // 计算时差（Spencer公式，更精确）
    static double equationOfTime(int day_of_year);
    
    // 计算日地距离修正因子
    static double earthSunDistanceFactor(int day_of_year);
};

} // namespace environment
} // namespace opto_engine

太阳位置计算虽然原理不复杂，但细节很多------不同的精度等级、不同的近似公式、不同的角度定义约定。在引擎实现中，我们通常提供两个版本：快速版 （简化公式，精度约 0.5°，用于实时仿真）和精确版（SPA 算法或类似，精度约 0.0003°，用于高精度离线仿真）。用户可以根据需求选择。

大气质量（Air Mass）是一个重要的衍生参数，它表示太阳光穿过大气的路径长度与天顶方向路径长度的比值。最简单的近似是 AM = 1/cos(θ_z)，但这个公式在大天顶角时（接近地平线）会发散，因为它忽略了地球的曲率。更精确的 Kasten-Young 公式为：

AM = \frac{1}{\cos\theta_z + 0.50572 \cdot (96.07995 - \theta_z)^{-1.6364}}

其中 θ_z 以度为单位。这个公式在天顶角 0°~90° 范围内都能给出合理的结果。

9.2 天空背景辐射：晴空模型、云的影响、天空亮度分布

天空背景辐射是光电仿真中背景辐射的重要组成部分。对于可见光和近红外成像，天空背景的亮度决定了场景的整体光照水平和对比度；对于红外成像，天空背景的热辐射会影响目标与背景的对比度，并且是路径辐射的重要来源。

晴空模型（Clear Sky Model） 是天空背景辐射建模的基础。在晴空条件下，天空的辐射来自两个部分：

0. 太阳光的散射：大气分子和气溶胶粒子对太阳光的散射，是可见光波段天空亮度的主要来源。瑞利散射导致短波（蓝光）散射更强，所以天空呈现蓝色。
1. 大气自身的热发射：大气分子和水汽的热辐射，是红外波段天空辐射的主要来源。

对于可见光/近红外波段的天空亮度分布，有多个经典模型：

• CIE 标准天空模型：国际照明委员会（CIE）定义的一系列标准天空亮度分布，包括 CIE 标准晴天空、CIE 标准阴天空、以及多种中间状态的天空类型。CIE 模型用相对亮度分布函数来描述天空各点的亮度与天顶亮度的比值：

  \frac{L(\theta, \gamma)}{L_z} = \frac{f(\theta, \gamma) \cdot \phi(\gamma)}{f(0, \gamma_s) \cdot \phi(0)}

  其中 θ 是天空点的天顶角，γ 是天空点与太阳的角距离，γ_s 是太阳天顶角，f 是散射指示函数，φ 是渐变函数。CIE 共定义了 15 种标准天空类型，用户可以根据天气条件选择。

• Perez 模型：由 Perez 等人提出的全晴天空亮度模型，考虑了太阳位置、大气质量、亮度和浑浊度等参数，精度较高，在建筑采光和太阳能领域应用广泛。

• Hosek-Wilkie 模型：一种现代的天空亮度模型，专门为实时图形学应用设计。它将天空亮度表示为一组基函数的线性组合，计算速度快，视觉效果好，在游戏和虚拟现实中广泛使用。

对于红外波段的天空辐射，常用的模型包括：

• 等效黑体模型：将整个天空等效为一个温度均匀的黑体，用天空有效温度 T_sky 来表示。这种模型最简单，但忽略了天空辐射的角度分布。
• 大气辐射传输模型：如 MODTRAN，可以精确计算不同天顶角和不同波长下的天空辐射亮度。这是精度最高的方法，但计算量也最大。
• 经验公式模型：如 Swinbank 公式、Brutsaert 公式（见第8章），用环境温度和水汽压来估算天空的有效发射率或有效温度。

以下是天空背景辐射模块的设计：

// sky_radiance.h
#pragma once
#include <vector>
#include <functional>

namespace opto_engine {
namespace environment {

// 天空模型类型
enum class SkyModelType {
    CIE_CLEAR,              // CIE 标准晴空
    CIE_OVERCAST,           // CIE 标准阴天
    PEREZ,                  // Perez 模型
    HOSEK_WILKIE,           // Hosek-Wilkie 模型（可见光实时渲染）
    MODTRAN_SKY,            // MODTRAN 精确计算（红外）
    EFFECTIVE_BLACKBODY     // 等效黑体模型（红外简化）
};

// 天空光谱辐射亮度计算结果
struct SkyRadianceResult {
    std::vector<double> wavelengths;       // 波长 (μm)
    std::vector<double> radiance;          // 光谱辐射亮度 (W/(m²·sr·μm))
};

// 天空背景辐射计算器
class SkyRadianceCalculator {
public:
    SkyRadianceCalculator();
    ~SkyRadianceCalculator();
    
    // 设置天空模型
    void setModel(SkyModelType type) { model_type_ = type; }
    SkyModelType getModel() const { return model_type_; }
    
    // 设置太阳位置
    void setSolarPosition(double solar_zenith_deg, double solar_azimuth_deg) {
        solar_zenith_ = solar_zenith_deg;
        solar_azimuth_ = solar_azimuth_deg;
    }
    
    // 设置大气参数
    void setAtmosphereParams(double turbidity = 2.0, 
                             double visibility_km = 23.0,
                             double ground_albedo = 0.2) {
        turbidity_ = turbidity;
        visibility_ = visibility_km;
        ground_albedo_ = ground_albedo;
    }
    
    // 设置气象参数（用于红外模型）
    void setWeatherParams(double ambient_temp_K = 290.0,
                          double relative_humidity = 0.6,
                          double cloud_cover = 0.0) {
        ambient_temp_ = ambient_temp_K;
        humidity_ = relative_humidity;
        cloud_cover_ = cloud_cover;
    }
    
    // 计算指定方向的天空光谱辐射亮度
    // zenith_deg: 观测方向天顶角
    // azimuth_deg: 观测方向方位角
    SkyRadianceResult computeRadiance(
        double zenith_deg,
        double azimuth_deg,
        const std::vector<double>& wavelengths
    ) const;
    
    // 计算可见光波段的天空亮度（积分值）
    double computeVisibleLuminance(double zenith_deg, 
                                    double azimuth_deg) const;
    
    // 计算长波红外波段的天空有效辐射温度
    double computeEffectiveSkyTemperature(double zenith_deg) const;
    
    // 计算整个天空半球的向下辐照度（单位面积接收到的总天空辐射）
    double computeSkyIrradiance(double wavelength_min_um,
                                 double wavelength_max_um) const;
    
private:
    SkyModelType model_type_ = SkyModelType::CIE_CLEAR;
    
    // 太阳位置
    double solar_zenith_ = 45.0;
    double solar_azimuth_ = 180.0;
    
    // 大气参数
    double turbidity_ = 2.0;
    double visibility_ = 23.0;
    double ground_albedo_ = 0.2;
    
    // 气象参数
    double ambient_temp_ = 290.0;
    double humidity_ = 0.6;
    double cloud_cover_ = 0.0;
    
    // CIE 天空模型的相对亮度计算
    double cieRelativeLuminance(double zenith_deg, double gamma_deg,
                                 int sky_type) const;
    
    // Perez 模型计算
    double perezRadiance(double zenith_deg, double azimuth_deg,
                          double wavelength_um) const;
    
    // Hosek-Wilkie 模型计算
    double hosekWilkieRadiance(double zenith_deg, double azimuth_deg,
                                double wavelength_um) const;
    
    // 等效黑体模型计算红外辐射
    double effectiveBlackbodyRadiance(double zenith_deg, 
                                       double wavelength_um) const;
    
    // 云层修正：根据云量调整天空辐射
    double cloudCorrection(double cloud_cover, double zenith_deg) const;
};

} // namespace environment
} // namespace opto_engine

云的影响是天空辐射建模中不可忽视的因素。云层对天空辐射的影响主要体现在以下几个方面：

0. 对可见光的影响：云层增加了太阳散射，使天空的漫射辐射增加。阴天时，整个天空的亮度比较均匀，没有明显的太阳方向；薄云时，太阳仍然可见但被柔化。
1. 对红外的影响：云层本身具有较高的温度（接近环境温度）和很高的发射率（接近 1），因此阴天的天空有效红外辐射温度比晴天高得多。这也是为什么阴天夜晚比晴天夜晚暖和的原因------云层像一床被子，阻挡了地面的辐射冷却。
2. 对太阳直接辐射的影响：云层会吸收和散射太阳直接辐射，使到达地面的 DNI 大幅减少。厚云可以完全阻挡直射阳光。

在工程模型中，云量（Cloud Cover）通常用 01 的小数或 010 的数字来表示。天空辐射的云量修正可以用简单的线性插值或更复杂的经验公式来实现。比如，对于长波红外的天空有效温度，可以用下式估算：

T_{sky,cloudy} = T_{sky,clear} + (T_{amb} - T_{sky,clear}) \cdot C^k

其中 C 是云量（01），k 是经验指数（通常取 1.52.0）。当 C=0 时，退化为晴空温度；当 C=1 时，天空温度接近环境温度。

9.3 地表背景辐射：地表温度、地表发射率、地表反射

地表是光电仿真场景中另一个重要的背景辐射源。对于地面目标的仿真，地表既是背景（占据图像的大部分像素），也是环境交互的介质（目标与地表之间存在辐射和对流换热）。

地表背景辐射包括三部分：

0. 地表自身的热发射：在中波和长波红外波段占主导地位
1. 地表对太阳辐射的反射：在可见光和近红外波段占主导地位
2. 地表对天空辐射的反射：在所有波段都有贡献，但通常占比较小

地表温度是决定地表红外辐射的关键参数。地表温度的时空变化非常复杂，受以下因素影响：

• 太阳辐射的日变化和季节变化
• 地表类型（土壤、岩石、植被、水体、冰雪等）
• 土壤湿度和含水量
• 风速和环境温度
• 地形（坡度、坡向、海拔）
• 云量和大气条件

在光电仿真中，地表温度的建模有多种方法，精度从低到高依次为：

0. 经验公式法：用简单的经验公式估算地表温度的日变化。比如，假设地表温度在一天中呈正弦变化，最高温出现在下午 2 点左右，最低温出现在日出前后。这种方法最简单，但精度有限。

1. 热平衡法：基于地表的能量平衡方程来计算地表温度。地表的能量平衡方程为：

   (1 - \alpha_s) G_{solar} + L_{down} = \varepsilon \sigma T_s^4 + H + LE + G

   左边是吸收的能量：太阳短波辐射（减去反射）+ 向下的大气长波辐射 右边是失去的能量：地表热辐射 + 感热通量（对流）+ 潜热通量（蒸发）+ 土壤热通量

   通过求解这个方程（通常迭代求解，因为 T_s 出现在四次方项中），可以得到地表温度。这种方法的物理基础更扎实，精度也更高。

2. 数值模型法：用一维或三维的土壤热传导模型来计算地表温度和土壤温度廓线。这种方法精度最高，但需要的输入参数也最多（土壤热物性、湿度剖面等），计算量也最大。

以下是地表温度计算模块的设计：

// surface_temperature.h
#pragma once
#include <vector>
#include <string>

namespace opto_engine {
namespace environment {

// 地表类型
enum class SurfaceType {
    GRASS,          // 草地
    SOIL_DRY,       // 干燥土壤
    SOIL_WET,       // 湿润土壤
    ASPHALT,        // 沥青路面
    CONCRETE,       // 混凝土
    SAND,           // 沙地
    ROCK,           // 岩石
    WATER,          // 水体
    SNOW,           // 积雪
    FOREST_DECIDUOUS,  // 落叶林
    FOREST_CONIFEROUS, // 针叶林
    CUSTOM          // 自定义
};

// 地表热特性参数
struct SurfaceThermalProperties {
    double solar_absorptivity = 0.7;     // 太阳吸收率
    double thermal_emissivity = 0.95;    // 热红外发射率
    double thermal_conductivity = 1.0;   // 表层热导率 W/(m·K)
    double volumetric_heat_capacity = 1.5e6; // 体积热容 J/(m³·K)
    double albedo = 0.2;                 // 反照率（太阳波段反射率）
};

// 地表温度计算器
class SurfaceTemperatureModel {
public:
    SurfaceTemperatureModel();
    ~SurfaceTemperatureModel();
    
    // 设置地表类型
    void setSurfaceType(SurfaceType type);
    void setCustomProperties(const SurfaceThermalProperties& props);
    
    // 设置环境条件
    void setEnvironment(double ambient_temp_K, double wind_speed_m_s,
                        double relative_humidity, double pressure_kPa);
    
    // 设置太阳辐照度
    void setSolarIrradiance(double direct_normal, double diffuse_horizontal);
    
    // 设置天空长波辐射
    void setSkyLongwaveRadiation(double sky_irradiance_Wm2);
    
    // 简化模型：估算某时刻的地表温度（正弦日变化）
    double estimateSimple(int hour, int minute,
                          double T_max_day, double T_min_night) const;
    
    // 能量平衡模型：计算稳态地表温度
    double computeEnergyBalance(double solar_incident_angle_cos) const;
    
    // 全瞬态模型：计算一天内地表温度的变化
    std::vector<std::pair<double, double>> computeDailyCycle(
        int day_of_year,
        double latitude_deg,
        double longitude_deg,
        int time_steps_per_day = 96  // 默认每15分钟一个点
    );
    
    // 获取地表特性参数
    const SurfaceThermalProperties& getProperties() const { return props_; }
    
private:
    SurfaceType surface_type_ = SurfaceType::GRASS;
    SurfaceThermalProperties props_;
    
    // 环境参数
    double ambient_temp_ = 290.0;
    double wind_speed_ = 2.0;
    double humidity_ = 0.6;
    double pressure_ = 101.325;
    
    // 辐射参数
    double solar_dni_ = 800.0;
    double solar_dhi_ = 150.0;
    double sky_lw_irradiance_ = 300.0;
    
    // 初始化各类型地表的默认参数
    void initDefaultProperties();
    
    // 计算感热通量（对流换热）
    double computeSensibleHeatFlux(double T_surface, double T_air) const;
    
    // 计算潜热通量（蒸发）
    double computeLatentHeatFlux(double T_surface, double T_air,
                                  double relative_humidity) const;
    
    // 计算土壤热通量
    double computeSoilHeatFlux(double T_surface, double T_deep,
                                double soil_conductivity, double depth) const;
    
    // 能量平衡残差函数（用于牛顿迭代求解）
    double energyBalanceResidual(double T_surface, double cos_solar_zenith) const;
};

} // namespace environment
} // namespace opto_engine

地表发射率是决定地表红外辐射特性的另一个重要参数。不同类型的地表具有不同的发射率：

• 水体：约 0.96~0.99（很高）
• 植被：约 0.95~0.98（很高）
• 土壤：约 0.90~0.96（取决于湿度，湿土发射率更高）
• 岩石：约 0.85~0.95（取决于岩石类型）
• 金属：很低（抛光金属可低至 0.05），但自然界中很少见
• 冰雪：约 0.85~0.95（新雪发射率高，陈雪较低）

大多数自然地表的发射率都很高（> 0.9），因此在很多工程近似中可以假设地表为灰体，发射率取 0.95。但如果需要更高的精度，特别是在中波红外波段，发射率的光谱变化就不能忽略了。

地表反射率（反照率） 决定了地表对太阳辐射的反射能力。反照率同样与地表类型密切相关：

• 新雪：0.8~0.9（很高）
• 干沙：0.3~0.4
• 草地：0.2~0.3
• 森林：0.1~0.2（很低）
• 水体：0.05~0.1（太阳高度角大时很低，接近地平线时很高）
• 沥青：0.05~0.1
• 混凝土：0.3~0.4

反照率的光谱依赖性也是一个重要的考虑因素。比如，植被在可见光波段的反照率很低（叶绿素吸收），但在近红外波段的反照率很高（叶片内部结构散射）。这种"红边效应"是植被遥感的重要特征。在高光谱仿真中，必须考虑反照率的光谱变化。

9.4 路径辐射：大气自身的热辐射与散射

路径辐射（Path Radiance）是指观测路径上的大气自身发射和散射的辐射，它直接进入传感器，构成了图像的背景噪声（或背景信号）。路径辐射是降低目标对比度、影响探测距离的重要因素。

路径辐射由两部分组成：

0. 大气热发射（Thermal Emission Path Radiance） ：大气中的气体分子和气溶胶粒子在自身温度下的热辐射。在热红外波段（814 μm 和 35 μm），大气热发射是路径辐射的主要来源。大气越热、越厚，热发射路径辐射越强。
1. 散射路径辐射（Scattering Path Radiance） ：大气分子和气溶胶将太阳辐射、地面辐射等散射到观测方向的部分。在可见光和近红外波段，太阳散射是路径辐射的主要来源。在红外波段，散射路径辐射通常远小于热发射，可以忽略。

路径辐射的精确计算需要求解辐射传输方程（见第7章），计算量较大。但在工程应用中，我们可以用一些简化方法来估算：

对于可见光/近红外波段的散射路径辐射，常用的近似公式为：

L_{path}(\lambda) = \frac{\omega(\lambda) \cdot F_0(\lambda) \cdot \cos\theta_s \cdot \tau_r(\lambda) \cdot P(\cos\Theta)}{4\pi \mu} \cdot (1 - e^{-\tau(\lambda)/\mu})

其中 F₀ 是大气上界的太阳光谱辐照度，θs 是太阳天顶角，τr 是反射率（或单次散射反照率相关量），P 是散射相函数，Θ 是太阳光方向与观测方向的夹角，μ 是观测天顶角的余弦，τ 是大气光学厚度。

这个公式的物理意义是：路径辐射来自于太阳光在大气中的单次散射。多次散射的贡献更复杂，通常需要用更精确的模型（如 DISORT）来计算。

对于热红外波段的大气热发射路径辐射，在局地热平衡和灰体近似下，可以表示为：

L_{path}^{thermal}(\lambda) = \int_0^R \alpha_\lambda(s) B_\lambda(T(s)) \cdot \tau_\lambda(s, R) ds

其中 αλ(s) 是距离 s 处的吸收系数，Bλ(T) 是普朗克函数，τ_λ(s, R) 是从 s 到 R 的透过率（即 s 处的辐射在到达传感器之前还要经过 R-s 距离的大气衰减）。

这个积分的物理意义很直观：路径上每一个气元 ds 都会发射热辐射，但其辐射在到达传感器的路上会被剩余路径的大气吸收和散射衰减，因此需要乘上从该点到传感器的透过率。

在均匀大气（温度和吸收系数不随位置变化）的简化假设下，路径辐射可以简化为：

L_{path}^{thermal}(\lambda) = B_\lambda(T) \cdot (1 - \tau_\lambda)

其中 τ_λ 是整条路径的透过率。这个公式很有用------它告诉我们，路径辐射等于大气温度对应的黑体辐射乘以（1 - 透过率）。透过率越低（大气越不透明），路径辐射越强，极限情况下（τ=0，完全不透明），路径辐射等于黑体辐射，目标被完全淹没在大气辐射中。

在引擎架构设计中，路径辐射的计算通常集成在大气传输模块中（见第7章），作为大气计算结果的一部分返回。这样，光学渲染模块在计算像素辐射亮度时，可以直接将路径辐射加到目标辐射（经过大气衰减后）上：

L_{sensor} = L_{target} \cdot \tau + L_{path}

这是一个非常重要的公式，它描述了辐射从目标出发、穿过大气、到达传感器的整个过程：目标辐射被大气衰减了 τ 倍，同时叠加了大气自身的路径辐射 L_path。

9.5 环境参数系统：经纬度、时间、气象参数的管理

前面几节讨论了太阳、天空、地表、路径辐射等各种环境辐射模型。这些模型都依赖于一系列环境参数，如地理位置（经纬度）、时间（日期和时刻）、气象参数（温度、湿度、风速、云量等）。如果这些参数分散在各个模块中，管理起来会非常混乱，也容易导致参数不一致的问题。

因此，一个完善的光电仿真引擎需要一个统一的环境参数管理系统，负责集中管理所有环境相关的参数，并提供统一的访问接口。各个子模块（太阳计算、天空辐射、地表温度、大气传输等）都从这个统一的环境系统中获取参数，而不是各自维护一套。

环境参数管理系统的设计需要考虑以下几个方面：

0. 参数分类与组织：将环境参数按类别组织（地理位置、时间、气象、大气、地表等），便于管理和查找。
1. 时间演化：环境参数通常是随时间变化的（如太阳位置、环境温度的日变化）。系统需要支持时间推进和参数的时间插值。
2. 参数来源：支持多种参数输入方式------手动输入、文件导入、实时气象数据接入、标准模型生成等。
3. 参数一致性：确保所有子模块使用的是同一套环境参数，避免出现"太阳位置模块用的是12点，温度模块用的是14点"之类的不一致问题。
4. 场景脚本支持：支持通过脚本定义环境参数随时间的变化（如"日出到日落，温度从10°C升到25°C，风速从1 m/s增加到3 m/s"）。

以下是环境参数管理系统的设计框架：

// environment_system.h
#pragma once
#include <string>
#include <vector>
#include <functional>
#include <memory>
#include "solar_position.h"
#include "sky_radiance.h"
#include "surface_temperature.h"
#include "../atmosphere/atmosphere_profile.h"

namespace opto_engine {
namespace environment {

// 地理位置
struct GeoLocation {
    double latitude_deg;     // 纬度（北正南负）
    double longitude_deg;    // 经度（东正西负）
    double altitude_m;       // 海拔高度 (m)
    std::string name;        // 地点名称（可选）
};

// 时间信息
struct TimeInfo {
    int year;
    int month;
    int day;
    double hour_utc;         // UTC 小时（含小数，如 12.5 = 12:30）
    
    // 计算年积日
    int dayOfYear() const;
    
    // 获取本地时间（根据经度计算）
    double localHour(double longitude_deg) const;
};

// 气象参数
struct WeatherParameters {
    double ambient_temp_K = 290.0;      // 环境温度 (K)
    double relative_humidity = 0.6;     // 相对湿度 (0-1)
    double wind_speed_m_s = 2.0;        // 风速 (m/s)
    double wind_direction_deg = 0.0;    // 风向 (度，从北顺时针)
    double pressure_kPa = 101.325;      // 大气压 (kPa)
    double cloud_cover = 0.0;           // 云量 (0-1)
    double visibility_km = 23.0;        // 能见度 (km)
    double precipitation_mm_h = 0.0;    // 降水量 (mm/h)
};

// 环境系统：统一管理所有环境参数
class EnvironmentSystem {
public:
    EnvironmentSystem();
    ~EnvironmentSystem();
    
    // ========== 参数设置 ==========
    
    // 设置地理位置
    void setLocation(double latitude_deg, double longitude_deg, 
                     double altitude_m = 0.0);
    
    // 设置时间
    void setTime(int year, int month, int day, double hour_utc);
    void setTime(const TimeInfo& time_info);
    
    // 设置气象参数
    void setWeather(const WeatherParameters& weather);
    
    // 设置大气模型
    void setAtmosphereModel(atmosphere::AtmosphereModelType type);
    
    // 设置地表类型
    void setSurfaceType(SurfaceType type);
    
    // ========== 时间推进 ==========
    
    // 推进时间（秒）
    void advanceTime(double delta_seconds);
    
    // 设置时间倍速（用于快速仿真日变化）
    void setTimeScale(double scale) { time_scale_ = scale; }
    
    // ========== 参数查询 ==========
    
    const GeoLocation& getLocation() const { return location_; }
    const TimeInfo& getTime() const { return current_time_; }
    const WeatherParameters& getWeather() const { return weather_; }
    
    // 获取太阳位置
    SolarPosition getSolarPosition() const;
    
    // 获取天空辐射计算器（已配置好参数）
    const SkyRadianceCalculator& getSkyCalculator() const;
    
    // 获取地表温度模型（已配置好参数）
    SurfaceTemperatureModel& getSurfaceModel();
    
    // 获取大气廓线（已配置好模型）
    const atmosphere::AtmosphereProfile& getAtmosphereProfile() const;
    
    // ========== 动态参数计算 ==========
    
    // 计算当前时刻的太阳辐照度（直接法向 + 水平散射）
    void computeSolarIrradiance(double& dni, double& dhi) const;
    
    // 计算当前时刻的地表温度
    double computeSurfaceTemperature() const;
    
    // 计算当前时刻的天空有效温度
    double computeSkyEffectiveTemperature() const;
    
    // ========== 场景脚本 ==========
    
    // 加载环境脚本（定义参数随时间的变化）
    bool loadScript(const std::string& script_file);
    
    // 环境变化回调：当环境参数改变时通知相关模块
    using EnvironmentChangeCallback = std::function<void()>;
    void registerChangeCallback(EnvironmentChangeCallback cb);
    
private:
    GeoLocation location_;
    TimeInfo current_time_;
    WeatherParameters weather_;
    
    atmosphere::AtmosphereModelType atm_model_ = 
        atmosphere::AtmosphereModelType::MIDLATITUDE_SUMMER;
    SurfaceType surface_type_ = SurfaceType::GRASS;
    
    double time_scale_ = 1.0;  // 时间倍速
    
    // 子计算器
    mutable SkyRadianceCalculator sky_calculator_;
    mutable SurfaceTemperatureModel surface_model_;
    
    // 变更回调列表
    std::vector<EnvironmentChangeCallback> change_callbacks_;
    
    // 通知所有观察者环境已变化
    void notifyChange();
    
    // 更新子计算器的参数（当环境参数变化时调用）
    void updateSubCalculators() const;
};

} // namespace environment
} // namespace opto_engine

这个环境系统设计体现了单一数据源（Single Source of Truth） 的架构原则：所有环境参数都集中存储在一个地方，各子模块通过统一的接口访问，确保了参数的一致性。同时，它还采用了观察者模式（Observer Pattern） ------当环境参数发生变化时，系统会通知所有注册了回调的模块，让它们更新自己的状态。这对于需要实时响应环境变化的仿真场景非常有用。

在实际工程中，环境参数的时间变化建模是一个重要的功能。比如，用户可能希望仿真一个完整昼夜周期内的目标红外特征变化。这就需要环境系统能够按照一定的规律自动更新温度、风速、太阳位置等参数。常见的时间变化模型包括：

• 日变化模型：温度、湿度、风速等参数按日周期变化（正弦曲线或更复杂的经验模型）
• 季节变化模型：根据季节调整平均温度和太阳高度
• 天气演变模型：模拟天气系统的移动和变化（如冷锋过境、云层移动等）

这些模型可以通过脚本系统来定义和扩展，让用户可以根据具体的仿真场景灵活配置环境的时间演化。

9.6 架构师视角：环境模型复杂度与仿真精度的权衡

环境建模是光电仿真中"输入"性质的环节------环境模型的精度决定了仿真结果的可信度上限。但环境建模又是一个极其复杂的领域，涉及大气科学、气象学、地理学、海洋学等多个学科。作为光电仿真引擎的架构师，我们必须在环境模型的复杂度与仿真精度之间做出合理的权衡。

第一个权衡：物理保真度与参数可获得性的矛盾。

理论上，我们希望环境模型越精确越好。但高精度的环境模型需要大量的输入参数来驱动。比如，一个完整的三维非均匀大气模型需要知道每个空间点的温度、压力、湿度、气溶胶浓度等参数------这些数据在实际应用中往往是难以获得的。用户可能只有一个大概的地点和日期，连当天的准确气温都不知道，更不用说三维大气廓线了。

如果环境模型的参数需求远超用户能够提供的范围，那么模型再精确也没有意义------因为输入参数的不确定性带来的误差可能远大于模型本身的误差。

架构师的建议是 ：采用分级模型 + 智能默认值的策略。引擎提供多个精度等级的环境模型，从简单到复杂排列。同时，为每个参数提供合理的默认值（基于标准模型或统计平均）。用户只需要提供他们已知的参数，未知参数使用默认值。当用户提供了更详细的数据时，系统自动升级到更高级的模型。

比如，对于地表温度的计算：

• 如果用户只提供了"夏天、中纬度"------使用标准日变化曲线，温度范围取中纬度夏季的典型值
• 如果用户提供了具体的日期、经纬度和环境温度------使用能量平衡模型
• 如果用户还提供了土壤类型、湿度剖面、逐时气象数据------使用一维土壤热传导模型

这种设计既满足了高级用户的精度需求，又降低了普通用户的使用门槛。

第二个权衡：空间均匀性假设与真实三维环境的差距。

大多数工程级的光电仿真模型都假设大气是水平均匀的（平面平行大气）、地表是均匀的、环境参数在空间上是不变的。这在很多情况下是合理的近似------比如目标尺寸不大、观测距离不太远时，路径上的大气条件确实比较均匀。

但在某些场景下，均匀假设就不够了。比如：

• 大视场、远距离的红外成像系统，不同视线方向穿过的大气路径差异很大
• 复杂地形场景，山坡和山谷的温度、风速、太阳照射条件都不同
• 城市热岛效应，市区和郊区的温度和地表特性差异显著
• 三维非均匀大气，如云层的空间分布、烟尘羽流的扩散等

三维环境建模的精度更高，但实现难度和计算量也呈指数增长。一个三维的大气辐射传输计算，其计算量可能是一维平面平行模型的成千上万倍。

架构师的建议是 ：采用多层级环境模型的架构。底层是一维均匀模型（满足 80% 的常规需求），中层是参数化的二维/三维变化模型（如水平梯度、地形修正），高层是完全的三维模型（用于特殊场景）。通过统一的接口对外提供服务，上层应用不需要知道底层用的是哪一级模型。

比如，对于大气传输计算，可以设计这样的层级：

• L1：水平均匀大气，整个场景用一条大气路径代表
• L2：一维垂直廓线 + 水平梯度，不同位置的大气参数按梯度修正
• L3：三维大气数值模式（如 WRF 输出），每个空间格点有独立的大气参数

用户可以根据场景的复杂度和精度需求，选择合适的层级。

第三个权衡：实时性与物理真实性的平衡。

这个权衡在仿真训练、虚拟现实等需要实时渲染的场景中尤为突出。实时环境渲染（如实时天空、实时太阳阴影、实时大气散射）需要在每帧 16ms 内完成所有环境计算，这就要求环境模型必须极度简化。

比如，在实时图形学中，常用的大气散射近似方法（如 Preetham 模型、Hosek-Wilkie 模型）都是基于解析近似或预计算的，与真实的大气辐射传输相比有明显的简化。它们的目标是"看起来像"，而不是"物理上精确"。

但在光电仿真中，我们不仅需要"看起来像"，还需要辐射度量级的精度。这就对实时环境建模提出了更高的要求。

架构师的建议是 ：区分视觉级仿真 和度量级仿真，采用不同的环境模型。视觉级仿真（用于人眼观察的场景渲染）追求视觉真实感，允许较大的物理误差，可以用 GPU 加速的实时模型。度量级仿真（用于红外辐射计算、目标对比度分析、探测距离估算等）追求物理精度，必须使用经过验证的物理模型，计算量再大也得保证精度。

在同一个引擎中，这两种模式可以并存。比如，场景的可视化显示用快速近似模型，而辐射计算的核心链路用高精度模型。两者共享相同的环境参数，但使用不同的计算路径。

第四个权衡：标准模型的通用性与特定场景的定制化需求。

标准大气模型（如中纬度夏季、热带大气等）是基于大量观测数据的统计平均，适用于大多数常规场景。但在某些特殊场景下，标准模型可能与实际情况相差甚远。比如：

• 高原地区（空气稀薄，大气质量不同）
• 海洋环境（高湿度、海洋性气溶胶）
• 工业污染区（气溶胶浓度高、成分复杂）
• 极端天气（沙尘暴、暴雨、浓雾）

如果引擎只支持标准模型，那么在这些特殊场景下的仿真可信度就会大打折扣。

架构师的建议是：在提供丰富的标准模型库的同时，设计良好的扩展接口，允许用户导入自定义的环境数据。比如：

• 支持探空数据导入，生成自定义大气廓线
• 支持用户自定义气溶胶模型（粒径分布、折射率等）
• 支持导入地表类型图（土地利用分类图）
• 支持接入数值天气预报模式的输出数据

这种"内置标准 + 可扩展"的设计，既保证了通用性，又为特殊场景的定制化留下了空间。

最后，作为架构师，我们还要认识到：环境建模是光电仿真中不确定性最大的环节之一 。无论我们的模型多么精确，真实环境的变化往往超出我们的预期。因此，除了不断提高模型精度，我们还应该在系统中引入不确定性分析 和灵敏度分析的功能------让用户知道"当环境参数变化 X% 时，仿真结果会变化多少"。这比给出一个看似精确但实际充满不确定性的结果，对用户来说更有价值。

---