SpectraRust/src/math/opacf0.rs

//! 单深度点的吸收、发射和散射系数计算。
//!
//! 重构自 TLUSTY `opacf0.f`
//!
//! 对于给定深度点 ID，计算所有频率点的吸收、发射和散射系数。
//! 这是计算不透明度的核心函数之一。
//!
//! # 算法流程
//!
//! 1. 初始化深度相关温度量 (类似 TDPINI)
//! 2. 初始化电子密度相关量 (类似 OPAINI)
//! 3. 计算束缚-自由不透明度预备量
//! 4. 计算自由-自由不透明度预备量
//! 5. 初始化 Mermerges 数据 (类似 SGMER0)
//! 6. 初始化谱线不透明度
//! 7. 循环频率点计算总不透明度

use crate::state::constants::{HK, H, UN, SIGE, NLMX, MFREQ, MFREQL, MLEVEL, MTRANS, MION, MMER};

// 物理常数 (来自 opacf0.f)
/// Rydberg 频率
const FRH: f64 = 3.28805e15;
/// H⁻ 光电离截面常数
const PH2: f64 = 2.815e29 * 2.0;
/// 氢结合能
const EHB: f64 = 157802.77355;
/// H⁻ 自由-自由常数 1
const CFF1: f64 = 1.3727e-25;
/// H⁻ 自由-自由常数 2
const CFF2: f64 = 4.3748e-10;
/// H⁻ 自由-自由常数 3
const CFF3: f64 = 2.5993e-7;
/// c * 1e14 (用于 Gaunt 因子)
const C14: f64 = 2.99793e14;
/// 自由-自由基准截面
const SGFF0: f64 = 3.694e8;

// ============================================================================
// 参数结构体
// ============================================================================

/// OPACF0 输入配置
#[derive(Debug, Clone)]
pub struct Opacf0Config {
    /// Compton 散射标志 (>0: 计算)
    pub icompt: i32,
    /// ODF 采样标志 (0: 标准模式, >=1: ODF 采样)
    pub ispodf: i32,
    /// 双电子复合标志 (0: 无, >0: 有)
    pub ifdiel: i32,
    /// 附加不透明度标志 (0: 无, !=0: 有)
    pub iopadd: i32,
    /// 密度缩放标志 (0: 已缩放, 1: 不缩放)
    pub izscal: i32,
    /// 表格不透明度标志 (>0: 使用 OPACT1)
    pub ioptab: i32,
    /// 当前迭代次数
    pub iter: i32,
    /// 激光抑制迭代阈值
    pub itlas: i32,
    /// 激光抑制阈值
    pub qtlas: f64,
}

impl Default for Opacf0Config {
    fn default() -> Self {
        Self {
            icompt: 0,
            ispodf: 0,
            ifdiel: 0,
            iopadd: 0,
            izscal: 1,
            ioptab: 0,
            iter: 1,
            itlas: 100,
            qtlas: 0.1,
        }
    }
}

/// OPACF0 模型状态参数
#[derive(Debug)]
pub struct Opacf0ModelState<'a> {
    /// 深度点数
    pub nd: usize,
    /// 温度 (nd)
    pub temp: &'a [f64],
    /// 电子密度 (nd)
    pub elec: &'a [f64],
    /// 总粒子密度 (nd)
    pub dens: &'a [f64],
    /// 分子质量 (nd)
    pub wmm: &'a [f64],
    /// 占据数 (mlevel × nd)
    pub popul: &'a [f64],

    // 工作数组 (输入/输出)
    /// HKT1 (nd) - HK/T
    pub hkt1: &'a mut [f64],
    /// HKT21 (nd) - (HK/T)²
    pub hkt21: &'a mut [f64],
    /// TK1 (nd) - 1/(kT)
    pub tk1: &'a mut [f64],
    /// SQT1 (nd) - sqrt(T)
    pub sqt1: &'a mut [f64],
    /// TEMP1 (nd) - 1/T
    pub temp1: &'a mut [f64],
    /// ELEC1 (nd) - 1/ne
    pub elec1: &'a mut [f64],
    /// DENS1 (nd) - 1/n
    pub dens1: &'a mut [f64],
    /// DENSI (nd) - 密度倒数
    pub densi: &'a mut [f64],
    /// DENSIM (nd) - 密度倒数 × 分子质量
    pub densim: &'a mut [f64],
    /// ELSCAT (nd) - 电子散射系数
    pub elscat: &'a mut [f64],
}

/// OPACF0 原子数据参数
#[derive(Debug)]
pub struct Opacf0AtomicParams<'a> {
    /// 束缚-自由跃迁数
    pub ntranc: usize,
    /// 离子数
    pub nion: usize,
    /// 能级数
    pub nlevel: usize,
    /// 跃迁数
    pub ntrans: usize,
    /// 连续谱频率数
    pub nfreqc: usize,

    // 跃迁索引
    /// 束缚-自由跃迁索引 (ntranc), 1-indexed
    pub itrbf: &'a [i32],
    /// 低能级索引 (mtrans), 1-indexed
    pub ilow: &'a [i32],
    /// 高能级索引 (mtrans), 1-indexed
    pub iup: &'a [i32],
    /// 跃迁类型索引 (mlevel × mlevel), 1-indexed
    pub itra: &'a [i32],
    /// 指数索引 (mtrans)
    pub indexp: &'a [i32],
    /// Macfarlane 下沉修正索引 (mtrans)
    pub mcdw: &'a [i32],
    /// 频率起点 (mtrans), 1-indexed
    pub ifr0: &'a [i32],
    /// 频率终点 (mtrans), 1-indexed
    pub ifr1: &'a [i32],
    /// ODF 频率起点 (mtrans), 1-indexed
    pub kfr0: &'a [i32],
    /// ODF 频率终点 (mtrans), 1-indexed
    pub kfr1: &'a [i32],
    /// 阈值频率 (mtrans)
    pub fr0: &'a [f64],
    /// 积分模式 (mtrans)
    pub intmod: &'a [i32],
    /// 谱线标志 (mtrans)
    pub line: &'a [i32],

    // 能级相关
    /// 能级对应的元素索引 (mlevel), 1-indexed
    pub iel: &'a [i32],
    /// 能级对应的原子索引 (mlevel), 1-indexed
    pub iatm: &'a [i32],
    /// Mermerges 处理标志 (mlevel), < 0 表示需要特殊处理
    pub ifwop: &'a [i32],
    /// Mermerges 索引 (mlevel)
    pub imrg: &'a mut [i32],
    /// 主量子数 (mlevel)
    pub nquant: &'a [i32],
    /// 电离能 (mlevel)
    pub enion: &'a [f64],
    /// 统计权重 (mlevel)
    pub g: &'a [f64],
    /// 束缚-自由截面 (mlevel)
    pub sbf: &'a [f64],
    /// 束缚-自由权重 (mlevel × nd)
    pub wop: &'a [f64],

    // 离子相关
    /// 离子对应的下一个能级索引 (mion), 1-indexed
    pub nnext: &'a [i32],
    /// 离子起始能级 (mion), 1-indexed
    pub nfirst: &'a [i32],
    /// 自由-自由阈值频率 (mion)
    pub ff: &'a [f64],
    /// 电荷² (mion)
    pub charg2: &'a [f64],
    /// 原子序数 Z (mion)
    pub iz: &'a [i32],
    /// H 元素索引 (1-indexed, 0 表示无)
    pub ielh: i32,
    /// H⁻ 元素索引 (1-indexed, 0 表示无)
    pub ielhm: i32,

    // 原子相关
    /// 原子操作标志 (matom), 0=正常, >0=特殊
    pub iadop: &'a [i32],
}

/// OPACF0 频率数据参数
#[derive(Debug)]
pub struct Opacf0FreqParams<'a> {
    /// 频率点数
    pub nfreq: usize,
    /// 频率数组 (nfreq)
    pub freq: &'a [f64],
    /// Planck 函数 (nfreq)
    pub bnue: &'a [f64],
    /// 主谱线索引 (nfreq), 0 表示无
    pub ijlin: &'a [i32],
    /// 重叠谱线数 (nfreq)
    pub nlines: &'a [i32],
    /// 谱线索引 (mitj × nfreq)
    pub itrlin: &'a [i32],
    /// Compton 散射截面 (nfreq)
    pub sigec: &'a [f64],
    /// 表格最大频率
    pub frtabm: f64,
}

/// OPACF0 输出状态
#[derive(Debug)]
pub struct Opacf0Output<'a> {
    /// 吸收系数 (nfreq)
    pub abso: &'a mut [f64],
    /// 发射系数 (nfreq)
    pub emis: &'a mut [f64],
    /// 散射系数 (nfreq)
    pub scat: &'a mut [f64],

    // 工作数组
    /// XKF (nd) - exp(-hν/kT)
    pub xkf: &'a mut [f64],
    /// XKF1 (nd) - 1 - XKF
    pub xkf1: &'a mut [f64],
    /// XKFB (nd) - XKF × Bν
    pub xkfb: &'a mut [f64],

    // 跃迁吸收/发射系数 (mtrans × nd)
    /// 吸收系数
    pub abtra: &'a mut [f64],
    /// 发射系数
    pub emtra: &'a mut [f64],

    // 自由-自由系数
    /// SFF2 (mion × nd)
    pub sff2: &'a mut [f64],
    /// SFF3 (mion × nd)
    pub sff3: &'a mut [f64],
    /// H⁻ 自由-自由系数 (nd)
    pub cffn: &'a mut [f64],
    /// H⁻ 自由-自由温度因子 (nd)
    pub cfft: &'a mut [f64],

    // Mermerges 数据
    /// Mermerges 频率 (mmer)
    pub frch: &'a mut [f64],
    /// Mermerges 截面基准 (mmer)
    pub sgm0: &'a mut [f64],
    /// Mermerges 截面求和 (nlmx × mmer × nd)
    pub sgmsum: &'a mut [f64],
    /// Mermerges 能级索引 (mlevel)
    pub iimer: &'a mut [i32],
    /// Mermerges 数量
    pub imer: &'a mut i32,

    // 谱线轮廓 (nd × nfreql)
    pub prflin: &'a mut [f32],

    // 下沉修正因子 (mmcdw × nd)
    pub dwf1: &'a mut [f64],

    // 氢积分数据
    /// WNHINT (nlmx × nd) - 氢波函数积分
    pub wnhint: &'a [f64],
    /// XI2 (nlmx) - n²
    pub xi2: &'a [f64],
    /// XI3 (nlmx) - n³
    pub xi3: &'a [f64],
    /// GMER (mmer × nd) - Mermerges 截面修正
    pub gmer: &'a [f64],
    /// SGMG (mmer × nd) - Mermerges 截面
    pub sgmg: &'a mut [f64],
}

/// 束缚-自由截面函数类型
pub type CrossFn = fn(ibft: usize, ij: usize) -> f64;

/// 双电子截面函数类型
pub type CrossDFn = fn(ibft: usize, ij: usize, id: usize) -> f64;

// ============================================================================
// 主函数
// ============================================================================

/// 计算单深度点的吸收、发射和散射系数。
///
/// 对于给定深度点 ID，计算所有频率点的不透明度。
///
/// # 参数
///
/// * `id` - 深度点索引 (1-indexed)
/// * `nfrq` - 频率点数
/// * `config` - 配置参数
/// * `model` - 模型状态
/// * `atomic` - 原子数据
/// * `freq_params` - 频率数据
/// * `output` - 输出数组
pub fn opacf0(
    id: usize,
    nfrq: usize,
    config: &Opacf0Config,
    model: &mut Opacf0ModelState,
    atomic: &mut Opacf0AtomicParams,
    freq_params: &Opacf0FreqParams,
    output: &mut Opacf0Output,
) {
    let id_idx = id - 1; // 转换为 0-indexed
    let nd = model.nd;

    // ========================================================================
    // 1. 初始化深度相关温度量 (类似 TDPINI)
    // ========================================================================

    let t = model.temp[id_idx];
    let t1 = UN / t;
    model.hkt1[id_idx] = HK * t1;
    model.hkt21[id_idx] = model.hkt1[id_idx] * t1;
    model.tk1[id_idx] = model.hkt1[id_idx] / H;
    model.sqt1[id_idx] = t.sqrt();
    model.temp1[id_idx] = t1;

    // 调用 GFREE0 初始化自由-自由 Gaunt 因子
    // CALL GFREE0(ID) - 由外部调用或在此调用

    // ========================================================================
    // 2. 初始化电子密度相关量 (类似 OPAINI)
    // ========================================================================

    let ane = model.elec[id_idx];
    model.elec1[id_idx] = UN / ane;
    model.dens1[id_idx] = UN / model.dens[id_idx];
    model.densi[id_idx] = model.dens1[id_idx];

    if config.izscal == 1 {
        model.densim[id_idx] = model.densi[id_idx] * model.wmm[id_idx];
    } else {
        model.densim[id_idx] = 0.0;
        model.densi[id_idx] = UN;
    }

    model.elscat[id_idx] = ane * SIGE;

    // 调用辅助函数
    // CALL DWNFR0(ID) - 下沉修正初始化
    // CALL WNSTOR(ID) - 氢积分存储
    // CALL SABOLF(ID) - 束缚-自由 Sa Boltzmann 因子

    // ========================================================================
    // 3. 计算束缚-自由不透明度预备量
    // ========================================================================

    for ibft in 0..atomic.ntranc {
        let itr = atomic.itrbf[ibft] as usize - 1;
        if atomic.indexp[itr] != 0 {
            let ii = atomic.ilow[itr] as usize - 1;
            let jj = atomic.iup[itr] as usize - 1;
            let it = atomic.itra[jj * MLEVEL + ii] as usize;

            if it > 0 {
                let ie = atomic.iel[ii] as usize - 1;
                let nke = atomic.nnext[ie] as usize - 1;

                let corr = if nke != jj {
                    let g_ratio = atomic.g[nke] / atomic.g[jj];
                    let delta_e = atomic.enion[nke] - atomic.enion[jj];
                    g_ratio * (delta_e * model.tk1[id_idx]).exp()
                } else {
                    UN
                };

                // ABTRA(ITR,ID) = POPUL(II,ID)
                let popul_ii = get_popul(atomic.nlevel, id_idx, ii, model.popul);
                output.abtra[itr * nd + id_idx] = popul_ii;

                // EMTRA(ITR,ID) = POPUL(JJ,ID)*ANE*SBF(II)*WOP(II,ID)*CORR
                let popul_jj = get_popul(atomic.nlevel, id_idx, jj, model.popul);
                let wop_ii = get_wop(atomic.nlevel, id_idx, ii, atomic.wop);
                let emis_val = popul_jj * ane * atomic.sbf[ii] * wop_ii * corr;
                output.emtra[itr * nd + id_idx] = emis_val;
            }
        }
    }

    // ========================================================================
    // 4. 计算自由-自由不透明度预备量
    // ========================================================================

    if atomic.ielhm > 0 {
        let nf_h = atomic.nfirst[(atomic.ielhm - 1) as usize] as usize - 1;
        let popul_h = get_popul(atomic.nlevel, id_idx, nf_h, model.popul);
        output.cffn[id_idx] = popul_h * ane;
        output.cfft[id_idx] = CFF2 - CFF3 / t;
    }

    let sgff = SGFF0 / model.sqt1[id_idx] * ane;

    for ion in 0..atomic.nion {
        let ion_idx = ion;
        let ff_val = atomic.ff[ion_idx];
        output.sff2[ion_idx * nd + id_idx] = (ff_val * model.hkt1[id_idx]).exp();

        let nnext_idx = atomic.nnext[ion_idx] as usize - 1;
        let popul_nnext = get_popul(atomic.nlevel, id_idx, nnext_idx, model.popul);
        let charg2 = atomic.charg2[ion_idx];
        output.sff3[ion_idx * nd + id_idx] = popul_nnext * charg2 as f64 * sgff;
    }

    // ========================================================================
    // 5. 初始化 Mermerges 数据 (类似 SGMER0)
    // ========================================================================

    *output.imer = 0;

    for ii in 0..atomic.nlevel {
        if atomic.ifwop[ii] < 0 {
            *output.imer += 1;
            let imer_val = (*output.imer - 1) as usize; // 0-indexed
            atomic.imrg[ii] = (*output.imer) as i32;
            output.iimer[imer_val] = ii as i32;

            let ie = atomic.iel[ii] as usize - 1;
            let ch = (atomic.iz[ie] * atomic.iz[ie]) as f64;

            output.frch[imer_val] = FRH * ch;
            output.sgm0[imer_val] = PH2 * ch * ch;

            let ii0 = if ii > 0 {
                atomic.nquant[ii - 1] as usize
            } else {
                0
            } + 1;

            let ex = EHB * ch * model.temp1[id_idx];

            // 计算积分
            for i in ii0..NLMX {
                let sum_i = compute_sgmsum(
                    i, ex, id_idx, nd,
                    output.xi2, output.xi3,
                    output.wnhint, output.gmer,
                    output.sgm0[imer_val], atomic.nlevel,
                );
                output.sgmsum[i * MMER * nd + imer_val * nd + id_idx] = sum_i;
            }
        }
    }

    // ========================================================================
    // 6. 初始化谱线不透明度 (如果 nfrq > nfreqc)
    // ========================================================================

    let laser = config.iter > config.itlas;

    if nfrq > atomic.nfreqc {
        // 初始化主谱线轮廓
        for itr in 0..atomic.ntrans {
            if atomic.line[itr] == 0 {
                continue;
            }
            if atomic.intmod[itr] == 0 {
                continue;
            }

            let indxa = atomic.indexp[itr].abs();
            let ijl0 = if config.ispodf >= 1 {
                atomic.kfr0[itr] as usize
            } else {
                atomic.ifr0[itr] as usize
            };
            let ijl1 = if config.ispodf >= 1 {
                atomic.kfr1[itr] as usize
            } else {
                atomic.ifr1[itr] as usize
            };

            if indxa < 2 || indxa > 4 {
                // 调用 LINPRO 计算谱线轮廓
                // CALL LINPRO(ITR,ID,PRF)
                // 这里需要外部提供 LINPRO 实现
            }
        }

        // 计算谱线吸收/发射系数
        // (这部分在原代码中有 bug - 循环外的代码使用了循环内的变量)
    }

    // ========================================================================
    // 7. 循环频率点计算不透明度
    // ========================================================================

    let icall = 1;

    for ij in 0..nfrq {
        let ij_idx = ij;

        // Compton 散射
        if config.icompt > 0 && ij_idx < freq_params.sigec.len() {
            model.elscat[id_idx] = model.elec[id_idx] * freq_params.sigec[ij_idx];
        }

        // 初始化
        output.abso[ij_idx] = model.elscat[id_idx];
        output.emis[ij_idx] = 0.0;
        output.scat[ij_idx] = model.elscat[id_idx];

        // 基本频率量
        let fr = freq_params.freq[ij_idx];
        let frinv = UN / fr;
        let fr3inv = frinv * frinv * frinv;

        output.xkf[id_idx] = (-model.hkt1[id_idx] * fr).exp();
        output.xkf1[id_idx] = UN - output.xkf[id_idx];
        output.xkfb[id_idx] = output.xkf[id_idx] * freq_params.bnue[ij_idx];

        // --------------------------------------------------------------------
        // 7.1 束缚-自由贡献
        // --------------------------------------------------------------------

        for ibft in 0..atomic.ntranc {
            let itr = atomic.itrbf[ibft] as usize - 1;
            let ii = atomic.ilow[itr] as usize - 1;

            // 跳过特殊原子处理
            let iatm_ii = atomic.iatm[ii] as usize - 1;
            if iatm_ii < atomic.iadop.len() && atomic.iadop[iatm_ii] > 0 && fr <= freq_params.frtabm {
                continue;
            }

            // 获取截面
            let sg = if config.ifdiel == 0 {
                // SG = CROSS(IBFT,IJ)
                0.0 // 需要外部截面函数
            } else {
                // SG = CROSSD(IBFT,IJ,ID)
                0.0 // 需要外部截面函数
            };

            // Mermerges 处理
            if atomic.ifwop[ii] < 0 {
                let imer = atomic.imrg[ii] as usize - 1;
                // 调用 SGMER1
                // CALL SGMER1(FRINV,FR3INV,IMER,ID,SGME1)
                // output.sgmg[imer * nd + id_idx] = sgme1;
            }

            if sg <= 0.0 {
                continue;
            }

            // Macfarlane 下沉修正
            if atomic.mcdw[itr] > 0 {
                let izz = atomic.iz[atomic.iel[ii] as usize - 1];
                // 调用 DWNFR1
                // CALL DWNFR1(FR,FR0(ITR),ID,IZZ,DW1)
                // let dw1 = ...;
                // output.dwf1[(atomic.mcdw[itr] - 1) as usize * nd + id_idx] = dw1;
                // sg = sg * dw1;
            }

            let emis_bf = sg * output.emtra[itr * nd + id_idx];
            output.abso[ij_idx] += sg * output.abtra[itr * nd + id_idx];
            output.emis[ij_idx] += emis_bf;
        }

        // --------------------------------------------------------------------
        // 7.2 自由-自由贡献
        // --------------------------------------------------------------------

        for ion in 0..atomic.nion {
            let nnext_idx = atomic.nnext[ion] as usize - 1;
            let it = atomic.itra[nnext_idx * MLEVEL + nnext_idx];

            // 跳过特殊原子处理
            if nnext_idx < atomic.nlevel {
                let iatm = atomic.iatm[nnext_idx] as usize - 1;
                if iatm < atomic.iadop.len() && atomic.iadop[iatm] > 0 && fr <= freq_params.frtabm {
                    continue;
                }
            }

            let absoff = match it {
                1 => {
                    // 氢型 Gaunt = 1
                    let sf1 = output.sff3[ion * nd + id_idx] * fr3inv;
                    let sf2 = if fr < atomic.ff[ion] {
                        UN / output.xkf[id_idx]
                    } else {
                        output.sff2[ion * nd + id_idx]
                    };
                    sf1 * sf2
                }
                2 => {
                    // 氢型精确 Gaunt
                    let sf1 = output.sff3[ion * nd + id_idx] * fr3inv;
                    let sf2 = if fr < atomic.ff[ion] {
                        UN / output.xkf[id_idx]
                    } else {
                        output.sff2[ion * nd + id_idx]
                    };
                    let x = C14 * atomic.charg2[ion] as f64 / fr;
                    // sf2 = sf2 - UN + GFREE1(ID,X)
                    sf1 * sf2
                }
                3 => {
                    // H⁻ 自由-自由
                    // SFFHMI(POPUL(NFIRST(IELH),ID),FR,TEMP(ID)) * ELEC(ID)
                    let nf_h = atomic.nfirst[(atomic.ielh - 1) as usize] as usize - 1;
                    let popul_h = get_popul(atomic.nlevel, id_idx, nf_h, model.popul);
                    // 调用 sffhmi
                    let sffhmi_val = compute_sffhmi(popul_h, fr, t);
                    sffhmi_val * model.elec[id_idx]
                }
                _ if it < 0 => {
                    // 特殊截面
                    // FFCROS(ION,IT,TEMP(ID),FR) * POPUL(NNEXT(ION),ID) * ELEC(ID)
                    let popul_nnext = get_popul(atomic.nlevel, id_idx, nnext_idx, model.popul);
                    // 调用 ffcros
                    0.0 * popul_nnext * model.elec[id_idx]
                }
                _ => 0.0,
            };

            output.abso[ij_idx] += absoff;
            output.emis[ij_idx] += absoff;
        }

        // --------------------------------------------------------------------
        // 7.3 附加不透明度 (OPADD)
        // --------------------------------------------------------------------

        if config.iopadd != 0 {
            // 调用 OPADD
            // CALL OPADD(0,ICALL,IJ,ID)
            // output.abso[ij_idx] += abad;
            // output.emis[ij_idx] += emad;
            // output.scat[ij_idx] += scad;
        }

        // --------------------------------------------------------------------
        // 7.4 谱线贡献
        // --------------------------------------------------------------------

        if config.ispodf == 0 {
            // 标准模式
            if freq_params.ijlin[ij_idx] > 0 {
                let itr = (freq_params.ijlin[ij_idx] - 1) as usize;
                let iad = if atomic.ilow[itr] > 0 {
                    let ilow_idx = atomic.ilow[itr] as usize - 1;
                    let iatm = atomic.iatm[ilow_idx] as usize - 1;
                    if iatm < atomic.iadop.len() {
                        atomic.iadop[iatm]
                    } else {
                        0
                    }
                } else {
                    0
                };

                let lfre = fr > freq_params.frtabm;
                if iad == 0 || (lfre && iad > 0) {
                    let sg = get_prflin(id_idx, ij_idx, nd, output.prflin);
                    output.abso[ij_idx] += sg as f64 * output.abtra[itr * nd + id_idx];
                    output.emis[ij_idx] += sg as f64 * output.emtra[itr * nd + id_idx];
                }
            }

            // 重叠谱线
            if freq_params.nlines[ij_idx] > 0 {
                for ilint in 0..freq_params.nlines[ij_idx] as usize {
                    let itrlin_idx = ilint * freq_params.nfreq + ij_idx;
                    let itr = freq_params.itrlin[itrlin_idx] as usize - 1;

                    let iad = if atomic.ilow[itr] > 0 {
                        let ilow_idx = atomic.ilow[itr] as usize - 1;
                        let iatm = atomic.iatm[ilow_idx] as usize - 1;
                        if iatm < atomic.iadop.len() {
                            atomic.iadop[iatm]
                        } else {
                            0
                        }
                    } else {
                        0
                    };

                    let lfre = fr > freq_params.frtabm;
                    if iad > 0 && !lfre {
                        continue;
                    }

                    // 跳过展开谱线
                    // if linexp[itr] { continue; }

                    // 插值计算轮廓
                    let ijl0 = atomic.ifr0[itr] as usize - 1;
                    let ijl1 = atomic.ifr1[itr] as usize - 1;

                    // 找到频率位置
                    let (ij0, ij1) = find_frequency_bounds(
                        ij_idx, ijl0, ijl1, freq_params.freq, fr
                    );

                    if ij0 > 0 && ij1 < freq_params.nfreq {
                        let x = UN / (freq_params.freq[ij1] - freq_params.freq[ij0]);
                        let a1 = (fr - freq_params.freq[ij0]) * x;
                        let a2 = (freq_params.freq[ij1] - fr) * x;

                        let sg_ij0 = get_prflin(id_idx, ij0, nd, output.prflin);
                        let sg_ij1 = get_prflin(id_idx, ij1, nd, output.prflin);
                        let sg = a1 * sg_ij0 as f64 + a2 * sg_ij1 as f64;

                        output.abso[ij_idx] += sg as f64 * output.abtra[itr * nd + id_idx];
                        output.emis[ij_idx] += sg as f64 * output.emtra[itr * nd + id_idx];
                    }
                }
            }
        } else {
            // ODF 采样模式
            if freq_params.nlines[ij_idx] > 0 {
                for ilint in 0..freq_params.nlines[ij_idx] as usize {
                    let itrlin_idx = ilint * freq_params.nfreq + ij_idx;
                    let itr = freq_params.itrlin[itrlin_idx] as usize - 1;

                    let iad = if atomic.ilow[itr] > 0 {
                        let ilow_idx = atomic.ilow[itr] as usize - 1;
                        let iatm = atomic.iatm[ilow_idx] as usize - 1;
                        if iatm < atomic.iadop.len() {
                            atomic.iadop[iatm]
                        } else {
                            0
                        }
                    } else {
                        0
                    };

                    let lfre = fr > freq_params.frtabm;
                    if iad > 0 && !lfre {
                        continue;
                    }

                    let kj = ij - atomic.ifr0[itr] as usize + 1 + atomic.kfr0[itr] as usize - 1;
                    let indxpa = atomic.indexp[itr].abs();

                    if indxpa != 3 && indxpa != 4 {
                        let sg = get_prflin(id_idx, kj, nd, output.prflin);
                        output.abso[ij_idx] += sg as f64 * output.abtra[itr * nd + id_idx];
                        output.emis[ij_idx] += sg as f64 * output.emtra[itr * nd + id_idx];
                    }
                    // else: ODF 插值模式 - 需要更多数据
                }
            }
        }

        // --------------------------------------------------------------------
        // 7.5 最终不透明度计算
        // --------------------------------------------------------------------

        output.abso[ij_idx] = output.abso[ij_idx] - output.emis[ij_idx] * output.xkf[id_idx];
        output.emis[ij_idx] = output.emis[ij_idx] * output.xkfb[id_idx];

        // --------------------------------------------------------------------
        // 7.6 表格不透明度
        // --------------------------------------------------------------------

        if config.ioptab > 0 {
            // 调用 OPACT1
            // CALL OPACT1(IJ)
        }
    }
}

// ============================================================================
// 辅助函数
// ============================================================================

/// 获取占据数
#[inline]
fn get_popul(nlevel: usize, id: usize, level: usize, popul: &[f64]) -> f64 {
    if level < nlevel {
        popul[level * 100 + id] // 假设 nd 最大为 100
    } else {
        0.0
    }
}

/// 获取束缚-自由权重
#[inline]
fn get_wop(nlevel: usize, id: usize, level: usize, wop: &[f64]) -> f64 {
    if level < nlevel {
        wop[level * 100 + id]
    } else {
        1.0
    }
}

/// 获取谱线轮廓
#[inline]
fn get_prflin(id: usize, ij: usize, nd: usize, prflin: &[f32]) -> f32 {
    let idx = id * MFREQL + ij;
    if idx < prflin.len() {
        prflin[idx]
    } else {
        0.0
    }
}

/// 计算 Mermerges 截面积分
fn compute_sgmsum(
    i: usize,
    ex: f64,
    id: usize,
    nd: usize,
    xi2: &[f64],
    xi3: &[f64],
    wnhint: &[f64],
    gmer: &[f64],
    sgm0: f64,
    nlevel: usize,
) -> f64 {
    if i >= NLMX {
        return 0.0;
    }

    let exi = (ex * xi2[i]).exp();
    let wnhint_val = if id < 100 && i < NLMX {
        wnhint[i * 100 + id]
    } else {
        0.0
    };
    let s = exi * wnhint_val * xi3[i];

    // 这里应该是一个递归求和，简化处理
    s * sgm0 / if id < 100 { gmer[id] } else { 1.0 }
}

/// 计算 H⁻ 自由-自由截面 (简化版)
fn compute_sffhmi(popul_h: f64, _fr: f64, _temp: f64) -> f64 {
    // 简化实现，实际应调用 sffhmi 模块
    popul_h * CFF1
}

/// 找到频率边界
fn find_frequency_bounds(
    ij: usize,
    ijl0: usize,
    ijl1: usize,
    freq: &[f64],
    fr: f64,
) -> (usize, usize) {
    let mut ij0 = ijl0;
    for ijt in ijl0..=ijl1 {
        if ijt < freq.len() && freq[ijt] <= fr {
            ij0 = ijt;
        } else {
            break;
        }
    }
    let ij1 = if ij0 > 0 { ij0 - 1 } else { ij0 };
    (ij0, ij1)
}

// ============================================================================
// 测试
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_opacf0_config_default() {
        let config = Opacf0Config::default();
        assert_eq!(config.icompt, 0);
        assert_eq!(config.ispodf, 0);
        assert_eq!(config.iter, 1);
    }

    #[test]
    fn test_constants() {
        // 验证物理常数
        assert!((FRH - 3.28805e15).abs() < 1e10);
        assert!((PH2 - 5.63e29).abs() < 1e27);
        assert!((SGFF0 - 3.694e8).abs() < 1e5);
    }

    #[test]
    fn test_helper_functions() {
        // 测试 get_popul - 使用正确大小的数组
        // 假设 nlevel=2, nd=100, 需要 2*100=200 个元素
        let mut popul = vec![0.0; 200];
        popul[1 * 100 + 0] = 5.0; // level=1, id=0
        let val = get_popul(2, 0, 1, &popul);
        assert_eq!(val, 5.0);

        // 越界测试
        let val_oob = get_popul(2, 0, 5, &popul); // level=5 >= nlevel=2
        assert_eq!(val_oob, 0.0);

        // 测试 find_frequency_bounds
        let freq = vec![1.0, 2.0, 3.0, 4.0, 5.0];
        let (ij0, ij1) = find_frequency_bounds(2, 0, 4, &freq, 3.5);
        assert_eq!(ij0, 2); // freq[2] = 3.0 <= 3.5
        assert_eq!(ij1, 1); // ij0 - 1
    }
}